C++ Evaluator::evaluate方法代码示例

// Compare solution with a randomly generated opponent, return whichever
// has the higher fitness
void hill_climb::binary_tournament(Random & rand, vector<bool> & solution,
                                   float & fitness, Evaluator& evaluator) {
  auto guess = rand_vector(rand, solution.size());
  float guess_fitness = evaluator.evaluate(guess);
  if (fitness < guess_fitness) {
    solution = guess;
    fitness = guess_fitness;
  }
}

bool TestDocument::evaluate(Evaluator &evaluator) {
  bool rval = true;
  XMLSize_t numpass = 0;
  XMLSize_t numfail = 0;
  std::map<char *, bool, ltcstr> test_state;
  XMLCh *TEST = xercesc::XMLString::transcode("test");
  XMLCh *PREREQ = xercesc::XMLString::transcode("prereq");
  xercesc::DOMElement *root = doc->dom->getDocument()->getDocumentElement();
  xercesc::DOMNodeList *tests = root->getElementsByTagName(TEST);
  XMLSize_t numtests = tests->getLength();
  std::cout << numtests << " tests found in " << doc->path << std::endl;
  for (int i = 0; i < numtests; i++) {
    xercesc::DOMElement *e = static_cast<xercesc::DOMElement*>(tests->item(i));
    Test test(*this, e);
    bool testval = true;
    std::cout << "test " << (i+1) << " of " << numtests << ": " << test.id << "... ";
    if (e->hasAttribute(PREREQ)) {
      char *prereqs = xercesc::XMLString::transcode(e->getAttribute(PREREQ));
      char *scan = prereqs;
      std::stringstream prereq;
      while (char c = *scan++) {
        if (c == ' ' || c == ',') {
          testval = __checkPrereq(test, test_state, prereq) && testval;
          prereq.str("");
        }
        else {
          prereq << c;
        }
      }
      testval = __checkPrereq(test, test_state, prereq) && testval;
      xercesc::XMLString::release(&prereqs);
    }
    if (testval) {
      testval = evaluator.evaluate(*this, test)  && testval;
      testval = js_evaluator.evaluate(*this, test) && testval;
    }
    if (testval) {
      std::cout << "[OK]";
      numpass++;
    }
    else {
      std::cout << "[FAIL] (" << test.messages.str() << ")";
      numfail++;
    }
    std::cout << std::endl;
    test_state[xercesc::XMLString::replicate(test.id)] = testval;
    rval = testval && rval;
  }
  for (std::map<char *, bool, ltcstr>::iterator i = test_state.begin(); i != test_state.end(); i++) {
    xercesc::XMLString::release((char**)&i->first);
  }
  xercesc::XMLString::release(&TEST);
  xercesc::XMLString::release(&PREREQ);
  std::cout << numpass << " of " << numtests << " tests passed, " << numfail << " failed (" << ( ((double)numpass) / ((double)numtests) * 100.0 ) << "%)" << std::endl;
  return rval;
}

double backtracking_linear_search(
	Evaluator& evaluator,   // class of objective function value evaluation
	double *xp, // backup place for x
	double *p, // negative of search direction
	double *fx, // current function value at x
	double c, // sufficient decrease condition threshold
	double init_step, // initial step length
	double r, // scale factor in backtracking
	int *evaluateCnt // counter
){
	double *x=0; //current points
	int n=evaluator.get_current_parameter(x);
	double *g=evaluator.get_gradient_vec();
	double dec=vec_dot(g,p,n);
	//cout<<"#IN_LINEAR_SEARCH unit decrease of g'p="<<dec<<endl;
	if(dec<0){ // non suitable step,p is not a descent search direction
		return -1;
	}
//	for(int i=0;i<5;i++) 		cout<<"x["<<i<<"]="<<x[i]<<" p["<<i<<"]="<<p[i]<<endl; 
	double alpha=init_step;
	//vec_add(xp,x,p,n,1,-alpha);  // p is the negative of search of direction
	//TODO: do it better
	for(int i=0;i<n;++i) xp[i]=(x[i]-alpha*p[i]<1e-6)?0:(x[i]-alpha*p[i]);
	double old_fx=*fx;
	*fx=evaluator.evaluate(xp,g);
	++(*evaluateCnt);
	int trials=0;
	while( *fx > old_fx-alpha*c*dec ){
		//cout<<"-----try step length "<<alpha<<" get obj="<<*fx<<" dec="<<old_fx-*fx<<" require min dec="<<alpha*c*dec<<endl;
		alpha*=r;
		//vec_add(xp,x,p,n,1,-alpha);
		//TODO: do it better
		for(int i=0;i<n;++i) xp[i]=(x[i]-alpha*p[i]<1e-6)?0:(x[i]-alpha*p[i]);
		*fx=evaluator.evaluate(xp,g);
		++(*evaluateCnt);
		++trials;
	}
	//cout<<"#IN_LINEAR_SEARCH success linear search, get alpha="<<alpha<<" obj="<<*fx<<" dec="<<old_fx-*fx<<" required min dec="<<alpha*c*dec<<" trails="<<trials<<endl;
	return alpha;
}

