modelstat.h

Amis - A maximum entropy estimator 一个最大熵模型统计工具

#ifndef Amis_ModelStat_h_

#define Amis_ModelStat_h_

#include <amis/configure.h>
#include <amis/Real.h>
#include <amis/EmpiricalExpect.h>
#include <amis/ModelFunction.h>
#include <memory>

AMIS_NAMESPACE_BEGIN

class ModelStatBase {
protected:
  std::vector< Real > emp_cnt;
  std::vector< Real > val_sums;
  std::vector< Real > vval_sums;
  std::vector< Real > bayes_emps;
  std::vector< Real > bayes_raw_sigmas;
  std::vector< Real > bayes_sigmas;
  std::vector< Real > bayes_hist_emps;
  std::vector< Real > bayes_hist_raw_sigmas;
  std::vector< Real > bayes_hist_sigmas;

public:
  ModelStatBase() {}
  virtual ~ModelStatBase() {}

public:
  Real getBayesSigma( FeatureID i ) const { return bayes_sigmas[ i ]; }
  Real getBayesRawSigma( FeatureID i ) const { return bayes_raw_sigmas[ i ]; }
  Real getBayesHistSigma( FeatureID i ) const {	return bayes_hist_sigmas[ i ]; }
  Real getBayesHistRawSigma( FeatureID i ) const { return bayes_hist_raw_sigmas[ i ]; }

  virtual void setModelStatistics( const EmpiricalExpectBase& empirical_expectation ) = 0;
};

//////////////////////////////////////////////////////////////////////

template < class Model, class EventSpace >
class ModelStat : public ModelStatBase {
public:
  typedef typename EventSpace::FeatureType Feature;
  typedef typename EventSpace::EventType Event;

protected:
  const Model* model;
  const EventSpace* event_space;

public:
  ModelStat() {
    model = NULL;
    event_space = NULL;
  }
  virtual ~ModelStat() {}

  virtual void initialize( const Model& init_model,
                           const EventSpace& init_event_space ) {
    model = &init_model;
    event_space = &init_event_space;
    emp_cnt.assign( model->numFeatures(), 0.0 );
    val_sums.assign( model->numFeatures(), 0.0 );
    vval_sums.assign( model->numFeatures(), 0.0 );
    bayes_emps.assign( model->numFeatures(), 0.0 );
    bayes_raw_sigmas.assign( model->numFeatures(), 0.0 );
    bayes_sigmas.assign( model->numFeatures(), 0.0 );
    bayes_hist_emps.assign( model->numFeatures(), 0.0 );
    bayes_hist_raw_sigmas.assign( model->numFeatures(), 0.0 );
    bayes_hist_sigmas.assign( model->numFeatures(), 0.0 );
  }

  void setModelStatistics( const EmpiricalExpectBase& empirical_expectation ) {
    /*
    setEmpiricalExpectVariance();
    for ( int i = 0; i < numFeatures(); ++i ) {
      Real emp = empirical_expectation[ i ];
      Real fc  = getFeatureCount( i );
      Real ec  = getEventCount();
      Real e   = ( 1.0 + fc ) / ( 2.0 + ec );
      Real vn  = ( 1.0 + fc ) * ( 1.0 + ec - fc );
      Real vd  = ( 2.0 + ec ) * ( 2.0 + ec ) * ( 3.0 + ec );
      Real v   = vn / vd;
      Real s   = sqrt( v );
      Real bayes_emp   = expect_variance.val_sums[ i ] * e;
      Real bayes_v     = expect_variance.vval_sums[ i ] * v;
      Real bayes_sigma = sqrt( bayes_v );
      bayes_emps[ i ]       = bayes_emp;
      bayes_raw_sigmas[ i ] = s;
      bayes_sigmas[ i ]     = bayes_sigma;
    }
    */
  }

protected:
  virtual void setEmpiricalExpectVariance() {
    /*
    for( int i = 0; i < event_space->numEvents(); ++i ) {
      const Event& event = (*event_space)[ i ];
      ModelFunction< Model, Event >().setEmpiricalExpectVariance( *model, emp_cnt, val_sums, vval_sums );
    }
    for ( int i = 0; i < model->numFeatures(); ++i ) {
      val_sums[ i ] *= event_space->eventEmpiricalExpectation();
      vval_sums[ i ] *= event_space->eventEmpiricalExpectation() * event_space->eventEmpiricalExpectation();
    }
    */
  }
};

typedef std::auto_ptr< ModelStatBase > ModelStatPtr;

AMIS_NAMESPACE_END

#endif // Amis_ModelStat_h_
// end of ModelStat.h