modelexpecttree.h

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

//////////////////////////////////////////////////////////////////////
///
///  Copyright (c) 2000, Yusuke Miyao
///  You may distribute under the terms of the Artistic License.
///
///  <id>$Id: ModelExpectTree.h,v 1.10 2003/05/16 13:03:46 yusuke Exp $</id>
///  <collection>Maximum Entropy Estimator</collection>
///  <name>ModelExpectTree.h</name>
///  <overview>Feature expectations given by the model for feature forest</overview>
///
//////////////////////////////////////////////////////////////////////

#ifndef Amis_ModelExpectTree_h_

#define Amis_ModelExpectTree_h_

#include <amis/configure.h>
#include <amis/Real.h>
#include <amis/EventTreeSpaceBase.h>
#include <amis/ModelBase.h>
#include <amis/ModelExpect.h>
#include <amis/AlphaTree.h>

#include <vector>

AMIS_NAMESPACE_BEGIN

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

template < class Feature, class FeatureFreqArray, class AlphaSet, bool EnableJointProb = false >
class ModelExpectTree : public ModelExpectBase< FeatureFreqArray > {
private:
  const ModelBase* model;
  const EventTreeSpaceBase< Feature >* event_space;
  AlphaTree< Feature, AlphaSet > alpha_tree;
#ifdef AMIS_PARALLEL
  int num_threads;
#endif // AMIS_AMIS_PARALLEL

public:
  void initialize( const ModelBase& init_model, const EventTreeSpaceBase< Feature >& init_event, int num = 1 ) {
    model = &init_model;
    event_space = &init_event;
    AMIS_DEBUG_MESSAGE( 3, "Set internal data...\n" );
    resize( model->numFeatures() );
    for ( typename std::vector< FeatureFreqArray >::iterator it = begin(); it != end(); ++it ) {
      it->reserve( event_space->maxFeatureCount() + 1 );
      it->clear();
    }
    alpha_tree.initialize( event_space->maxEventTreeNodes(), event_space->maxFeatureCount() + 1 );
//     std::cerr << "# event tree nodes = " << event_space->numEventTreeNodes() << std::endl;
//     std::cerr << "Max event tree nodes = " << event_space->maxEventTreeNodes() << std::endl;
//     std::cerr << "Max feature count = " << event_space->maxFeatureCount() << std::endl;
#ifdef AMIS_PARALLEL
    num_threads = num;
#endif // AMIS_PARALLEL
  }
  /// Initialization of the internal data before estimation

public:
  Real setModelExpectation( bool report_iteration = true ) {
    if ( report_iteration ) {
      return setModelExpectationInternal< true >();
    } else {
      return setModelExpectationInternal< false >();
    }
  }

protected:
  template < bool REPORT >
  Real setModelExpectationInternal( void ) {
  for ( typename std::vector< FeatureFreqArray >::iterator it = begin(); it != end(); ++it ) it->clear();
    Real log_likelihood = 0.0;
    Real event_empirical_expectation = event_space->eventEmpiricalExpectation();
    AMIS_DEBUG_MESSAGE( 5, "\t\t------------------------------\n" );
    for ( int event_id = 0; event_id < event_space->numEvents(); ++event_id ) {
      AMIS_DEBUG_MESSAGE( 5, "\t\tEvent ID = " << event_id << '\n' );
      const EventTree< Feature >& tree = (*event_space)[ event_id ];
      //cerr << "Event " << event_id << "  # nodes = " << tree.numEventTreeNodes()<< std::endl;
      AMIS_DEBUG_MESSAGE( 5, "\t\tMake AlphaProdTree\n" );
      alpha_tree.setProduct( *model, tree );
      Real sum = alpha_tree.sumProduct();
      AMIS_DEBUG_MESSAGE( 5, "\t\t  Sum = " << sum << '\n' );
      if ( ! finite( sum ) ) continue;
      Real inv_sum = 1.0 / sum;
      Real denom = tree.eventFrequency() * event_empirical_expectation * inv_sum;

      if ( EnableJointProb ) denom *= tree.eventProbability();
      //cerr << "denom=" << denom << endl;

      AMIS_DEBUG_MESSAGE( 5, "\t\tSet model expectations for features\n" );
      AlphaSet alpha_product;
      for ( int i = 0; i < tree.numEventTreeNodes(); ++i ) {
        const EventTreeNode< Feature >& event_node = tree[ i ];
        if ( ! event_node.isDisjunctiveNode() ) {
          alpha_product.product( alpha_tree.insideProd( i ),
                                 alpha_tree.outsideProd( i ) );
          AMIS_DEBUG_MESSAGE( 5, alpha_product << std::endl );
          alpha_product *= denom;
          for ( typename FeatureList< Feature >::const_iterator feature = event_node.featureList().begin();
                feature != event_node.featureList().end();
                ++feature ) {
            alpha_product.incFeatureFreqArray( (*this)[ feature->id() ], feature->freq() );
          }
        }
      }
      if ( REPORT ) {
	log_likelihood += event_empirical_expectation * tree.frequency() * ModelBase::safe_log( ModelFunction< ModelBase, EventTree< Feature > >().product( *model, tree.observedEvent() ) * inv_sum );
        AMIS_DEBUG_MESSAGE( 5, "\t\tLog-likelihood = " << log_likelihood << std::endl );
        //cerr << model->product( event_space->activeEvent( event_id ) ) << " " << sum << " " << inv_sum << std::endl;
      }
    }
    AMIS_DEBUG_MESSAGE( 5, "\t\t------------------------------\n" );
//     for ( int i = 0; i < model_expectation.size(); ++i ) {
//       std::cerr << "fid=" << i;
//       model_expectation[ i ].debugInfo( cerr );
//       std::cerr << "  " << empirical_expectation[ i ] << std::endl;
//     }
    return log_likelihood;
  }
  /// Set the model expectation of features
};

AMIS_NAMESPACE_END

#endif // ModelExpect_h_
// end of ModelExpect.h