perceptron-model.H

Go to the documentation of this file.

// Copyright 2012, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//   * Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above
//     copyright notice, this list of conditions and the following disclaimer
//     in the documentation and/or other materials provided with the
//     distribution.
//   * Neither the name of Google Inc. nor the names of its
//     contributors may be used to endorse or promote products derived from
//     this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// -----------------------------------------------------------------------------
//
//

#ifndef RERANKER_PERCEPTRON_MODEL_H_
#define RERANKER_PERCEPTRON_MODEL_H_

#include <vector>
#include <unordered_set>
#include <memory>

#include "candidate-set.H"
#include "dot-product.H"
#include "model.H"
#include "training-time.H"
#include "training-vector-set.H"

#define DEFAULT_MAX_EPOCHS_IN_DECLINE 5

namespace reranker {

using std::shared_ptr;
using std::unordered_set;
using std::vector;

class PerceptronModel : public Model {
 public:
  friend class PerceptronModelProtoWriter;
  friend class PerceptronModelProtoReader;

  PerceptronModel() :
      Model("", new DotProduct()),
      models_(),
      best_models_(),
      best_model_epoch_(-1),
      max_epochs_in_decline_(DEFAULT_MAX_EPOCHS_IN_DECLINE),
      num_epochs_in_decline_(0),
      step_size_(1.0) {
    SetDefaultObjects();
  }

  PerceptronModel(const string &name) :
      Model(name, new DotProduct()),
      models_(),
      best_models_(),
      best_model_epoch_(-1),
      max_epochs_in_decline_(DEFAULT_MAX_EPOCHS_IN_DECLINE),
      num_epochs_in_decline_(0),
      step_size_(1.0) {
    SetDefaultObjects();
  }

  PerceptronModel(const string &name, KernelFunction *kernel_fn) :
      Model(name, kernel_fn),
      models_(),
      best_models_(),
      best_model_epoch_(-1),
      max_epochs_in_decline_(DEFAULT_MAX_EPOCHS_IN_DECLINE),
      num_epochs_in_decline_(0),
      step_size_(1.0) {
    SetDefaultObjects();
  }

  PerceptronModel(const string &name, KernelFunction *kernel_fn,
                  Symbols *symbols) :
      Model(name, kernel_fn, symbols),
      models_(),
      best_models_(),
      best_model_epoch_(-1),
      max_epochs_in_decline_(DEFAULT_MAX_EPOCHS_IN_DECLINE),
      num_epochs_in_decline_(0),
      step_size_(1.0) {
    SetDefaultObjects();
  }


  virtual ~PerceptronModel() { }

  class DefaultUpdatePredicate : public Model::UpdatePredicate {
    virtual bool NeedToUpdate(Model *model, CandidateSet &example);
  };

  class DefaultUpdater : public Model::Updater {
    virtual void Update(Model *m, CandidateSet &example);
  };

  virtual const string &model_spec() const { return model_spec_; }

  virtual const string &proto_reader_spec() const {
    return proto_reader_spec_;
  }

  virtual const string &proto_writer_spec() const {
    return proto_writer_spec_;
  }

  virtual int best_model_epoch() const { return best_model_epoch_; }

  virtual void RegisterInitializers(Initializers &initializers);

  virtual void Init(const Environment *env, const string &arg);

  // training methods

  virtual bool NeedToKeepTraining();

  virtual void Train(CandidateSetIterator &examples,
                     CandidateSetIterator &development_test);

  virtual void NewEpoch();

  virtual void EndOfEpoch();

  virtual void TrainOneEpoch(CandidateSetIterator &examples);

  virtual void TrainOnExample(CandidateSet &example);

  virtual bool NeedToUpdate(CandidateSet &example);

  virtual void Update(CandidateSet &example);

  virtual double Evaluate(CandidateSetIterator &development_test);

  virtual void ScoreCandidates(CandidateSet &candidates, bool training);

  virtual double ScoreCandidate(Candidate &candidate, bool training);

  // mutators

  virtual void CompactifyFeatureUids();
  
  void set_max_epochs_in_decline(int max_epochs_in_decline) {
    max_epochs_in_decline_ = max_epochs_in_decline;
  }

  virtual const TrainingVectorSet &models() const { return models_; }

 protected:
  void SetDefaultObjects() {
    update_predicate_ =
        GetUpdatePredicate("PerceptronModelDefaultUpdatePredicate()");
    updater_ =
        GetUpdater("PerceptronModelDefaultUpdater()");
  }

  virtual void ComputeFeaturesToUpdate(const CandidateSet &example,
                                       unordered_set<int> &
                                       gold_features_to_update,
                                       unordered_set<int> &
                                       best_scoring_features_to_update) const;

  virtual double ComputeStepSize(const unordered_set<int> &gold_features,
                               const unordered_set<int> &best_scoring_features,
                               const CandidateSet &example) {
    return step_size_;
    // For MIRA, simply derive class and override to be
    /*
    int feature_count = gold_features.size() + best_scoring_features.size();
    double loss_diff =
      example.GetBestScoring().loss() - example.GetGold().loss();
    double score_diff =
      example.GetBestScoring().score() - example.GetGold().score();
    double raw_step = (loss_diff + score_diff) / feature_count;
    step_size_ = raw_step > mira_clip_ : mira_clip_ : raw_step;
    return step_size_;
    */
  }

  // data members
  TrainingVectorSet models_;
  TrainingVectorSet best_models_;
  int best_model_epoch_;
  int max_epochs_in_decline_;
  int num_epochs_in_decline_;
  double step_size_;
  string model_spec_;

  static string proto_reader_spec_;
  static string proto_writer_spec_;
};

}  // namespace reranker

#endif