fix, cleaned up headers

7 files changed, 144 insertions, 154 deletions

diff --git a/training/dtrain/dtrain.cc b/training/dtrain/dtrain.cc
index 149f87d4..83e4e440 100644
--- a/training/dtrain/dtrain.cc
+++ b/training/dtrain/dtrain.cc
@@ -1,4 +1,10 @@
 #include "dtrain.h"
+#include "score.h"
+#include "kbestget.h"
+#include "ksampler.h"
+#include "pairsampling.h"
+
+using namespace dtrain;
 
 
 bool
@@ -138,23 +144,23 @@ main(int argc, char** argv)
   string scorer_str = cfg["scorer"].as<string>();
   LocalScorer* scorer;
   if (scorer_str == "bleu") {
-    scorer = dynamic_cast<BleuScorer*>(new BleuScorer);
+    scorer = static_cast<BleuScorer*>(new BleuScorer);
   } else if (scorer_str == "stupid_bleu") {
-    scorer = dynamic_cast<StupidBleuScorer*>(new StupidBleuScorer);
+    scorer = static_cast<StupidBleuScorer*>(new StupidBleuScorer);
   } else if (scorer_str == "fixed_stupid_bleu") {
-    scorer = dynamic_cast<FixedStupidBleuScorer*>(new FixedStupidBleuScorer);
+    scorer = static_cast<FixedStupidBleuScorer*>(new FixedStupidBleuScorer);
   } else if (scorer_str == "smooth_bleu") {
-    scorer = dynamic_cast<SmoothBleuScorer*>(new SmoothBleuScorer);
+    scorer = static_cast<SmoothBleuScorer*>(new SmoothBleuScorer);
   } else if (scorer_str == "sum_bleu") {
-    scorer = dynamic_cast<SumBleuScorer*>(new SumBleuScorer);
+    scorer = static_cast<SumBleuScorer*>(new SumBleuScorer);
   } else if (scorer_str == "sumexp_bleu") {
-    scorer = dynamic_cast<SumExpBleuScorer*>(new SumExpBleuScorer);
+    scorer = static_cast<SumExpBleuScorer*>(new SumExpBleuScorer);
   } else if (scorer_str == "sumwhatever_bleu") {
-    scorer = dynamic_cast<SumWhateverBleuScorer*>(new SumWhateverBleuScorer);
+    scorer = static_cast<SumWhateverBleuScorer*>(new SumWhateverBleuScorer);
   } else if (scorer_str == "approx_bleu") {
-    scorer = dynamic_cast<ApproxBleuScorer*>(new ApproxBleuScorer(N, approx_bleu_d));
+    scorer = static_cast<ApproxBleuScorer*>(new ApproxBleuScorer(N, approx_bleu_d));
   } else if (scorer_str == "lc_bleu") {
-    scorer = dynamic_cast<LinearBleuScorer*>(new LinearBleuScorer(N));
+    scorer = static_cast<LinearBleuScorer*>(new LinearBleuScorer(N));
   } else {
     cerr << "Don't know scoring metric: '" << scorer_str << "', exiting." << endl;
     exit(1);
@@ -166,9 +172,9 @@ main(int argc, char** argv)
   MT19937 rng; // random number generator, only for forest sampling
   HypSampler* observer;
   if (sample_from == "kbest")
-    observer = dynamic_cast<KBestGetter*>(new KBestGetter(k, filter_type));
+    observer = static_cast<KBestGetter*>(new KBestGetter(k, filter_type));
   else
-    observer = dynamic_cast<KSampler*>(new KSampler(k, &rng));
+    observer = static_cast<KSampler*>(new KSampler(k, &rng));
   observer->SetScorer(scorer);
 
   // init weights
diff --git a/training/dtrain/dtrain.h b/training/dtrain/dtrain.h
index eb0b9f17..3981fb39 100644
--- a/training/dtrain/dtrain.h
+++ b/training/dtrain/dtrain.h
@@ -11,16 +11,19 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/program_options.hpp>
 
-#include "ksampler.h"
-#include "pairsampling.h"
-
-#include "filelib.h"
-
+#include "decoder.h"
+#include "ff_register.h"
+#include "sentence_metadata.h"
+#include "verbose.h"
+#include "viterbi.h"
 
 using namespace std;
-using namespace dtrain;
 namespace po = boost::program_options;
 
+namespace dtrain
+{
+
+
 inline void register_and_convert(const vector<string>& strs, vector<WordID>& ids)
 {
   vector<string>::const_iterator it;
@@ -42,17 +45,55 @@ inline string gettmpf(const string path, const string infix)
   return string(fn);
 }
 
-inline void split_in(string& s, vector<string>& parts)
+typedef double score_t;
+
+struct ScoredHyp
 {
-  unsigned f = 0;
-  for(unsigned i = 0; i < 3; i++) {
-    unsigned e = f;
-    f = s.find("\t", f+1);
-    if (e != 0) parts.push_back(s.substr(e+1, f-e-1));
-    else parts.push_back(s.substr(0, f));
+  vector<WordID> w;
+  SparseVector<double> f;
+  score_t model;
+  score_t score;
+  unsigned rank;
+};
+
+struct LocalScorer
+{
+  unsigned N_;
+  vector<score_t> w_;
+
+  virtual score_t
+  Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned rank, const unsigned src_len)=0;
+
+  virtual void Reset() {} // only for ApproxBleuScorer, LinearBleuScorer
+
+  inline void
+  Init(unsigned N, vector<score_t> weights)
+  {
+    assert(N > 0);
+    N_ = N;
+    if (weights.empty()) for (unsigned i = 0; i < N_; i++) w_.push_back(1./N_);
+    else w_ = weights;
   }
-  s.erase(0, f+1);
-}
+
+  inline score_t
+  brevity_penalty(const unsigned hyp_len, const unsigned ref_len)
+  {
+    if (hyp_len > ref_len) return 1;
+    return exp(1 - (score_t)ref_len/hyp_len);
+  }
+};
+
+struct HypSampler : public DecoderObserver
+{
+  LocalScorer* scorer_;
+  vector<WordID>* ref_;
+  unsigned f_count_, sz_;
+  virtual vector<ScoredHyp>* GetSamples()=0;
+  inline void SetScorer(LocalScorer* scorer) { scorer_ = scorer; }
+  inline void SetRef(vector<WordID>& ref) { ref_ = &ref; }
+  inline unsigned get_f_count() { return f_count_; }
+  inline unsigned get_sz() { return sz_; }
+};
 
 struct HSReporter
 {
@@ -88,5 +129,8 @@ inline T sign(T z)
   return z < 0 ? -1 : +1;
 }
 
+
+} // namespace
+
 #endif
 
