mimic.hxx

改算法基于遗传算法

// coded by H.Handa       02/11/26  Ver.0.1
//                         Time-stamp: <2007-07-12 12:10:50 handa>

#ifndef MIMIC_HH
#define MIMIC_HH
using namespace std;

#include "estimation_and_sampling.hxx"
#include <algorithm>
#include <list>
#include <vector>
#include <math.h>
#include "plog.hxx"


// This class is the Mutual Information Maximization for Input Clustering
// class.

template <class T> class mimic: public estimation_and_sampling<T> {
protected:
  vector<vector<double> > pd;  // the probabitily distribution;
  vector<vector<vector<double> > > cpmu; 
  // the conditional probabilites for calculating the mean uncertainty in X given Y;
  vector<double> prob; // probability
  vector<vector<vector<double> > > cps; 
  // the conditional probabilities
  vector<int> permutation;
  environment<T>& env;
  int sampleSize;
public:
  mimic(random_number& r, int len, int v, int s, environment<T>& arg) 
    : estimation_and_sampling<T>(r), env(arg) {
    int i,j;

  sampleSize = s;
    pd.resize(len);
    for(i =0;i < len;i++) {
      pd[i].resize(v);
    }

    cpmu.resize(len);
    for(i =0;i < len;i++) {
      cpmu[i].resize(v);
      for(j =0;j < v;j++) {
	cpmu[i][j].resize(v);
      }
    }

    prob.resize(v);

    cps.resize(len -1);
    for(i =0;i < len -1;i++) {
      cps[i].resize(v);
      for(j =0;j < v;j++) {
	cps[i][j].resize(v);
      }
    }
  }  
  void estimation(vector<chromosome<T> *>& pool) {
    int i, j, k, l, m;
    double dtmp;
    int itmp;
    permutation.clear();

    // initialize the matrix of the prob. distribuiton.
    for (i = 0; i < pd.size(); i++) 
      for (j = 0; j < pd[i].size(); j++) 
	pd[i][j] = 0.0;

    double fraction = 1.0 / pool.size();

    for (i = 0; i < pool.size(); i++) 
      for (j = 0; j < pool[i]->Size(); j++) 
	pd[j][pool[i]->getgene(j)] += fraction;

    double min = 10000000000.0;
    int v;
    for (i = 0; i < pd.size(); i++) {
      dtmp  = 0.0;
      for (j = 0; j < pd[i].size(); j++) 
	if (pd[i][j] != 0.0)
	  dtmp -= plog(pd[i][j]); //pd[i][j] * log(pd[i][j]);
      if (dtmp < min) {
	v = i;
	min = dtmp;
      }
    }

    permutation.push_back(v);
    for(i = 0; i < prob.size(); i++)
      prob[i] = pd[v][i];

    for(k = 0;k < permutation.size() ;k++) {
      min = 10000000000.0;
      v = -1;
      for (j = 0; j < cpmu.size(); j++) {
	if (find(permutation.begin(),permutation.end(), j) == permutation.end()) {
	  for (l = 0; l < cpmu[j].size(); l++)
	    for (m = 0; m < cpmu[j][l].size(); m++)
	      cpmu[j][l][m] = 0.0;

	  for (i = 0; i < pool.size(); i++) {
	    itmp = pool[i]->getgene(permutation[k]);
	    cpmu[j][itmp][pool[i]->getgene(j)] += 
	      fraction / pd[permutation[k]][itmp];
	  }

	  dtmp  = 0.0;
	  for (l = 0; l < cpmu[j].size(); l++)
	    for (m = 0; m < cpmu[j][l].size(); m++) 
	      if(cpmu[j][l][m] != 0)
		dtmp -= plog(cpmu[j][l][m])*pd[permutation[k]][l]; // cpmu[j][l][m] * log(cpmu[j][l][m]) * pd[permutation[k]][l];
	  if (dtmp < min) {
	    v = j;
	    min = dtmp;
	  }
	}
      }
      if (v != -1) {
	itmp = permutation.size() -1;
	for (l = 0; l < cpmu[v].size(); l++)
	  for (m = 0; m < cpmu[v][l].size(); m++)
	    cps[itmp][l][m] = cpmu[v][l][m];
	permutation.push_back(v);
      }	
    }
  }

  virtual void sampling(list<chromosome<T> *>& pop, int decedent) {
    int i, j, k, l, m;
    double dtmp;
    int itmp;
    chromosome<T>* ctmp;
    
    for (i = 0; i < sampleSize; i++) {
      int prev;
      ctmp = new chromosome<T>(env);
      dtmp = this->rn.urand(1.0);
      for (k = 0; k < prob.size(); k++) {
	dtmp -= prob[k];
	if (dtmp <= 0.0) {
	  ctmp->setgene(permutation[0], k);
	  prev = k;
	  break;
	}
      }
      for (j = 0; j < cps.size(); j++) {
	dtmp = this->rn.urand(1.0);
	for (k = 0; k < cps[j].size(); k++) {
	  dtmp -= cps[j][prev][k];
	  if (dtmp <= 0.0) {
	    ctmp->setgene(permutation[j+1], k);
	    prev = k;
	    break;
	  }
	}
      }
      ctmp->setDecedent(decedent);
      pop.push_back(ctmp);
    }
  }
  virtual void generating(vector<chromosome<T> *>& pool,
			  list<chromosome<T> *>& pop) {
    int decedent = pool[0]->isDecedent();
    estimation(pool);
    sampling(pop, decedent);
  }

  virtual estimation_and_sampling<T>& operator=(const estimation_and_sampling<T>& arg) {
    if(this == &arg) return *this;
    this->rn = arg.rn;     // random
  }
  
};


#endif