view src/population.cpp @ 0:add35537fdbb tip

Initial import

//  Copyright 2011, Ian Hobson.
//
//  This file is part of gpsynth.
//
//  gpsynth is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  gpsynth 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 gpsynth in the file COPYING. 
//  If not, see http://www.gnu.org/licenses/.

#include "population.hpp"

#include "boost_ex.hpp"
#include "graph_helpers.hpp"
#include "logger.hpp"
#include "statistics.hpp"
#include "std_ex.hpp"

#include "boost/bind.hpp"
#include "boost/filesystem.hpp"
#include "boost/lexical_cast.hpp"
#include "boost/math/special_functions/fpclassify.hpp"

#include <algorithm>
#include <cmath>
#include <fstream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <vector>

namespace bf = boost::filesystem;

namespace {
  
  const std::string g_default_work_folder = "/tmp";
  
// mutated graphs might have imported parameters outside of the graph's range
// or removed parameter inputs making some parameters redundant
void UpdateParameters(sg::Graph& graph) {
  std::size_t parameter_count = graph[boost::graph_bundle].parameters_.size();
  // scan through vertices to find parameter inputs
  std::map<int, std::vector<sg::Vertex> > parameters;
  sg::VertexIterator vertex;
  sg::VertexIterator vertex_end;
  for (boost::tie(vertex, vertex_end) = boost::vertices(graph); 
       vertex != vertex_end; 
       ++vertex) {
    const sg::Node& node_info = graph[*vertex];
    if (node_info.type_ == sg::kParameter) {
      parameters[node_info.id_].push_back(*vertex);
    }
  }
  // check if any corrections required
  if (parameters.size() == parameter_count) {
    if (parameter_count == 0) {
      // no parameters in the graph, nothing to do
      return;
    }
    // check that last parameter id is correct, otherwise corrections are needed
    if (parameters.rbegin()->first == (parameter_count)) {
      // all seems well, get out of here
      return;  
    }
  } else if (parameters.size() > parameter_count) {
    // add extra parameters to the graph
    std::generate_n(std::back_inserter(graph[boost::graph_bundle].parameters_),
                    parameters.size() - parameter_count,
                    stdx::RandomCoefficient);
  } else {
    // remove redundant parameters
    graph[boost::graph_bundle].parameters_.resize(parameters.size());
  }
  // reassign parameter ids through the graph
  int parameter_id = 1;
  typedef std::map<int, std::vector<sg::Vertex> >::value_type ParameterMapping;
  foreach (ParameterMapping p, parameters) {
    foreach (sg::Vertex v, p.second) {
      graph[v].id_ = parameter_id;
    }
    ++parameter_id;
  }
  // job done
}

} // namespace

Population::Population(GrammarInterface* grammar,
                       ConverterInterface* converter,
                       EvaluatorInterface* evaluator)
: grammar_(grammar),
  converter_(converter),
  evaluator_(evaluator),
  generation_(0),
  max_generations_(0),
  fitness_threshold_(0),
  tournament_size_(7),
  crossover_rate_(0.65),
  mutation_rate_(0.3),
  reproduce_best_(false),
  keep_temp_folders_(false)
{
  evaluator_->SetListener(this);
  mutators_.push_back(boost::bind(&GrammarInterface::MutationReplaceSubTree,
                                  grammar, _1));
  mutators_.push_back(boost::bind(&GrammarInterface::MutationAddSubTree,
                                  grammar, _1));
  mutators_.push_back(boost::bind(&GrammarInterface::MutationModifyInputs,
                                  grammar, _1));
  mutators_.push_back(boost::bind(&GrammarInterface::MutationModifyConnections,
                                  grammar, _1));
  mutators_.push_back(boost::bind(&GrammarInterface::MutationReplaceCommand,
                                  grammar, _1));
//  mutators_.push_back(boost::bind(&GrammarInterface::MutationInsertCommand,
//                                  grammar, _1));
  SetupGeneticOperationSelector();
  SetWorkFolder(g_default_work_folder);
}

void Population::SetWorkFolder(const std::string &path) {
  work_folder_ = path;
  log_folder_ = path + "/logs";
  render_folder_ = path + "/render";
  dot_folder_ = path + "/dot";
  export_folder_ = path + "/export";
}

