00001 // #include "mmsapt.h" 00002 // currently broken 00003 00004 // namespace Moses 00005 // { 00006 // using namespace sapt; 00007 // using namespace std; 00008 // using namespace boost; 00009 00010 // struct PPgreater 00011 // { 00012 // bool operator()(PhrasePair const& a, PhrasePair const& b) 00013 // { 00014 // return a.score > b.score; 00015 // } 00016 // }; 00017 00018 // void 00019 // Mmsapt:: 00020 // setWeights(vector<float> const & w) 00021 // { 00022 // assert(w.size() == this->m_numScoreComponents); 00023 // this->feature_weights = w; 00024 // } 00025 00026 // struct PhraseAlnHyp 00027 // { 00028 // PhrasePair pp; 00029 // ushort s1,e1,s2,e2; // start and end positions 00030 // int prev; // preceding alignment hypothesis 00031 // float score; 00032 // bitvector scov; // source coverage 00033 // PhraseAlnHyp(PhrasePair const& ppx, int slen, 00034 // pair<uint32_t,uint32_t> const& sspan, 00035 // pair<uint32_t,uint32_t> const& tspan) 00036 // : pp(ppx), prev(-1), score(ppx.score), scov(slen) 00037 // { 00038 // s1 = sspan.first; e1 = sspan.second; 00039 // s2 = tspan.first; e2 = tspan.second; 00040 // for (size_t i = s1; i < e1; ++i) 00041 // scov.set(i); 00042 // } 00043 00044 // bool operator<(PhraseAlnHyp const& other) const 00045 // { 00046 // return this->score < other.score; 00047 // } 00048 00049 // bool operator>(PhraseAlnHyp const& other) const 00050 // { 00051 // return this->score > other.score; 00052 // } 00053 00054 // PhraseOrientation 00055 // po_bwd(PhraseAlnHyp const* prev) const 00056 // { 00057 // if (s2 == 0) return po_first; 00058 // assert(prev); 00059 // assert(prev->e2 <= s2); 00060 // if (prev->e2 < s2) return po_other; 00061 // if (prev->e1 == s1) return po_mono; 00062 // if (prev->e1 < s1) return po_jfwd; 00063 // if (prev->s1 == e1) return po_swap; 00064 // if (prev->s1 > e1) return po_jbwd; 00065 // return po_other; 00066 // } 00067 00068 // PhraseOrientation 00069 // po_fwd(PhraseAlnHyp const* next) const 00070 // { 00071 // if (!next) return po_last; 00072 // assert(next->s2 >= e2); 00073 // if (next->s2 < e2) return po_other; 00074 // if (next->e1 == s1) return po_swap; 00075 // if (next->e1 < s1) return po_jbwd; 00076 // if (next->s1 == e1) return po_mono; 00077 // if (next->s1 > e1) return po_jfwd; 00078 // return po_other; 00079 // } 00080 00081 // float 00082 // dprob_fwd(PhraseAlnHyp const& next) 00083 // { 00084 // return pp.dfwd[po_fwd(&next)]; 00085 // } 00086 00087 // float 00088 // dprob_bwd(PhraseAlnHyp const& prev) 00089 // { 00090 // return pp.dbwd[po_bwd(&prev)]; 00091 // } 00092 00093 // }; 00094 00095 // class Alignment 00096 // { 00097 // typedef L2R_Token<SimpleWordId> Token; 00098 // typedef TSA<Token> tsa; 00099 // typedef pair<uint32_t, uint32_t> span; 00100 // typedef vector<vector<uint64_t> > pidmap_t; // span -> phrase ID 00101 // typedef boost::unordered_map<uint64_t,vector<span> > pid2span_t; 00102 // typedef pstats::trg_map_t jStatsTable; 00103 00104 // Mmsapt const& PT; 00105 // vector<id_type> s,t; 00106 // pidmap_t sspan2pid, tspan2pid; // span -> phrase ID 00107 // pid2span_t spid2span,tpid2span; 00108 // vector<vector<SPTR<pstats> > > spstats; 00109 00110 // vector<PhrasePair> PP; 00111 // // position-independent phrase pair info 00112 // public: 00113 // vector<PhraseAlnHyp> PAH; 00114 // vector<vector<int> > tpos2ahyp; 00115 // // maps from target start positions to PhraseAlnHyps starting at 00116 // // that position 00117 00118 // SPTR<pstats> getPstats(span const& sspan); 00119 // void fill_tspan_maps(); 00120 // void fill_sspan_maps(); 00121 // public: 00122 // Alignment(Mmsapt const& pt, string const& src, string const& trg); 00123 // void show(ostream& out); 00124 // void show(ostream& out, PhraseAlnHyp const& ah); 00125 // }; 00126 00127 // void 00128 // Alignment:: 00129 // show(ostream& out, PhraseAlnHyp const& ah) 00130 // { 00131 // #if 0 00132 // LexicalPhraseScorer2<Token>::table_t const& 00133 // COOCjnt = PT.calc_lex.scorer.COOC; 00134 00135 // out << setw(10) << exp(ah.score) << " " 00136 // << PT.btfix.T2->pid2str(PT.btfix.V2.get(), ah.pp.p2) 00137 // << " <=> " 00138 // << PT.btfix.T1->pid2str(PT.btfix.V1.get(), ah.pp.p1); 00139 // vector<uchar> const& a = ah.pp.aln; 00140 // // BOOST_FOREACH(int x,a) cout << "[" << x << "] "; 00141 // for (size_t u = 0; u+1 < a.size(); u += 2) 00142 // out << " " << int(a[u+1]) << "-" << int(a[u]); 00143 00144 // if (ah.e2-ah.s2 == 1 and ah.e1-ah.s1 == 1) 00145 // out << " " << COOCjnt[s[ah.s1]][t[ah.s2]] 00146 // << "/" << PT.COOCraw[s[ah.s1]][t[ah.s2]] 00147 // << "=" << float(COOCjnt[s[ah.s1]][t[ah.s2]])/PT.COOCraw[s[ah.s1]][t[ah.s2]]; 00148 // out << endl; 00149 // // float const* ofwdj = ah.pp.dfwd; 00150 // // float const* obwdj = ah.pp.dbwd; 00151 // // uint32_t const* ofwdm = spstats[ah.s1][ah.e1-ah.s1-1]->ofwd; 00152 // // uint32_t const* obwdm = spstats[ah.s1][ah.e1-ah.s1-1]->obwd; 00153 // // out << " [first: " << ofwdj[po_first]<<"/"<<ofwdm[po_first] 00154 // // << " last: " << ofwdj[po_last]<<"/"<<ofwdm[po_last] 00155 // // << " mono: " << ofwdj[po_mono]<<"/"<<ofwdm[po_mono] 00156 // // << " jfwd: " << ofwdj[po_jfwd]<<"/"<<ofwdm[po_jfwd] 00157 // // << " swap: " << ofwdj[po_swap]<<"/"<<ofwdm[po_swap] 00158 // // << " jbwd: " << ofwdj[po_jbwd]<<"/"<<ofwdm[po_jbwd] 00159 // // << " other: " << ofwdj[po_other]<<"/"<<ofwdm[po_other] 00160 // // << "]" << endl 00161 // // << " [first: " << obwdj[po_first]<<"/"<<obwdm[po_first] 00162 // // << " last: " << obwdj[po_last]<<"/"<<obwdm[po_last] 00163 // // << " mono: " << obwdj[po_mono]<<"/"<<obwdm[po_mono] 00164 // // << " jfwd: " << obwdj[po_jfwd]<<"/"<<obwdm[po_jfwd] 00165 // // << " swap: " << obwdj[po_swap]<<"/"<<obwdm[po_swap] 00166 // // << " jbwd: " << obwdj[po_jbwd]<<"/"<<obwdm[po_jbwd] 00167 // // << " other: " << obwdj[po_other]<<"/"<<obwdm[po_other] 00168 // // << "]" << endl; 00169 // #endif 00170 // } 00171 00172 // void 00173 // Alignment:: 00174 // show(ostream& out) 00175 // { 00176 // // show what we have so far ... 00177 // for (size_t s2 = 0; s2 < t.size(); ++s2) 00178 // { 00179 // VectorIndexSorter<PhraseAlnHyp> foo(PAH); 00180 // sort(tpos2ahyp[s2].begin(), tpos2ahyp[s2].end(), foo); 00181 // for (size_t h = 0; h < tpos2ahyp[s2].size(); ++h) 00182 // show(out,PAH[tpos2ahyp[s2][h]]); 00183 // } 00184 // } 00185 00186 // SPTR<pstats> 00187 // Alignment:: 00188 // getPstats(span const& sspan) 00189 // { 00190 // size_t k = sspan.second - sspan.first - 1; 00191 // if (k < spstats[sspan.first].size()) 00192 // return spstats[sspan.first][k]; 00193 // else return SPTR<pstats>(); 00194 // } 00195 00196 // void 00197 // Alignment:: 00198 // fill_tspan_maps() 00199 // { 00200 // tspan2pid.assign(t.size(),vector<uint64_t>(t.size(),0)); 00201 // for (size_t i = 0; i < t.size(); ++i) 00202 // { 00203 // tsa::tree_iterator m(PT.btfix.I2.get()); 00204 // for (size_t k = i; k < t.size() && m.extend(t[k]); ++k) 00205 // { 00206 // uint64_t pid = m.getPid(); 00207 // tpid2span[pid].push_back(pair<uint32_t,uint32_t>(i,k+1)); 00208 // tspan2pid[i][k] = pid; 00209 // } 00210 // } 00211 // } 00212 00213 // void 00214 // Alignment:: 00215 // fill_sspan_maps() 00216 // { 00217 // sspan2pid.assign(s.size(),vector<uint64_t>(s.size(),0)); 00218 // spstats.resize(s.size()); 00219 // for (size_t i = 0; i < s.size(); ++i) 00220 // { 00221 // tsa::tree_iterator m(PT.btfix.I1.get()); 00222 // for (size_t k = i; k < s.size() && m.extend(s[k]); ++k) 00223 // { 00224 // uint64_t pid = m.getPid(); 00225 // sspan2pid[i][k] = pid; 00226 // pid2span_t::iterator p = spid2span.find(pid); 00227 // if (p != spid2span.end()) 00228 // { 00229 // int x = p->second[0].first; 00230 // int y = p->second[0].second-1; 00231 // spstats[i].push_back(spstats[x][y-x]); 00232 // } 00233 // else 00234 // { 00235 // spstats[i].push_back(PT.btfix.lookup(m)); 00236 // cout << PT.btfix.T1->pid2str(PT.btfix.V1.get(),pid) << " " 00237 // << spstats[i].back()->good << "/" << spstats[i].back()->sample_cnt 00238 // << endl; 00239 // } 00240 // spid2span[pid].push_back(pair<uint32_t,uint32_t>(i,k+1)); 00241 // } 00242 // } 00243 // } 00244 00245 // Alignment:: 00246 // Alignment(Mmsapt const& pt, string const& src, string const& trg) 00247 // : PT(pt) 00248 // { 00249 // PT.btfix.V1->fillIdSeq(src,s); 00250 // PT.btfix.V2->fillIdSeq(trg,t); 00251 00252 // // LexicalPhraseScorer2<Token>::table_t const& COOC = PT.calc_lex.scorer.COOC; 00253 // // BOOST_FOREACH(id_type i, t) 00254 // // { 00255 // // cout << (*PT.btfix.V2)[i]; 00256 // // if (i < PT.wlex21.size()) 00257 // // { 00258 // // BOOST_FOREACH(id_type k, PT.wlex21[i]) 00259 // // { 00260 // // size_t j = COOC[k][i]; 00261 // // size_t m1 = COOC.m1(k); 00262 // // size_t m2 = COOC.m2(i); 00263 // // if (j*1000 > m1 && j*1000 > m2) 00264 // // cout << " " << (*PT.btfix.V1)[k]; 00265 // // } 00266 // // } 00267 // // cout << endl; 00268 // // } 00269 00270 // fill_tspan_maps(); 00271 // fill_sspan_maps(); 00272 // tpos2ahyp.resize(t.size()); 00273 // // now fill the association score table 00274 // PAH.reserve(1000000); 00275 // typedef pid2span_t::iterator psiter; 00276 // for (psiter L = spid2span.begin(); L != spid2span.end(); ++L) 00277 // { 00278 // if (!L->second.size()) continue; // should never happen anyway 00279 // int i = L->second[0].first; 00280 // int k = L->second[0].second - i -1; 00281 // SPTR<pstats> ps = spstats[i][k]; 00282 // PhrasePair pp; pp.init(L->first,*ps, PT.m_numScoreComponents); 00283 // jStatsTable & J = ps->trg; 00284 // for (jStatsTable::iterator y = J.begin(); y != J.end(); ++y) 00285 // { 00286 // psiter R = tpid2span.find(y->first); 00287 // if (R == tpid2span.end()) continue; 00288 // pp.update(y->first, y->second); 00289 // PT.ScorePPfix(pp); 00290 // pp.eval(PT.feature_weights); 00291 // PP.push_back(pp); 00292 // BOOST_FOREACH(span const& sspan, L->second) 00293 // { 00294 // BOOST_FOREACH(span const& tspan, R->second) 00295 // { 00296 // tpos2ahyp[tspan.first].push_back(PAH.size()); 00297 // PAH.push_back(PhraseAlnHyp(PP.back(),s.size(),sspan,tspan)); 00298 // } 00299 // } 00300 // } 00301 // } 00302 // } 00303 00304 00305 00306 // int 00307 // extend(vector<PhraseAlnHyp> & PAH, int edge, int next) 00308 // { 00309 // if ((PAH[edge].scov & PAH[next].scov).count()) 00310 // return -1; 00311 // int ret = PAH.size(); 00312 // PAH.push_back(PAH[next]); 00313 // PhraseAlnHyp & h = PAH.back(); 00314 // h.prev = edge; 00315 // h.scov |= PAH[edge].scov; 00316 // h.score += log(PAH[edge].dprob_fwd(PAH[next])); 00317 // h.score += log(PAH[next].dprob_bwd(PAH[edge])); 00318 // return ret; 00319 // } 00320 00321 // SPTR<vector<int> > 00322 // Mmsapt:: 00323 // align(string const& src, string const& trg) const 00324 // { 00325 // // For the time being, we consult only the fixed bitext. 00326 // // We might also consider the dynamic bitext. => TO DO. 00327 // Alignment A(*this,src,trg); 00328 // VectorIndexSorter<PhraseAlnHyp> foo(A.PAH); 00329 // vector<size_t> o; foo.GetOrder(o); 00330 // BOOST_FOREACH(int i, o) A.show(cout,A.PAH[i]); 00331 // SPTR<vector<int> > aln; 00332 // return aln; 00333 // } 00334 // } 00335 00336