Merge branch 'master' of github.com:redpony/cdec

29 files changed, 1634 insertions, 197 deletions

diff --git a/decoder/Makefile.am b/decoder/Makefile.am
index ef98289e..914faaea 100644
--- a/decoder/Makefile.am
+++ b/decoder/Makefile.am
@@ -143,7 +143,13 @@ libcdec_a_SOURCES = \
   ff_csplit.cc \
   ff_tagger.cc \
   ff_source_path.cc \
+  ff_parse_match.cc \
+	ff_soft_syntax.cc \
+	ff_soft_syntax2.cc \
   ff_source_syntax.cc \
+	ff_source_syntax_p.cc \
+  ff_source_syntax2.cc \
+  ff_source_syntax2_p.cc \
   ff_bleu.cc \
   ff_factory.cc \
   incremental.cc \
diff --git a/decoder/cdec_ff.cc b/decoder/cdec_ff.cc
index 0bf441d4..e7b31f50 100644
--- a/decoder/cdec_ff.cc
+++ b/decoder/cdec_ff.cc
@@ -14,8 +14,18 @@
 #include "ff_rules.h"
 #include "ff_ruleshape.h"
 #include "ff_bleu.h"
+#include "ff_soft_syntax.h"
+#include "ff_soft_syntax2.h"
 #include "ff_source_path.h"
+
+
+#include "ff_parse_match.h"
 #include "ff_source_syntax.h"
+#include "ff_source_syntax_p.h"
+#include "ff_source_syntax2.h"
+#include "ff_source_syntax2_p.h"
+
+
 #include "ff_register.h"
 #include "ff_charset.h"
 #include "ff_wordset.h"
