training-vector-set.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_TRAINING_VECTOR_SET_H_
#define RERANKER_TRAINING_VECTOR_SET_H_

#include <iostream>
#include <unordered_map>
#include <unordered_set>

#include "training-time.H"
#include "feature-vector.H"

namespace reranker {

using std::cerr;
using std::endl;
using std::unordered_map;
using std::unordered_set;

class TrainingVectorSet {
 public:
  friend class PerceptronModelProtoReader;
  TrainingVectorSet() { }
  virtual ~TrainingVectorSet() { }

  // accessors

  const FeatureVector<int,double> &weights() const { return weights_; }
  const FeatureVector<int,double> &average_weights() const {
    return average_weights_;
  }

  const FeatureVector<int,double> &GetModel(bool raw) const {
    return raw ? weights() : average_weights();
  }

  // mutators

  template <typename Collection>
  void UpdateWeights(const Time &time,
                     const Collection &feature_uids,
                     const FeatureVector<int,double> &feature_vector,
                     double scalar) {
    weights_.AddScaledSubvector(feature_uids, feature_vector, scalar);
  }

  template <typename Collection>
  void UpdateGoldAndCandidateFeatureAverages(const Time &time,
                                             const Collection &
                                               gold_feature_uids,
                                             const Collection &
                                               candidate_feature_uids) {
    UpdateFeatureAverages(time,
                          gold_feature_uids.begin(),
                          gold_feature_uids.end());
    UpdateFeatureAverages(time,
                          candidate_feature_uids.begin(),
                          candidate_feature_uids.end());
  }

  void UpdateAllFeatureAverages(const Time &time) {
    // Get set union of non-zero feature weights and average feature weights.
    unordered_set<int> uids;
    weights_.GetNonZeroFeatures(uids);
    average_weights_.GetNonZeroFeatures(uids);
    UpdateFeatureAverages(time, uids.begin(), uids.end());
  }

  void RemapFeatureUids(const unordered_map<int, int> &old_to_new_uids) {
    RemapFeatureUids(old_to_new_uids, weights_);
    RemapFeatureUids(old_to_new_uids, average_weights_);
    RemapFeatureUids(old_to_new_uids, weight_sums_);
    RemapFeatureUids(old_to_new_uids, last_update_indices_);
  }

  // I/O methods
  friend ostream &operator<<(ostream &os, const TrainingVectorSet &tvs) {
    os << "weights: " << tvs.weights_ << "\n"
       << "average weights: " << tvs.average_weights_ << "\n"
       << "weight sums: " << tvs.weight_sums_ << "\n"
       << "last update indices: " << tvs.last_update_indices_ << "\n";
    return os;
  }

 private:

  template <typename V>
  void RemapFeatureUids(const unordered_map<int, int> &old_to_new_uids,
                        FeatureVector<int, V> &vector) {
    FeatureVector<int, V> old_vector = vector;
    vector.clear();
    typedef typename FeatureVector<int, V>::const_iterator fv_const_iterator;
    for (fv_const_iterator old_vector_it = old_vector.begin();
         old_vector_it != old_vector.end();
         ++old_vector_it) {
      int old_uid = old_vector_it->first;
      unordered_map<int, int>::const_iterator old_to_new_uid_it =
          old_to_new_uids.find(old_uid);
      if (old_to_new_uid_it != old_to_new_uids.end()) {
        int new_uid = old_to_new_uid_it->second;
        V old_value = old_vector_it->second;
        vector.SetWeight(new_uid, old_value);
      }
    }
  }

  void UpdateAverage(const Time &time, int uid) {
    int iterations_since_update =
        time.absolute_index() - last_update_indices_.GetValue(uid);
    if (iterations_since_update <= 0) {
      return;
    }
    // Add in perceptron values to weight sum.
    double add_to_sum = iterations_since_update * weights_.GetWeight(uid);
    double new_weight_sum = weight_sums_.IncrementWeight(uid, add_to_sum);
    average_weights_.SetWeight(uid, new_weight_sum / time.absolute_index());
    last_update_indices_.SetValue(uid, time.absolute_index());
  }

  template <typename Iterator>
  void UpdateFeatureAverages(const Time &time,
                             Iterator feature_uids_begin_it,
                             Iterator feature_uids_end_it) {
    for (Iterator it = feature_uids_begin_it; it != feature_uids_end_it; ++it) {
      UpdateAverage(time, *it);
    }
  }

  // data members
  FeatureVector<int,double> weights_;
  FeatureVector<int,double> average_weights_;
  FeatureVector<int,double> weight_sums_;
  FeatureVector<int,int> last_update_indices_;
};

}  // namespace reranker

#endif