00001 #include "LRModel.h"
00002 #include "moses/Range.h"
00003 #include "moses/Bitmap.h"
00004 #include "moses/InputType.h"
00005 #include "HReorderingForwardState.h"
00006 #include "HReorderingBackwardState.h"
00007 #include "PhraseBasedReorderingState.h"
00008 #include "BidirectionalReorderingState.h"
00009 #include "SparseReordering.h"
00010
00011 namespace Moses
00012 {
00013
00014 bool
00015 IsMonotonicStep(Range const& prev,
00016 Range const& cur,
00017 Bitmap const& cov)
00018 {
00019 size_t e = prev.GetEndPos() + 1;
00020 size_t s = cur.GetStartPos();
00021 return (s == e || (s >= e && !cov.GetValue(e)));
00022 }
00023
00024 bool
00025 IsSwap(Range const& prev, Range const& cur, Bitmap const& cov)
00026 {
00027 size_t s = prev.GetStartPos();
00028 size_t e = cur.GetEndPos();
00029 return (e+1 == s || (e < s && !cov.GetValue(s-1)));
00030 }
00031
00032 size_t
00033 LRModel::
00034 GetNumberOfTypes() const
00035 {
00036 return ((m_modelType == MSD) ? 3 :
00037 (m_modelType == MSLR) ? 4 : 2);
00038 }
00039
00040 size_t
00041 LRModel::
00042 GetNumScoreComponents() const
00043 {
00044 size_t score_per_dir = m_collapseScores ? 1 : GetNumberOfTypes();
00045 return ((m_direction == Bidirectional)
00046 ? 2 * score_per_dir + m_additionalScoreComponents
00047 : score_per_dir + m_additionalScoreComponents);
00048 }
00049
00050 void
00051 LRModel::
00052 ConfigureSparse(const std::map<std::string,std::string>& sparseArgs,
00053 const LexicalReordering* producer)
00054 {
00055 if (sparseArgs.size()) {
00056 m_sparse.reset(new SparseReordering(sparseArgs, producer));
00057 }
00058 }
00059
00060 void
00061 LRModel::
00062 SetAdditionalScoreComponents(size_t number)
00063 {
00064 m_additionalScoreComponents = number;
00065 }
00066
00068 LRModel::ReorderingType
00069 LRModel::
00070 GetOrientation(Range const& cur) const
00071 {
00072 UTIL_THROW_IF2(m_modelType == None, "Reordering Model Type is None");
00073 return ((m_modelType == LeftRight) ? R :
00074 (cur.GetStartPos() == 0) ? M :
00075 (m_modelType == MSD) ? D :
00076 (m_modelType == MSLR) ? DR : NM);
00077 }
00078
00079 LRModel::ReorderingType
00080 LRModel::
00081 GetOrientation(Range const& prev, Range const& cur) const
00082 {
00083 UTIL_THROW_IF2(m_modelType == None, "No reordering model type specified");
00084 return ((m_modelType == LeftRight)
00085 ? prev.GetEndPos() <= cur.GetStartPos() ? R : L
00086 : (cur.GetStartPos() == prev.GetEndPos() + 1) ? M
00087 : (m_modelType == Monotonic) ? NM
00088 : (prev.GetStartPos() == cur.GetEndPos() + 1) ? S
00089 : (m_modelType == MSD) ? D
00090 : (cur.GetStartPos() > prev.GetEndPos()) ? DR : DL);
00091 }
00092
00093 LRModel::ReorderingType
00094 LRModel::
00095 GetOrientation(int const reoDistance) const
00096 {
00097
00098 return ((m_modelType == LeftRight)
00099 ? (reoDistance >= 1) ? R : L
00100 : (reoDistance == 1) ? M
00101 : (m_modelType == Monotonic) ? NM
00102 : (reoDistance == -1) ? S
00103 : (m_modelType == MSD) ? D
00104 : (reoDistance > 1) ? DR : DL);
00105 }
00106
00107 LRModel::ReorderingType
00108 LRModel::
00109 GetOrientation(Range const& prev, Range const& cur,
00110 Bitmap const& cov) const
00111 {
00112 return ((m_modelType == LeftRight)
00113 ? cur.GetStartPos() > prev.GetEndPos() ? R : L
00114 : IsMonotonicStep(prev,cur,cov) ? M
00115 : (m_modelType == Monotonic) ? NM
00116 : IsSwap(prev,cur,cov) ? S
00117 : (m_modelType == MSD) ? D
00118 : cur.GetStartPos() > prev.GetEndPos() ? DR : DL);
00119 }
00120
00121 LRModel::
00122 LRModel(const std::string &modelType)
00123 : m_modelString(modelType)
00124 , m_scoreProducer(NULL)
00125 , m_modelType(None)
00126 , m_phraseBased(true)
00127 , m_collapseScores(false)
00128 , m_direction(Backward)
00129 , m_additionalScoreComponents(0)
00130 {
00131 std::vector<std::string> config = Tokenize<std::string>(modelType, "-");
00132
00133 for (size_t i=0; i<config.size(); ++i) {
00134 if (config[i] == "hier") {
00135 m_phraseBased = false;
00136 } else if (config[i] == "phrase") {
00137 m_phraseBased = true;
00138 } else if (config[i] == "wbe") {
00139 m_phraseBased = true;
00140 }
00141
00142
00143
00144 else if (config[i] == "msd") {
00145 m_modelType = MSD;
00146 } else if (config[i] == "mslr") {
00147 m_modelType = MSLR;
00148 } else if (config[i] == "monotonicity") {
00149 m_modelType = Monotonic;
00150 } else if (config[i] == "leftright") {
00151 m_modelType = LeftRight;
00152 }
00153
00154
00155 else if (config[i] == "unidirectional") {
00156 m_direction = Backward;
00157 } else if (config[i] == "backward") {
00158 m_direction = Backward;
00159 } else if (config[i] == "forward") {
00160 m_direction = Forward;
00161 } else if (config[i] == "bidirectional") {
00162 m_direction = Bidirectional;
00163 }
00164
00165 else if (config[i] == "f") {
00166 m_condition = F;
00167 } else if (config[i] == "fe") {
00168 m_condition = FE;
00169 }
00170
00171 else if (config[i] == "collapseff") {
00172 m_collapseScores = true;
00173 } else if (config[i] == "allff") {
00174 m_collapseScores = false;
00175 } else {
00176 std::cerr
00177 << "Illegal part in the lexical reordering configuration string: "
00178 << config[i] << std::endl;
00179 exit(1);
00180 }
00181 }
00182
00183 if (m_modelType == None) {
00184 std::cerr
00185 << "You need to specify the type of the reordering model "
00186 << "(msd, monotonicity,...)" << std::endl;
00187 exit(1);
00188 }
00189 }
00190
00191 LRState *
00192 LRModel::
00193 CreateLRState(const InputType &input) const
00194 {
00195 LRState *bwd = NULL, *fwd = NULL;
00196 size_t offset = 0;
00197
00198 switch(m_direction) {
00199 case Backward:
00200 case Bidirectional:
00201 if (m_phraseBased)
00202 bwd = new PhraseBasedReorderingState(*this, Backward, offset);
00203 else
00204 bwd = new HReorderingBackwardState(*this, offset);
00205 offset += m_collapseScores ? 1 : GetNumberOfTypes();
00206 if (m_direction == Backward) return bwd;
00207 case Forward:
00208 if (m_phraseBased)
00209 fwd = new PhraseBasedReorderingState(*this, Forward, offset);
00210 else
00211 fwd = new HReorderingForwardState(*this, input.GetSize(), offset);
00212 offset += m_collapseScores ? 1 : GetNumberOfTypes();
00213 if (m_direction == Forward) return fwd;
00214 }
00215 return new BidirectionalReorderingState(*this, bwd, fwd, 0);
00216 }
00217
00218 }
00219