static void EvoMain(string[] args)
{
var random = new Random();
var evoEng = new EvolutionEngine(random)
{
CrossoverRate = 1,
EliteCopyRate = 10,
EliteThreshold = 4,
MaxPerturbation = 1,
MutationRate = .1,
Population = new int[100].Select(i => new Brain(3, 1, 3, 1, p: .001, rand: random)).ToList()
};
var trainingSet = new int[1000].Select(i => new List <double> {
random.Next(-10, 10), random.Next(-10, 10), 1
}).ToList();
var trainingAnswers = new int[1000].Select((i, idx) => Convert.ToDouble(trainingSet[idx][0] >= 2 * trainingSet[idx][1] ? 1 : 0)).ToList();
while (true)
{
foreach (var brain in evoEng.Population)
{
var error = 0.0;
for (var i = 0; i < trainingSet.Count; i++)
{
var output = brain.Think(trainingSet[i]).Last().First();
error += Math.Abs(trainingAnswers[i] - output);
}
brain.FitnessScore = 1 / Math.Pow(error, 10);
}
Console.WriteLine($"Generation: {evoEng.Generation}, AvgFitness: {evoEng.AvgFitness}, MaxFitness: {evoEng.MaxFitness}, MinFitness: {evoEng.MinFitness}");
evoEng.Evolve();
}
}
public static int FeedOn(Creature creature)
{
int foodType = GetFoodType(creature.DNA);
if (foodType == 0)
{
creature.Energy += Env.GetSunEnergy(creature.transform.position);
}
else if (foodType == 1)
{
creature.Energy += Env.GetMineralEnergy(creature.transform.position);
}
else if (foodType == 2)
{
RaycastHit raycastHit = RayCast(creature.gameObject);
if (raycastHit.transform != null)
{
if (raycastHit.transform.parent.gameObject.tag == "Microorganism")
{
EvolutionEngine.GiveBackObject(raycastHit.transform.parent.gameObject);
Move(creature.gameObject, true);
creature.Energy += 8;
}
}
}
return(0);
}
void Update()
{
time += Time.deltaTime;
//if (time >= 0.1)
{
VirtualMachine.Step(this);
if (DNA.GenePos >= DNA.Genes.Count)
{
DNA.GenePos = 0;
}
Energy--;
if (Energy <= 0)
{
EvolutionEngine.GiveBackObject(gameObject);
}
LifeTime++;
if (LifeTime >= MaxLifeTime)
{
DNA.GenePos = 0;
Statistics.AddOldestDNA(this);
EvolutionEngine.GiveBackObject(gameObject);
}
if (Energy >= MaxEnergy)
{
Division();
}
time = 0;
}
//Test();
}
public void GeneratePopulation()
{
Vector3 pos = new Vector3(Random.Range(0, Width) * CellSize, 0, (Height - 1) * CellSize);
GameObject bio = EvolutionEngine.TakeObject();
bio.transform.position = pos;
bio.SetActive(true);
bio.transform.GetChild(0).gameObject.SetActive(true);
}
public MainForm()
{
InitializeComponent();
Settings = Serializer.DeserializeSettings();
if (Settings == null)
{
Settings = new Settings();
}
_evolutionEngine = new EvolutionEngine(picPattern.Image as Bitmap);
}
void Start()
{
CellPrefab.transform.localScale = new Vector3(CellSize, CellSize, CellSize);
BioPrefab.transform.localScale = new Vector3(BioSize, BioSize, BioSize);
Vector3 pos = Vector3.zero;
pos.x = (Width / 2) * CellSize - (CellSize / 2);
pos.z = (Height / 2) * CellSize - (CellSize / 2);
GameObject cell = Instantiate(CellPrefab, pos, Quaternion.identity);
cell.transform.SetParent(gameObject.transform);
cell.transform.localScale = new Vector3(Width * CellSize, 1, Height * CellSize);
EvolutionEngine.InitializeObjectPool(Width * Height, BioPrefab);
GeneratePopulation();
//GeneratePopulation();
}
private void Division()
{
List <Vector3> freePos = new List <Vector3>();
for (int i = 0; i < 4; i++)
{
Vector3 direction = GetRandomVector(i);
RaycastHit raycastHit = VirtualMachine.RayCast(gameObject, direction);
if (raycastHit.transform == null)
{
Vector3 inRange = this.transform.position + direction;
if (inRange.x >= 0 && inRange.x < VirtualMachine.Env.Width * VirtualMachine.Env.CellSize &&
inRange.z < VirtualMachine.Env.Height * VirtualMachine.Env.CellSize && inRange.z >= 0)
{
freePos.Add(direction);
}
}
}
if (freePos.Count == 0)
{
//EvolutionEngine.GiveBackObject(gameObject);
}
else
{
Vector3 pos = freePos[Random.Range(0, freePos.Count)];
GameObject child = EvolutionEngine.TakeObject();
child.transform.position = this.transform.position + pos;
Creature childCreature = child.GetComponent <Creature>();
VirtualMachine.Rotate(child);
List <Gene> genes = this.DNA.Copy();
childCreature.InitializeDNA(genes);
child.SetActive(true);
child.transform.GetChild(0).gameObject.SetActive(true);
GameObject childVisual = null;
childVisual = child.transform.GetChild(0).gameObject;
Color parentColor = this.GetComponentInChildren <Renderer>().material.color;
childVisual.GetComponent <Renderer>().material.color = new Color(parentColor.r, parentColor.g, parentColor.b, parentColor.a);
if (Random.Range(0, 100) < 5)
{
childCreature.DNA.Mutate();
child.GetComponentInChildren <Renderer>().material.color = EvolutionEngine.GetMutationColor(VirtualMachine.GetFoodType(childCreature.DNA));
//childCreature.DNA.DisplayGenes();
}
Energy = 1;
}
}
private void OpenImage()
{
Stop();
string fileName = FileUtil.GetOpenFileName(FileUtil.ImgExtension);
if (string.IsNullOrEmpty(fileName))
{
return;
}
picPattern.Image = Image.FromFile(fileName);
_evolutionEngine = new EvolutionEngine(picPattern.Image as Bitmap);
SetCanvasSize();
splitContainer1.SplitterDistance = picPattern.Width + 30;
}
public static int Run(ProgramSettings settings)
{
ThreadPool.SetMaxThreads(Environment.ProcessorCount, Environment.ProcessorCount);
PrintSettings(settings);
(var trainDataset, var testDataset) = DatasetLoader.LoadDatasets(
trainDataFilename: settings.TrainDataPath,
trainLabelsFilename: settings.TrainLabelsPath,
testDataFilename: settings.TestDataPath,
testLabelsFilename: settings.TestLabelsPath,
classificationType: settings.ClassificationType);
Console.WriteLine();
PrintTrainDatasetInformation(trainDataset);
Console.WriteLine();
var hyperRectangleCoverageComputer = new HyperRectangleCoverageComputer(dataset: trainDataset);
var featureTestIntervalConveter = new FeatureTestDimensionIntervalConverter(trainDataset);
var ruleAntecedentHyperRectangleConverter = new RuleAntecedentHyperRectangleConverter(featureTestIntervalConveter);
var seedSelector = new CFSBESeedFinder(
ruleConverter: ruleAntecedentHyperRectangleConverter,
coverageComputer: hyperRectangleCoverageComputer);
var antecedentCreator = new AntecedentCreator(ruleAntecedentHyperRectangleConverter: ruleAntecedentHyperRectangleConverter);
var consequentCreator = settings.ClassificationType switch
{
ClassificationType.SingleLabel => (IConsequentCreator) new SingleLabelConsequentCreator(dataset: trainDataset),
ClassificationType.MultiLabel => (IConsequentCreator) new MultiLabelConsequentCreator(dataset: trainDataset, threshold: settings.RuleConsequentThreshold),
_ => throw CommonExceptions.UnknownClassificationType,
};
var hyperRectangleIntersector = new HyperRectangleIntersector(trainDataset);
var nonIntersectingHyperRectangleCreator = new NonIntersectingRectangleCreator(hyperRectangleIntersector);
var ruleCreator = new CoverageAwareRuleCreator(
seedSelector: seedSelector,
boxConverter: ruleAntecedentHyperRectangleConverter,
boxCreator: nonIntersectingHyperRectangleCreator,
coverageComputer: hyperRectangleCoverageComputer,
antecedentCreator: antecedentCreator,
consequentCreator: consequentCreator,
hyperRectangleIntersector: hyperRectangleIntersector,
targetNumberOfInstancesToCover: settings.TargetNumberOfInstancesToCoverDuringRuleCreationg,
runExpensiveSanityChecks: settings.SkipExpensiveSanityChecks);
var individualMutationChooser = BiasedOptionChooser <IndividualMutationType> .Create(
new Dictionary <IndividualMutationType, int>() {
[IndividualMutationType.AddRule] = settings.IndividualMutationAddRuleWeight,
[IndividualMutationType.ModifyRule] = settings.IndividualMutationModifyRuleWeight,
[IndividualMutationType.RemoveRule] = settings.IndividualMutationRemoveRuleWeight
});
var ruleSwappingindividualMutator = new RuleSwappingIndividualMutator(
mutationChooser: individualMutationChooser,
ruleCreator: ruleCreator);
var populationMutator = new PopulationMutator(
individualMutator: ruleSwappingindividualMutator,
mutantsPerGeneration: settings.MutantsPerGeneration,
maximumFailedAttemptsPerGeneration: settings.MaximumFailedMutationAttemptsPerGeneration);
var trainMetrics = IMetricParser.ParseMetrics(
dataset: trainDataset,
metricsNames: settings.MetricNames,
classificationType: settings.ClassificationType);
var trainFitnessEvaluator = new FitnessEvaluator(trainMetrics);
var testMetrics = IMetricParser.ParseMetrics(
dataset: testDataset,
metricsNames: settings.MetricNames,
classificationType: settings.ClassificationType);
var testFitnessEvaluator = new FitnessEvaluator(testMetrics);
var fittestIdentifier = IFittestIdentifierParser.Parse(
name: settings.SelectionAlgorithm,
fittestCount: settings.PopulationSize);
var individualCreator = new SingleRuleIndividualCreator(ruleCreator: ruleCreator);
var initialPopulation = CreateInitialPopulation(
individualCreator: individualCreator,
settings: settings);
var modelSerializer = new ModelSerializer();
var populationFitnessSerializer = new PopulationFitnessSerializer(
trainFitnessEvaluator: trainFitnessEvaluator,
testFitnessEvaluator: testFitnessEvaluator);
var trainPredictionsSerializer = new PredictionsSerializer(dataset: trainDataset);
var testPredictionsSerializer = new PredictionsSerializer(dataset: testDataset);
var persistentOutputManager = new PersistentOutputManager(
outputDirectory: settings.OutputDirectory,
saveModels: settings.SaveModels,
saveTrainPredictions: settings.SaveTrainPredictions,
saveTestPredictions: settings.SaveTestPredictions,
modelSerializer: modelSerializer,
populationFitnessSerializer: populationFitnessSerializer,
trainPredictionsSerializer: trainPredictionsSerializer,
testPredictionsSerializer: testPredictionsSerializer);
//var consistencyChecker = new RuleConsistencyChecker(
// ruleAntecedentHyperRectangleConverterconverter: ruleAntecedentHyperRectangleConverter,
// hyperRectangleIntersector: hyperRectangleIntersector);
var evolutionEngine = new EvolutionEngine(
maximumNumberOfGenerations: settings.MaximumGenerations,
fitnessEvaluator: trainFitnessEvaluator,
populationMutator: populationMutator,
fittestIdentifier: fittestIdentifier);
var lastGenerationSummary = evolutionEngine.Run(initialPopulation);
if (lastGenerationSummary.GenerationNumber == settings.MaximumGenerations)
{
Console.WriteLine($"Evolution cycle stopped. Reason: maximum number of generations reached.");
}
else
{
Console.WriteLine($"Evolution cycle stopped. Reason: maximum number of generations reached.");
}
persistentOutputManager.SaveWhatMustBeSaved(population: lastGenerationSummary.Population);
Console.WriteLine("Done.");
return(0);
}