// Attempt to flip each bit in a random order, accepting improvements
// as they are found.  Test each bit exactly once for improvement
void hill_climb::once_each(Random & rand, vector<bool> & solution,
                           float & fitness, Evaluator& evaluator) {
  vector<int> options(solution.size());
  iota(options.begin(), options.end(), 0);
  float new_fitness;
  std::shuffle(options.begin(), options.end(), rand);

  for (const auto& index : options) {
    // flip the bit and evaluate new fitness
    solution[index] = not solution[index];
    new_fitness = evaluator.evaluate(solution);
    if (fitness < new_fitness) {
      fitness = new_fitness;
    } else {
      solution[index] = not solution[index];
    }
  }
}

BitMoveOrderingIterator::BitMoveOrderingIterator(
    const Board& board,
    Evaluator<Board>& eval)
    : board_(board), sorted_next_() {
    std::vector<eval_t> sort_key;

    BitBoard::data_type moves = board.get_move_bit();
    while (moves.any()) {
        BitBoard::data_type next = moves.get_next_bit();
        unsigned pos = next.get_next();
        BitBoard next_board(board);
        next_board.try_move(pos);
        eval_t v = eval.evaluate(next_board, BLACK);
        sort_insert(sort_key,
                    sorted_next_,
                    v,
                    pos);
        moves ^= next;
    }
    current_ = sorted_next_.begin();
}

int main() {
    
    Evaluator eval;
    
    string input;
    
    cout<<"'exit' to quit"<<endl<<endl;
    
    while (true) {
        cout<<"Enter expression: ";
        std::getline(cin, input, '\n');
        if (input == "exit") break;
        try {
            Object obj = eval.evaluate(input);
            cout<<obj.symbol()<<" = "<<obj.value().value()<<endl;
        } catch (Error error) {
            cout<<error.message<<endl;
        }
    }
    
    return 0;
}

// Only modify the solution once you know which single bit change will
// result in the best fitness improvement
void hill_climb::steepest_ascent(Random & rand, vector<bool> & solution,
                                 float & fitness, Evaluator& evaluator) {
  float new_fitness;
  bool improved;
  // keep a list of which locations are tied for the most improvement
  vector<size_t> bests;
  // Stores which bit was flipped to create the current solution
  size_t previous = -1;
  // Keep looping until there is no single bit flip improvement
  do {
    improved = false;
    for (size_t working = 0; working < solution.size(); working++) {
      if (working != previous) {
        // flip the bit and determine the new fitness
        solution[working] = not solution[working];
        new_fitness = evaluator.evaluate(solution);
        if (fitness <= new_fitness) {
          // strict improvements clear out the old list
          if (fitness < new_fitness) {
            fitness = new_fitness;
            improved = true;
            bests.clear();
          }
          // Record the index of each solution that obtained the best fitness
          bests.push_back(working);
        }
        // revert the change
        solution[working] = not solution[working];
      }
    }
    if (improved) {
      // choose a random gene from those resulting in an equally large improvement
      int index = std::uniform_int_distribution<int>(0, bests.size() - 1)(rand);
      previous = bests[index];
      solution[previous] = not solution[previous];
      bests.clear();
    }
  } while (improved);
}

