GeneticTrainer.h

// Copyright (C) Entropy Software LLC - All Rights Reserved
 
#pragma once
 
#include "Graph.h"
#include "Loss.h"
#include "LossTrainer.h"
 
namespace SmartEngine
{
 
class IGeneticTrainer;
 
#pragma pack(push, 4)
struct GeneticTrainerCInfo : public LossTrainerCInfo
{
    ILoss* loss = nullptr;
};
 
struct GeneticTrainerInitializationInfo
{
    int populationCount = 20;
 
    bool randomizePopulation = true;
};
 
enum class MutationTarget : byte
{
    Auto,
 
    Weight,
 
    Neuron,
};
 
enum class GeneSwapTarget : byte
{
    Weight,
 
    Neuron,
};
 
struct MutationInfo
{
    MutationTarget target = MutationTarget::Auto;
 
    float nodesToMutate = -1.0f;
 
    float targetsToMutate = 0.08f;
 
    float standardDeviation = 1.0f;
 
    float minStandardDeviation = 1e-3f;
 
    bool adaptiveStandardDeviation = true;
 
    int stepsUntilLowerStandardDeviation = 1;
 
    int stepsUntilRaiseStandardDeviation = 1;
};
 
struct GeneSwapInfo
{
    GeneSwapTarget target = GeneSwapTarget::Neuron;
 
    float countCrossover = 0.4f;
 
    float selectionStandardDeviation = 0.4f;
};
 
struct GeneticTrainingInfo
{
    float countTopPerformers = 0.1f;
 
    float countToKeepUnchanged = 0.4f;
 
    float countToRandomize = 0.1f;
 
    MutationInfo mutation;
 
    GeneSwapInfo geneSwap;
};
#pragma pack(pop)
 
class SMARTENGINE_EXPORT IGeneticTrainer : public ILossTrainer
{
public:
    SMARTENGINE_DECLARE_CLASS(IGeneticTrainer)
 
    using ILossTrainer::GetLoss;
 
    virtual void Initialize(const GeneticTrainerInitializationInfo& info) = 0;
 
    virtual void Step() = 0;
 
    virtual int GetPopulationCount() const = 0;
 
    virtual void SortPopulation() = 0;
 
    virtual float GetMutationStandardDeviation() const = 0;
 
    virtual int GetChromosomeLastIndex(int index) const = 0;
 
    virtual void SetChromosome(int index) = 0;
 
    virtual void SetBestChromosome() = 0;
 
    virtual void CopyOutChromosome(int index, IGraph* graph) = 0;
 
    virtual void CopyOutBestChromosome(IGraph* graph) = 0;
 
    virtual void CopyOutTopAverage(float count, IGraph* graph, bool weightedAverage) = 0;
 
    virtual float GetLoss(int index) = 0;
 
    virtual void SetLoss(int index, float loss) = 0;
 
    virtual void SetTrainingInfo(const GeneticTrainingInfo& info) = 0;
};
 
SMARTENGINE_EXPORT ObjectPtr<IGeneticTrainer> CreateGeneticTrainer(const GeneticTrainerCInfo& cinfo);
 
extern "C"
{
    SMARTENGINE_EXPORT ObjPtr GeneticTrainer_CreateInstance(const GeneticTrainerCInfo& cinfo);
    SMARTENGINE_EXPORT void GeneticTrainer_Initialize(ObjPtr object, const GeneticTrainerInitializationInfo& info);
    SMARTENGINE_EXPORT void GeneticTrainer_Step(ObjPtr object);
    SMARTENGINE_EXPORT void GeneticTrainer_SetTrainingInfo(ObjPtr object, const GeneticTrainingInfo& info);
    SMARTENGINE_EXPORT int GeneticTrainer_GetPopulationCount(ObjPtr object);
    SMARTENGINE_EXPORT void GeneticTrainer_SortPopulation(ObjPtr object);
    SMARTENGINE_EXPORT float GeneticTrainer_GetMutationStandardDeviation(ObjPtr object);
    SMARTENGINE_EXPORT int GeneticTrainer_GetChromosomeLastIndex(ObjPtr object, int index);
    SMARTENGINE_EXPORT void GeneticTrainer_SetChromosome(ObjPtr object, int index);
    SMARTENGINE_EXPORT void GeneticTrainer_SetBestChromosome(ObjPtr object);
    SMARTENGINE_EXPORT void GeneticTrainer_CopyOutChromosome(ObjPtr object, int index, ObjPtr graph);
    SMARTENGINE_EXPORT void GeneticTrainer_CopyOutBestChromosome(ObjPtr object, ObjPtr graph);
    SMARTENGINE_EXPORT void GeneticTrainer_CopyOutTopAverage(ObjPtr object, float count, ObjPtr graph, int weightedAverage);
    SMARTENGINE_EXPORT float GeneticTrainer_GetLoss(ObjPtr object, int index);
    SMARTENGINE_EXPORT void GeneticTrainer_SetLoss(ObjPtr object, int index, float loss);
}
 
} // namespace SmartEngine