public async Task <IActionResult> Edit(int id, [Bind("id,name,numOfNeurons,numOfLayers")] NeuralNetworks neuralNetworks)
{
if (id != neuralNetworks.id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(neuralNetworks);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!NeuralNetworksExists(neuralNetworks.id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(neuralNetworks));
}
public async Task <IActionResult> Create([Bind("id,name,numOfNeurons,numOfLayers")] NeuralNetworks neuralNetworks)
{
if (ModelState.IsValid)
{
_context.Add(neuralNetworks);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(neuralNetworks));
}
public void FeddForwardTest()
{
var topology = new Topology(4, 1, 2);
var neuralNetwork = new NeuralNetworks(topology);
neuralNetwork.Layers[1].Neurons[0].SetWeights(0.5, -0.1, 0.3, -0.1);
neuralNetwork.Layers[1].Neurons[1].SetWeights(0.1, -0.3, 0.7, -0.3);
neuralNetwork.Layers[2].Neurons[0].SetWeights(1.2, 0.8);
var result = neuralNetwork.FeddForward(new List <double> {
1, 0, 0, 0
});
}
public NeuralNetwork Train(
IEnumerable <double[]> inputs,
Func <NeuralNetwork, IEnumerable <double[]>, double> fitness)
{
NeuralNetworks.AsParallel()
.ForAll(nn => nn.UpdateFitness(inputs, fitness));
Offspring();
return(NeuralNetworks
.OrderByDescending(nn => nn.Fitness)
.ThenByDescending(nn => nn.Generation)
.First());
}
private void Breed(ref INeuralNetwork[] orderedNetworks)
{
var top = orderedNetworks.Take((orderedNetworks.Length - 1) / 2).ToArray();
var newnetwork = new List <INeuralNetwork>();
for (int i = 0; i < _speciesCount; i++)
{
var index = i % (top.Length - 1);
if (index < top.Length)
{
newnetwork.Add((INeuralNetwork)top[index].Clone());
}
}
NeuralNetworks = newnetwork;
orderedNetworks = FitnessVal.Maximize ? NeuralNetworks.OrderByDescending(p => p.Error).ToArray() : NeuralNetworks.OrderBy(p => p.Error).ToArray();
}
public IGeneration EvolveGeneration()
{
#if Roslyn
Parallel.ForEach(NeuralNetworks, p =>
{
var fitness = FitnessVal.EvaluateFitness(p);
p.Error = fitness;
});
#endif
#if Bridge
foreach (var neuralNetwork in NeuralNetworks)
{
var fitness = FitnessVal.EvaluateFitness(neuralNetwork);
neuralNetwork.Error = fitness;
}
#endif
var orderedNetworks = FitnessVal.Maximize ? NeuralNetworks.OrderByDescending(p => p.Error).ToArray() : NeuralNetworks.OrderBy(p => p.Error).ToArray();
//keep top 50
//todo: copy top 50 networks and evolve the new networks
var gen = new Generation(orderedNetworks, orderedNetworks[0], orderedNetworks[orderedNetworks.Length - 1], orderedNetworks[(orderedNetworks.Length - 1) / 2], Generation);
Breed(ref orderedNetworks);
var r = orderedNetworks.ToList();
r.Reverse();
var reverse = r.Take((int)(orderedNetworks.Length - orderedNetworks.Length * 0.1));
#if Roslyn
Parallel.ForEach(reverse, Mutate);
#endif
#if Bridge
foreach (var neuralNetwork in reverse)
{
Mutate(neuralNetwork);
}
#endif
OnGenerationFinished(gen);
Generation++;
return(gen);
}
