public void TrainDataSet()
{
do
{
_iterations++; _error = 0.0;
_idx.Permute(DataSet.Size);
for (int i = 0; i < DataSet.Size; i++)
{
var input = DataSet.Data[_idx[i]].Input;
var output = DataSet.Data[_idx[i]].Output;
_error += Network.Train(ref input,
ref output,
TrainingRate, Momentum);
DataSet.Data[_idx[i]].Input = input;
DataSet.Data[_idx[i]].Output = output;
}
_errorHistory.Add(_error);
if (_iterations % NudgeWindow == 0)
{
CheckNudge();
}
IterationCompleted?.Invoke(this, new TrainingProgressReport(_iterations, _error));
} while (_error > MaxError && _iterations < MaxIterations);
}
private async Task OnGenerationFinished(PopulationState state)
{
var simulationState = new SimulatorState
{
Iteration = state.Generation,
HighScore = state.HighScore,
HighRatedIndividualsIds = state.HighRatedIndividuals.Select(ind => ind.Id).ToArray()
};
if (IterationCompleted != null)
{
await IterationCompleted.Invoke(simulationState);
}
}
public void RUN(Population population)
{
FitnessFunction.SetFitness(population);
var i = 0ul;
while (!_stop)
{
population = Selection.RUN(population);
population = _crossover.RUN(population);
population = _mutation.RUN(population);
FitnessFunction.SetFitness(population);
IterationCompleted?.Invoke(population, ++i);
}
}
/// <summary>
/// Starts calculations
/// </summary>
/// <returns>Returns best indviduum</returns>
public virtual Individuum <T> Do()
{
for (int i = 0; i < iterations; i++)
{
IterationStarted?.Invoke(this, EventArgs.Empty);
double SummedFitness = CalculateSummedFitness();
Individuum <T>[] NewPopulation = GetElitist();
for (int j = (int)Math.Ceiling(populationSize * elitistChance); j < populationSize; j++)
{
bool born = false;
if (rand.NextDouble() <= crossoverChance)
{
Individuum <T> parent1 = null;
Individuum <T> parent2 = null;
ChooseParents(SummedFitness, ref parent1, ref parent2);
Individuum <T> child = Crossover(parent1, parent2);
child.Fitness = CalculateFitness(child);
if (child.Fitness != parent1.Fitness && child.Fitness != parent2.Fitness)
{
NewPopulation[j] = child;
born = true;
}
}
if (!born)
{
if (surviveChance >= rand.NextDouble())
{
Mutation(dna[j]);
NewPopulation[j] = dna[j];
}
else
{
NewPopulation[j] = CreateGen();
}
}
}
dna = NewPopulation;
IterationCompleted?.Invoke(this, new IterationArgs <T>(Best, i));
}
return(Best);
}
/// <summary>
/// Обучить нейронную сеть.
/// </summary>
/// <param name="inputDataSet">Набор входных данных для обучения.</param>
/// <param name="neuronsCount">Количество нейронов.</param>
/// <param name="iterationsCount">Количество эпох.</param>
public virtual void Study(NetworkDataSet inputDataSet, int neuronsCount, int iterationsCount)
{
GenerateNeurons(inputDataSet?.Attributes, neuronsCount);
for (int iteration = 0; iteration < iterationsCount; iteration++)
{
var randomNumber = _random.Next(0, inputDataSet.Entities.Count - 1);
var randomEntity = inputDataSet.Entities[randomNumber];
var attributeValues = randomEntity.AttributeValues
.Select(e => new InputAttributeValue
{
InputAttributeNumber = e.Attribute.OrderNumber,
Value = e.GetNormalizedValue(NormalizationType)
})
.ToList();
var totalError = StudyInputEntity(attributeValues, iteration, iterationsCount);
IterationCompleted?.Invoke(this, null);
}
}
