mosesdecoder/moses/TranslationOptionCollectionText.cpp

145 lines
4.8 KiB
C++
Raw Normal View History

// $Id$
/***********************************************************************
Moses - factored phrase-based language decoder
Copyright (C) 2006 University of Edinburgh
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
***********************************************************************/
#include "TranslationOptionCollectionText.h"
#include "Sentence.h"
#include "DecodeStep.h"
#include "DecodeStepTranslation.h"
#include "FactorCollection.h"
#include "WordsRange.h"
#include <list>
using namespace std;
namespace Moses
{
/** constructor; just initialize the base class */
TranslationOptionCollectionText::TranslationOptionCollectionText(Sentence const &input, size_t maxNoTransOptPerCoverage, float translationOptionThreshold)
: TranslationOptionCollection(input, maxNoTransOptPerCoverage, translationOptionThreshold)
{
size_t size = input.GetSize();
2013-08-02 21:24:36 +04:00
m_inputPathMatrix.resize(size);
for (size_t phaseSize = 1; phaseSize <= size; ++phaseSize) {
for (size_t startPos = 0; startPos < size - phaseSize + 1; ++startPos) {
size_t endPos = startPos + phaseSize -1;
2013-08-02 21:24:36 +04:00
vector<InputPath*> &vec = m_inputPathMatrix[startPos];
2013-06-28 21:06:36 +04:00
WordsRange range(startPos, endPos);
Phrase subphrase(input.GetSubString(WordsRange(startPos, endPos)));
const NonTerminalSet &labels = input.GetLabelSet(startPos, endPos);
2013-07-09 17:28:03 +04:00
InputPath *node;
if (range.GetNumWordsCovered() == 1) {
node = new InputPath(subphrase, labels, range, NULL, NULL);
vec.push_back(node);
2013-07-05 02:38:18 +04:00
} else {
2013-07-07 05:14:51 +04:00
const InputPath &prevNode = GetInputPath(startPos, endPos - 1);
node = new InputPath(subphrase, labels, range, &prevNode, NULL);
2013-07-05 02:38:18 +04:00
vec.push_back(node);
}
2013-07-09 17:28:03 +04:00
m_phraseDictionaryQueue.push_back(node);
2013-06-28 21:06:36 +04:00
}
}
}
/* forcibly create translation option for a particular source word.
* For text, this function is easy, just call the base class' ProcessOneUnknownWord()
*/
void TranslationOptionCollectionText::ProcessUnknownWord(size_t sourcePos)
{
const InputPath &inputPath = GetInputPath(sourcePos, sourcePos);
ProcessOneUnknownWord(inputPath,sourcePos);
}
/**
* Check the source sentence for coverage data
*/
bool TranslationOptionCollectionText::HasXmlOptionsOverlappingRange(size_t startPosition, size_t endPosition) const
{
Sentence const& source=dynamic_cast<Sentence const&>(m_source);
return source.XmlOverlap(startPosition,endPosition);
}
/**
* Create xml-based translation options for the specific input span
*/
void TranslationOptionCollectionText::CreateXmlOptionsForRange(size_t startPos, size_t endPos)
{
Sentence const& source=dynamic_cast<Sentence const&>(m_source);
InputPath &inputPath = GetInputPath(startPos,endPos);
vector <TranslationOption*> xmlOptions;
source.GetXmlTranslationOptions(xmlOptions,startPos,endPos);
//get vector of TranslationOptions from Sentence
for(size_t i=0; i<xmlOptions.size(); i++) {
2013-08-09 21:17:18 +04:00
TranslationOption *transOpt = xmlOptions[i];
transOpt->SetInputPath(inputPath);
Add(transOpt);
}
};
2013-07-07 05:14:51 +04:00
InputPath &TranslationOptionCollectionText::GetInputPath(size_t startPos, size_t endPos)
{
size_t offset = endPos - startPos;
2013-08-02 21:24:36 +04:00
CHECK(offset < m_inputPathMatrix[startPos].size());
return *m_inputPathMatrix[startPos][offset];
}
2013-06-28 20:40:22 +04:00
void TranslationOptionCollectionText::CreateTranslationOptions()
{
GetTargetPhraseCollectionBatch();
2013-06-28 20:40:22 +04:00
TranslationOptionCollection::CreateTranslationOptions();
}
/** create translation options that exactly cover a specific input span.
* Called by CreateTranslationOptions() and ProcessUnknownWord()
* \param decodeGraph list of decoding steps
* \param factorCollection input sentence with all factors
* \param startPos first position in input sentence
* \param lastPos last position in input sentence
* \param adhereTableLimit whether phrase & generation table limits are adhered to
*/
void TranslationOptionCollectionText::CreateTranslationOptionsForRange(
const DecodeGraph &decodeGraph
, size_t startPos
, size_t endPos
, bool adhereTableLimit
, size_t graphInd)
{
2013-07-11 12:28:08 +04:00
InputPath &inputPath = GetInputPath(startPos, endPos);
2013-06-28 21:05:49 +04:00
TranslationOptionCollection::CreateTranslationOptionsForRange(decodeGraph
2013-07-11 19:20:15 +04:00
, startPos
, endPos
, adhereTableLimit
, graphInd
, inputPath);
}
}