mosesdecoder/phrase-extract/ExtractionPhrasePair.h
Matthias Huck 3a5dee12e8 implementation of phrase orientation in GHKM extraction
(...but a corresponding feature function for the chart-based decoder has not been written yet)
2014-07-28 18:27:12 +01:00

176 lines
6.2 KiB
C++

/***********************************************************************
Moses - factored phrase-based language decoder
Copyright (C) 2009 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
***********************************************************************/
#pragma once
#include "tables-core.h"
#include <vector>
#include <set>
#include <map>
#include <boost/unordered_map.hpp>
namespace MosesTraining {
typedef std::vector< std::set<size_t> > ALIGNMENT;
class ExtractionPhrasePair {
protected:
typedef std::map<std::string,float> PROPERTY_VALUES;
typedef std::map<std::string,float>::iterator LAST_PROPERTY_VALUE;
bool m_isValid;
const PHRASE *m_phraseSource;
const PHRASE *m_phraseTarget;
float m_count;
float m_pcfgSum;
std::map<ALIGNMENT*,float> m_targetToSourceAlignments;
std::map<std::string,
std::pair< PROPERTY_VALUES*, LAST_PROPERTY_VALUE* > > m_properties;
float m_lastCount;
float m_lastPcfgSum;
std::map<ALIGNMENT*,float>::iterator m_lastTargetToSourceAlignment;
public:
ExtractionPhrasePair( const PHRASE *phraseSource,
const PHRASE *phraseTarget,
ALIGNMENT *targetToSourceAlignment,
float count, float pcfgSum );
~ExtractionPhrasePair();
bool Add( ALIGNMENT *targetToSourceAlignment,
float count, float pcfgSum );
void IncrementPrevious( float count, float pcfgSum );
bool Matches( const PHRASE *otherPhraseSource,
const PHRASE *otherPhraseTarget,
ALIGNMENT *otherTargetToSourceAlignment ) const;
bool Matches( const PHRASE *otherPhraseSource,
const PHRASE *otherPhraseTarget,
ALIGNMENT *otherTargetToSourceAlignment,
bool &sourceMatch,
bool &targetMatch,
bool &alignmentMatch ) const;
bool MatchesAlignment( ALIGNMENT *otherTargetToSourceAlignment ) const;
void Clear();
bool IsValid() const {
return m_isValid;
}
const PHRASE *GetSource() const {
return m_phraseSource;
}
const PHRASE *GetTarget() const {
return m_phraseTarget;
}
float GetCount() const {
return m_count;
}
float GetPcfgScore() const {
return m_pcfgSum;
}
const size_t GetNumberOfProperties() const {
return m_properties.size();
}
const std::map<std::string,float> *GetProperty( const std::string &key ) const {
std::map<std::string, std::pair< PROPERTY_VALUES*, LAST_PROPERTY_VALUE* > >::const_iterator iter;
iter = m_properties.find(key);
if (iter == m_properties.end()) {
return NULL;
} else {
return iter->second.first;
}
}
const ALIGNMENT *FindBestAlignmentTargetToSource() const;
const std::string *FindBestPropertyValue(const std::string &key) const;
std::string CollectAllPropertyValues(const std::string &key) const;
std::string CollectAllLabelsSeparateLHSAndRHS(const std::string& propertyKey,
std::set<std::string>& sourceLabelSet,
boost::unordered_map<std::string,float>& sourceLHSCounts,
boost::unordered_map<std::string, boost::unordered_map<std::string,float>* >& sourceRHSAndLHSJointCounts,
Vocabulary &vcbT) const;
void CollectAllPhraseOrientations(const std::string &key,
const std::vector<float> &orientationClassPriorsL2R,
const std::vector<float> &orientationClassPriorsR2L,
double smoothingFactor,
std::ostream &out) const;
void AddProperties( const std::string &str, float count );
void AddProperty( const std::string &key, const std::string &value, float count )
{
std::map<std::string,
std::pair< PROPERTY_VALUES*, LAST_PROPERTY_VALUE* > >::iterator iter = m_properties.find(key);
if ( iter == m_properties.end() ) {
// key not found: insert property key and value
PROPERTY_VALUES *propertyValues = new PROPERTY_VALUES();
std::pair<LAST_PROPERTY_VALUE,bool> insertedProperty = propertyValues->insert( std::pair<std::string,float>(value,count) );
LAST_PROPERTY_VALUE *lastPropertyValue = new LAST_PROPERTY_VALUE(insertedProperty.first);
m_properties[key] = std::pair< PROPERTY_VALUES*, LAST_PROPERTY_VALUE* >(propertyValues, lastPropertyValue);
} else {
LAST_PROPERTY_VALUE *lastPropertyValue = (iter->second).second;
if ( (*lastPropertyValue)->first == value ) { // same property key-value pair has been seen right before
// property key-value pair exists already: add count
(*lastPropertyValue)->second += count;
} else { // need to check whether the property key-value pair has appeared before (insert if not)
// property key exists, but not in combination with this value:
// add new value with count
PROPERTY_VALUES *propertyValues = (iter->second).first;
std::pair<LAST_PROPERTY_VALUE,bool> insertedProperty = propertyValues->insert( std::pair<std::string,float>(value,count) );
if ( !insertedProperty.second ) { // property value for this key appeared before: add count
insertedProperty.first->second += count;
}
LAST_PROPERTY_VALUE *lastPropertyValue = new LAST_PROPERTY_VALUE(insertedProperty.first);
delete (iter->second).second;
(iter->second).second = lastPropertyValue;
}
}
}
};
}