@@ -48,8 +58,23 @@ void register_feature_functions() {
   ff_registry.Register("NgramFeatures", new FFFactory<NgramDetector>());
   ff_registry.Register("RuleContextFeatures", new FFFactory<RuleContextFeatures>());
   ff_registry.Register("RuleIdentityFeatures", new FFFactory<RuleIdentityFeatures>());
+
+
+  ff_registry.Register("ParseMatchFeatures", new FFFactory<ParseMatchFeatures>);
+
+  ff_registry.Register("SoftSyntacticFeatures", new FFFactory<SoftSyntacticFeatures>);
+  ff_registry.Register("SoftSyntacticFeatures2", new FFFactory<SoftSyntacticFeatures2>);
+
   ff_registry.Register("SourceSyntaxFeatures", new FFFactory<SourceSyntaxFeatures>);
+  ff_registry.Register("SourceSyntaxFeatures2", new FFFactory<SourceSyntaxFeatures2>);
+
   ff_registry.Register("SourceSpanSizeFeatures", new FFFactory<SourceSpanSizeFeatures>);
+
+  //ff_registry.Register("PSourceSyntaxFeatures", new FFFactory<PSourceSyntaxFeatures>);
+  //ff_registry.Register("PSourceSpanSizeFeatures", new FFFactory<PSourceSpanSizeFeatures>);
+  //ff_registry.Register("PSourceSyntaxFeatures2", new FFFactory<PSourceSyntaxFeatures2>);
+
+
   ff_registry.Register("CMR2008ReorderingFeatures", new FFFactory<CMR2008ReorderingFeatures>());
   ff_registry.Register("RuleSourceBigramFeatures", new FFFactory<RuleSourceBigramFeatures>());
   ff_registry.Register("RuleTargetBigramFeatures", new FFFactory<RuleTargetBigramFeatures>());
diff --git a/decoder/ff_parse_match.cc b/decoder/ff_parse_match.cc
new file mode 100644
index 00000000..ed556b91
--- /dev/null
+++ b/decoder/ff_parse_match.cc
@@ -0,0 +1,218 @@
+#include "ff_parse_match.h"
+
+#include <sstream>
+#include <stack>
+#include <string>
+
+#include "sentence_metadata.h"
+#include "array2d.h"
+#include "filelib.h"
+
+using namespace std;
+
+// implements the parse match features as described in Vilar et al. (2008)
+// source trees must be represented in Penn Treebank format, e.g.
+//     (S (NP John) (VP (V left)))
+
+struct ParseMatchFeaturesImpl {
+  ParseMatchFeaturesImpl(const string& param) {
+    if (param.compare("") != 0) {
+      char score_param = (char) param[0];
+      switch(score_param) {
+        case 'b':
+          scoring_method = 0;
+          break;
+        case 'l':
+          scoring_method = 1;
+          break;
+        case 'e':
+          scoring_method = 2;
+          break;
+        case 'r':
+          scoring_method = 3;
+          break;
+        default:
+          scoring_method = 0;
+      }
+    }
+    else {
+      scoring_method = 0;
+    }
+  }
+
+  void InitializeGrids(const string& tree, unsigned src_len) {
+    assert(tree.size() > 0);
+    //fids_cat.clear();
+    fids_ef.clear();
+    src_tree.clear();
+    //fids_cat.resize(src_len, src_len + 1);
+    fids_ef.resize(src_len, src_len + 1);
+    src_tree.resize(src_len, src_len + 1, TD::Convert("XX"));
+    ParseTreeString(tree, src_len);
+  }
+
+  void ParseTreeString(const string& tree, unsigned src_len) {
+    //cerr << "TREE: " << tree << endl;
+    src_sent_len = src_len;
+    stack<pair<int, WordID> > stk;  // first = i, second = category
+    pair<int, WordID> cur_cat; cur_cat.first = -1;
+    unsigned i = 0;
+    unsigned p = 0;
+    while(p < tree.size()) {
+      const char cur = tree[p];
+      if (cur == '(') {
+        stk.push(cur_cat);
+        ++p;
+        unsigned k = p + 1;
+        while (k < tree.size() && tree[k] != ' ') { ++k; }
+        cur_cat.first = i;
+        cur_cat.second = TD::Convert(tree.substr(p, k - p));
+        // cerr << "NT: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+        p = k + 1;
+      } else if (cur == ')') {
+        unsigned k = p;
+        while (k < tree.size() && tree[k] == ')') { ++k; }
+        const unsigned num_closes = k - p;
+        for (unsigned ci = 0; ci < num_closes; ++ci) {
+          // cur_cat.second spans from cur_cat.first to i
+          // cerr << TD::Convert(cur_cat.second) << " from " << cur_cat.first << " to " << i << endl;
+          // NOTE: unary rule chains end up being labeled with the top-most category
+          src_tree(cur_cat.first, i) = cur_cat.second;
+          cur_cat = stk.top();
+          stk.pop();
+        }
+        p = k;
+        while (p < tree.size() && (tree[p] == ' ' || tree[p] == '\t')) { ++p; }
+      } else if (cur == ' ' || cur == '\t') {
+        cerr << "Unexpected whitespace in: " << tree << endl;
+        abort();
+      } else { // terminal symbol
+        unsigned k = p + 1;
+        do {
+          while (k < tree.size() && tree[k] != ')' && tree[k] != ' ') { ++k; }
+          // cerr << "TERM: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+          ++i;
+          assert(i <= src_len);
+          while (k < tree.size() && tree[k] == ' ') { ++k; }
+          p = k;
+        } while (p < tree.size() && tree[p] != ')');
+      }
+    //cerr << "i=" << i << "  src_len=" << src_len << endl;
+    }
+    //cerr << "i=" << i << "  src_len=" << src_len << endl;
+    assert(i == src_len);  // make sure tree specified in src_tree is
+                           // the same length as the source sentence
+  }
+
+  int FireFeatures(const TRule& rule, const int i, const int j, int* ants, SparseVector<double>* feats) {
+    //cerr << "fire features: " << rule.AsString() << " for " << i << "," << j << endl;
+    //cerr << rule << endl;
+    //cerr << "span: " << i << " " << j << endl;
+    const WordID lhs = src_tree(i,j);
+    int fid_ef = FD::Convert("PM");
+    int min_dist; // minimal distance to next syntactic constituent of this rule's LHS
+    int summed_min_dists; // minimal distances of LHS and NTs summed up
+    if (TD::Convert(lhs).compare("XX") != 0) 
+        min_dist= 0;
+    // compute the distance to the next syntactical constituent
+    else {
+      int ok = 0;
+      for (unsigned int k = 1; k < (j - i); k++) {
+        min_dist = k;
+        for (unsigned int l = 0; l <= k; l++) {
+          // check if adding k words to the rule span will
+          // lead to a syntactical constituent
+          int l_add = i-l;
+          int r_add = j+(k-l);
+          //cerr << "Adding: " << l_add << " " << r_add << endl;
+          if ((l_add < src_tree.width() && r_add < src_tree.height()) && (TD::Convert(src_tree(l_add, r_add)).compare("XX") != 0)) {
+            //cerr << TD::Convert(src_tree(i-l,j+(k-l))) << endl;
+            //cerr << "span_add: " << l_add << " " << r_add << endl;
+            ok = 1;
+            break;
+          }
+          // check if removing k words from the rule span will 
+          // lead to a syntactical constituent
+          else {
+            //cerr << "Hilfe...!" << endl;
+            int l_rem= i+l;
+            int r_rem = j-(k-l);
+            //cerr << "Removing: " << l_rem << " " << r_rem << endl;
+            if ((l_rem < src_tree.width() && r_rem < src_tree.height()) && TD::Convert(src_tree(l_rem, r_rem)).compare("XX") != 0) {
+              //cerr << TD::Convert(src_tree(i+l,j-(k-l))) << endl;
+              //cerr << "span_rem: " << l_rem << " " << r_rem << endl;
+              ok = 1;
+              break;
+            }
+          }    
+        }
+        if (ok) break;
+      }
+    }
+    summed_min_dists = min_dist;
+    //cerr << min_dist << endl;
+    unsigned ntc = 0;
+    for (unsigned k = 0; k < rule.f_.size(); ++k) {
+      int fj = rule.f_[k];
+      if (fj <= 0)
+        summed_min_dists += ants[ntc++];
+    }
+    switch(scoring_method) {
+      case 0:
+        // binary scoring
+        feats->set_value(fid_ef, (summed_min_dists == 0));
+        break;
+      // CHECK: for the remaining scoring methods, the question remains if
+      // min_dist or summed_min_dists should be used
+      case 1:
+        // linear scoring
+        feats->set_value(fid_ef, 1.0/(min_dist+1));
+        break;
+      case 2:
+        // exponential scoring
+        feats->set_value(fid_ef, 1.0/exp(min_dist));
+        break;
+      case 3:
+        // relative scoring
+        feats->set_value(fid_ef, (j-i)/((j-i) + min_dist));
+        break;
+      default:
+        // binary scoring in case nothing is defined
+        feats->set_value(fid_ef, (summed_min_dists == 0));
+    }
+    return min_dist;
+  }
+
+  Array2D<WordID> src_tree;  // src_tree(i,j) NT = type
+  unsigned int src_sent_len;
+  mutable Array2D<map<const TRule*, int> > fids_ef;    // fires for fully lexicalized
+  int scoring_method;
+};
+
+ParseMatchFeatures::ParseMatchFeatures(const string& param) :
+    FeatureFunction(sizeof(WordID)) {
+  impl = new ParseMatchFeaturesImpl(param);
+}
+
+ParseMatchFeatures::~ParseMatchFeatures() {
+  delete impl;
+  impl = NULL;
+}
+
+void ParseMatchFeatures::TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const {
+  int ants[8];
+  for (unsigned i = 0; i < ant_contexts.size(); ++i)
+    ants[i] = *static_cast<const int*>(ant_contexts[i]);
+
+  *static_cast<int*>(context) =
+     impl->FireFeatures(*edge.rule_, edge.i_, edge.j_, ants, features);
+}
+
+void ParseMatchFeatures::PrepareForInput(const SentenceMetadata& smeta) {
+  impl->InitializeGrids(smeta.GetSGMLValue("src_tree"), smeta.GetSourceLength());
+}
diff --git a/decoder/ff_parse_match.h b/decoder/ff_parse_match.h
new file mode 100644
index 00000000..fa73481a
--- /dev/null
+++ b/decoder/ff_parse_match.h
@@ -0,0 +1,25 @@
+#ifndef _FF_PARSE_MATCH_H_
+#define _FF_PARSE_MATCH_H_
+
+#include "ff.h"
+#include "hg.h"
+
+struct ParseMatchFeaturesImpl;
+
+class ParseMatchFeatures : public FeatureFunction {
+ public:
+  ParseMatchFeatures(const std::string& param);
+  ~ParseMatchFeatures();
+ protected:
+  virtual void TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const std::vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const;
+  virtual void PrepareForInput(const SentenceMetadata& smeta);
+ private:
+  ParseMatchFeaturesImpl* impl;
+};
+
+#endif
diff --git a/decoder/ff_soft_syntax.cc b/decoder/ff_soft_syntax.cc
new file mode 100644
index 00000000..9981fa45
--- /dev/null
+++ b/decoder/ff_soft_syntax.cc
@@ -0,0 +1,201 @@
+#include "ff_soft_syntax.h"
+
+#include <cstdio>
+#include <sstream>
+#include <stack>
+#include <string>
+#include <vector>
+
+#include "sentence_metadata.h"
+#include "stringlib.h"
+#include "array2d.h"
+#include "filelib.h"
+
+using namespace std;
+
+// Implements the soft syntactic features described in 
+// Marton and Resnik (2008): "Soft Syntacitc Constraints for Hierarchical Phrase-Based Translation".
+// Source trees must be represented in Penn Treebank format,
+// e.g. (S (NP John) (VP (V left))).
+
+struct SoftSyntacticFeaturesImpl {
+  SoftSyntacticFeaturesImpl(const string& param) {
+    vector<string> labels = SplitOnWhitespace(param);
+	for (unsigned int i = 0; i < labels.size(); i++) 
+      //cerr << "Labels: " << labels.at(i) << endl;
+    for (unsigned int i = 0; i < labels.size(); i++) {
+      string label = labels.at(i);
+      pair<string, string> feat_label;
+      feat_label.first = label.substr(0, label.size() - 1);
+      feat_label.second = label.at(label.size() - 1);
+      feat_labels.push_back(feat_label);
+    }
+}
+
+  void InitializeGrids(const string& tree, unsigned src_len) {
+    assert(tree.size() > 0);
+    //fids_cat.clear();
+    fids_ef.clear();
+    src_tree.clear();
+    //fids_cat.resize(src_len, src_len + 1);
+    fids_ef.resize(src_len, src_len + 1);
+    src_tree.resize(src_len, src_len + 1, TD::Convert("XX"));
+    ParseTreeString(tree, src_len);
+  }
+
+  void ParseTreeString(const string& tree, unsigned src_len) {
+    stack<pair<int, WordID> > stk;  // first = i, second = category
+    pair<int, WordID> cur_cat; cur_cat.first = -1;
+    unsigned i = 0;
+    unsigned p = 0;
+    //cerr << "String " << tree << endl;
+    while(p < tree.size()) {
+      const char cur = tree[p];
+      if (cur == '(') {
+        stk.push(cur_cat);
+        ++p;
+        unsigned k = p + 1;
+        while (k < tree.size() && tree[k] != ' ') { ++k; }
+        cur_cat.first = i;
+        cur_cat.second = TD::Convert(tree.substr(p, k - p));
+        //cerr << "NT: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+        p = k + 1;
+      } else if (cur == ')') {
+        unsigned k = p;
+        while (k < tree.size() && tree[k] == ')') { ++k; }
+        const unsigned num_closes = k - p;
+        for (unsigned ci = 0; ci < num_closes; ++ci) {
+          // cur_cat.second spans from cur_cat.first to i
+          //cerr << TD::Convert(cur_cat.second) << " from " << cur_cat.first << " to " << i << endl;
+          // NOTE: unary rule chains end up being labeled with the top-most category
+          src_tree(cur_cat.first, i) = cur_cat.second;
+          cur_cat = stk.top();
+          stk.pop();
+        }
+        p = k;
+        while (p < tree.size() && (tree[p] == ' ' || tree[p] == '\t')) { ++p; }
+      } else if (cur == ' ' || cur == '\t') {
+        cerr << "Unexpected whitespace in: " << tree << endl;
+        abort();
+      } else { // terminal symbol
+        unsigned k = p + 1;
+        do {
+          while (k < tree.size() && tree[k] != ')' && tree[k] != ' ') { ++k; }
+          // cerr << "TERM: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+          ++i;
+          assert(i <= src_len);
+          while (k < tree.size() && tree[k] == ' ') { ++k; }
+          p = k;
+        } while (p < tree.size() && tree[p] != ')');
+      }
+    }
+    //cerr << "i=" << i << "  src_len=" << src_len << endl;
+    assert(i == src_len);  // make sure tree specified in src_tree is
+                           // the same length as the source sentence
+  }
+
+  WordID FireFeatures(const TRule& rule, const int i, const int j, const WordID* ants, SparseVector<double>* feats) {
+    //cerr << "fire features: " << rule.AsString() << " for " << i << "," << j << endl;
+    const WordID lhs = src_tree(i,j);
+	string lhs_str = TD::Convert(lhs);
+    //cerr << "LHS: " << lhs_str << " from " << i << " to " << j << endl;
+	//cerr << "RULE :"<< rule << endl;
+    int& fid_ef = fids_ef(i,j)[&rule];
+    for (unsigned int i = 0; i < feat_labels.size(); i++) {
+      ostringstream os;
+      string label = feat_labels.at(i).first;
+      //cerr << "This Label: " << label << endl;
+      char feat_type = (char) feat_labels.at(i).second.c_str()[0];
+      //cerr << "feat_type: " << feat_type << endl;
+      switch(feat_type) {
+        case '2':
+          if (lhs_str.compare(label) == 0) {
+            os << "SYN:" << label << "_conform";
+          }
+          else {
+            os << "SYN:" << label << "_cross";
+          }
+          fid_ef = FD::Convert(os.str());
+          if (fid_ef > 0) {
+            //cerr << "Feature :" << os.str() << endl;
+            feats->set_value(fid_ef, 1.0);
+          }
+          break;
+        case '_':
+          os << "SYN:" << label;
+          fid_ef = FD::Convert(os.str());
+          if (lhs_str.compare(label) == 0) {
+            if (fid_ef > 0) {
+            //cerr << "Feature: " << os.str() << endl;
+              feats->set_value(fid_ef, 1.0);
+            }
+          }
+          else {
+            if (fid_ef > 0) {
+              //cerr << "Feature: " << os.str() << endl;
+              feats->set_value(fid_ef, -1.0);
+            }
+          }
+          break;
+        case '+':
+          if (lhs_str.compare(label) == 0) {
+            os << "SYN:" << label << "_conform";
+            fid_ef = FD::Convert(os.str());
+            if (fid_ef > 0) {
+              //cerr << "Feature: " << os.str() << endl;
+              feats->set_value(fid_ef, 1.0);
+            }
+          }
+          break;
+        case '-': 
+          //cerr << "-" << endl;           
+          if (lhs_str.compare(label) != 0) {
+            os << "SYN:" << label << "_cross";
+            fid_ef = FD::Convert(os.str());
+            if (fid_ef > 0) {
+              //cerr << "Feature :" << os.str() << endl;
+              feats->set_value(fid_ef, 1.0);
+            }
+          }
+          break;
+        os.clear();
+        os.str("");
+      }
+      //cerr << "Feature: " << os.str() << endl;
+      //cerr << endl;
+    }
+    return lhs;
+  }
+
+  Array2D<WordID> src_tree;  // src_tree(i,j) NT = type
+  mutable Array2D<map<const TRule*, int> > fids_ef;    // fires for fully lexicalized
+  vector<pair<string, string> > feat_labels;
+};
+
+SoftSyntacticFeatures::SoftSyntacticFeatures(const string& param) :
+    FeatureFunction(sizeof(WordID)) {
+  impl = new SoftSyntacticFeaturesImpl(param);
+}
+
+SoftSyntacticFeatures::~SoftSyntacticFeatures() {
+  delete impl;
+  impl = NULL;
+}
+
+void SoftSyntacticFeatures::TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const {
+  WordID ants[8];
+  for (unsigned i = 0; i < ant_contexts.size(); ++i)
+    ants[i] = *static_cast<const WordID*>(ant_contexts[i]);
+
+  *static_cast<WordID*>(context) =
+     impl->FireFeatures(*edge.rule_, edge.i_, edge.j_, ants, features);
+}
+
+void SoftSyntacticFeatures::PrepareForInput(const SentenceMetadata& smeta) {
+  impl->InitializeGrids(smeta.GetSGMLValue("src_tree"), smeta.GetSourceLength());
+}
diff --git a/decoder/ff_soft_syntax.h b/decoder/ff_soft_syntax.h
new file mode 100644
index 00000000..79352f49
--- /dev/null
+++ b/decoder/ff_soft_syntax.h
@@ -0,0 +1,27 @@
+#ifndef _FF_SOFTSYNTAX_H_
+#define _FF_SOFTSYNTAX_H_
+
+#include "ff.h"
+#include "hg.h"
+
+struct SoftSyntacticFeaturesImpl;
+
+class SoftSyntacticFeatures : public FeatureFunction {
+ public:
+  SoftSyntacticFeatures(const std::string& param);
+  ~SoftSyntacticFeatures();
+ protected:
+  virtual void TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const std::vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const;
+  virtual void PrepareForInput(const SentenceMetadata& smeta);
+ private:
+  SoftSyntacticFeaturesImpl* impl;
+};
+
+
+
+#endif
diff --git a/decoder/ff_soft_syntax2.cc b/decoder/ff_soft_syntax2.cc
new file mode 100644
index 00000000..121bc39b
--- /dev/null
+++ b/decoder/ff_soft_syntax2.cc
@@ -0,0 +1,234 @@
+#include "ff_soft_syntax2.h"
+
+#include <cstdio>
+#include <sstream>
+#include <stack>
+#include <string>
+#include <vector>
+
+#include "sentence_metadata.h"
+#include "stringlib.h"
+#include "array2d.h"
+#include "filelib.h"
+
+using namespace std;
+
+// Implements the soft syntactic features described in 
+// Marton and Resnik (2008): "Soft Syntacitc Constraints for Hierarchical Phrase-Based Translation".
+// Source trees must be represented in Penn Treebank format,
+// e.g. (S (NP John) (VP (V left))).
+
+struct SoftSyntacticFeatures2Impl {
+  SoftSyntacticFeatures2Impl(const string& param) {
+    vector<string> labels = SplitOnWhitespace(param);
+	//for (unsigned int i = 0; i < labels.size(); i++) 
+      //cerr << "Labels: " << labels.at(i) << endl;
+    for (unsigned int i = 0; i < labels.size(); i++) {
+      string label = labels.at(i);
+      pair<string, string> feat_label;
+      feat_label.first = label.substr(0, label.size() - 1);
+      feat_label.second = label.at(label.size() - 1);
+      feat_labels.push_back(feat_label);
+    }
+  } 
+
+  void InitializeGrids(const string& tree, unsigned src_len) {
+    assert(tree.size() > 0);
+    //fids_cat.clear();
+    fids_ef.clear();
+    src_tree.clear();
+    //fids_cat.resize(src_len, src_len + 1);
+    fids_ef.resize(src_len, src_len + 1);
+    src_tree.resize(src_len, src_len + 1, TD::Convert("XX"));
+    ParseTreeString(tree, src_len);
+  }
+
+  void ParseTreeString(const string& tree, unsigned src_len) {
+    stack<pair<int, WordID> > stk;  // first = i, second = category
+    pair<int, WordID> cur_cat; cur_cat.first = -1;
+    unsigned i = 0;
+    unsigned p = 0;
+    //cerr << "String " << tree << endl;
+    while(p < tree.size()) {
+      const char cur = tree[p];
+      if (cur == '(') {
+        stk.push(cur_cat);
+        ++p;
+        unsigned k = p + 1;
+        while (k < tree.size() && tree[k] != ' ') { ++k; }
+        cur_cat.first = i;
+        cur_cat.second = TD::Convert(tree.substr(p, k - p));
+        //cerr << "NT: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+        p = k + 1;
+      } else if (cur == ')') {
+        unsigned k = p;
+        while (k < tree.size() && tree[k] == ')') { ++k; }
+        const unsigned num_closes = k - p;
+        for (unsigned ci = 0; ci < num_closes; ++ci) {
+          // cur_cat.second spans from cur_cat.first to i
+          //cerr << TD::Convert(cur_cat.second) << " from " << cur_cat.first << " to " << i << endl;
+          // NOTE: unary rule chains end up being labeled with the top-most category
+          src_tree(cur_cat.first, i) = cur_cat.second;
+          cur_cat = stk.top();
+          stk.pop();
+        }
+        p = k;
+        while (p < tree.size() && (tree[p] == ' ' || tree[p] == '\t')) { ++p; }
+      } else if (cur == ' ' || cur == '\t') {
+        cerr << "Unexpected whitespace in: " << tree << endl;
+        abort();
+      } else { // terminal symbol
+        unsigned k = p + 1;
+        do {
+          while (k < tree.size() && tree[k] != ')' && tree[k] != ' ') { ++k; }
+          // cerr << "TERM: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+          ++i;
+          assert(i <= src_len);
+          while (k < tree.size() && tree[k] == ' ') { ++k; }
+          p = k;
+        } while (p < tree.size() && tree[p] != ')');
+      }
+    }
+    //cerr << "i=" << i << "  src_len=" << src_len << endl;
+    assert(i == src_len);  // make sure tree specified in src_tree is
+                           // the same length as the source sentence
+  }
+
+  WordID FireFeatures(const TRule& rule, const int i, const int j, const WordID* ants, SparseVector<double>* feats) {
+    //cerr << "fire features: " << rule.AsString() << " for " << i << "," << j << endl;
+    const WordID lhs = src_tree(i,j);
+	string lhs_str = TD::Convert(lhs);
+    //cerr << "LHS: " << lhs_str << " from " << i << " to " << j << endl;
+	//cerr << "RULE :"<< rule << endl;
+    int& fid_ef = fids_ef(i,j)[&rule];
+    string lhs_to_str = TD::Convert(lhs);
+    int min_dist;
+    string min_dist_label;
+    if (lhs_to_str.compare("XX") != 0) {
+      min_dist = 0;
+      min_dist_label = lhs_to_str;      
+    }
+    else {
+      int ok = 0;
+      for (unsigned int k = 1; k < (j - i); k++) {
+        min_dist = k;
+        for (unsigned int l = 0; l <= k; l++) {
+          int l_add = i-l;
+          int r_add = j+(k-l);
+          if ((l_add < src_tree.width() && r_add < src_tree.height()) && (TD::Convert(src_tree(l_add, r_add)).compare("XX") != 0)) {
+            ok = 1;
+            min_dist_label = (TD::Convert(src_tree(l_add, r_add)));
+            break;
+          }
+          else {
+            int l_rem= i+l;
+            int r_rem = j-(k-l);
+            if ((l_rem < src_tree.width() && r_rem < src_tree.height()) && TD::Convert(src_tree(l_rem, r_rem)).compare("XX") != 0) {
+              ok = 1;
+              min_dist_label = (TD::Convert(src_tree(l_rem, r_rem)));
+              break;
+            }
+          }    
+        }
+        if (ok) break;
+      }
+    }
+    //cerr << "SPAN: " << i << " " << j << endl;
+    //cerr << "MINDIST: " << min_dist << endl;
+    //cerr << "MINDISTLABEL: " << min_dist_label << endl;
+    for (unsigned int i = 0; i < feat_labels.size(); i++) {
+      ostringstream os;
+      string label = feat_labels.at(i).first;
+      //cerr << "This Label: " << label << endl;
+      char feat_type = (char) feat_labels.at(i).second.c_str()[0];
+      //cerr << "feat_type: " << feat_type << endl;
+      switch(feat_type) {
+        case '2':
+          if (min_dist_label.compare(label) == 0) {
+            if (min_dist == 0) {
+              os << "SYN:" << label << "_conform";
+            }
+            else {
+              os << "SYN:" << label << "_cross";
+            }
+            fid_ef = FD::Convert(os.str());
+            //cerr << "Feature :" << os.str() << endl;
+            feats->set_value(fid_ef, 1.0);
+          }
+          break;
+        case '_':
+          os << "SYN:" << label;
+          fid_ef = FD::Convert(os.str());
+          if (min_dist_label.compare(label) == 0) {
+            //cerr << "Feature: " << os.str() << endl;
+            if (min_dist == 0) {
+              feats->set_value(fid_ef, 1.0);
+            }
+            else {
+              //cerr << "Feature: " << os.str() << endl;
+              feats->set_value(fid_ef, -1.0);
+            }
+          }
+          break;
+        case '+':
+          if (min_dist_label.compare(label) == 0) {
+            os << "SYN:" << label << "_conform";
+            fid_ef = FD::Convert(os.str());
+            if (min_dist == 0) {
+              //cerr << "Feature: " << os.str() << endl;
+              feats->set_value(fid_ef, 1.0);
+            }
+          }
+          break;
+        case '-': 
+          //cerr << "-" << endl;           
+          if (min_dist_label.compare(label) != 0) {
+            os << "SYN:" << label << "_cross";
+            fid_ef = FD::Convert(os.str());
+            if (min_dist > 0) {
+              //cerr << "Feature :" << os.str() << endl;
+              feats->set_value(fid_ef, 1.0);
+            }
+          }
+          break;
+        os.clear();
+        os.str("");
+      }
+      //cerr << "FEATURE: " << os.str() << endl;
+      //cerr << endl;
+    }
+    return lhs;
+  }
+
+  Array2D<WordID> src_tree;  // src_tree(i,j) NT = type
+  mutable Array2D<map<const TRule*, int> > fids_ef;    // fires for fully lexicalized
+  vector<pair<string, string> > feat_labels;
+};
+
+SoftSyntacticFeatures2::SoftSyntacticFeatures2(const string& param) :
+    FeatureFunction(sizeof(WordID)) {
+  impl = new SoftSyntacticFeatures2Impl(param);
+}
+
+SoftSyntacticFeatures2::~SoftSyntacticFeatures2() {
+  delete impl;
+  impl = NULL;
+}
+
+void SoftSyntacticFeatures2::TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const {
+  WordID ants[8];
+  for (unsigned i = 0; i < ant_contexts.size(); ++i)
+    ants[i] = *static_cast<const WordID*>(ant_contexts[i]);
+
+  *static_cast<WordID*>(context) =
+     impl->FireFeatures(*edge.rule_, edge.i_, edge.j_, ants, features);
+}
+
+void SoftSyntacticFeatures2::PrepareForInput(const SentenceMetadata& smeta) {
+  impl->InitializeGrids(smeta.GetSGMLValue("src_tree"), smeta.GetSourceLength());
+}
diff --git a/decoder/ff_soft_syntax2.h b/decoder/ff_soft_syntax2.h
new file mode 100644
index 00000000..4de91d86
--- /dev/null
+++ b/decoder/ff_soft_syntax2.h
@@ -0,0 +1,27 @@
+#ifndef _FF_SOFTSYNTAX2_H_
+#define _FF_SOFTSYNTAX2_H_
+
+#include "ff.h"
+#include "hg.h"
+
+struct SoftSyntacticFeatures2Impl;
+
+class SoftSyntacticFeatures2 : public FeatureFunction {
+ public:
+  SoftSyntacticFeatures2(const std::string& param);
+  ~SoftSyntacticFeatures2();
+ protected:
+  virtual void TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const std::vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const;
+  virtual void PrepareForInput(const SentenceMetadata& smeta);
+ private:
+  SoftSyntacticFeatures2Impl* impl;
+};
+
+
+
+#endif
diff --git a/decoder/ff_source_syntax2.cc b/decoder/ff_source_syntax2.cc
new file mode 100644
index 00000000..08ece917
--- /dev/null
+++ b/decoder/ff_source_syntax2.cc
@@ -0,0 +1,159 @@
+#include "ff_source_syntax2.h"
+
+#include <sstream>
+#include <stack>
+#include <string>
+#include <tr1/unordered_set>
+
+#include "sentence_metadata.h"
+#include "array2d.h"
+#include "filelib.h"
+
+using namespace std;
+
+// implements the source side syntax features described in Blunsom et al. (EMNLP 2008)
+// source trees must be represented in Penn Treebank format, e.g.
+//     (S (NP John) (VP (V left)))
+
+struct SourceSyntaxFeatures2Impl {
+  SourceSyntaxFeatures2Impl(const string& param) {
+    if (!(param.compare("") == 0)) {
+      string triggered_features_fn = param;
+      ReadFile triggered_features(triggered_features_fn);
+      string in;
+      while(getline(*triggered_features, in)) {
+        feature_filter.insert(FD::Convert(in));
+      }
+    }
+  }
+
+  void InitializeGrids(const string& tree, unsigned src_len) {
+    assert(tree.size() > 0);
+    //fids_cat.clear();
+    fids_ef.clear();
+    src_tree.clear();
+    //fids_cat.resize(src_len, src_len + 1);
+    fids_ef.resize(src_len, src_len + 1);
+    src_tree.resize(src_len, src_len + 1, TD::Convert("XX"));
+    ParseTreeString(tree, src_len);
+  }
+
+  void ParseTreeString(const string& tree, unsigned src_len) {
+    //cerr << "TREE: " << tree << endl;
+    stack<pair<int, WordID> > stk;  // first = i, second = category
+    pair<int, WordID> cur_cat; cur_cat.first = -1;
+    unsigned i = 0;
+    unsigned p = 0;
+    while(p < tree.size()) {
+      const char cur = tree[p];
+      if (cur == '(') {
+        stk.push(cur_cat);
+        ++p;
+        unsigned k = p + 1;
+        while (k < tree.size() && tree[k] != ' ') { ++k; }
+        cur_cat.first = i;
+        cur_cat.second = TD::Convert(tree.substr(p, k - p));
+        // cerr << "NT: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+        p = k + 1;
+      } else if (cur == ')') {
+        unsigned k = p;
+        while (k < tree.size() && tree[k] == ')') { ++k; }
+        const unsigned num_closes = k - p;
+        for (unsigned ci = 0; ci < num_closes; ++ci) {
+          src_tree(cur_cat.first, i) = cur_cat.second;
+          cur_cat = stk.top();
+          stk.pop();
+        }
+        p = k;
+        while (p < tree.size() && (tree[p] == ' ' || tree[p] == '\t')) { ++p; }
+      } else if (cur == ' ' || cur == '\t') {
+        cerr << "Unexpected whitespace in: " << tree << endl;
+        abort();
+      } else { // terminal symbol
+        unsigned k = p + 1;
+        do {
+          while (k < tree.size() && tree[k] != ')' && tree[k] != ' ') { ++k; }
+          // cerr << "TERM: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+          ++i;
+          assert(i <= src_len);
+          while (k < tree.size() && tree[k] == ' ') { ++k; }
+          p = k;
+        } while (p < tree.size() && tree[p] != ')');
+      }
+    //cerr << "i=" << i << "  src_len=" << src_len << endl;
+    }
+    //cerr << "i=" << i << "  src_len=" << src_len << endl;
+    assert(i == src_len);  // make sure tree specified in src_tree is
+                           // the same length as the source sentence
+  }
+
+  WordID FireFeatures(const TRule& rule, const int i, const int j, const WordID* ants, SparseVector<double>* feats) {
+    //cerr << "fire features: " << rule.AsString() << " for " << i << "," << j << endl;
+    const WordID lhs = src_tree(i,j);
+    int& fid_ef = fids_ef(i,j)[&rule];
+    ostringstream os;
+    os << "SYN:" << TD::Convert(lhs);
+    os << ':';
+    unsigned ntc = 0;
+    for (unsigned k = 0; k < rule.f_.size(); ++k) {
+      int fj = rule.f_[k];
+      if (k > 0 && fj <= 0) os << '_';
+      if (fj <= 0) {
+        os << '[' << TD::Convert(ants[ntc++]) << ']';
+      } /*else {
+        os << TD::Convert(fj);
+      }*/
+    }
+    os << ':';
+    for (unsigned k = 0; k < rule.e_.size(); ++k) {
+      const int ei = rule.e_[k];
+      if (k > 0) os << '_';
+      if (ei <= 0)
+        os << '[' << (1-ei) << ']';
+      else
+        os << TD::Convert(ei);
+    }
+    fid_ef = FD::Convert(os.str());
+    //cerr << "FEATURE: " << os.str() << endl;
+    //cerr << "FID_EF: " << fid_ef << endl;
+    if (feature_filter.find(fid_ef) != feature_filter.end()) {
+      cerr << "SYN-Feature was trigger more than once on training set." << endl;
+      feats->set_value(fid_ef, 1.0);
+    }
+    else cerr << "SYN-Feature was triggered less than once on training set." << endl;
+    return lhs;
+  }
+
+  Array2D<WordID> src_tree;  // src_tree(i,j) NT = type
+  mutable Array2D<map<const TRule*, int> > fids_ef;    // fires for fully lexicalized
+  tr1::unordered_set<int> feature_filter;
+
+};
+
+SourceSyntaxFeatures2::SourceSyntaxFeatures2(const string& param) :
+    FeatureFunction(sizeof(WordID)) {
+  impl = new SourceSyntaxFeatures2Impl(param);
+}
+
+SourceSyntaxFeatures2::~SourceSyntaxFeatures2() {
+  delete impl;
+  impl = NULL;
+}
+
+void SourceSyntaxFeatures2::TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const {
+  WordID ants[8];
+  for (unsigned i = 0; i < ant_contexts.size(); ++i)
+    ants[i] = *static_cast<const WordID*>(ant_contexts[i]);
+
+  *static_cast<WordID*>(context) =
+     impl->FireFeatures(*edge.rule_, edge.i_, edge.j_, ants, features);
+}
+
+void SourceSyntaxFeatures2::PrepareForInput(const SentenceMetadata& smeta) {
+  impl->InitializeGrids(smeta.GetSGMLValue("src_tree"), smeta.GetSourceLength());
+}
diff --git a/decoder/ff_source_syntax2.h b/decoder/ff_source_syntax2.h
new file mode 100644
index 00000000..b6b7dc3d
--- /dev/null
+++ b/decoder/ff_source_syntax2.h
@@ -0,0 +1,25 @@
+#ifndef _FF_SOURCE_TOOLS2_H_
+#define _FF_SOURCE_TOOLS2_H_
+
+#include "ff.h"
+#include "hg.h"
+
+struct SourceSyntaxFeatures2Impl;
+
+class SourceSyntaxFeatures2 : public FeatureFunction {
+ public:
+  SourceSyntaxFeatures2(const std::string& param);
+  ~SourceSyntaxFeatures2();
+ protected:
+  virtual void TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const std::vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const;
+  virtual void PrepareForInput(const SentenceMetadata& smeta);
+ private:
+  SourceSyntaxFeatures2Impl* impl;
+};
+
+#endif
diff --git a/decoder/ff_source_syntax2_p.cc b/decoder/ff_source_syntax2_p.cc
new file mode 100644
index 00000000..dfa791ea
--- /dev/null
+++ b/decoder/ff_source_syntax2_p.cc
@@ -0,0 +1,166 @@
+#include "ff_source_syntax2_p.h"
+
+#include <sstream>
+#include <stack>
+#include <string>
+#include <tr1/unordered_set>
+
+#include "sentence_metadata.h"
+#include "array2d.h"
+#include "filelib.h"
+
+using namespace std;
+
+// implements the source side syntax features described in Blunsom et al. (EMNLP 2008)
+// source trees must be represented in Penn Treebank format, e.g.
+//     (S (NP John) (VP (V left)))
+
+struct PSourceSyntaxFeatures2Impl {
+  PSourceSyntaxFeatures2Impl(const string& param) {
+    if (param.compare("") != 0) {
+      string triggered_features_fn = param;
+      ReadFile triggered_features(triggered_features_fn);
+      string in;
+      while(getline(*triggered_features, in)) {
+        feature_filter.insert(FD::Convert(in));
+      }
+    }
+    /*cerr << "find(\"One\") == " << boolalpha << (table.find("One") != table.end()) << endl; 
+    cerr << "find(\"Three\") == " << boolalpha << (table.find("Three") != table.end()) << endl;*/
+  }
+
+  void InitializeGrids(const string& tree, unsigned src_len) {
+    assert(tree.size() > 0);
+    //fids_cat.clear();
+    fids_ef.clear();
+    src_tree.clear();
+    //fids_cat.resize(src_len, src_len + 1);
+    fids_ef.resize(src_len, src_len + 1);
+    src_tree.resize(src_len, src_len + 1, TD::Convert("XX"));
+    ParseTreeString(tree, src_len);
+  }
+
+  void ParseTreeString(const string& tree, unsigned src_len) {
+    //cerr << "TREE: " << tree << endl;
+    stack<pair<int, WordID> > stk;  // first = i, second = category
+    pair<int, WordID> cur_cat; cur_cat.first = -1;
+    unsigned i = 0;
+    unsigned p = 0;
+    while(p < tree.size()) {
+      const char cur = tree[p];
+      if (cur == '(') {
+        stk.push(cur_cat);
+        ++p;
+        unsigned k = p + 1;
+        while (k < tree.size() && tree[k] != ' ') { ++k; }
+        cur_cat.first = i;
+        cur_cat.second = TD::Convert(tree.substr(p, k - p));
+        // cerr << "NT: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+        p = k + 1;
+      } else if (cur == ')') {
+        unsigned k = p;
+        while (k < tree.size() && tree[k] == ')') { ++k; }
+        const unsigned num_closes = k - p;
+        for (unsigned ci = 0; ci < num_closes; ++ci) {
+          src_tree(cur_cat.first, i) = cur_cat.second;
+          cur_cat = stk.top();
+          stk.pop();
+        }
+        p = k;
+        while (p < tree.size() && (tree[p] == ' ' || tree[p] == '\t')) { ++p; }
+      } else if (cur == ' ' || cur == '\t') {
+        cerr << "Unexpected whitespace in: " << tree << endl;
+        abort();
+      } else { // terminal symbol
+        unsigned k = p + 1;
+        do {
+          while (k < tree.size() && tree[k] != ')' && tree[k] != ' ') { ++k; }
+          // cerr << "TERM: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+          ++i;
+          assert(i <= src_len);
+          while (k < tree.size() && tree[k] == ' ') { ++k; }
+          p = k;
+        } while (p < tree.size() && tree[p] != ')');
+      }
+    //cerr << "i=" << i << "  src_len=" << src_len << endl;
+    }
+    //cerr << "i=" << i << "  src_len=" << src_len << endl;
+    assert(i == src_len);  // make sure tree specified in src_tree is
+                           // the same length as the source sentence
+  }
+
+  WordID FireFeatures(const TRule& rule, const int i, const int j, const WordID* ants, SparseVector<double>* feats) {
+    //cerr << "fire features: " << rule.AsString() << " for " << i << "," << j << endl;
+    const WordID lhs = src_tree(i,j);
+    int& fid_ef = fids_ef(i,j)[&rule];
+    ostringstream os;
+    os << "SYN:" << TD::Convert(lhs);
+    os << ':';
+    unsigned ntc = 0;
+    for (unsigned k = 0; k < rule.f_.size(); ++k) {
+      int fj = rule.f_[k];
+      if (k > 0 && fj <= 0) os << '_';
+      if (fj <= 0) {
+        os << '[' << TD::Convert(ants[ntc++]) << ']';
+      } /*else {
+        os << TD::Convert(fj);
+      }*/
+    }
+    os << ':';
+    for (unsigned k = 0; k < rule.e_.size(); ++k) {
+      const int ei = rule.e_[k];
+      if (k > 0) os << '_';
+      if (ei <= 0)
+        os << '[' << (1-ei) << ']';
+      else
+        os << TD::Convert(ei);
+    }
+    fid_ef = FD::Convert(os.str());
+    //cerr << "FEATURE: " << os.str() << endl;
+    //cerr << "FID_EF: " << fid_ef << endl;
+    if (feature_filter.size() > 0) {
+      if (feature_filter.find(fid_ef) != feature_filter.end()) {
+        //cerr << "SYN-Feature was trigger more than once on training set." << endl;
+        feats->set_value(fid_ef, 1.0);
+      }  
+      //else cerr << "SYN-Feature was triggered less than once on training set." << endli;
+    }
+    else {
+      feats->set_value(fid_ef, 1.0);
+    }
+    return lhs;
+  }
+
+  Array2D<WordID> src_tree;  // src_tree(i,j) NT = type
+  mutable Array2D<map<const TRule*, int> > fids_ef;    // fires for fully lexicalized
+  tr1::unordered_set<int> feature_filter;
+
+};
+
+PSourceSyntaxFeatures2::PSourceSyntaxFeatures2(const string& param) :
+    FeatureFunction(sizeof(WordID)) {
+  impl = new PSourceSyntaxFeatures2Impl(param);
+}
+
+PSourceSyntaxFeatures2::~PSourceSyntaxFeatures2() {
+  delete impl;
+  impl = NULL;
+}
+
+void PSourceSyntaxFeatures2::TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const {
+  WordID ants[8];
+  for (unsigned i = 0; i < ant_contexts.size(); ++i)
+    ants[i] = *static_cast<const WordID*>(ant_contexts[i]);
+
+  *static_cast<WordID*>(context) =
+     impl->FireFeatures(*edge.rule_, edge.i_, edge.j_, ants, features);
+}
+
+void PSourceSyntaxFeatures2::PrepareForInput(const SentenceMetadata& smeta) {
+  impl->InitializeGrids(smeta.GetSGMLValue("src_tree"), smeta.GetSourceLength());
+}
diff --git a/decoder/ff_source_syntax2_p.h b/decoder/ff_source_syntax2_p.h
new file mode 100644
index 00000000..d56ecab0
--- /dev/null
+++ b/decoder/ff_source_syntax2_p.h
@@ -0,0 +1,25 @@
+#ifndef _FF_SOURCE_TOOLS2_H_
+#define _FF_SOURCE_TOOLS2_H_
+
+#include "ff.h"
+#include "hg.h"
+
+struct PSourceSyntaxFeatures2Impl;
+
+class PSourceSyntaxFeatures2 : public FeatureFunction {
+ public:
+  PSourceSyntaxFeatures2(const std::string& param);
+  ~PSourceSyntaxFeatures2();
+ protected:
+  virtual void TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const std::vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const;
+  virtual void PrepareForInput(const SentenceMetadata& smeta);
+ private:
+  PSourceSyntaxFeatures2Impl* impl;
+};
+
+#endif
diff --git a/decoder/ff_source_syntax_p.cc b/decoder/ff_source_syntax_p.cc
new file mode 100644
index 00000000..cd081544
--- /dev/null
+++ b/decoder/ff_source_syntax_p.cc
@@ -0,0 +1,245 @@
+#include "ff_source_syntax_p.h"
+
+#include <sstream>
+#include <stack>
+#include <tr1/unordered_set>
+
+#include "sentence_metadata.h"
+#include "array2d.h"
+#include "filelib.h"
+
+using namespace std;
+
+// implements the source side syntax features described in Blunsom et al. (EMNLP 2008)
+// source trees must be represented in Penn Treebank format, e.g.
+//     (S (NP John) (VP (V left)))
+
+// log transform to make long spans cluster together
+// but preserve differences
+inline int SpanSizeTransform(unsigned span_size) {
+  if (!span_size) return 0;
+  return static_cast<int>(log(span_size+1) / log(1.39)) - 1;
+}
+
+struct PSourceSyntaxFeaturesImpl {
+  PSourceSyntaxFeaturesImpl() {}
+
+  PSourceSyntaxFeaturesImpl(const string& param) {
+    if (!(param.compare("") == 0)) {
+      string triggered_features_fn = param;
+      ReadFile triggered_features(triggered_features_fn);
+      string in;
+      while(getline(*triggered_features, in)) {
+        feature_filter.insert(FD::Convert(in));
+      }
+    }
+  }
+
+  void InitializeGrids(const string& tree, unsigned src_len) {
+    assert(tree.size() > 0);
+    //fids_cat.clear();
+    fids_ef.clear();
+    src_tree.clear();
+    //fids_cat.resize(src_len, src_len + 1);
+    fids_ef.resize(src_len, src_len + 1);
+    src_tree.resize(src_len, src_len + 1, TD::Convert("XX"));
+    ParseTreeString(tree, src_len);
+  }
+
+  void ParseTreeString(const string& tree, unsigned src_len) {
+    stack<pair<int, WordID> > stk;  // first = i, second = category
+    pair<int, WordID> cur_cat; cur_cat.first = -1;
+    unsigned i = 0;
+    unsigned p = 0;
+    while(p < tree.size()) {
+      const char cur = tree[p];
+      if (cur == '(') {
+        stk.push(cur_cat);
+        ++p;
+        unsigned k = p + 1;
+        while (k < tree.size() && tree[k] != ' ') { ++k; }
+        cur_cat.first = i;
+        cur_cat.second = TD::Convert(tree.substr(p, k - p));
+        // cerr << "NT: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+        p = k + 1;
+      } else if (cur == ')') {
+        unsigned k = p;
+        while (k < tree.size() && tree[k] == ')') { ++k; }
+        const unsigned num_closes = k - p;
+        for (unsigned ci = 0; ci < num_closes; ++ci) {
+          // cur_cat.second spans from cur_cat.first to i
+          // cerr << TD::Convert(cur_cat.second) << " from " << cur_cat.first << " to " << i << endl;
+          // NOTE: unary rule chains end up being labeled with the top-most category
+          src_tree(cur_cat.first, i) = cur_cat.second;
+          cur_cat = stk.top();
+          stk.pop();
+        }
+        p = k;
+        while (p < tree.size() && (tree[p] == ' ' || tree[p] == '\t')) { ++p; }
+      } else if (cur == ' ' || cur == '\t') {
+        cerr << "Unexpected whitespace in: " << tree << endl;
+        abort();
+      } else { // terminal symbol
+        unsigned k = p + 1;
+        do {
+          while (k < tree.size() && tree[k] != ')' && tree[k] != ' ') { ++k; }
+          // cerr << "TERM: '" << tree.substr(p, k-p) << "' (i=" << i << ")\n";
+          ++i;
+          assert(i <= src_len);
+          while (k < tree.size() && tree[k] == ' ') { ++k; }
+          p = k;
+        } while (p < tree.size() && tree[p] != ')');
+      }
+    }
+    // cerr << "i=" << i << "  src_len=" << src_len << endl;
+    assert(i == src_len);  // make sure tree specified in src_tree is
+                           // the same length as the source sentence
+  }
+
+  WordID FireFeatures(const TRule& rule, const int i, const int j, const WordID* ants, SparseVector<double>* feats) {
+    //cerr << "fire features: " << rule.AsString() << " for " << i << "," << j << endl;
+    const WordID lhs = src_tree(i,j);
+    //int& fid_cat = fids_cat(i,j);
+    int& fid_ef = fids_ef(i,j)[&rule];
+    if (fid_ef <= 0) {
+      ostringstream os;
+      //ostringstream os2;
+      os << "SYN:" << TD::Convert(lhs);
+      //os2 << "SYN:" << TD::Convert(lhs) << '_' << SpanSizeTransform(j - i);
+      //fid_cat = FD::Convert(os2.str());
+      os << ':';
+      unsigned ntc = 0;
+      for (unsigned k = 0; k < rule.f_.size(); ++k) {
+        if (k > 0) os << '_';
+        int fj = rule.f_[k];
+        if (fj <= 0) {
+          os << '[' << TD::Convert(ants[ntc++]) << ']';
+        } else {
+          os << TD::Convert(fj);
+        }
+      }
+      os << ':';
+      for (unsigned k = 0; k < rule.e_.size(); ++k) {
+        const int ei = rule.e_[k];
+        if (k > 0) os << '_';
+        if (ei <= 0)
+          os << '[' << (1-ei) << ']';
+        else
+          os << TD::Convert(ei);
+      }
+      fid_ef = FD::Convert(os.str());
+    }
+    //if (fid_cat > 0)
+    //  feats->set_value(fid_cat, 1.0);
+    if (fid_ef > 0 && (feature_filter.find(fid_ef) != feature_filter.end()))
+      feats->set_value(fid_ef, 1.0);
+    return lhs;
+  }
+
+  Array2D<WordID> src_tree;  // src_tree(i,j) NT = type
+  // mutable Array2D<int> fids_cat;   // this tends to overfit baddly
+  mutable Array2D<map<const TRule*, int> > fids_ef;    // fires for fully lexicalized
+  tr1::unordered_set<int> feature_filter;
+};
+
+PSourceSyntaxFeatures::PSourceSyntaxFeatures(const string& param) :
+    FeatureFunction(sizeof(WordID)) {
+  impl = new PSourceSyntaxFeaturesImpl(param);
+}
+
+PSourceSyntaxFeatures::~PSourceSyntaxFeatures() {
+  delete impl;
+  impl = NULL;
+}
+
+void PSourceSyntaxFeatures::TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const {
+  WordID ants[8];
+  for (unsigned i = 0; i < ant_contexts.size(); ++i)
+    ants[i] = *static_cast<const WordID*>(ant_contexts[i]);
+
+  *static_cast<WordID*>(context) =
+     impl->FireFeatures(*edge.rule_, edge.i_, edge.j_, ants, features);
+}
+
+void PSourceSyntaxFeatures::PrepareForInput(const SentenceMetadata& smeta) {
+  impl->InitializeGrids(smeta.GetSGMLValue("src_tree"), smeta.GetSourceLength());
+}
+
+struct PSourceSpanSizeFeaturesImpl {
+  PSourceSpanSizeFeaturesImpl() {}
+
+  void InitializeGrids(unsigned src_len) {
+    fids.clear();
+    fids.resize(src_len, src_len + 1);
+  }
+
+  int FireFeatures(const TRule& rule, const int i, const int j, const WordID* ants, SparseVector<double>* feats) {
+    if (rule.Arity() > 0) {
+      int& fid = fids(i,j)[&rule];
+      if (fid <= 0) {
+        ostringstream os;
+        os << "SSS:";
+        unsigned ntc = 0;
+        for (unsigned k = 0; k < rule.f_.size(); ++k) {
+          if (k > 0) os << '_';
+          int fj = rule.f_[k];
+          if (fj <= 0) {
+            os << '[' << TD::Convert(-fj) << ants[ntc++] << ']';
+          } else {
+            os << TD::Convert(fj);
+          }
+        }
+        os << ':';
+        for (unsigned k = 0; k < rule.e_.size(); ++k) {
+          const int ei = rule.e_[k];
+          if (k > 0) os << '_';
+          if (ei <= 0)
+            os << '[' << (1-ei) << ']';
+          else
+            os << TD::Convert(ei);
+        }
+        fid = FD::Convert(os.str());
+      }
+      if (fid > 0)
+        feats->set_value(fid, 1.0);
+    }
+    return SpanSizeTransform(j - i);
+  }
+
+  mutable Array2D<map<const TRule*, int> > fids;
+};
+
+PSourceSpanSizeFeatures::PSourceSpanSizeFeatures(const string& param) :
+    FeatureFunction(sizeof(char)) {
+  impl = new PSourceSpanSizeFeaturesImpl;
+}
+
+PSourceSpanSizeFeatures::~PSourceSpanSizeFeatures() {
+  delete impl;
+  impl = NULL;
+}
+
+void PSourceSpanSizeFeatures::TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const {
+  int ants[8];
+  for (unsigned i = 0; i < ant_contexts.size(); ++i)
+    ants[i] = *static_cast<const char*>(ant_contexts[i]);
+
+  *static_cast<char*>(context) =
+     impl->FireFeatures(*edge.rule_, edge.i_, edge.j_, ants, features);
+}
+
+void PSourceSpanSizeFeatures::PrepareForInput(const SentenceMetadata& smeta) {
+  impl->InitializeGrids(smeta.GetSourceLength());
+}
+
+
diff --git a/decoder/ff_source_syntax_p.h b/decoder/ff_source_syntax_p.h
new file mode 100644
index 00000000..2dd9094a
--- /dev/null
+++ b/decoder/ff_source_syntax_p.h
@@ -0,0 +1,42 @@
+#ifndef _FF_SOURCE_TOOLS_H_
+#define _FF_SOURCE_TOOLS_H_
+
+#include "ff.h"
+#include "hg.h"
+
+struct PSourceSyntaxFeaturesImpl;
+
+class PSourceSyntaxFeatures : public FeatureFunction {
+ public:
+  PSourceSyntaxFeatures(const std::string& param);
+  ~PSourceSyntaxFeatures();
+ protected:
+  virtual void TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const std::vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const;
+  virtual void PrepareForInput(const SentenceMetadata& smeta);
+ private:
+  PSourceSyntaxFeaturesImpl* impl;
+};
+
+struct PSourceSpanSizeFeaturesImpl;
+class PSourceSpanSizeFeatures : public FeatureFunction {
+ public:
+  PSourceSpanSizeFeatures(const std::string& param);
+  ~PSourceSpanSizeFeatures();
+ protected:
+  virtual void TraversalFeaturesImpl(const SentenceMetadata& smeta,
+                                     const Hypergraph::Edge& edge,
+                                     const std::vector<const void*>& ant_contexts,
+                                     SparseVector<double>* features,
+                                     SparseVector<double>* estimated_features,
+                                     void* context) const;
+  virtual void PrepareForInput(const SentenceMetadata& smeta);
+ private:
+  PSourceSpanSizeFeaturesImpl* impl;
+};
+
+#endif
diff --git a/training/dtrain/README.md b/training/dtrain/README.md
index 2ab2f232..2bae6b48 100644
--- a/training/dtrain/README.md
+++ b/training/dtrain/README.md
@@ -17,6 +17,17 @@ To build only parts needed for dtrain do
   cd training/dtrain/; make
 ```
 
+Ideas
+-----
+ * get approx_bleu to work?
+ * implement minibatches (Minibatch and Parallelization for Online Large Margin Structured Learning)
+ * learning rate 1/T?
+ * use an oracle? mira-like (model vs. BLEU), feature repr. of reference!? 
+ * implement lc_bleu properly
+ * merge kbest lists of previous epochs (as MERT does)
+ * ``walk entire regularization path''
+ * rerank after each update?
+
 Running
 -------
 See directories under test/ .
diff --git a/training/dtrain/dtrain.cc b/training/dtrain/dtrain.cc
index 149f87d4..0ee2f124 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
@@ -360,6 +366,9 @@ main(int argc, char** argv)
         PROsampling(samples, pairs, pair_threshold, max_pairs);
       npairs += pairs.size();
 
+      SparseVector<weight_t> lambdas_copy;
+      if (l1naive||l1clip||l1cumul) lambdas_copy = lambdas;
+
       for (vector<pair<ScoredHyp,ScoredHyp> >::iterator it = pairs.begin();
            it != pairs.end(); it++) {
         bool rank_error;
@@ -369,7 +378,7 @@ main(int argc, char** argv)
           margin = std::numeric_limits<float>::max();
         } else {
           rank_error = it->first.model <= it->second.model;
-          margin = fabs(fabs(it->first.model) - fabs(it->second.model));
+          margin = fabs(it->first.model - it->second.model);
           if (!rank_error && margin < loss_margin) margin_violations++;
         }
         if (rank_error) rank_errors++;
@@ -383,23 +392,26 @@ main(int argc, char** argv)
       }
 
       // l1 regularization
-      // please note that this penalizes _all_ weights
-      // (contrary to only the ones changed by the last update)
-      // after a _sentence_ (not after each example/pair)
+      // please note that this regularizations happen
+      // after a _sentence_ -- not after each example/pair!
       if (l1naive) {
         FastSparseVector<weight_t>::iterator it = lambdas.begin();
         for (; it != lambdas.end(); ++it) {
-          it->second -= sign(it->second) * l1_reg;
+          if (!lambdas_copy.get(it->first) || lambdas_copy.get(it->first)!=it->second) {
+            it->second -= sign(it->second) * l1_reg;
+          }
         }
       } else if (l1clip) {
         FastSparseVector<weight_t>::iterator it = lambdas.begin();
         for (; it != lambdas.end(); ++it) {
-          if (it->second != 0) {
-            weight_t v = it->second;
-            if (v > 0) {
-              it->second = max(0., v - l1_reg);
-            } else {
-              it->second = min(0., v + l1_reg);
+          if (!lambdas_copy.get(it->first) || lambdas_copy.get(it->first)!=it->second) {
+            if (it->second != 0) {
+              weight_t v = it->second;
+              if (v > 0) {
+                it->second = max(0., v - l1_reg);
+              } else {
+                it->second = min(0., v + l1_reg);
+              }
             }
           }
         }
@@ -407,16 +419,18 @@ main(int argc, char** argv)
         weight_t acc_penalty = (ii+1) * l1_reg; // ii is the index of the current input
         FastSparseVector<weight_t>::iterator it = lambdas.begin();
         for (; it != lambdas.end(); ++it) {
-          if (it->second != 0) {
-            weight_t v = it->second;
-            weight_t penalized = 0.;
-            if (v > 0) {
-              penalized = max(0., v-(acc_penalty + cumulative_penalties.get(it->first)));
-            } else {
-              penalized = min(0., v+(acc_penalty - cumulative_penalties.get(it->first)));
+          if (!lambdas_copy.get(it->first) || lambdas_copy.get(it->first)!=it->second) {
+            if (it->second != 0) {
+              weight_t v = it->second;
+              weight_t penalized = 0.;
+              if (v > 0) {
+                penalized = max(0., v-(acc_penalty + cumulative_penalties.get(it->first)));
+              } else {
+                penalized = min(0., v+(acc_penalty - cumulative_penalties.get(it->first)));
+              }
+              it->second = penalized;
+              cumulative_penalties.set_value(it->first, cumulative_penalties.get(it->first)+penalized);
             }
-            it->second = penalized;
-            cumulative_penalties.set_value(it->first, cumulative_penalties.get(it->first)+penalized);
           }
         }
       }
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/parallelized/cdec.ini b/training/dtrain/examples/parallelized/cdec.ini
index e43ba1c4..5773029a 100644
--- a/training/dtrain/examples/parallelized/cdec.ini
+++ b/training/dtrain/examples/parallelized/cdec.ini
@@ -4,7 +4,7 @@ intersection_strategy=cube_pruning
 cubepruning_pop_limit=200
 scfg_max_span_limit=15
 feature_function=WordPenalty
-feature_function=KLanguageModel ../example/nc-wmt11.en.srilm.gz
+feature_function=KLanguageModel ../standard//nc-wmt11.en.srilm.gz
 #feature_function=ArityPenalty
 #feature_function=CMR2008ReorderingFeatures
 #feature_function=Dwarf
diff --git a/training/dtrain/examples/parallelized/dtrain.ini b/training/dtrain/examples/parallelized/dtrain.ini
index f19ef891..0b0932d6 100644
--- a/training/dtrain/examples/parallelized/dtrain.ini
+++ b/training/dtrain/examples/parallelized/dtrain.ini
@@ -11,6 +11,4 @@ pair_sampling=XYX
 hi_lo=0.1
 select_weights=last
 print_weights=Glue WordPenalty LanguageModel LanguageModel_OOV PhraseModel_0 PhraseModel_1 PhraseModel_2 PhraseModel_3 PhraseModel_4 PhraseModel_5 PhraseModel_6 PassThrough
-# newer version of the grammar extractor use different feature names: 
-#print_weights=Glue WordPenalty LanguageModel LanguageModel_OOV PhraseModel_0 PhraseModel_1 PhraseModel_2 PhraseModel_3 PhraseModel_4 PhraseModel_5 PhraseModel_6 PassThrough
 decoder_config=cdec.ini
diff --git a/training/dtrain/examples/parallelized/work/out.0.0 b/training/dtrain/examples/parallelized/work/out.0.0
index 7a00ed0f..c559dd4d 100644
--- a/training/dtrain/examples/parallelized/work/out.0.0
+++ b/training/dtrain/examples/parallelized/work/out.0.0
@@ -1,9 +1,9 @@
                 cdec cfg 'cdec.ini'
 Loading the LM will be faster if you build a binary file.
-Reading ../example/nc-wmt11.en.srilm.gz
+Reading ../standard//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
 ****************************************************************************************************
-Seeding random number sequence to 3121929377
+Seeding random number sequence to 405292278
 
 dtrain
 Parameters:
@@ -16,6 +16,7 @@ Parameters:
            learning rate 0.0001
                    gamma 0
              loss margin 1
+       faster perceptron 0
                    pairs 'XYX'
                    hi lo 0.1
           pair threshold 0
@@ -51,11 +52,11 @@ WEIGHTS
     non0 feature count: 12
            avg list sz: 100
            avg f count: 11.32
-(time 0.37 min, 4.4 s/S)
+(time 0.35 min, 4.2 s/S)
 
 Writing weights file to 'work/weights.0.0' ...
 done
 
 ---
 Best iteration: 1 [SCORE 'stupid_bleu'=0.17521].
-This took 0.36667 min.
+This took 0.35 min.
diff --git a/training/dtrain/examples/parallelized/work/out.0.1 b/training/dtrain/examples/parallelized/work/out.0.1
index e2bd6649..8bc7ea9c 100644
--- a/training/dtrain/examples/parallelized/work/out.0.1
+++ b/training/dtrain/examples/parallelized/work/out.0.1
@@ -1,9 +1,9 @@
                 cdec cfg 'cdec.ini'
 Loading the LM will be faster if you build a binary file.
-Reading ../example/nc-wmt11.en.srilm.gz
+Reading ../standard//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
 ****************************************************************************************************
-Seeding random number sequence to 2767202922
+Seeding random number sequence to 43859692
 
 dtrain
 Parameters:
@@ -16,6 +16,7 @@ Parameters:
            learning rate 0.0001
                    gamma 0
              loss margin 1
+       faster perceptron 0
                    pairs 'XYX'
                    hi lo 0.1
           pair threshold 0
@@ -52,11 +53,11 @@ WEIGHTS
     non0 feature count: 12
            avg list sz: 100
            avg f count: 10.496
-(time 0.32 min, 3.8 s/S)
+(time 0.35 min, 4.2 s/S)
 
 Writing weights file to 'work/weights.0.1' ...
 done
 
 ---
 Best iteration: 1 [SCORE 'stupid_bleu'=0.26638].
-This took 0.31667 min.
+This took 0.35 min.
diff --git a/training/dtrain/examples/parallelized/work/out.1.0 b/training/dtrain/examples/parallelized/work/out.1.0
index 6e790e38..65d1e7dc 100644
--- a/training/dtrain/examples/parallelized/work/out.1.0
+++ b/training/dtrain/examples/parallelized/work/out.1.0
@@ -1,9 +1,9 @@
                 cdec cfg 'cdec.ini'
 Loading the LM will be faster if you build a binary file.
-Reading ../example/nc-wmt11.en.srilm.gz
+Reading ../standard//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
 ****************************************************************************************************
-Seeding random number sequence to 1432415010
+Seeding random number sequence to 4126799437
 
 dtrain
 Parameters:
@@ -16,6 +16,7 @@ Parameters:
            learning rate 0.0001
                    gamma 0
              loss margin 1
+       faster perceptron 0
                    pairs 'XYX'
                    hi lo 0.1
           pair threshold 0
@@ -51,11 +52,11 @@ WEIGHTS
     non0 feature count: 11
            avg list sz: 100
            avg f count: 11.814
-(time 0.45 min, 5.4 s/S)
+(time 0.43 min, 5.2 s/S)
 
 Writing weights file to 'work/weights.1.0' ...
 done
 
 ---
 Best iteration: 1 [SCORE 'stupid_bleu'=0.10863].
-This took 0.45 min.
+This took 0.43333 min.
diff --git a/training/dtrain/examples/parallelized/work/out.1.1 b/training/dtrain/examples/parallelized/work/out.1.1
index 0b984761..f479fbbc 100644
--- a/training/dtrain/examples/parallelized/work/out.1.1
+++ b/training/dtrain/examples/parallelized/work/out.1.1
@@ -1,9 +1,9 @@
                 cdec cfg 'cdec.ini'
 Loading the LM will be faster if you build a binary file.
-Reading ../example/nc-wmt11.en.srilm.gz
+Reading ../standard//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
 ****************************************************************************************************
-Seeding random number sequence to 1771918374
+Seeding random number sequence to 2112412848
 
 dtrain
 Parameters:
@@ -16,6 +16,7 @@ Parameters:
            learning rate 0.0001
                    gamma 0
              loss margin 1
+       faster perceptron 0
                    pairs 'XYX'
                    hi lo 0.1
           pair threshold 0
@@ -52,11 +53,11 @@ WEIGHTS
     non0 feature count: 12
            avg list sz: 100
            avg f count: 11.224
-(time 0.42 min, 5 s/S)
+(time 0.45 min, 5.4 s/S)
 
 Writing weights file to 'work/weights.1.1' ...
 done
 
 ---
 Best iteration: 1 [SCORE 'stupid_bleu'=0.13169].
-This took 0.41667 min.
+This took 0.45 min.
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..21f91244 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 970626287
 
 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 = -614
+       WordPenalty = +1256.8
+     LanguageModel = +5610.5
+ LanguageModel_OOV = -1449
+     PhraseModel_0 = -2107
+     PhraseModel_1 = -4666.1
+     PhraseModel_2 = -2713.5
+     PhraseModel_3 = +4204.3
+     PhraseModel_4 = -1435.8
+     PhraseModel_5 = +916
+     PhraseModel_6 = +190
+       PassThrough = -2527
         ---
-       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.17874 (+0.17874)
+ 1best avg model score: 88399 (+88399)
+           avg # pairs: 798.2 (meaningless)
+        avg # rank err: 798.2
      avg # margin viol: 0
-    non0 feature count: 703
-           avg list sz: 90.9
-           avg f count: 100.09
-(time 0.25 min, 1.5 s/S)
+    non0 feature count: 887
+           avg list sz: 91.3
+           avg f count: 126.85
+(time 0.33 min, 2 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 = -1025
+       WordPenalty = +1751.5
+     LanguageModel = +10059
+ LanguageModel_OOV = -4490
+     PhraseModel_0 = -2640.7
+     PhraseModel_1 = -3757.4
+     PhraseModel_2 = -1133.1
+     PhraseModel_3 = +1837.3
+     PhraseModel_4 = -3534.3
+     PhraseModel_5 = +2308
+     PhraseModel_6 = +1677
+       PassThrough = -6222
         ---
-       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.30764 (+0.12891)
+ 1best avg model score: -2.5042e+05 (-3.3882e+05)
+           avg # pairs: 725.9 (meaningless)
+        avg # rank err: 725.9
      avg # margin viol: 0
-    non0 feature count: 1115
+    non0 feature count: 1499
            avg list sz: 91.3
-           avg f count: 90.755
-(time 0.3 min, 1.8 s/S)
+           avg f count: 114.34
+(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.30764].
+This took 0.65 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/parallelize.rb b/training/dtrain/parallelize.rb
index e661416e..285f3c9b 100755
--- a/training/dtrain/parallelize.rb
+++ b/training/dtrain/parallelize.rb
@@ -4,7 +4,7 @@ require 'trollop'
 
 def usage
   STDERR.write "Usage: "
-  STDERR.write "ruby parallelize.rb -c <dtrain.ini> [-e <epochs=10>] [--randomize/-z] [--reshard/-y] -s <#shards|0> [-p <at once=9999>] -i <input> -r <refs> [--qsub/-q] [--dtrain_binary <path to dtrain binary>] [-l \"l2 select_k 100000\"]\n"
+  STDERR.write "ruby parallelize.rb -c <dtrain.ini> [-e <epochs=10>] [--randomize/-z] [--reshard/-y] -s <#shards|0> [-p <at once=9999>] -i <input> -r <refs> [--qsub/-q] [--dtrain_binary <path to dtrain binary>] [-l \"l2 select_k 100000\"] [--extra_qsub \"-l virtual_free=24G\"]\n"
   exit 1
 end
 
@@ -20,6 +20,7 @@ opts = Trollop::options do
   opt :references, "references", :type => :string
   opt :qsub, "use qsub", :type => :bool, :default => false
   opt :dtrain_binary, "path to dtrain binary", :type => :string
+  opt :extra_qsub, "extra qsub args", :type => :string, :default => ""
 end
 usage if not opts[:config]&&opts[:shards]&&opts[:input]&&opts[:references]
 
@@ -119,11 +120,11 @@ end
       qsub_str_start = qsub_str_end = ''
       local_end = ''
       if use_qsub
-        qsub_str_start = "qsub -cwd -sync y -b y -j y -o work/out.#{shard}.#{epoch} -N dtrain.#{shard}.#{epoch} \""
+        qsub_str_start = "qsub #{opts[:extra_qsub]} -cwd -sync y -b y -j y -o work/out.#{shard}.#{epoch} -N dtrain.#{shard}.#{epoch} \""
         qsub_str_end = "\""
         local_end = ''
       else
-        local_end = "&>work/out.#{shard}.#{epoch}"
+        local_end = "2>work/out.#{shard}.#{epoch}"
       end
       pids << Kernel.fork {
         `#{qsub_str_start}#{dtrain_bin} -c #{ini}\
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