darwin.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 "ann_utils.h"
#include "utils.h"
#include "modules.h"
#include "properties.h"
#include "stringify.h"
#include "universe.h"

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

#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <functional>
#include <initializer_list>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <utility>
#include <vector>
using namespace std;

class QWidget;

namespace darwin {

enum class ComplexityHint {
  Minimal,   
  Balanced,  
  Extra,     
};

inline auto customStringify(core::TypeTag<ComplexityHint>) {
  static auto stringify = new core::StringifyKnownValues<ComplexityHint>{
    { ComplexityHint::Minimal, "minimal" },
    { ComplexityHint::Balanced, "balanced" },
    { ComplexityHint::Extra, "extra" },
  };
  return stringify;
}

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

  virtual void setInput(int index, float value) = 0;
  
  virtual float output(int index) const = 0;
  
  virtual void think() = 0;
  
  virtual void resetState() = 0;
};

struct Genealogy {
  string genetic_operator;

  vector<int> parents;

  Genealogy() = default;

  Genealogy(const string& genetic_operator, initializer_list<int> parents)
      : genetic_operator(genetic_operator), parents(parents) {}

  void reset() {
    genetic_operator.clear();
    parents.clear();
  }
};

class Genotype {
 public:
  float fitness = 0;
  
  Genealogy genealogy;

 public:
  virtual ~Genotype() = default;

  virtual unique_ptr<Brain> grow() const = 0;
  
  virtual unique_ptr<Genotype> clone() const = 0;

  virtual json save() const = 0;
  
  virtual void load(const json& json_obj) = 0;

  virtual void reset() {
    fitness = 0;
    genealogy.reset();
  }
};

class Population : public core::NonCopyable {
 public:
  Population() = default;
  virtual ~Population() = default;

  virtual size_t size() const = 0;

  virtual Genotype* genotype(size_t index) = 0;

  virtual const Genotype* genotype(size_t index) const = 0;

  virtual vector<size_t> rankingIndex() const = 0;

  virtual int generation() const = 0;

  virtual void createPrimordialGeneration(int population_size) = 0;

  virtual void createNextGeneration() = 0;

  Genotype* operator[](size_t index) { return genotype(index); }
  const Genotype* operator[](size_t index) const { return genotype(index); }
};

class Domain;

class PopulationFactory : public core::ModuleFactory {
 public:
  virtual unique_ptr<Population> create(const core::PropertySet& config,
                                        const Domain& domain) = 0;

  virtual unique_ptr<core::PropertySet> defaultConfig(ComplexityHint hint) const = 0;
};

class Domain : public core::NonCopyable {
 public:
  Domain() = default;
  virtual ~Domain() = default;

  virtual size_t inputs() const = 0;
  
  virtual size_t outputs() const = 0;

  virtual bool evaluatePopulation(Population* population) const = 0;

  virtual unique_ptr<core::PropertySet> calibrateGenotype([
      [maybe_unused]] const Genotype* genotype) const {
    return nullptr;
  }
};

class DomainFactory : public core::ModuleFactory {
 public:
  virtual unique_ptr<Domain> create(const core::PropertySet& config) = 0;

  virtual unique_ptr<core::PropertySet> defaultConfig(ComplexityHint hint) const = 0;
};

class DomainUiFactory : public core::ModuleFactory {
 public:
  virtual QWidget* newSandboxWindow() = 0;
};

struct Registry {
  core::ImplementationsSet<PopulationFactory> populations;

  core::ImplementationsSet<DomainFactory> domains;

  core::ImplementationsSet<DomainUiFactory> domains_ui;
};

inline Registry* registry() {
  static Registry instance;
  return &instance;
}

//
struct ExperimentSetup : public core::PropertySet {
  PROPERTY(population_size, int, 5000, "Population size");

  PROPERTY(population_name, string, "", "Population name");
  PROPERTY(domain_name, string, "", "Domain name");

  PROPERTY(population_hint,
           ComplexityHint,
           ComplexityHint::Balanced,
           "Population complexity hint");

  PROPERTY(domain_hint,
           ComplexityHint,
           ComplexityHint::Balanced,
           "Domain complexity hint");
};

class Experiment : public core::NonCopyable {
 public:
  Experiment(const optional<string>& name,
             const ExperimentSetup& setup,
             const optional<db::RowId>& base_variation_id,
             Universe* universe);

  Experiment(const DbExperiment* db_experiment, Universe* universe);

  const optional<string>& name() const { return name_; }
  
  const ExperimentSetup* setup() const { return &setup_; }

  PopulationFactory* populationFactory() const { return population_factory_; }

  DomainFactory* domainFactory() const { return domain_factory_; }
  
  DomainUiFactory* domainUiFactory() const { return domain_ui_factory_; }

  core::PropertySet* populationConfig() { return population_config_.get(); }
  const core::PropertySet* populationConfig() const { return population_config_.get(); }

  core::PropertySet* domainConfig() { return domain_config_.get(); }
  const core::PropertySet* domainConfig() const { return domain_config_.get(); }
  
  core::PropertySet* coreConfig() { return core_config_.get(); }
  const core::PropertySet* coreConfig() const { return core_config_.get(); }

  Universe* universe() const { return universe_; }

  db::RowId dbExperimentId() const;

  db::RowId dbVariationId() const;

  void setModified(bool modified) { modified_ = modified; }

  void prepareForEvolution();
  
  void save();

 private:
  void basicSetup(const optional<string>& name, const ExperimentSetup& setup);
  void loadLatestVariation();

 private:
  optional<string> name_;
  ExperimentSetup setup_;

  // configurations
  unique_ptr<core::PropertySet> population_config_;
  unique_ptr<core::PropertySet> domain_config_;
  unique_ptr<core::PropertySet> core_config_;

  // populations, domains factories
  PopulationFactory* population_factory_ = nullptr;
  DomainFactory* domain_factory_ = nullptr;
  DomainUiFactory* domain_ui_factory_ = nullptr;

  // corresponding database objects
  unique_ptr<DbExperiment> db_experiment_;
  unique_ptr<DbExperimentVariation> db_variation_;
  
  // tracks the configuration modification state
  bool modified_ = false;

  Universe* universe_ = nullptr;
};

}  // namespace darwin