mirror of
https://github.com/moses-smt/mosesdecoder.git
synced 2024-09-11 11:25:40 +03:00
171 lines
4.6 KiB
C++
171 lines
4.6 KiB
C++
#include <sstream>
|
|
#include <boost/algorithm/string/predicate.hpp>
|
|
#include <boost/foreach.hpp>
|
|
|
|
#include "moses/FF/FFState.h"
|
|
#include "moses/TranslationOptionList.h"
|
|
#include "LexicalReordering.h"
|
|
#include "LRState.h"
|
|
#include "moses/StaticData.h"
|
|
#include "moses/Util.h"
|
|
#include "moses/InputPath.h"
|
|
|
|
using namespace std;
|
|
using namespace boost::algorithm;
|
|
|
|
namespace Moses
|
|
{
|
|
LexicalReordering::
|
|
LexicalReordering(const std::string &line)
|
|
: StatefulFeatureFunction(line,false)
|
|
{
|
|
VERBOSE(1, "Initializing Lexical Reordering Feature.." << std::endl);
|
|
|
|
map<string,string> sparseArgs;
|
|
m_haveDefaultScores = false;
|
|
for (size_t i = 0; i < m_args.size(); ++i) {
|
|
const vector<string> &args = m_args[i];
|
|
|
|
if (args[0] == "type") {
|
|
m_configuration.reset(new LRModel(args[1]));
|
|
m_configuration->SetScoreProducer(this);
|
|
m_modelTypeString = m_configuration->GetModelString();
|
|
} else if (args[0] == "input-factor")
|
|
m_factorsF =Tokenize<FactorType>(args[1]);
|
|
else if (args[0] == "output-factor")
|
|
m_factorsE =Tokenize<FactorType>(args[1]);
|
|
else if (args[0] == "path")
|
|
m_filePath = args[1];
|
|
else if (starts_with(args[0], "sparse-"))
|
|
sparseArgs[args[0].substr(7)] = args[1];
|
|
else if (args[0] == "default-scores") {
|
|
vector<string> tokens = Tokenize(args[1],",");
|
|
for(size_t i=0; i<tokens.size(); i++)
|
|
m_defaultScores.push_back( TransformScore( Scan<float>(tokens[i])));
|
|
m_haveDefaultScores = true;
|
|
} else UTIL_THROW2("Unknown argument " + args[0]);
|
|
}
|
|
|
|
switch(m_configuration->GetCondition()) {
|
|
case LRModel::FE:
|
|
case LRModel::E:
|
|
UTIL_THROW_IF2(m_factorsE.empty(),
|
|
"TL factor mask for lexical reordering is "
|
|
<< "unexpectedly empty");
|
|
|
|
if(m_configuration->GetCondition() == LRModel::E)
|
|
break; // else fall through
|
|
case LRModel::F:
|
|
UTIL_THROW_IF2(m_factorsF.empty(),
|
|
"SL factor mask for lexical reordering is "
|
|
<< "unexpectedly empty");
|
|
break;
|
|
default:
|
|
UTIL_THROW2("Unknown conditioning option!");
|
|
}
|
|
|
|
// sanity check: number of default scores
|
|
size_t numScores
|
|
= m_numScoreComponents
|
|
= m_numTuneableComponents
|
|
= m_configuration->GetNumScoreComponents();
|
|
UTIL_THROW_IF2(m_haveDefaultScores && m_defaultScores.size() != numScores,
|
|
"wrong number of default scores (" << m_defaultScores.size()
|
|
<< ") for lexicalized reordering model (expected "
|
|
<< m_configuration->GetNumScoreComponents() << ")");
|
|
|
|
m_configuration->ConfigureSparse(sparseArgs, this);
|
|
// this->Register();
|
|
}
|
|
|
|
LexicalReordering::
|
|
~LexicalReordering()
|
|
{ }
|
|
|
|
void
|
|
LexicalReordering::
|
|
Load(AllOptions::ptr const& opts)
|
|
{
|
|
m_options = opts;
|
|
typedef LexicalReorderingTable LRTable;
|
|
if (m_filePath.size())
|
|
m_table.reset(LRTable::LoadAvailable(m_filePath, m_factorsF,
|
|
m_factorsE, std::vector<FactorType>()));
|
|
}
|
|
|
|
Scores
|
|
LexicalReordering::
|
|
GetProb(const Phrase& f, const Phrase& e) const
|
|
{
|
|
return m_table->GetScore(f, e, Phrase(ARRAY_SIZE_INCR));
|
|
}
|
|
|
|
FFState*
|
|
LexicalReordering::
|
|
EvaluateWhenApplied(const Hypothesis& hypo,
|
|
const FFState* prev_state,
|
|
ScoreComponentCollection* out) const
|
|
{
|
|
VERBOSE(3,"LexicalReordering::Evaluate(const Hypothesis& hypo,...) START" << std::endl);
|
|
const LRState *prev = static_cast<const LRState *>(prev_state);
|
|
LRState *next_state = prev->Expand(hypo.GetTranslationOption(), hypo.GetInput(), out);
|
|
|
|
VERBOSE(3,"LexicalReordering::Evaluate(const Hypothesis& hypo,...) END" << std::endl);
|
|
|
|
return next_state;
|
|
}
|
|
|
|
FFState const*
|
|
LexicalReordering::EmptyHypothesisState(const InputType &input) const
|
|
{
|
|
return m_configuration->CreateLRState(input);
|
|
}
|
|
|
|
bool
|
|
LexicalReordering::
|
|
IsUseable(const FactorMask &mask) const
|
|
{
|
|
BOOST_FOREACH(FactorType const& f, m_factorsE) {
|
|
if (!mask[f]) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
void
|
|
LexicalReordering::
|
|
SetCache(TranslationOption& to) const
|
|
{
|
|
if (to.GetLexReorderingScores(this)) return;
|
|
// Scores were were set already (e.g., by sampling phrase table)
|
|
|
|
if (m_table) {
|
|
Phrase const& sphrase = to.GetInputPath().GetPhrase();
|
|
Phrase const& tphrase = to.GetTargetPhrase();
|
|
to.CacheLexReorderingScores(*this, this->GetProb(sphrase,tphrase));
|
|
} else { // e.g. OOV with Mmsapt
|
|
// Scores vals(GetNumScoreComponents(), 0);
|
|
// to.CacheLexReorderingScores(*this, vals);
|
|
}
|
|
}
|
|
|
|
LRModel const&
|
|
LexicalReordering
|
|
::GetModel() const
|
|
{
|
|
return *m_configuration;
|
|
}
|
|
|
|
|
|
void
|
|
LexicalReordering::
|
|
SetCache(TranslationOptionList& tol) const
|
|
{
|
|
BOOST_FOREACH(TranslationOption* to, tol)
|
|
this->SetCache(*to);
|
|
}
|
|
|
|
|
|
}
|
|
|