learner.h

Go to the documentation of this file.

#ifndef __ZGEN_BESTFIRST_LEARNING_LEARNER_H__
#define __ZGEN_BESTFIRST_LEARNING_LEARNER_H__

#include "bestfirst/model/model.h"
#include "bestfirst/search/span.h"
#include "bestfirst/search/span_types.h"
#include "bestfirst/search/span_allocator.h"

namespace ZGen {

namespace BestFirst {

class Learner {
public:
  enum { CONVERGED = 0,
    SAFE_UNCONVERGED,
    UNSAFE_UNCONVERGED,
    NO_GOLD_IN_AGENDA };

  Learner(Model* model, int max_iteration= 1);

  void config_model(Model* model);

  void config_timestamp(int timestamp);

  int learn(const SpanSet& gold_spans,
      SpanMaxHeap& agenda);

private:
  bool test_convergence(int nr_gold_spans, const SpanSet& gold_spans);

  void learn_one_iteration();

  void load_sortedlist_from_agenda(SpanMaxHeap& agenda);

  void load_agenda_from_sortedlist(SpanMaxHeap& agenda);

  void load_agenda_from_sortedlist(const SpanSet& gold_spans,
      SpanMaxHeap& agenda);

  int count_number_of_gold_spans_in_sortedlist(const SpanSet& gold_spans);

  int collect_positive_spans(int nr_gold_spans,
      const SpanSet& gold_spans);

  int collect_negative_spans(int nr_gold_spans,
      const SpanSet& gold_spans);

  void increase_positive_spans(const std::vector<Span*>& positive_spans);

  void decrease_negative_spans(const std::vector<Span*>& negative_spans);

  void score_spans_in_sortedlist();
private:
  Model* model;
  int max_iteration;
  int timestamp;
  std::vector<Span *> positive_spans;
  std::vector<Span *> negative_spans;
  std::vector<Span *> sorted_span_list;
};

} //  end for namespace BestFirst

} //  end for namespace ZGen

#endif  //  end for __ZGEN_BESTFIRST_LEARNING_PERCEPTRON__