diff --git a/training/dtrain/examples/standard/dtrain.ini b/training/dtrain/examples/standard/dtrain.ini
index e1072d30..23e94285 100644
--- a/training/dtrain/examples/standard/dtrain.ini
+++ b/training/dtrain/examples/standard/dtrain.ini
@@ -10,15 +10,15 @@ print_weights=Glue WordPenalty LanguageModel LanguageModel_OOV PhraseModel_0 Phr
 stop_after=10 # stop epoch after 10 inputs
 
 # interesting stuff
-epochs=2                # run over input 2 times
-k=100                   # use 100best lists
-N=4                     # optimize (approx) BLEU4
-scorer=stupid_bleu      # use 'stupid' BLEU+1
-learning_rate=1.0       # learning rate, don't care if gamma=0 (perceptron)
-gamma=0                 # use SVM reg
-sample_from=kbest       # use kbest lists (as opposed to forest)
-filter=uniq             # only unique entries in kbest (surface form)
-pair_sampling=XYX       #
-hi_lo=0.1               # 10 vs 80 vs 10 and 80 vs 10 here
-pair_threshold=0        # minimum distance in BLEU (here: > 0)
-loss_margin=0           # update if correctly ranked, but within this margin
+epochs=2                 # run over input 2 times
+k=100                    # use 100best lists
+N=4                      # optimize (approx) BLEU4
+scorer=fixed_stupid_bleu # use 'stupid' BLEU+1
+learning_rate=1.0        # learning rate, don't care if gamma=0 (perceptron)
+gamma=0                  # use SVM reg
+sample_from=kbest        # use kbest lists (as opposed to forest)
+filter=uniq              # only unique entries in kbest (surface form)
+pair_sampling=XYX        #
+hi_lo=0.1                # 10 vs 80 vs 10 and 80 vs 10 here
+pair_threshold=0         # minimum distance in BLEU (here: > 0)
+loss_margin=0            # update if correctly ranked, but within this margin
diff --git a/training/dtrain/examples/standard/expected-output b/training/dtrain/examples/standard/expected-output
index 7cd09dbf..9a25062b 100644
--- a/training/dtrain/examples/standard/expected-output
+++ b/training/dtrain/examples/standard/expected-output
@@ -4,14 +4,14 @@ Reading ./nc-wmt11.en.srilm.gz
 ----5---10---15---20---25---30---35---40---45---50---55---60---65---70---75---80---85---90---95--100
 ****************************************************************************************************
   Example feature: Shape_S00000_T00000
