Tanl Linguistic Pipeline

classifier/MaxEnt.h

/*
**  Tanl
**  classifier/MaxEnt.h
**  ----------------------------------------------------------------------
**  Copyright (c) 2003  Giuseppe Attardi (attardi@di.unipi.it).
**  ----------------------------------------------------------------------
**
**  This file is part of Tanl.
**
**  Tanl is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  Tanl is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef Tanl_Classifier_MaxEnt_H
#define Tanl_Classifier_MaxEnt_H

#include "Classifier.h"
#include "include/unordered_map.h"
#include "text/strings.h"       // hash<string>

// standard
#include <list>

// use correction
#define SLACK

BEGIN_NAMESPACE_HASH
  template<> struct hash<std::pair<unsigned, unsigned> > {
    size_t operator()(const std::pair<unsigned, unsigned>& x) const {
      unsigned a = x.first + ~(x.first << 13);
      unsigned b = x.second + ~(x.second << 9);
      a += (b >> 13);
      return a ^ b;
      //return (x.first << 8) ^ x.second;
    }
  };

  template<> struct hash<std::pair<unsigned, std::vector<unsigned> > > {
    size_t operator()(const std::pair<unsigned, std::vector<unsigned> >& x) const {
      const std::vector<unsigned>& v = x.second;
      int n = x.first;
      for (int i = 0; i < v.size(); ++i)
        n += v[i] * (i+1);
      return n + v.size() * 47;
    }
  };
END_NAMESPACE_HASH

namespace Tanl {
namespace Classifier {

typedef std::pair<PID, ClassID> Feature;
typedef unordered_map<Feature, double>  FeatureMap;
typedef unordered_map<std::string, int> WordCounts;

class MaxEnt : public Classifier
{

public:

  MaxEnt() { }

  MaxEnt(int iterations, int cutoff) :
    iterations(iterations), cutoff(cutoff), pID(0),
    correctionConstant(1),
    correctionParam(0.0)
  { }

  MaxEnt(char const* file);

  MaxEnt(std::istream& ifs);

  virtual ~MaxEnt();

  void          estimate(Context& context, double prob[]) {
    estimate((std::vector<PID>&)context, prob);
  }

  void          estimate(Features& features, double prob[]) {
    Context context(features, predIndex);
    estimate((std::vector<PID>&)context, prob);
  }

  ClassID       BestOutcome(double* ocs) const;

  void          load(std::istream& is);

  void          save(char const* file);

  void          read(EventStream& eventStream);

protected:

  void          readEvent(Event* ev);

  ClassID               estimate(const std::vector<PID>& predicates, double alpha[]);

  FeatureMap            lambda; 
  PID                   numPreds; 
  int                   numTokens; 
  typedef unordered_map<std::pair<ClassID, std::vector<PID> >, int> EventMap;

  EventMap              eventMap; 

  unsigned              cutoff; 
  int                   iterations; 

  size_t                correctionConstant;
  double                correctionParam;

  // temporaries used by read() before train() gets called
  std::list<Event*>     events;
  WordCounts            counter;
  int                   pID;

  void                  loadZhang(std::istream& is);

  friend std::ostream& operator <<(std::ostream& s, MaxEnt const& m);

  // Build the EventMap of unique event occurrences,
  // assigning ids to predicates and labels.
  // It consumes and deletes events.
  static int buildIndex(std::list<Event*>& events,
                        Text::WordIndex& predIndex,
                        EventMap& eventMap,
                        std::vector<char const*>& outcomeLabels,
                        int evCutoff, bool verbose);
};

std::ostream& operator <<(std::ostream& s, MaxEnt const& m);

} // namespace Classifier
} // namespace Tanl

#endif // Tanl_Classifier_MaxEnt_H

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.