2008-06-11 14:52:57 +04:00
|
|
|
// $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"
|
2013-06-28 18:43:56 +04:00
|
|
|
#include "DecodeStepTranslation.h"
|
2008-06-11 14:52:57 +04:00
|
|
|
#include "FactorCollection.h"
|
|
|
|
#include "WordsRange.h"
|
2013-06-28 18:43:56 +04:00
|
|
|
#include <list>
|
2008-06-11 14:52:57 +04:00
|
|
|
|
|
|
|
using namespace std;
|
|
|
|
|
2008-10-09 03:51:26 +04:00
|
|
|
namespace Moses
|
|
|
|
{
|
2008-06-11 14:52:57 +04:00
|
|
|
/** constructor; just initialize the base class */
|
2013-06-28 16:21:04 +04:00
|
|
|
TranslationOptionCollectionText::TranslationOptionCollectionText(Sentence const &input, size_t maxNoTransOptPerCoverage, float translationOptionThreshold)
|
|
|
|
: TranslationOptionCollection(input, maxNoTransOptPerCoverage, translationOptionThreshold)
|
|
|
|
{
|
|
|
|
size_t size = input.GetSize();
|
|
|
|
m_targetPhrasesfromPt.resize(size);
|
2013-07-03 22:07:36 +04:00
|
|
|
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-07-09 17:19:35 +04:00
|
|
|
vector<InputPath*> &vec = m_targetPhrasesfromPt[startPos];
|
2013-07-03 22:07:36 +04:00
|
|
|
|
2013-06-28 21:06:36 +04:00
|
|
|
Phrase subphrase(input.GetSubString(WordsRange(startPos, endPos)));
|
|
|
|
WordsRange range(startPos, endPos);
|
2013-06-28 16:21:04 +04:00
|
|
|
|
2013-07-09 17:28:03 +04:00
|
|
|
InputPath *node;
|
2013-07-02 01:30:29 +04:00
|
|
|
if (range.GetNumWordsCovered() == 1) {
|
2013-07-09 17:28:03 +04:00
|
|
|
node = new InputPath(subphrase, range, NULL, NULL);
|
2013-07-02 01:30:29 +04:00
|
|
|
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);
|
2013-07-09 17:28:03 +04:00
|
|
|
node = new InputPath(subphrase, range, &prevNode, NULL);
|
2013-07-05 02:38:18 +04:00
|
|
|
vec.push_back(node);
|
2013-07-02 01:30:29 +04:00
|
|
|
}
|
2013-06-28 16:21:04 +04:00
|
|
|
|
2013-07-09 17:28:03 +04:00
|
|
|
m_phraseDictionaryQueue.push_back(node);
|
2013-06-28 21:06:36 +04:00
|
|
|
}
|
2013-06-28 16:21:04 +04:00
|
|
|
}
|
|
|
|
}
|
2008-06-11 14:52:57 +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)
|
|
|
|
{
|
2011-02-24 16:14:42 +03:00
|
|
|
const Word &sourceWord = m_source.GetWord(sourcePos);
|
|
|
|
ProcessOneUnknownWord(sourceWord,sourcePos);
|
2008-06-11 14:52:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check the source sentence for coverage data
|
|
|
|
*/
|
2011-02-24 16:14:42 +03:00
|
|
|
bool TranslationOptionCollectionText::HasXmlOptionsOverlappingRange(size_t startPosition, size_t endPosition) const
|
|
|
|
{
|
|
|
|
Sentence const& source=dynamic_cast<Sentence const&>(m_source);
|
|
|
|
return source.XmlOverlap(startPosition,endPosition);
|
2008-06-11 14:52:57 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create xml-based translation options for the specific input span
|
|
|
|
*/
|
2011-02-24 16:14:42 +03:00
|
|
|
void TranslationOptionCollectionText::CreateXmlOptionsForRange(size_t startPosition, size_t endPosition)
|
|
|
|
{
|
|
|
|
Sentence const& source=dynamic_cast<Sentence const&>(m_source);
|
|
|
|
|
|
|
|
vector <TranslationOption*> xmlOptions;
|
|
|
|
|
|
|
|
source.GetXmlTranslationOptions(xmlOptions,startPosition,endPosition);
|
|
|
|
|
|
|
|
//get vector of TranslationOptions from Sentence
|
|
|
|
for(size_t i=0; i<xmlOptions.size(); i++) {
|
|
|
|
Add(xmlOptions[i]);
|
|
|
|
}
|
2008-06-11 14:52:57 +04:00
|
|
|
|
|
|
|
};
|
|
|
|
|
2013-07-07 05:14:51 +04:00
|
|
|
InputPath &TranslationOptionCollectionText::GetInputPath(size_t startPos, size_t endPos)
|
2013-06-28 16:21:04 +04:00
|
|
|
{
|
|
|
|
size_t offset = endPos - startPos;
|
|
|
|
CHECK(offset < m_targetPhrasesfromPt[startPos].size());
|
2013-07-04 12:24:13 +04:00
|
|
|
return *m_targetPhrasesfromPt[startPos][offset];
|
2013-06-28 16:21:04 +04:00
|
|
|
}
|
|
|
|
|
2013-06-28 20:40:22 +04:00
|
|
|
void TranslationOptionCollectionText::CreateTranslationOptions()
|
|
|
|
{
|
2013-07-11 23:18:06 +04:00
|
|
|
GetTargetPhraseCollectionBatch();
|
2013-06-28 20:40:22 +04:00
|
|
|
TranslationOptionCollection::CreateTranslationOptions();
|
|
|
|
}
|
|
|
|
|
2013-06-28 18:43:56 +04:00
|
|
|
/** 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
|
|
|
|
2013-07-11 13:26:24 +04:00
|
|
|
TranslationOptionCollection::CreateTranslationOptionsForRange(decodeGraph
|
2013-07-11 19:20:15 +04:00
|
|
|
, startPos
|
|
|
|
, endPos
|
|
|
|
, adhereTableLimit
|
|
|
|
, graphInd
|
|
|
|
, inputPath);
|
2013-06-28 18:43:56 +04:00
|
|
|
}
|
|
|
|
|
2013-06-28 16:21:04 +04:00
|
|
|
|
2008-10-09 03:51:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-06-11 14:52:57 +04:00
|
|
|
|