void Population::Evolve(int max_generations) {
  max_generations_ = max_generations;
  // make sure the folders for storing best outputs are created
  bf::create_directories(render_folder_);
  bf::create_directories(dot_folder_);
  bf::create_directories(export_folder_);
  bf::create_directories(log_folder_);
  for (generation_ = 1; generation_ <= max_generations; generation_++) {
    NewGenerationMessage();
    SetGenerationFolder();
    ExportToDOT();
    EvaluateGeneration();
    AnalyzeGeneration();
    SaveGenerationBest();
    CleanTempFolders();
    if (CheckThreshold()) {
      logger::Log("Fitness threshold reached\n");
      return;
    }
    BreedNewGeneration();
  }
}

void Population::NewGenerationMessage() const {
  std::stringstream message;
  message << "Generation " << generation_ << '\n';
  logger::Log(message.str());
}

void Population::SetGenerationFolder() {
  std::stringstream path;
  path << work_folder_ << "/generation_" 
       << std::setw(std::log10(max_generations_) + 1) << std::setfill('0')
       << generation_ << '/';
  generation_folder_ = path.str();
}

bool Population::CheckThreshold() const {
  double best_fitness = population_[best_fit_][boost::graph_bundle].fitness_;
  return best_fitness <= fitness_threshold_;
}

void Population::CleanTempFolders() const {
  if (!keep_temp_folders_) {
    bf::remove_all(generation_folder_);
  }
}

void Population::InitializePopulation(std::size_t size) {
  population_.resize(size);
  fitnesses_.resize(size);
  for (int i = 0; i < size; i++) {
    grammar_->RandomGraph(population_[i]);
    population_[i][boost::graph_bundle].id_ = i;
  }
}

void Population::EvaluateGeneration() {
  // make sure we have a clean temp folder for the generation
  bf::remove_all(generation_folder_);
  evaluator_->SetWorkFolder(generation_folder_);
  evaluator_->RateGraphs(population_);
  logger::Log("\n");
  // store graph fitnesses
  for (std::size_t i = 0, size = population_.size(); i < size; i++) {
    fitnesses_[i] = population_[i][boost::graph_bundle].fitness_;
  }
}

void Population::AnalyzeGeneration() {
  double mean_fitness = stats::Mean(fitnesses_.begin(), fitnesses_.end());
  if (boost::math::isnan(mean_fitness)) {
    logger::Log("ruh roh\n"); // TODO
  }
  std::stringstream message;
  std::vector<double>::const_iterator best_fitness;
  best_fitness = std::min_element(fitnesses_.begin(), fitnesses_.end());
  best_fit_ = static_cast<int>(best_fitness - fitnesses_.begin());
  message << "Average Fitness:" << mean_fitness
          << " Best"
          //<< " [" << best_fit_ << "]"
          << ':' << *best_fitness << '\n';
  logger::Log(message.str());
  // save fitness values to logs
  std::stringstream average;
  average << generation_ << ' ' << mean_fitness;
  stdx::AppendToFile(average.str(), log_folder_ + "/average_fitnesses.txt");
  std::stringstream best;
  best << generation_ << ' ' << *best_fitness;
  stdx::AppendToFile(best.str(), log_folder_ + "/best_fitnesses.txt");
}

void Population::SaveGenerationBest() {
  std::stringstream generation_prefix;
  generation_prefix << "generation_" 
                    << std::setw(std::log10(max_generations_) + 1) 
                    << std::setfill('0')
                    << generation_;
  const sg::Graph& best_graph = population_[best_fit_];
  const sg::GraphProperties& graph_properties = best_graph[boost::graph_bundle];
  // copy the rendered output for the graph
  bf::path path = graph_properties.render_path_;
  if (bf::exists(path)) {
    std::string render_path = render_folder_ + '/' 
                              + generation_prefix.str() 
                              + path.extension().string();
    bf::copy_file(path, render_path);
  }
  // copy the dot script for the graph
  path = graph_properties.dot_path_;
  if (bf::exists(path)) {
    std::string dot_path = dot_folder_ + '/' 
                           + generation_prefix.str() 
                           + path.extension().string();
    bf::copy_file(path, dot_path);
  }
  // tell the converter to export the graph
  converter_->Export(best_graph, export_folder_, generation_prefix.str());
}

void Population::PerformCrossover(sg::Graph& child_1, sg::Graph& child_2) {
  int parent_id_1 = SelectIndividual();
  int parent_id_2;
  do {
    parent_id_2 = SelectIndividual(); 
  } while (parent_id_1 == parent_id_2);
  // pick the crossover points via the grammar
  const sg::Graph& parent_1 = population_[parent_id_1];
  const sg::Graph& parent_2 = population_[parent_id_2];
  sg::Vertex crossover_1;
  sg::Vertex crossover_2;
  grammar_->PickCrossoverNodes(parent_1, parent_2, &crossover_1, &crossover_2);
  // swap the subtrees
  SwapSubTrees(crossover_1, crossover_2, parent_1, parent_2, child_1, child_2);
}

