candidate.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_CANDIDATE_H_
#define RERANKER_CANDIDATE_H_

#include <iostream>
#include <string>
#include <sstream>

#include "../proto/data.pb.h"
#include "factory.H"
#include "feature-vector.H"
#include "symbol-table.H"

namespace reranker {

using std::ostream;
using std::string;

class Model;

class Candidate {
 public:
  friend class FeatureExtractor;
  friend class AbstractFileBackedFeatureExtractor;
  Candidate(int index,
            double loss,
            double baseline_score,
            int num_words,
            const string &raw_data) :
      index_(index), num_errors_(0), num_correct_(0),
      loss_(loss), score_(0.0), baseline_score_(baseline_score),
      num_words_(num_words), raw_data_(raw_data), compiled_(false) {
  }

  Candidate(int index,
            double loss,
            double baseline_score,
            int num_words,
            const string &raw_data,
            const FeatureVector<int,double> &features,
            const FeatureVector<string,double> &symbolic_features) : 
      index_(index), num_errors_(0), num_correct_(0),
      loss_(loss), score_(0.0), baseline_score_(baseline_score),
      num_words_(num_words), features_(features),
      symbolic_features_(symbolic_features), raw_data_(raw_data),
      compiled_(false) {
  }

  virtual ~Candidate() { }
  
  class Comparator : public FactoryConstructible {
   public:
    virtual int Compare(const Model &model,
                        const Candidate &c1, const Candidate &c2) = 0;
  };

  // accessors
  // in its set.
  int index() const { return index_; }
  int num_errors() const { return num_errors_; }
  int num_correct() const { return num_correct_; }
  double loss() const { return loss_; }
  double score() const { return score_; }
  double baseline_score() const { return baseline_score_; }
  int num_words() const { return num_words_; }
  const FeatureVector<int,double> &features() const { return features_;  }
  const FeatureVector<string,double> &symbolic_features() const {
    return symbolic_features_;
  }
  const string &raw_data() const { return raw_data_; }
  bool compiled() const { return compiled_; }

  // mutators
  void set_raw_data(const string &raw_data) { raw_data_ = raw_data; }

  void set_score(double score) { score_ = score; }

  void set_baseline_score(double baseline_score) {
    baseline_score_ = baseline_score;
  }

  void set_loss(double loss) { loss_ = loss; }

  bool Compile(Symbols *symbols,
               bool clear_features = false,
               bool clear_symbolic_features = true,
               bool force = false);

  void Decompile(Symbols *symbols,
                 bool clear_symbolic_features = false,
                 bool clear_features = true,
                 bool force = false);

  friend ostream &operator<<(ostream &os, const Candidate &c) {
    os << "{index:" << c.index() << "; loss:" << c.loss()
       << "; score:" << c.score() << "; baseline_score:" << c.baseline_score()
       << "; features:" << c.features()
       << "; symbolic_features:" << c.symbolic_features()
       << "; raw_data:\"" << c.raw_data() << "\""
       << "; compiled: " << (c.compiled() ? "true" : "false")
       << "}";
    return os;
  }

  string to_string() {
    std::ostringstream oss;
    oss << *this;
    return oss.str();
  }

 private:
  // Methods for friend class FeatureExtractor.
  FeatureVector<int,double> &mutable_features() { return features_; }
  FeatureVector<string,double> &mutable_symbolic_features() {
    return symbolic_features_;
  }

  // data members
  // The index of this candidate in its ordered list of candidates
  // (its candidate set).
  // TODO(dbikel,kbhall): Is this really necessary?  The CandidateSet
  //                      will contain this index.  Maybe this will be
  //                      necessary if we want to pass a single
  //                      Candidate to a feature function that needs
  //                      its "rank" in the CandidateSet.
  int index_;
  // TODO(dbikel,kbhall): The following three data members seem overly
  //                      specific to WER (and therefore to speech
  //                      evaluation).  The number of word errors in
  //                      this candidate.
  int num_errors_;
  // The number of correct words in this candidate.a
  int num_correct_;
  // The loss of this candidate relative to the reference.  For speech, this
  // value should be (num_errors_ / num_correct_).
  double loss_;
  // The score of this candidate according to the reranker.
  double score_;
  // The baseline model score for this candidate.
  double baseline_score_;
  // The number of words in this candidate.  (This value might be hard
  // or impossible to determine simply from features.)
  int num_words_;
  // The features for this candidate.
  FeatureVector<int,double> features_;
  // The symbolic features for this candidate.
  FeatureVector<string,double> symbolic_features_;
  // The raw data (string) corresponding to this candidate.
  string raw_data_;
  // Whether this candidate's symbolic features have been "compiled".
  bool compiled_;
};

#define REGISTER_NAMED_CANDIDATE_COMPARATOR(TYPE,NAME) \
  REGISTER_NAMED(TYPE,NAME,Candidate::Comparator)

#define REGISTER_CANDIDATE_COMPARATOR(TYPE) \
  REGISTER_NAMED_CANDIDATE_COMPARATOR(TYPE,TYPE)

}  // namespace reranker

#endif