diff options
author | Eva Hasler <ehasler@saxnot.inf.ed.ac.uk> | 2012-03-27 17:24:49 +0400 |
---|---|---|
committer | Eva Hasler <ehasler@saxnot.inf.ed.ac.uk> | 2012-03-27 17:24:49 +0400 |
commit | f5a4d61fd485797e412664f241038fb859457387 (patch) | |
tree | e1dfbbc31d0e198188df4b84c0fa1251492f9ac4 /mira | |
parent | 74b5907ae756a8d7708ef709965e3d2f80d22040 (diff) | |
parent | 5a17ef82b3c7449d9fb3686875a7936193e14a89 (diff) |
resolving conflicts
Diffstat (limited to 'mira')
-rw-r--r-- | mira/Decoder.cpp | 2 | ||||
-rw-r--r-- | mira/Decoder.h | 2 | ||||
-rw-r--r-- | mira/HildrethTest.cpp | 784 | ||||
-rw-r--r-- | mira/Jamfile | 12 | ||||
-rw-r--r-- | mira/Main.cpp | 2 | ||||
-rw-r--r-- | mira/MiraTest.cpp | 24 |
6 files changed, 824 insertions, 2 deletions
diff --git a/mira/Decoder.cpp b/mira/Decoder.cpp index 7e5e8c6c9..0a2555078 100644 --- a/mira/Decoder.cpp +++ b/mira/Decoder.cpp @@ -94,7 +94,7 @@ namespace Mira { { StaticData &staticData = StaticData::InstanceNonConst(); - m_sentence = new Sentence(Input); + m_sentence = new Sentence(); stringstream in(source + "\n"); const std::vector<FactorType> &inputFactorOrder = staticData.GetInputFactorOrder(); m_sentence->Read(in,inputFactorOrder); diff --git a/mira/Decoder.h b/mira/Decoder.h index 17a898a42..8d377b461 100644 --- a/mira/Decoder.h +++ b/mira/Decoder.h @@ -66,6 +66,8 @@ class MosesDecoder { void updateHistory(const std::vector< std::vector< const Moses::Word*> >& words, std::vector<size_t>& sourceLengths, std::vector<size_t>& ref_ids, size_t rank, size_t epoch); // void loadReferenceSentences(const std::vector<std::vector<std::string> >& refs); void printBleuFeatureHistory(std::ostream& out); + void printReferenceLength(const std::vector<size_t>& ref_ids); + size_t getReferenceLength(size_t ref_id); // void printReferenceLength(const std::vector<size_t>& ref_ids); size_t getClosestReferenceLength(size_t ref_id, int hypoLength); void setBleuParameters(bool sentenceBleu, bool scaleByInputLength, bool scaleByAvgInputLength, diff --git a/mira/HildrethTest.cpp b/mira/HildrethTest.cpp new file mode 100644 index 000000000..a32dcd1d3 --- /dev/null +++ b/mira/HildrethTest.cpp @@ -0,0 +1,784 @@ +/*********************************************************************** +Moses - factored phrase-based language decoder +Copyright (C) 2010 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 +***********************************************************************/ + +#include <cstdio> +#include <cstdlib> +#include <string> + +#include <boost/test/unit_test.hpp> + +#include "Hildreth.h" +#include "Optimiser.h" +#include "ScoreComponentCollection.h" + +using namespace std; +using namespace Moses; +using namespace Mira; + +namespace MosesTest +{ + +class MockSingleFeature : public StatelessFeatureFunction { + public: + MockSingleFeature(): StatelessFeatureFunction("MockSingle",1) {} + std::string GetScoreProducerWeightShortName(unsigned) const {return "sf";} +}; + +class MockMultiFeature : public StatelessFeatureFunction { + public: + MockMultiFeature(): StatelessFeatureFunction("MockMulti",5) {} + std::string GetScoreProducerWeightShortName(unsigned) const {return "mf";} +}; + +class MockSparseFeature : public StatelessFeatureFunction { + public: + MockSparseFeature(): StatelessFeatureFunction("MockSparse", ScoreProducer::unlimited) {} + std::string GetScoreProducerWeightShortName(unsigned) const {return "sf";} +}; + +struct MockProducers { + MockProducers() {} + + MockSingleFeature single; + MockMultiFeature multi; + MockSparseFeature sparse; +}; + + + +BOOST_AUTO_TEST_SUITE(hildreth_test) + +BOOST_FIXTURE_TEST_CASE(test_hildreth_1, MockProducers) +{ + // Feasible example with 2 constraints + cerr << "\n>>>>>Hildreth test, without slack and with 0.01 slack" << endl << endl; + vector< ScoreComponentCollection> featureValueDiffs; + vector< float> lossMinusModelScoreDiff; + + // initial weights + float w[] = { 1, 1, 1, 1, 0 }; + vector<float> vec(w,w+5); + ScoreComponentCollection weights; + weights.PlusEquals(&multi, vec); + + // feature values (second is oracle) + //float arr1[] = {0, -5, -27.0908, -1.83258, 0 }; + //float arr2[] = {0, -5, -29.158, -1.83258, 0 }; + //float arr3[] = {0, -5, -27.0908, -1.83258, 0 }; + + // feature value differences (to oracle) + ScoreComponentCollection s1, s2, s3; + float arr1[] = { 0, 0, -2.0672, 0, 0 }; + float arr2[] = { 0, 0, 0, 0, 0 }; + float arr3[] = { 0, 0, -2.0672, 0, 0 }; + + float loss1 = 2.34085; + float loss2 = 0; + float loss3 = 2.34085; + + vector<float> vec1(arr1,arr1+5); + vector<float> vec2(arr2,arr2+5); + vector<float> vec3(arr3,arr3+5); + + s1.PlusEquals(&multi,vec1); + s2.PlusEquals(&multi,vec2); + s3.PlusEquals(&multi,vec3); + + featureValueDiffs.push_back(s1); + featureValueDiffs.push_back(s2); + featureValueDiffs.push_back(s3); + + cerr << "feature value diff: " << featureValueDiffs[0] << endl; + cerr << "feature value diff: " << featureValueDiffs[1] << endl; + cerr << "feature value diff: " << featureValueDiffs[2] << endl << endl; + + float oldModelScoreDiff1 = featureValueDiffs[0].InnerProduct(weights); + float oldModelScoreDiff2 = featureValueDiffs[1].InnerProduct(weights); + float oldModelScoreDiff3 = featureValueDiffs[2].InnerProduct(weights); + + cerr << "model score diff: " << oldModelScoreDiff1 << ", loss: " << loss1 << endl; + cerr << "model score diff: " << oldModelScoreDiff2 << ", loss: " << loss2 << endl; + cerr << "model score diff: " << oldModelScoreDiff3 << ", loss: " << loss3 << endl << endl; + + lossMinusModelScoreDiff.push_back(loss1 - oldModelScoreDiff1); + lossMinusModelScoreDiff.push_back(loss2 - oldModelScoreDiff2); + lossMinusModelScoreDiff.push_back(loss3 - oldModelScoreDiff3); + + vector< float> alphas1 = Hildreth::optimise(featureValueDiffs, lossMinusModelScoreDiff); + vector< float> alphas2 = Hildreth::optimise(featureValueDiffs, lossMinusModelScoreDiff, 0.01); + + cerr << "\nalphas without slack:" << endl; + for (size_t i = 0; i < alphas1.size(); ++i) { + cerr << "alpha " << i << ": " << alphas1[i] << endl; + } + cerr << endl; + + cerr << "partial updates:" << endl; + vector< ScoreComponentCollection> featureValueDiffs1(featureValueDiffs); + FVector totalUpdate1 = ScoreComponentCollection::CreateFVector(); + for (size_t k = 0; k < featureValueDiffs1.size(); ++k) { + featureValueDiffs1[k].MultiplyEquals(alphas1[k]); + cerr << k << ": " << featureValueDiffs1[k].GetScoresVector() << endl; + FVector update = featureValueDiffs1[k].GetScoresVector(); + totalUpdate1 += update; + } + cerr << endl; + cerr << "total update: " << totalUpdate1 << endl << endl; + + ScoreComponentCollection weightsUpdate1(weights); + weightsUpdate1.PlusEquals(totalUpdate1); + cerr << "new weights: " << weightsUpdate1 << endl << endl; + + float newModelScoreDiff1 = featureValueDiffs[0].InnerProduct(weightsUpdate1); + float newModelScoreDiff2 = featureValueDiffs[1].InnerProduct(weightsUpdate1); + float newModelScoreDiff3 = featureValueDiffs[2].InnerProduct(weightsUpdate1); + + cerr << "new model score diff: " << newModelScoreDiff1 << ", loss: " << loss1 << endl; + cerr << "new model score diff: " << newModelScoreDiff2 << ", loss: " << loss2 << endl; + cerr << "new model score diff: " << newModelScoreDiff3 << ", loss: " << loss3 << endl; + + cerr << "\n\nalphas with slack 0.01:" << endl; + for (size_t i = 0; i < alphas2.size(); ++i) { + cerr << "alpha " << i << ": " << alphas2[i] << endl; + } + cerr << endl; + + cerr << "partial updates:" << endl; + vector< ScoreComponentCollection> featureValueDiffs2(featureValueDiffs); + FVector totalUpdate2 = ScoreComponentCollection::CreateFVector(); + for (size_t k = 0; k < featureValueDiffs2.size(); ++k) { + featureValueDiffs2[k].MultiplyEquals(alphas2[k]); + cerr << k << ": " << featureValueDiffs2[k].GetScoresVector() << endl; + FVector update = featureValueDiffs2[k].GetScoresVector(); + totalUpdate2 += update; + } + cerr << endl; + cerr << "total update: " << totalUpdate2 << endl << endl; + + ScoreComponentCollection weightsUpdate2(weights); + weightsUpdate2.PlusEquals(totalUpdate2); + cerr << "new weights: " << weightsUpdate2 << endl << endl; + + float newModelScoreDiff4 = featureValueDiffs[0].InnerProduct(weightsUpdate2); + float newModelScoreDiff5 = featureValueDiffs[1].InnerProduct(weightsUpdate2); + float newModelScoreDiff6 = featureValueDiffs[2].InnerProduct(weightsUpdate2); + + cerr << "new model score diff: " << newModelScoreDiff4 << ", loss: " << loss1 << endl; + cerr << "new model score diff: " << newModelScoreDiff5 << ", loss: " << loss2 << endl; + cerr << "new model score diff: " << newModelScoreDiff6 << ", loss: " << loss3 << endl; +} + + +BOOST_FIXTURE_TEST_CASE(test_hildreth_3, MockProducers) +{ + // Unfeasible example with 21 constraints + cerr << "\n>>>>>Hildreth test, without slack and with 0.01 slack" << endl << endl; + vector< ScoreComponentCollection> featureValueDiffs; + vector< float> lossMinusModelScoreDiff; + + // initial weights + float w[] = { 1, 1, 0.638672, 1, 0 }; + vector<float> vec(w,w+5); + ScoreComponentCollection weights; + weights.PlusEquals(&multi, vec); + + int numberOfConstraints = 21; + + // feature value differences (to oracle) + // NOTE: these feature values are only approximations + ScoreComponentCollection s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21; + float arr1[] = { 0, 0, -2.0672, 0, 0 }; + float arr2[] = { 0, 0, 0, 0, 0 }; + float arr3[] = { 0, 0, -2.08436, 1.38629, 0 }; + float arr4[] = { 0, 0, -0.0171661, 1.38629, 0 }; + float arr5[] = { 0, 0, 4.4283, 0, 0 }; + float arr6[] = { 0, 0, 3.84829, 1.38629, 0 }; + float arr7[] = { 0, 0, 6.83689, 0, 0 }; + float arr8[] = { 0, 0, 0, 0, 0 }; + float arr9[] = { 0, 0, -2.0672, 0, 0 }; + float arr10[] = { 0, 0, -0.0171661, 1.38629, 0 }; + float arr11[] = { 0, 0, -2.08436, 1.38629, 0 }; + float arr12[] = { 0, 0, 4.4283, 0, 0 }; + float arr13[] = { 3, 0, 2.41089, 0, 0 }; + float arr14[] = { 3, 0, 2.32709, 0, 0 }; + float arr15[] = { 0, 0, -2.0672, 0, 0 }; + float arr16[] = { 0, 0, -2.08436, 1.38629, 0 }; + float arr17[] = { 0, 0, 4.4283, 0, 0 }; + float arr18[] = { 0, 0, 3.84829, 1.38629, 0 }; + float arr19[] = { 0, 0, -0.0171661, 1.38629, 0 }; + float arr20[] = { 0, 0, 0, 0, 0 }; + float arr21[] = { 0, 0, 6.83689, 0, 0 }; + + vector<float> losses; + losses.push_back(2.73485); + losses.push_back(0); + losses.push_back(3.64118); + losses.push_back(1.47347); + losses.push_back(3.64118); + losses.push_back(4.16278); + losses.push_back(3.13952); + losses.push_back(0); + losses.push_back(2.73485); + losses.push_back(1.47347); + losses.push_back(3.64118); + losses.push_back(3.64118); + losses.push_back(2.51662); + losses.push_back(2.73485); + losses.push_back(2.73485); + losses.push_back(3.64118); + losses.push_back(3.64118); + losses.push_back(4.16278); + losses.push_back(1.47347); + losses.push_back(0); + losses.push_back(3.13952); + + vector<float> vec1(arr1,arr1+5); + vector<float> vec2(arr2,arr2+5); + vector<float> vec3(arr3,arr3+5); + vector<float> vec4(arr4,arr4+5); + vector<float> vec5(arr5,arr5+5); + vector<float> vec6(arr6,arr6+5); + vector<float> vec7(arr7,arr7+5); + vector<float> vec8(arr8,arr8+5); + vector<float> vec9(arr9,arr9+5); + vector<float> vec10(arr10,arr10+5); + vector<float> vec11(arr11,arr11+5); + vector<float> vec12(arr12,arr12+5); + vector<float> vec13(arr13,arr13+5); + vector<float> vec14(arr14,arr14+5); + vector<float> vec15(arr15,arr15+5); + vector<float> vec16(arr16,arr16+5); + vector<float> vec17(arr17,arr17+5); + vector<float> vec18(arr18,arr18+5); + vector<float> vec19(arr19,arr19+5); + vector<float> vec20(arr20,arr20+5); + vector<float> vec21(arr21,arr21+5); + + s1.PlusEquals(&multi,vec1); + s2.PlusEquals(&multi,vec2); + s3.PlusEquals(&multi,vec3); + s4.PlusEquals(&multi,vec4); + s5.PlusEquals(&multi,vec5); + s6.PlusEquals(&multi,vec6); + s7.PlusEquals(&multi,vec7); + s8.PlusEquals(&multi,vec8); + s9.PlusEquals(&multi,vec9); + s10.PlusEquals(&multi,vec10); + s11.PlusEquals(&multi,vec11); + s12.PlusEquals(&multi,vec12); + s13.PlusEquals(&multi,vec13); + s14.PlusEquals(&multi,vec14); + s15.PlusEquals(&multi,vec15); + s16.PlusEquals(&multi,vec16); + s17.PlusEquals(&multi,vec17); + s18.PlusEquals(&multi,vec18); + s19.PlusEquals(&multi,vec19); + s20.PlusEquals(&multi,vec20); + s21.PlusEquals(&multi,vec21); + + featureValueDiffs.push_back(s1); + featureValueDiffs.push_back(s2); + featureValueDiffs.push_back(s3); + featureValueDiffs.push_back(s4); + featureValueDiffs.push_back(s5); + featureValueDiffs.push_back(s6); + featureValueDiffs.push_back(s7); + featureValueDiffs.push_back(s8); + featureValueDiffs.push_back(s9); + featureValueDiffs.push_back(s10); + featureValueDiffs.push_back(s11); + featureValueDiffs.push_back(s12); + featureValueDiffs.push_back(s13); + featureValueDiffs.push_back(s14); + featureValueDiffs.push_back(s15); + featureValueDiffs.push_back(s16); + featureValueDiffs.push_back(s17); + featureValueDiffs.push_back(s18); + featureValueDiffs.push_back(s19); + featureValueDiffs.push_back(s20); + featureValueDiffs.push_back(s21); + + vector<float> oldModelScoreDiff; + for (int i = 0; i < numberOfConstraints; ++i) { + oldModelScoreDiff.push_back(featureValueDiffs[i].InnerProduct(weights)); + } + + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "old model score diff: " << oldModelScoreDiff[i] << ", loss: " << losses[i] << "\t" << (oldModelScoreDiff[i] >= losses[i] ? 1 : 0) << endl; + } + + for (int i = 0; i < numberOfConstraints; ++i) { + lossMinusModelScoreDiff.push_back(losses[i] - oldModelScoreDiff[i]); + } + + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "A: " << featureValueDiffs[i] << ", b: " << lossMinusModelScoreDiff[i] << endl; + } + + vector< float> alphas1 = Hildreth::optimise(featureValueDiffs, lossMinusModelScoreDiff); + vector< float> alphas2 = Hildreth::optimise(featureValueDiffs, lossMinusModelScoreDiff, 0.01); + + cerr << "\nalphas without slack:" << endl; + for (size_t i = 0; i < alphas1.size(); ++i) { + cerr << "alpha " << i << ": " << alphas1[i] << endl; + } + cerr << endl; + + cerr << "partial updates:" << endl; + vector< ScoreComponentCollection> featureValueDiffs1(featureValueDiffs); + FVector totalUpdate1 = ScoreComponentCollection::CreateFVector(); + for (size_t k = 0; k < featureValueDiffs1.size(); ++k) { + featureValueDiffs1[k].MultiplyEquals(alphas1[k]); + cerr << k << ": " << featureValueDiffs1[k].GetScoresVector() << endl; + FVector update = featureValueDiffs1[k].GetScoresVector(); + totalUpdate1 += update; + } + cerr << endl; + cerr << "total update: " << totalUpdate1 << endl << endl; + + ScoreComponentCollection weightsUpdate1(weights); + weightsUpdate1.PlusEquals(totalUpdate1); + cerr << "old weights: " << weights << endl; + cerr << "new weights: " << weightsUpdate1 << endl << endl; + + vector<float> newModelScoreDiff; + for (int i = 0; i < numberOfConstraints; ++i) { + newModelScoreDiff.push_back(featureValueDiffs[i].InnerProduct(weightsUpdate1)); + } + + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "new model score diff: " << newModelScoreDiff[i] << ", loss: " << losses[i] << "\t" << (newModelScoreDiff[i] >= losses[i] ? 1 : 0) << endl; + } + + cerr << "\n\nalphas with slack 0.01:" << endl; + for (size_t i = 0; i < alphas2.size(); ++i) { + cerr << "alpha " << i << ": " << alphas2[i] << endl; + } + cerr << endl; + + cerr << "partial updates:" << endl; + vector< ScoreComponentCollection> featureValueDiffs2(featureValueDiffs); + FVector totalUpdate2 = ScoreComponentCollection::CreateFVector(); + for (size_t k = 0; k < featureValueDiffs2.size(); ++k) { + featureValueDiffs2[k].MultiplyEquals(alphas2[k]); + cerr << k << ": " << featureValueDiffs2[k].GetScoresVector() << endl; + FVector update = featureValueDiffs2[k].GetScoresVector(); + totalUpdate2 += update; + } + cerr << endl; + cerr << "total update: " << totalUpdate2 << endl << endl; + + ScoreComponentCollection weightsUpdate2(weights); + weightsUpdate2.PlusEquals(totalUpdate2); + cerr << "old weights: " << weights << endl; + cerr << "new weights: " << weightsUpdate2 << endl << endl; + + newModelScoreDiff.clear(); + for (int i = 0; i < numberOfConstraints; ++i) { + newModelScoreDiff.push_back(featureValueDiffs[i].InnerProduct(weightsUpdate2)); + } + + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "new model score diff: " << newModelScoreDiff[i] << ", loss: " << losses[i] << endl; + } +} + +BOOST_FIXTURE_TEST_CASE(test_hildreth_4, MockProducers) +{ + // Feasible example with 8 constraints + cerr << "\n>>>>>Hildreth test, without slack and with 0.01 slack" << endl << endl; + vector< ScoreComponentCollection> featureValueDiffs; + vector< float> lossMinusModelScoreDiff; + + // initial weights + float w[] = { 1, 1, 0.638672, 1, 0 }; + vector<float> vec(w,w+5); + ScoreComponentCollection weights; + weights.PlusEquals(&multi, vec); + + int numberOfConstraints = 8; + + // feature value differences (to oracle) + // NOTE: these feature values are only approximations + ScoreComponentCollection s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20, s21; + float arr1[] = { 0, 0, -2.0672, 0, 0 }; + float arr2[] = { 0, 0, 0, 0, 0 }; + float arr3[] = { 0, 0, -2.08436, 1.38629, 0 }; + float arr4[] = { 0, 0, -0.0171661, 1.38629, 0 }; +// float arr5[] = { 0, 0, 4.4283, 0, 0 }; +// float arr6[] = { 0, 0, 3.84829, 1.38629, 0 }; +// float arr7[] = { 0, 0, 6.83689, 0, 0 }; + + float arr8[] = { 0, 0, 0, 0, 0 }; + float arr9[] = { 0, 0, -2.0672, 0, 0 }; +// float arr10[] = { 0, 0, -0.0171661, 1.38629, 0 }; +// float arr11[] = { 0, 0, -2.08436, 1.38629, 0 }; +// float arr12[] = { 0, 0, 4.4283, 0, 0 }; +// float arr13[] = { 3, 0, 2.41089, 0, 0 }; +// float arr14[] = { 3, 0, 2.32709, 0, 0 }; + + float arr15[] = { 0, 0, -2.0672, 0, 0 }; + float arr16[] = { 0, 0, -2.08436, 1.38629, 0 }; +// float arr17[] = { 0, 0, 4.4283, 0, 0 }; +// float arr18[] = { 0, 0, 3.84829, 1.38629, 0 }; +// float arr19[] = { 0, 0, -0.0171661, 1.38629, 0 }; +// float arr20[] = { 0, 0, 0, 0, 0 }; +// float arr21[] = { 0, 0, 6.83689, 0, 0 }; + + vector<float> losses; + losses.push_back(2.73485); + losses.push_back(0); + losses.push_back(3.64118); + losses.push_back(1.47347); +// losses.push_back(3.64118); +// losses.push_back(4.16278); +// losses.push_back(3.13952); + losses.push_back(0); + losses.push_back(2.73485); +// losses.push_back(1.47347); +// losses.push_back(3.64118); +// losses.push_back(3.64118); +// losses.push_back(2.51662); +// losses.push_back(2.73485); + losses.push_back(2.73485); + losses.push_back(3.64118); +// losses.push_back(3.64118); +// losses.push_back(4.16278); +// losses.push_back(1.47347); +// losses.push_back(0); +// losses.push_back(3.13952); + + vector<float> vec1(arr1,arr1+5); + vector<float> vec2(arr2,arr2+5); + vector<float> vec3(arr3,arr3+5); + vector<float> vec4(arr4,arr4+5); +// vector<float> vec5(arr5,arr5+5); +// vector<float> vec6(arr6,arr6+5); +// vector<float> vec7(arr7,arr7+5); + vector<float> vec8(arr8,arr8+5); + vector<float> vec9(arr9,arr9+5); +// vector<float> vec10(arr10,arr10+5); +// vector<float> vec11(arr11,arr11+5); +// vector<float> vec12(arr12,arr12+5); +// vector<float> vec13(arr13,arr13+5); +// vector<float> vec14(arr14,arr14+5); + vector<float> vec15(arr15,arr15+5); + vector<float> vec16(arr16,arr16+5); +// vector<float> vec17(arr17,arr17+5); +// vector<float> vec18(arr18,arr18+5); +// vector<float> vec19(arr19,arr19+5); +// vector<float> vec20(arr20,arr20+5); +// vector<float> vec21(arr21,arr21+5); + + s1.PlusEquals(&multi,vec1); + s2.PlusEquals(&multi,vec2); + s3.PlusEquals(&multi,vec3); + s4.PlusEquals(&multi,vec4); +// s5.PlusEquals(&multi,vec5); +// s6.PlusEquals(&multi,vec6); +// s7.PlusEquals(&multi,vec7); + s8.PlusEquals(&multi,vec8); + s9.PlusEquals(&multi,vec9); +// s10.PlusEquals(&multi,vec10); +// s11.PlusEquals(&multi,vec11); +// s12.PlusEquals(&multi,vec12); +// s13.PlusEquals(&multi,vec13); +// s14.PlusEquals(&multi,vec14); + s15.PlusEquals(&multi,vec15); + s16.PlusEquals(&multi,vec16); +// s17.PlusEquals(&multi,vec17); +// s18.PlusEquals(&multi,vec18); +// s19.PlusEquals(&multi,vec19); +// s20.PlusEquals(&multi,vec20); +// s21.PlusEquals(&multi,vec21); + + featureValueDiffs.push_back(s1); + featureValueDiffs.push_back(s2); + featureValueDiffs.push_back(s3); + featureValueDiffs.push_back(s4); +// featureValueDiffs.push_back(s5); +// featureValueDiffs.push_back(s6); +// featureValueDiffs.push_back(s7); + featureValueDiffs.push_back(s8); + featureValueDiffs.push_back(s9); +// featureValueDiffs.push_back(s10); +// featureValueDiffs.push_back(s11); +// featureValueDiffs.push_back(s12); +// featureValueDiffs.push_back(s13); +// featureValueDiffs.push_back(s14); + featureValueDiffs.push_back(s15); + featureValueDiffs.push_back(s16); +// featureValueDiffs.push_back(s17); +// featureValueDiffs.push_back(s18); +// featureValueDiffs.push_back(s19); +// featureValueDiffs.push_back(s20); +// featureValueDiffs.push_back(s21); + + vector<float> oldModelScoreDiff; + for (int i = 0; i < numberOfConstraints; ++i) { + oldModelScoreDiff.push_back(featureValueDiffs[i].InnerProduct(weights)); + } + + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "old model score diff: " << oldModelScoreDiff[i] << ", loss: " << losses[i] << "\t" << (oldModelScoreDiff[i] >= losses[i] ? 1 : 0) << endl; + } + + for (int i = 0; i < numberOfConstraints; ++i) { + lossMinusModelScoreDiff.push_back(losses[i] - oldModelScoreDiff[i]); + } + + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "A: " << featureValueDiffs[i] << ", b: " << lossMinusModelScoreDiff[i] << endl; + } + + vector< float> alphas1 = Hildreth::optimise(featureValueDiffs, lossMinusModelScoreDiff); + vector< float> alphas2 = Hildreth::optimise(featureValueDiffs, lossMinusModelScoreDiff, 0.01); + + cerr << "\nalphas without slack:" << endl; + for (size_t i = 0; i < alphas1.size(); ++i) { + cerr << "alpha " << i << ": " << alphas1[i] << endl; + } + cerr << endl; + + cerr << "partial updates:" << endl; + vector< ScoreComponentCollection> featureValueDiffs1(featureValueDiffs); + FVector totalUpdate1 = ScoreComponentCollection::CreateFVector(); + for (size_t k = 0; k < featureValueDiffs1.size(); ++k) { + featureValueDiffs1[k].MultiplyEquals(alphas1[k]); + cerr << k << ": " << featureValueDiffs1[k].GetScoresVector() << endl; + FVector update = featureValueDiffs1[k].GetScoresVector(); + totalUpdate1 += update; + } + cerr << endl; + cerr << "total update: " << totalUpdate1 << endl << endl; + + ScoreComponentCollection weightsUpdate1(weights); + weightsUpdate1.PlusEquals(totalUpdate1); + cerr << "old weights: " << weights << endl; + cerr << "new weights: " << weightsUpdate1 << endl << endl; + + vector<float> newModelScoreDiff; + for (int i = 0; i < numberOfConstraints; ++i) { + newModelScoreDiff.push_back(featureValueDiffs[i].InnerProduct(weightsUpdate1)); + } + + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "new model score diff: " << newModelScoreDiff[i] << ", loss: " << losses[i] << "\t" << (newModelScoreDiff[i] >= losses[i] ? 1 : 0) << endl; + } + + cerr << "\n\nalphas with slack 0.01:" << endl; + for (size_t i = 0; i < alphas2.size(); ++i) { + cerr << "alpha " << i << ": " << alphas2[i] << endl; + } + cerr << endl; + + cerr << "partial updates:" << endl; + vector< ScoreComponentCollection> featureValueDiffs2(featureValueDiffs); + FVector totalUpdate2 = ScoreComponentCollection::CreateFVector(); + for (size_t k = 0; k < featureValueDiffs2.size(); ++k) { + featureValueDiffs2[k].MultiplyEquals(alphas2[k]); + cerr << k << ": " << featureValueDiffs2[k].GetScoresVector() << endl; + FVector update = featureValueDiffs2[k].GetScoresVector(); + totalUpdate2 += update; + } + cerr << endl; + cerr << "total update: " << totalUpdate2 << endl << endl; + + ScoreComponentCollection weightsUpdate2(weights); + weightsUpdate2.PlusEquals(totalUpdate2); + cerr << "old weights: " << weights << endl; + cerr << "new weights: " << weightsUpdate2 << endl << endl; + + newModelScoreDiff.clear(); + for (int i = 0; i < numberOfConstraints; ++i) { + newModelScoreDiff.push_back(featureValueDiffs[i].InnerProduct(weightsUpdate2)); + } + + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "new model score diff: " << newModelScoreDiff[i] << ", loss: " << losses[i] << endl; + } +} + +BOOST_FIXTURE_TEST_CASE(test_hildreth_5, MockProducers) +{ + // Unfeasible example with 2 constraints + cerr << "\n>>>>>Hildreth test, without slack and with 0.01 slack" << endl << endl; + vector< ScoreComponentCollection> featureValueDiffs; + vector< float> lossMinusModelScoreDiff; + + // initial weights + float w[] = { 1, 1, 0.638672, 1, 0 }; + vector<float> vec(w,w+5); + ScoreComponentCollection weights; + weights.PlusEquals(&multi, vec); + + int numberOfConstraints = 2; + + // feature value differences (to oracle) + // NOTE: these feature values are only approximations + ScoreComponentCollection s1, s17; + float arr1[] = { 0, 0, -2.0672, 0, 0 }; + float arr17[] = { 0, 0, 4.4283, 0, 0 }; + vector<float> losses; + losses.push_back(2.73485); + losses.push_back(3.64118); + + vector<float> vec1(arr1,arr1+5); + vector<float> vec17(arr17,arr17+5); + + s1.PlusEquals(&multi,vec1); + s17.PlusEquals(&multi,vec17); + + featureValueDiffs.push_back(s1); + featureValueDiffs.push_back(s17); + + vector<float> oldModelScoreDiff; + for (int i = 0; i < numberOfConstraints; ++i) { + oldModelScoreDiff.push_back(featureValueDiffs[i].InnerProduct(weights)); + } + + float sumOfOldError = 0; + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "old model score diff: " << oldModelScoreDiff[i] << ", loss: " << losses[i] << "\t" << (oldModelScoreDiff[i] >= losses[i] ? 1 : 0) << endl; + sumOfOldError += (losses[i] - oldModelScoreDiff[i]); + } + cerr << "sum of old error: " << sumOfOldError << endl; + + for (int i = 0; i < numberOfConstraints; ++i) { + lossMinusModelScoreDiff.push_back(losses[i] - oldModelScoreDiff[i]); + } + + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "A: " << featureValueDiffs[i] << ", b: " << lossMinusModelScoreDiff[i] << endl; + } + + vector< float> alphas1 = Hildreth::optimise(featureValueDiffs, lossMinusModelScoreDiff); + vector< float> alphas2 = Hildreth::optimise(featureValueDiffs, lossMinusModelScoreDiff, 0.01); + vector< float> alphas3 = Hildreth::optimise(featureValueDiffs, lossMinusModelScoreDiff, 0.1); + + cerr << "\nalphas without slack:" << endl; + for (size_t i = 0; i < alphas1.size(); ++i) { + cerr << "alpha " << i << ": " << alphas1[i] << endl; + } + cerr << endl; + + cerr << "partial updates:" << endl; + vector< ScoreComponentCollection> featureValueDiffs1(featureValueDiffs); + FVector totalUpdate1 = ScoreComponentCollection::CreateFVector(); + for (size_t k = 0; k < featureValueDiffs1.size(); ++k) { + featureValueDiffs1[k].MultiplyEquals(alphas1[k]); + cerr << k << ": " << featureValueDiffs1[k].GetScoresVector() << endl; + FVector update = featureValueDiffs1[k].GetScoresVector(); + totalUpdate1 += update; + } + cerr << endl; + cerr << "total update: " << totalUpdate1 << endl << endl; + + ScoreComponentCollection weightsUpdate1(weights); + weightsUpdate1.PlusEquals(totalUpdate1); + cerr << "old weights: " << weights << endl; + cerr << "new weights: " << weightsUpdate1 << endl << endl; + + vector<float> newModelScoreDiff; + for (int i = 0; i < numberOfConstraints; ++i) { + newModelScoreDiff.push_back(featureValueDiffs[i].InnerProduct(weightsUpdate1)); + } + + float sumOfNewError = 0; + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "new model score diff: " << newModelScoreDiff[i] << ", loss: " << losses[i] << "\t" << (newModelScoreDiff[i] >= losses[i] ? 1 : 0) << endl; + sumOfNewError += (losses[i] - newModelScoreDiff[i]); + } + cerr << "sum of new error: " << sumOfNewError << endl; + + cerr << "\n\nalphas with slack 0.01:" << endl; + for (size_t i = 0; i < alphas2.size(); ++i) { + cerr << "alpha " << i << ": " << alphas2[i] << endl; + } + cerr << endl; + + cerr << "partial updates:" << endl; + vector< ScoreComponentCollection> featureValueDiffs2(featureValueDiffs); + FVector totalUpdate2 = ScoreComponentCollection::CreateFVector(); + for (size_t k = 0; k < featureValueDiffs2.size(); ++k) { + featureValueDiffs2[k].MultiplyEquals(alphas2[k]); + cerr << k << ": " << featureValueDiffs2[k].GetScoresVector() << endl; + FVector update = featureValueDiffs2[k].GetScoresVector(); + totalUpdate2 += update; + } + cerr << endl; + cerr << "total update: " << totalUpdate2 << endl << endl; + + ScoreComponentCollection weightsUpdate2(weights); + weightsUpdate2.PlusEquals(totalUpdate2); + cerr << "old weights: " << weights << endl; + cerr << "new weights: " << weightsUpdate2 << endl << endl; + + newModelScoreDiff.clear(); + for (int i = 0; i < numberOfConstraints; ++i) { + newModelScoreDiff.push_back(featureValueDiffs[i].InnerProduct(weightsUpdate2)); + } + + sumOfNewError = 0; + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "new model score diff: " << newModelScoreDiff[i] << ", loss: " << losses[i] << "\t" << (newModelScoreDiff[i] >= losses[i] ? 1 : 0) << endl; + sumOfNewError += (losses[i] - newModelScoreDiff[i]); + } + cerr << "sum of new error: " << sumOfNewError << endl; + + cerr << "\n\nalphas with slack 0.1:" << endl; + for (size_t i = 0; i < alphas3.size(); ++i) { + cerr << "alpha " << i << ": " << alphas3[i] << endl; + } + cerr << endl; + + cerr << "partial updates:" << endl; + vector< ScoreComponentCollection> featureValueDiffs3(featureValueDiffs); + FVector totalUpdate3 = ScoreComponentCollection::CreateFVector(); + for (size_t k = 0; k < featureValueDiffs3.size(); ++k) { + featureValueDiffs3[k].MultiplyEquals(alphas3[k]); + cerr << k << ": " << featureValueDiffs3[k].GetScoresVector() << endl; + FVector update = featureValueDiffs3[k].GetScoresVector(); + totalUpdate3 += update; + } + cerr << endl; + cerr << "total update: " << totalUpdate3 << endl << endl; + + ScoreComponentCollection weightsUpdate3(weights); + weightsUpdate3.PlusEquals(totalUpdate3); + cerr << "old weights: " << weights << endl; + cerr << "new weights: " << weightsUpdate3 << endl << endl; + + newModelScoreDiff.clear(); + for (int i = 0; i < numberOfConstraints; ++i) { + newModelScoreDiff.push_back(featureValueDiffs[i].InnerProduct(weightsUpdate3)); + } + + sumOfNewError = 0; + for (int i = 0; i < numberOfConstraints; ++i) { + cerr << "new model score diff: " << newModelScoreDiff[i] << ", loss: " << losses[i] << "\t" << (newModelScoreDiff[i] >= losses[i] ? 1 : 0) << endl; + sumOfNewError += (losses[i] - newModelScoreDiff[i]); + } + cerr << "sum of new error: " << sumOfNewError << endl; +} + +BOOST_AUTO_TEST_SUITE_END() + +} + diff --git a/mira/Jamfile b/mira/Jamfile new file mode 100644 index 000000000..feef3bd83 --- /dev/null +++ b/mira/Jamfile @@ -0,0 +1,12 @@ +lib mira_lib : +[ glob *.cpp : *Test.cpp Main.cpp ] + ../moses/src//moses ../OnDiskPt//OnDiskPt ..//boost_program_options ; + +exe mira : Main.cpp mira_lib ; + +alias programs : mira ; + +import testing ; + +unit-test mira_test : [ glob *Test.cpp ] mira_lib ..//boost_unit_test_framework ; + diff --git a/mira/Main.cpp b/mira/Main.cpp index c70f1d6c3..9558869b7 100644 --- a/mira/Main.cpp +++ b/mira/Main.cpp @@ -606,7 +606,7 @@ int main(int argc, char** argv) { // number of weight dumps this epoch size_t weightMixingThisEpoch = 0; size_t weightEpochDump = 0; - + size_t shardPosition = 0; vector<size_t>::const_iterator sid = shard.begin(); while (sid != shard.end()) { diff --git a/mira/MiraTest.cpp b/mira/MiraTest.cpp new file mode 100644 index 000000000..774b324f8 --- /dev/null +++ b/mira/MiraTest.cpp @@ -0,0 +1,24 @@ +/*********************************************************************** +Moses - factored phrase-based language decoder +Copyright (C) 2010 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 +***********************************************************************/ + + +//Supplies the main for the mira test module +#define BOOST_TEST_MODULE mira +#include <boost/test/unit_test.hpp> + |