2010-07-18 03:23:09 +04:00
|
|
|
// $Id$
|
2010-04-12 14:15:49 +04:00
|
|
|
// vim:tabstop=2
|
|
|
|
/***********************************************************************
|
|
|
|
Moses - factored phrase-based language decoder
|
|
|
|
Copyright (C) 2010 Hieu Hoang
|
2011-02-24 15:36:50 +03:00
|
|
|
|
2010-04-12 14:15:49 +04:00
|
|
|
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.
|
2011-02-24 15:36:50 +03:00
|
|
|
|
2010-04-12 14:15:49 +04:00
|
|
|
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.
|
2011-02-24 15:36:50 +03:00
|
|
|
|
2010-04-12 14:15:49 +04:00
|
|
|
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
|
|
|
|
***********************************************************************/
|
2010-04-08 21:16:10 +04:00
|
|
|
|
|
|
|
#include <algorithm>
|
|
|
|
#include "ChartCell.h"
|
|
|
|
#include "ChartTranslationOptionCollection.h"
|
|
|
|
#include "ChartCellCollection.h"
|
2011-03-11 19:28:36 +03:00
|
|
|
#include "RuleCubeQueue.h"
|
|
|
|
#include "RuleCube.h"
|
2011-03-11 16:08:43 +03:00
|
|
|
#include "WordsRange.h"
|
|
|
|
#include "Util.h"
|
|
|
|
#include "StaticData.h"
|
|
|
|
#include "ChartTranslationOption.h"
|
|
|
|
#include "ChartTranslationOptionList.h"
|
2010-04-08 21:16:10 +04:00
|
|
|
|
|
|
|
using namespace std;
|
|
|
|
|
|
|
|
namespace Moses
|
|
|
|
{
|
2011-02-24 15:36:50 +03:00
|
|
|
extern bool g_debug;
|
2010-04-08 21:16:10 +04:00
|
|
|
|
2011-03-11 16:08:43 +03:00
|
|
|
ChartCell::ChartCell(size_t startPos, size_t endPos, ChartManager &manager)
|
2011-02-24 15:36:50 +03:00
|
|
|
:m_coverage(startPos, endPos)
|
|
|
|
,m_manager(manager)
|
2010-04-08 21:16:10 +04:00
|
|
|
{
|
2011-02-24 15:36:50 +03:00
|
|
|
const StaticData &staticData = StaticData::Instance();
|
|
|
|
m_nBestIsEnabled = staticData.IsNBestEnabled();
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
2011-03-11 16:08:43 +03:00
|
|
|
/** Get all hypotheses in the cell that have the specified constituent label */
|
2011-03-11 19:28:36 +03:00
|
|
|
const HypoList &ChartCell::GetSortedHypotheses(const Word &constituentLabel) const
|
2010-04-08 21:16:10 +04:00
|
|
|
{
|
2011-03-11 19:28:36 +03:00
|
|
|
std::map<Word, ChartHypothesisCollection>::const_iterator
|
2011-03-11 16:08:43 +03:00
|
|
|
iter = m_hypoColl.find(constituentLabel);
|
2011-02-24 15:36:50 +03:00
|
|
|
assert(iter != m_hypoColl.end());
|
|
|
|
return iter->second.GetSortedHypotheses();
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
2011-03-11 16:08:43 +03:00
|
|
|
/** Add the given hypothesis to the cell */
|
|
|
|
bool ChartCell::AddHypothesis(ChartHypothesis *hypo)
|
2010-04-08 21:16:10 +04:00
|
|
|
{
|
2011-02-24 15:36:50 +03:00
|
|
|
const Word &targetLHS = hypo->GetTargetLHS();
|
|
|
|
return m_hypoColl[targetLHS].AddHypothesis(hypo, m_manager);
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
2011-03-11 16:08:43 +03:00
|
|
|
/** Pruning */
|
2010-04-08 21:16:10 +04:00
|
|
|
void ChartCell::PruneToSize()
|
|
|
|
{
|
2011-03-11 19:28:36 +03:00
|
|
|
std::map<Word, ChartHypothesisCollection>::iterator iter;
|
2011-02-24 15:36:50 +03:00
|
|
|
for (iter = m_hypoColl.begin(); iter != m_hypoColl.end(); ++iter) {
|
2011-03-11 16:08:43 +03:00
|
|
|
ChartHypothesisCollection &coll = iter->second;
|
2011-02-24 15:36:50 +03:00
|
|
|
coll.PruneToSize(m_manager);
|
|
|
|
}
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
2011-03-11 16:08:43 +03:00
|
|
|
/** Decoding at span level: fill chart cell with hypotheses
|
|
|
|
* (implementation of cube pruning)
|
|
|
|
* \param transOptList list of applicable rules to create hypotheses for the cell
|
|
|
|
* \param allChartCells entire chart - needed to look up underlying hypotheses
|
|
|
|
*/
|
2010-09-23 21:39:32 +04:00
|
|
|
void ChartCell::ProcessSentence(const ChartTranslationOptionList &transOptList
|
2011-02-24 15:36:50 +03:00
|
|
|
, const ChartCellCollection &allChartCells)
|
2010-04-08 21:16:10 +04:00
|
|
|
{
|
2011-02-24 15:36:50 +03:00
|
|
|
const StaticData &staticData = StaticData::Instance();
|
|
|
|
|
2011-03-09 20:55:27 +03:00
|
|
|
// priority queue for applicable rules with selected hypotheses
|
2011-06-27 19:13:15 +04:00
|
|
|
RuleCubeQueue queue(m_manager);
|
2011-02-24 15:36:50 +03:00
|
|
|
|
|
|
|
// add all trans opt into queue. using only 1st child node.
|
|
|
|
ChartTranslationOptionList::const_iterator iterList;
|
2011-03-09 20:55:27 +03:00
|
|
|
for (iterList = transOptList.begin(); iterList != transOptList.end(); ++iterList)
|
|
|
|
{
|
2011-02-24 15:36:50 +03:00
|
|
|
const ChartTranslationOption &transOpt = **iterList;
|
2011-06-27 19:13:15 +04:00
|
|
|
RuleCube *ruleCube = new RuleCube(transOpt, allChartCells, m_manager);
|
2011-03-11 19:28:36 +03:00
|
|
|
queue.Add(ruleCube);
|
2011-02-24 15:36:50 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// pluck things out of queue and add to hypo collection
|
|
|
|
const size_t popLimit = staticData.GetCubePruningPopLimit();
|
2011-03-11 19:28:36 +03:00
|
|
|
for (size_t numPops = 0; numPops < popLimit && !queue.IsEmpty(); ++numPops)
|
2011-03-09 20:55:27 +03:00
|
|
|
{
|
2011-06-27 19:13:15 +04:00
|
|
|
ChartHypothesis *hypo = queue.Pop();
|
2011-02-24 15:36:50 +03:00
|
|
|
AddHypothesis(hypo);
|
|
|
|
}
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void ChartCell::SortHypotheses()
|
|
|
|
{
|
2011-02-24 15:36:50 +03:00
|
|
|
// sort each mini cells & fill up target lhs list
|
2011-03-11 16:08:43 +03:00
|
|
|
assert(m_constituentLabelSet.empty());
|
2011-03-11 19:28:36 +03:00
|
|
|
std::map<Word, ChartHypothesisCollection>::iterator iter;
|
2011-02-24 15:36:50 +03:00
|
|
|
for (iter = m_hypoColl.begin(); iter != m_hypoColl.end(); ++iter) {
|
2011-03-11 16:08:43 +03:00
|
|
|
m_constituentLabelSet.insert(iter->first);
|
2011-02-24 15:36:50 +03:00
|
|
|
|
2011-03-11 16:08:43 +03:00
|
|
|
ChartHypothesisCollection &coll = iter->second;
|
2011-02-24 15:36:50 +03:00
|
|
|
coll.SortHypotheses();
|
|
|
|
}
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
2011-03-11 16:08:43 +03:00
|
|
|
/** Return the highest scoring hypothesis in the cell */
|
|
|
|
const ChartHypothesis *ChartCell::GetBestHypothesis() const
|
2010-04-08 21:16:10 +04:00
|
|
|
{
|
2011-03-11 16:08:43 +03:00
|
|
|
const ChartHypothesis *ret = NULL;
|
2011-02-24 15:36:50 +03:00
|
|
|
float bestScore = -std::numeric_limits<float>::infinity();
|
|
|
|
|
2011-03-11 19:28:36 +03:00
|
|
|
std::map<Word, ChartHypothesisCollection>::const_iterator iter;
|
2011-02-24 15:36:50 +03:00
|
|
|
for (iter = m_hypoColl.begin(); iter != m_hypoColl.end(); ++iter) {
|
|
|
|
const HypoList &sortedList = iter->second.GetSortedHypotheses();
|
|
|
|
assert(sortedList.size() > 0);
|
|
|
|
|
2011-03-11 16:08:43 +03:00
|
|
|
const ChartHypothesis *hypo = sortedList[0];
|
2011-02-24 15:36:50 +03:00
|
|
|
if (hypo->GetTotalScore() > bestScore) {
|
|
|
|
bestScore = hypo->GetTotalScore();
|
|
|
|
ret = hypo;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
2011-03-11 16:08:43 +03:00
|
|
|
/** Is there a hypothesis in the cell that has the specified constituent label? */
|
2011-03-11 19:28:36 +03:00
|
|
|
bool ChartCell::ConstituentLabelExists(const Word &constituentLabel) const
|
2010-04-08 21:16:10 +04:00
|
|
|
{
|
2011-03-11 19:28:36 +03:00
|
|
|
std::map<Word, ChartHypothesisCollection>::const_iterator iter;
|
2011-03-11 16:08:43 +03:00
|
|
|
iter = m_hypoColl.find(constituentLabel);
|
2011-02-24 15:36:50 +03:00
|
|
|
return (iter != m_hypoColl.end());
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void ChartCell::CleanupArcList()
|
|
|
|
{
|
2011-02-24 15:36:50 +03:00
|
|
|
// only necessary if n-best calculations are enabled
|
|
|
|
if (!m_nBestIsEnabled) return;
|
|
|
|
|
2011-03-11 19:28:36 +03:00
|
|
|
std::map<Word, ChartHypothesisCollection>::iterator iter;
|
2011-02-24 15:36:50 +03:00
|
|
|
for (iter = m_hypoColl.begin(); iter != m_hypoColl.end(); ++iter) {
|
2011-03-11 16:08:43 +03:00
|
|
|
ChartHypothesisCollection &coll = iter->second;
|
2011-02-24 15:36:50 +03:00
|
|
|
coll.CleanupArcList();
|
|
|
|
}
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void ChartCell::OutputSizes(std::ostream &out) const
|
|
|
|
{
|
2011-03-11 19:28:36 +03:00
|
|
|
std::map<Word, ChartHypothesisCollection>::const_iterator iter;
|
2011-02-24 15:36:50 +03:00
|
|
|
for (iter = m_hypoColl.begin(); iter != m_hypoColl.end(); ++iter) {
|
2011-03-11 19:28:36 +03:00
|
|
|
const Word &targetLHS = iter->first;
|
2011-03-11 16:08:43 +03:00
|
|
|
const ChartHypothesisCollection &coll = iter->second;
|
2011-02-24 15:36:50 +03:00
|
|
|
|
|
|
|
out << targetLHS << "=" << coll.GetSize() << " ";
|
|
|
|
}
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t ChartCell::GetSize() const
|
|
|
|
{
|
2011-02-24 15:36:50 +03:00
|
|
|
size_t ret = 0;
|
2011-03-11 19:28:36 +03:00
|
|
|
std::map<Word, ChartHypothesisCollection>::const_iterator iter;
|
2011-02-24 15:36:50 +03:00
|
|
|
for (iter = m_hypoColl.begin(); iter != m_hypoColl.end(); ++iter) {
|
2011-03-11 16:08:43 +03:00
|
|
|
const ChartHypothesisCollection &coll = iter->second;
|
2011-02-24 15:36:50 +03:00
|
|
|
|
|
|
|
ret += coll.GetSize();
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
2011-06-27 04:38:43 +04:00
|
|
|
void ChartCell::GetSearchGraph(long translationId, std::ostream &outputSearchGraphStream, const std::map<int,bool> &reachable) const
|
2010-04-08 21:16:10 +04:00
|
|
|
{
|
2011-03-11 19:28:36 +03:00
|
|
|
std::map<Word, ChartHypothesisCollection>::const_iterator iterOutside;
|
2011-02-24 15:36:50 +03:00
|
|
|
for (iterOutside = m_hypoColl.begin(); iterOutside != m_hypoColl.end(); ++iterOutside) {
|
2011-03-11 16:08:43 +03:00
|
|
|
const ChartHypothesisCollection &coll = iterOutside->second;
|
2011-06-27 04:38:43 +04:00
|
|
|
coll.GetSearchGraph(translationId, outputSearchGraphStream, reachable);
|
2011-02-24 15:36:50 +03:00
|
|
|
}
|
|
|
|
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
std::ostream& operator<<(std::ostream &out, const ChartCell &cell)
|
|
|
|
{
|
2011-03-11 19:28:36 +03:00
|
|
|
std::map<Word, ChartHypothesisCollection>::const_iterator iterOutside;
|
2011-02-24 15:36:50 +03:00
|
|
|
for (iterOutside = cell.m_hypoColl.begin(); iterOutside != cell.m_hypoColl.end(); ++iterOutside) {
|
2011-03-11 19:28:36 +03:00
|
|
|
const Word &targetLHS = iterOutside->first;
|
2011-02-24 15:36:50 +03:00
|
|
|
cerr << targetLHS << ":" << endl;
|
|
|
|
|
2011-03-11 16:08:43 +03:00
|
|
|
const ChartHypothesisCollection &coll = iterOutside->second;
|
2011-02-24 15:36:50 +03:00
|
|
|
cerr << coll;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
ChartCell::HCType::const_iterator iter;
|
|
|
|
for (iter = cell.m_hypos.begin(); iter != cell.m_hypos.end(); ++iter)
|
|
|
|
{
|
2011-03-11 16:08:43 +03:00
|
|
|
const ChartHypothesis &hypo = **iter;
|
2011-02-24 15:36:50 +03:00
|
|
|
out << hypo << endl;
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
return out;
|
2010-04-08 21:16:10 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|