// Iteratively tests bits in a random order, accepting improvements as they
// are found.  Tracks bits that have been tested since the last modification
// to prevent waste.
void hill_climb::first_improvement(Random & rand, vector<bool> & solution,
                                   float & fitness, Evaluator& evaluator) {
  // Set up data structure for random bit selection
  vector<int> options(solution.size());
  iota(options.begin(), options.end(), 0);
  float new_fitness;
  bool improvement;
  // keep track of locations already tried since last improvement
  std::unordered_set<int> tried;

  // Keep looping until there is no single bit flip improvement
  do {
    improvement = false;
    // Test the bits in a random order
    std::shuffle(options.begin(), options.end(), rand);
    for (const auto& index : options) {
      // If this location has already been tried, skip to the next one
      if (tried.count(index) != 0) {
        continue;
      }

      // flip and evaluate the modification
      solution[index] = not solution[index];
      new_fitness = evaluator.evaluate(solution);
      if (fitness < new_fitness) {
        // Keep change, update variables
        fitness = new_fitness;
        improvement = true;
        tried.clear();
      } else {
        // Revert the change
        solution[index] = not solution[index];
      }
      tried.insert(index);
    }
  } while (improvement);
}

	virtual int evaluate(char* buf, int maxbuf, Range range) const {
		assert(e != 0);
		return e->evaluate(buf, maxbuf);		
	}

int main(int argc, char *args[])
{
  int n = 8;
  cerr << "argc:"<<argc<<endl;
  if(argc!=n){
    hyperdatasetUsage(args[0]);
    exit(1);
  }

  int rands = 0;
  rands = atoi(args[1]);
  if(rands!=0)
    srand(rands);
  else{
    rands = time(0);
    srand(rands);
    cout << "ny seed: " << rands << endl;
  }

  //1. load the example file
  NEATsettings * s = new NEATsettings();
  ifstream ifs(args[2],ios::in);
  ifs>>s;
  ifs.close();  

  //2. generate the pop
  TransferFunctions * tfs = new TransferFunctions(s);
  Population * pop = makePopulation(args[3],s,tfs);
  
  //3. then the selector
  Selector * sel = makeSelector(args[4]);

  int g = atoi(args[5]);
  int iter = atoi(args[6]);

  string dfile = args[7];
  DataSet * set = new DataSet(false,dfile,0.0);
  FitnessEvaluator * de = new DatasetHyperNEAT(s,tfs,set);
  Evaluator * ev = new Evaluator(de); 
  LocalReproducer * rp = new LocalReproducer();
  int gc = 0; double sum=0; double sum2=0; double sum3=0;
  Phenotype * cbest = NULL;
  Phenotype * sbest = NULL;
  Phenotype * best = NULL;
  int osize=pop->getMembers()->size();
  int ss=0;
  double ocomp=0;
  time_t startt;
  double timesum = 0;
  for(int i2=0;i2<iter;i2++){
    gc = 0;
    best = NULL;
    startt = time(0);
    for(int i=0;i<g;i++){
      gc++;
//       cout << "before eval.." << endl;
      ev->evaluate(pop->getMembers(),pop->getMembers()->size());
//       cout << "after eval.." << endl;
      if((unsigned int)pop->getOriginalSize()!=pop->getMembers()->size())
 	cout << "size not right after eval.." << endl;
      ss=pop->getSpecies()->size();
//       cout << "before pop juggling.." << endl;
      pop->updateSpeciesStats();
      pop->sortmembers();
      pop->sortspecies();
      cbest = pop->getCopyOfCurrentBest();
      de->f(cbest);
//       cout << "before best juggling.." << endl;
      if(best==NULL){
	best = cbest;
      }else if(cbest->getFitness()>best->getFitness()){
	delete best;
	best = cbest;
      }else{
	delete cbest;
      }
//       cout << "after best juggling.." << endl;
      cout << "gen: "<<i<<" best: " << best->getFitness() << "worst: " << pop->getMembers()->at(pop->getMembers()->size()-1)->getFitness() << endl;
      if(((DatasetHyperNEAT*)de)->done(best)){
	i = g;
// 	cout << best;
	((DatasetHyperNEAT*)de)->runTest(best);
      }
//       cout << "after xor testing.." << endl;
      sel->select(pop,0);
      rp->reproduce(pop);
//       cout << "after select and reproduce.." << endl;
    }
    if(sbest==NULL)
      sbest = best;
    else if(best->getFitness()>sbest->getFitness())
      sbest = best;
    time_t ft = time(0)-startt;
    timesum += ft;
    cout << "run: "<<i2+1<<" gc: "<<gc<<" maxfitness: " << pop->getHighestFitness() 
	 << " sbest fitness: " << sbest->getFitness() << " species: " << ss 
	 << " time: " << ft << " time/gen: " << (double)ft/(double)gc << endl;
    sum += gc;
    sum2 += best->getGenome()->extrons();
    sum3 += best->getGenome()->countHidden();
//.........这里部分代码省略.........