-Seeding random number sequence to 2679584485
+Seeding random number sequence to 1677737427
 
 dtrain
 Parameters:
                        k 100
                        N 4
                        T 2
-                  scorer 'stupid_bleu'
+                  scorer 'fixed_stupid_bleu'
              sample from 'kbest'
                   filter 'uniq'
            learning rate 1
@@ -34,58 +34,58 @@ Iteration #1 of 2.
  . 10
 Stopping after 10 input sentences.
 WEIGHTS
-              Glue = -576
-       WordPenalty = +417.79
-     LanguageModel = +5117.5
- LanguageModel_OOV = -1307
-     PhraseModel_0 = -1612
-     PhraseModel_1 = -2159.6
-     PhraseModel_2 = -677.36
-     PhraseModel_3 = +2663.8
-     PhraseModel_4 = -1025.9
-     PhraseModel_5 = -8
-     PhraseModel_6 = +70
-       PassThrough = -1455
+              Glue = -1155
+       WordPenalty = -329.63
+     LanguageModel = +3903
+ LanguageModel_OOV = -1630
+     PhraseModel_0 = +2746.9
+     PhraseModel_1 = +1200.3
+     PhraseModel_2 = -1004.1
+     PhraseModel_3 = +2223.1
+     PhraseModel_4 = +551.58
+     PhraseModel_5 = +217
+     PhraseModel_6 = +1816
+       PassThrough = -1603
         ---
-       1best avg score: 0.27697 (+0.27697)
- 1best avg model score: -47918 (-47918)
-           avg # pairs: 581.9 (meaningless)
-        avg # rank err: 581.9
+       1best avg score: 0.19344 (+0.19344)
+ 1best avg model score: 81387 (+81387)
+           avg # pairs: 616.3 (meaningless)
+        avg # rank err: 616.3
      avg # margin viol: 0
-    non0 feature count: 703
+    non0 feature count: 673
            avg list sz: 90.9
-           avg f count: 100.09
-(time 0.25 min, 1.5 s/S)
+           avg f count: 104.26
+(time 0.38 min, 2.3 s/S)
 
 Iteration #2 of 2.
  . 10
 WEIGHTS
-              Glue = -622
-       WordPenalty = +898.56
-     LanguageModel = +8066.2
- LanguageModel_OOV = -2590
-     PhraseModel_0 = -4335.8
-     PhraseModel_1 = -5864.4
-     PhraseModel_2 = -1729.8
-     PhraseModel_3 = +2831.9
-     PhraseModel_4 = -5384.8
-     PhraseModel_5 = +1449
-     PhraseModel_6 = +480
-       PassThrough = -2578
+              Glue = -994
+       WordPenalty = -778.69
+     LanguageModel = +2348.9
+ LanguageModel_OOV = -1967
+     PhraseModel_0 = -412.72
+     PhraseModel_1 = +1428.9
+     PhraseModel_2 = +1967.4
+     PhraseModel_3 = -944.99
+     PhraseModel_4 = -239.7
+     PhraseModel_5 = +708
+     PhraseModel_6 = +645
+       PassThrough = -1866
         ---
-       1best avg score: 0.37119 (+0.094226)
- 1best avg model score: -1.3174e+05 (-83822)
-           avg # pairs: 584.1 (meaningless)
-        avg # rank err: 584.1
+       1best avg score: 0.22395 (+0.03051)
+ 1best avg model score: -31388 (-1.1278e+05)
+           avg # pairs: 702.3 (meaningless)
+        avg # rank err: 702.3
      avg # margin viol: 0
-    non0 feature count: 1115
+    non0 feature count: 955
            avg list sz: 91.3
-           avg f count: 90.755
-(time 0.3 min, 1.8 s/S)
+           avg f count: 103.45
+(time 0.32 min, 1.9 s/S)
 
 Writing weights file to '-' ...
 done
 
 ---
-Best iteration: 2 [SCORE 'stupid_bleu'=0.37119].
-This took 0.55 min.
+Best iteration: 2 [SCORE 'fixed_stupid_bleu'=0.22395].
+This took 0.7 min.
diff --git a/training/dtrain/kbestget.h b/training/dtrain/kbestget.h
index dd8882e1..85252db3 100644
--- a/training/dtrain/kbestget.h
+++ b/training/dtrain/kbestget.h
@@ -1,76 +1,12 @@
 #ifndef _DTRAIN_KBESTGET_H_
 #define _DTRAIN_KBESTGET_H_
 
