evolution.h

// Copyright 2018 The Darwin Neuroevolution Framework Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#pragma once

#include "darwin.h"
#include "pubsub.h"
#include "thread_pool.h"

#include <third_party/json/json.h>
using nlohmann::json;

#include <chrono>
#include <memory>
#include <mutex>
#include <string>
#include <utility>
#include <vector>
using namespace std;

namespace darwin {

class Evolution;

struct GenerationSummary {
  int generation = 0;

  float best_fitness = 0;

  float median_fitness = 0;

  float worst_fitness = 0;

  shared_ptr<core::PropertySet> calibration_fitness;

  shared_ptr<Genotype> champion;

  GenerationSummary() = default;

  GenerationSummary(const Population* population,
                    shared_ptr<core::PropertySet> calibration_fitness);
};

struct CompressedFitnessValue {
  int index = -1;

  float value = 0;

  CompressedFitnessValue(int index, float value) : index(index), value(value) {}
};

enum class FitnessInfoKind {
  SamplesOnly,     
  FullCompressed,  
  FullRaw,         
};

inline auto customStringify(core::TypeTag<FitnessInfoKind>) {
  static auto stringify = new core::StringifyKnownValues<FitnessInfoKind>{
    { FitnessInfoKind::SamplesOnly, "samples_only" },
    { FitnessInfoKind::FullCompressed, "full_compressed" },
    { FitnessInfoKind::FullRaw, "full_raw" },
  };
  return stringify;
}

enum class ProfileInfoKind {
  GenerationOnly,  
  AllStages,       
};

inline auto customStringify(core::TypeTag<ProfileInfoKind>) {
  static auto stringify = new core::StringifyKnownValues<ProfileInfoKind>{
    { ProfileInfoKind::GenerationOnly, "generation_only" },
    { ProfileInfoKind::AllStages, "all_stages" },
  };
  return stringify;
}

struct EvolutionConfig : public core::PropertySet {
  PROPERTY(max_generations,
           int,
           1000000,
           "Automatically stop the experiment after the max number of generations");

  PROPERTY(save_champion_genotype,
           bool,
           true,
           "Save the best genotype from each generation");

  PROPERTY(fitness_information,
           FitnessInfoKind,
           FitnessInfoKind::FullCompressed,
           "What kind of fitness information to save");

  PROPERTY(save_genealogy,
           bool,
           false,
           "Save the genealogy information (can be very large!)");

  PROPERTY(profile_information,
           ProfileInfoKind,
           ProfileInfoKind::GenerationOnly,
           "Performance trace (counters/timings)");
};

vector<CompressedFitnessValue> compressFitness(const Population* population);

class EvolutionStage {
  using Clock = std::chrono::steady_clock;

 public:
  enum Annotation : uint32_t {
    Paused = 1,      
    Canceled = 2,    
    Generation = 4,  
  };

 public:
  EvolutionStage() = default;

  EvolutionStage(const string& name_, size_t size_, uint32_t annotations);

  void start() { start_timestamp_ = Clock::now(); }

  void finish() { finish_timestamp_ = Clock::now(); }

  const string& name() const { return name_; }

  double elapsed() const;

  int progressPercent() const;

  const vector<EvolutionStage>& subStages() const { return sub_stages_; }

  void recordSubStage(const EvolutionStage& stage);
  void advanceProgress(size_t increment);
  void addAnnotations(uint32_t annotations);
  uint32_t annotations() const { return annotations_; }

  friend void to_json(json& json_obj, const EvolutionStage& stage);

 private:
  string name_;
  size_t size_ = 0;
  size_t progress_ = 0;
  Clock::time_point start_timestamp_;
  Clock::time_point finish_timestamp_;
  uint32_t annotations_ = 0;
  vector<EvolutionStage> sub_stages_;
};

class EvolutionTrace : public core::NonCopyable {
 public:
  EvolutionTrace(shared_ptr<const Experiment> experiment, const EvolutionConfig& config);

  int size() const;

  GenerationSummary generationSummary(int generation) const;