// called for mutated graphs to prepare for next generation
void Population::PrepareNewChild(sg::Graph& child) {
  // reset fitness rating
  child[boost::graph_bundle].fitness_ = sg::kFitnessUnrated;
  // make sure parameters in graph are valid
  UpdateParameters(child);
}

void Population::BreedNewGeneration() {
  // Used to store reproduced graph ids, prevents a graph being reproduced
  // more than once.
  std::set<int> reproduced;
  std::vector<sg::Graph> next_generation;
  next_generation.reserve(population_.size());
  if (reproduce_best_) {
    next_generation.push_back(population_[best_fit_]);
  }
  std::size_t population_size = population_.size();
  while (next_generation.size() < population_size) {
    GeneticOperation operation;
    operation = static_cast<GeneticOperation>(genetic_operation_selector_());
    if (operation == kCrossover) {
      // Crossover
      // create two empty graphs to receive results of crossover
      // (creating them directly in the next_generation container causes
      // memory problems when performing crossover, couldn't fathom why..)
      sg::Graph child_1;
      sg::Graph child_2;
      PerformCrossover(child_1, child_2);
      PrepareNewChild(child_1);
      PrepareNewChild(child_2);
      next_generation.push_back(child_1);
      next_generation.push_back(child_2);
    } else if (operation == kMutation) {
      // mutation
      // store a copy of an individual from current population
      next_generation.push_back(population_[SelectIndividual()]);
      sg::Graph& child = next_generation.back();
      // call random mutation operator on child
      bool mutated;
      do {
        // some mutators might not be able to operate on a specific graph
        // and will return false, so try another mutator
        mutated = mutators_[stdx::Random(mutators_.size())](child);
      } while (!mutated);
      PrepareNewChild(child);
    } else {
      // reproduction
      int graph_id = SelectIndividual();
      // only reproduce the individual if it hasn't already been reproduced
      if (reproduced.find(graph_id) == reproduced.end()) {
        next_generation.push_back(population_[graph_id]);
        reproduced.insert(graph_id);
      }
    }
  }
  // we might have an extra individual from crossover
  next_generation.resize(population_size);
  // reassign graph ids
  for (std::size_t i = 0, size = population_.size(); i < size; i++) {
    next_generation[i][boost::graph_bundle].id_ = static_cast<int>(i);
  }
  // replace the population with the newly created generation
  population_.swap(next_generation);
}

// tournament selection 
int Population::SelectIndividual() {
  // select n individuals from the population
  std::set<std::size_t> tournament;
  while (tournament.size() < tournament_size_) {
    tournament.insert(stdx::Random(population_.size()));
  }
  double best_fitness = std::numeric_limits<double>::max();
  std::size_t result = -1;
  // find best graph from selection
  foreach (std::size_t graph_id, tournament) {
    if (fitnesses_[graph_id] < best_fitness) {
      best_fitness = fitnesses_[graph_id];
      result = graph_id;
    }
  }
  return static_cast<int>(result);
}

void Population::ExportToDOT() {
  std::string dot_folder = generation_folder_ + "/dot/";
  bf::create_directories(dot_folder);
  std::stringstream path;
  foreach (sg::Graph& graph, population_) {
    path.str("");
    path << dot_folder 
         << "gpsynth_" << graph[boost::graph_bundle].id_ << ".dot";
    std::ofstream file(path.str().c_str());
    file << converter_->ToDOT(graph);
    file.close();
    graph[boost::graph_bundle].dot_path_ = path.str();
  }
}

void Population::GraphRatedNotification(std::size_t graphs_rated) {
  std::stringstream message;
  message << "\rRated " << graphs_rated << " / " << population_.size();
  logger::Log(message.str());
}

void Population::SetCrossoverRate(double rate) {
  crossover_rate_ = rate;
  SetupGeneticOperationSelector();
}

void Population::SetMutationRate(double rate) {
  mutation_rate_ = rate;
  SetupGeneticOperationSelector();
}

void Population::SetupGeneticOperationSelector() {
  std::vector<double> genetic_probabilities(2);
  genetic_probabilities[kCrossover] = crossover_rate_;
  genetic_probabilities[kMutation] = mutation_rate_;
  // reproduction is left over probability
  genetic_operation_selector_.SetProbabilities(genetic_probabilities);
}