-#include "kbest.h" // cdec
-#include "sentence_metadata.h"
-
-#include "verbose.h"
-#include "viterbi.h"
-#include "ff_register.h"
-#include "decoder.h"
-#include "weights.h"
-#include "logval.h"
-
-using namespace std;
+#include "kbest.h"
 
 namespace dtrain
 {
 
 
-typedef double score_t;
-
-struct ScoredHyp
-{
-  vector<WordID> w;
-  SparseVector<double> f;
-  score_t model;
-  score_t score;
-  unsigned rank;
-};
-
-struct LocalScorer
-{
-  unsigned N_;
-  vector<score_t> w_;
-
-  virtual score_t
-  Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned rank, const unsigned src_len)=0;
-
-  void Reset() {} // only for approx bleu
-
-  inline void
-  Init(unsigned N, vector<score_t> weights)
-  {
-    assert(N > 0);
-    N_ = N;
-    if (weights.empty()) for (unsigned i = 0; i < N_; i++) w_.push_back(1./N_);
-    else w_ = weights;
-  }
-
-  inline score_t
-  brevity_penalty(const unsigned hyp_len, const unsigned ref_len)
-  {
-    if (hyp_len > ref_len) return 1;
-    return exp(1 - (score_t)ref_len/hyp_len);
-  }
-};
-
-struct HypSampler : public DecoderObserver
-{
-  LocalScorer* scorer_;
-  vector<WordID>* ref_;
-  unsigned f_count_, sz_;
-  virtual vector<ScoredHyp>* GetSamples()=0;
-  inline void SetScorer(LocalScorer* scorer) { scorer_ = scorer; }
-  inline void SetRef(vector<WordID>& ref) { ref_ = &ref; }
-  inline unsigned get_f_count() { return f_count_; }
-  inline unsigned get_sz() { return sz_; }
-};
-////////////////////////////////////////////////////////////////////////////////
-
-
-
-
 struct KBestGetter : public HypSampler
 {
   const unsigned k_;
diff --git a/training/dtrain/ksampler.h b/training/dtrain/ksampler.h
index bc2f56cd..29dab667 100644
--- a/training/dtrain/ksampler.h
+++ b/training/dtrain/ksampler.h
@@ -1,13 +1,12 @@
 #ifndef _DTRAIN_KSAMPLER_H_
 #define _DTRAIN_KSAMPLER_H_
 
-#include "hg_sampler.h" // cdec
-#include "kbestget.h"
-#include "score.h"
+#include "hg_sampler.h"
 
 namespace dtrain
 {
 
+
 bool
 cmp_hyp_by_model_d(ScoredHyp a, ScoredHyp b)
 {
diff --git a/training/dtrain/score.h b/training/dtrain/score.h
index bddaa071..53e970ba 100644
--- a/training/dtrain/score.h
+++ b/training/dtrain/score.h
@@ -1,9 +1,7 @@
 #ifndef _DTRAIN_SCORE_H_
 #define _DTRAIN_SCORE_H_
 
-#include "kbestget.h"
-
-using namespace std;
+#include "dtrain.h"
 
 namespace dtrain
 {
@@ -141,36 +139,43 @@ struct BleuScorer : public LocalScorer
 {
   score_t Bleu(NgramCounts& counts, const unsigned hyp_len, const unsigned ref_len);
   score_t Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned /*rank*/, const unsigned /*src_len*/);
+  void Reset() {}
 };
 
 struct StupidBleuScorer : public LocalScorer
 {
   score_t Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned /*rank*/, const unsigned /*src_len*/);
+  void Reset() {}
 };
 
 struct FixedStupidBleuScorer : public LocalScorer
 {
   score_t Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned /*rank*/, const unsigned /*src_len*/);
+  void Reset() {}
 };
 
 struct SmoothBleuScorer : public LocalScorer
 {
   score_t Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned /*rank*/, const unsigned /*src_len*/);
+  void Reset() {}
 };
 
 struct SumBleuScorer : public LocalScorer
 {
-   score_t Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned /*rank*/, const unsigned /*src_len*/);
+  score_t Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned /*rank*/, const unsigned /*src_len*/);
+  void Reset() {}
 };
 
 struct SumExpBleuScorer : public LocalScorer
 {
-   score_t Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned /*rank*/, const unsigned /*src_len*/);
+  score_t Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned /*rank*/, const unsigned /*src_len*/);
+  void Reset() {}
 };
 
 struct SumWhateverBleuScorer : public LocalScorer
 {
-   score_t Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned /*rank*/, const unsigned /*src_len*/);
+  score_t Score(vector<WordID>& hyp, vector<WordID>& ref, const unsigned /*rank*/, const unsigned /*src_len*/);
+  void Reset() {};
 };
 
 struct ApproxBleuScorer : public BleuScorer