  GenerationSummary addGeneration(const Population* population,
                                  shared_ptr<core::PropertySet> calibration_fitness,
                                  const EvolutionStage& top_stage);

 private:
  mutable mutex lock_;

  // a brief history of the generations
  vector<GenerationSummary> generations_;

  shared_ptr<const Experiment> experiment_;
  EvolutionConfig config_;

  unique_ptr<DbEvolutionTrace> db_trace_;
};

class ProgressMonitor {
 public:
  virtual ~ProgressMonitor() = default;

  virtual void beginStage(const string& name, size_t size, uint32_t annotations) = 0;

  virtual void finishStage(const string& name) = 0;

  virtual void reportProgress(size_t increment) = 0;
};

class ProgressManager {
 public:
  static void beginStage(const string& name, size_t size, uint32_t annotations) {
    if (progress_monitor_ != nullptr) {
      progress_monitor_->beginStage(name, size, annotations);
    }
  }

  static void finishStage(const string& name) {
    if (progress_monitor_ != nullptr) {
      progress_monitor_->finishStage(name);
    }
  }

  static void reportProgress(size_t increment = 1) {
    if (progress_monitor_ != nullptr) {
      progress_monitor_->reportProgress(increment);
    }
  }

  static void registerMonitor(ProgressMonitor* monitor) {
    CHECK(progress_monitor_ == nullptr);
    progress_monitor_ = monitor;
  }

 private:
  static ProgressMonitor* progress_monitor_;
};

class Evolution : public core::NonCopyable,
                  public pp::Controller,
                  public ProgressMonitor {
  friend Evolution* evolution();

 public:
  enum class State {
    Invalid,       
    Initializing,  
    Running,       
    Pausing,       
    Paused,        
    Canceling,     
    Stopped        
  };

  enum EventFlag : uint32_t {
    StateChanged = 1 << 0,    
    ProgressUpdate = 1 << 1,  
    EndGeneration = 1 << 2,   
    EndEvolution = 1 << 3,    
    NewExperiment = 1 << 4,   
    Reset = 1 << 5,           
    All = EventFlag(-1),      
  };

  core::PubSub<uint32_t> events;

  core::PubSub<GenerationSummary> generation_summary;

  core::PubSub<EvolutionStage> top_stages;

  struct Snapshot {
    State state = State::Invalid;

    int generation = 0;

    EvolutionStage stage;

    shared_ptr<const Experiment> experiment;

    shared_ptr<const EvolutionTrace> trace;

    const Population* population = nullptr;

    const Domain* domain = nullptr;
  };

 public:
  static void init();

  bool newExperiment(shared_ptr<Experiment> experiment, const EvolutionConfig& config);

  Snapshot snapshot() const;

  const Experiment& experiment() const { return *experiment_; }

  const EvolutionConfig& config() const { return config_; }

  void run();

  void pause();

  bool reset();

  void waitForState(State target_state) const;

 private:
  Evolution() {
    pp::ParallelForSupport::init(this);
    ProgressManager::registerMonitor(this);
  }

  void mainThread();

  void evolutionCycle();

  // pp::Controller interface
  void checkpoint() override;

  // ProgressMonitor interface
  void beginStage(const string& name, size_t size, uint32_t annotations) override;
  void finishStage(const string& name) override;
  void reportProgress(size_t increment = 1) override;

 private:
  std::thread::id main_thread_id_;

  mutable mutex lock_;
  mutable condition_variable state_cv_;

  State state_ = State::Initializing;
  vector<EvolutionStage> stage_stack_;

  EvolutionConfig config_;

  // population & domain
  unique_ptr<Population> population_;
  unique_ptr<Domain> domain_;

  shared_ptr<Experiment> experiment_;
  shared_ptr<EvolutionTrace> trace_;
};

inline Evolution* evolution() {
  static Evolution* instance = new Evolution();
  return instance;
}

class StageScope {
 public:
  StageScope(const string& name, size_t size = 0, uint32_t annotations = 0)
      : name_(name) {
    ProgressManager::beginStage(name, size, annotations);
  }

  ~StageScope() { ProgressManager::finishStage(name_); }

 private:
  string name_;
};

}  // namespace darwin