//误差反向传播,先不要更新权重，先计算所有的误差传播，然后再更新权重
public void BackPropagate(params double[] targets)
{
var i = 0;
OutputLayer.ForEach(a => a.CalculateErrorAndGradient(targets[i++])); //计算输出层的误差
TotalError = OutputLayer.Sum(a => Math.Abs(a.Error));
HiddenLayers.Reverse(); //将隐藏层反转，从后往前反推
//HiddenLayers.ForEach(a => a.ForEach(b => b.CalculateErrorAndGradient()));
foreach (List <Neuron> HiddenLayer in HiddenLayers)
{
Parallel.ForEach(HiddenLayer, a =>
{
a.CalculateErrorAndGradient();
});
}
//更新连接权重
OutputLayer.ForEach(a => a.UpdateWeights(LearnRate, Momentum));
//HiddenLayers.ForEach(a => a.ForEach(b => b.UpdateWeights(LearnRate, Momentum)));
foreach (List <Neuron> HiddenLayer in HiddenLayers)
{
Parallel.ForEach(HiddenLayer, a =>
{
a.UpdateWeights(LearnRate, Momentum);
});
}
HiddenLayers.Reverse();//将隐藏层反转回去
}
internal async Task InitTrain()
{
await Reset();
CurrentDemo.TrainingEnded -= TrainingEnded;
CurrentDemo.TrainingEnded += TrainingEnded;
if (string.IsNullOrWhiteSpace(HiddenLayers) == false)
{
CurrentDemo.HiddenLayers = HiddenLayers.Split(',').Select(l => int.Parse(l)).ToArray();
}
else
{
CurrentDemo.HiddenLayers = new int[] { };
}
CurrentDemo.Speed = SpeedValue;
CurrentDemo.LearningRate = LearningRate;
CurrentDemo.TargetError = TargetError;
CurrentDemo.CreateNeuralNetwork();
TotalSteps = CurrentDemo.TotalSteps;
TotalError = CurrentDemo.TotalError;
Input = string.Join(",", CurrentDemo.TrainingSet[0]);
Output = string.Join(",", CurrentDemo.NeuralNetwork.Update(CurrentDemo.TrainingSet[0]));
TargetOutput = string.Join(",", CurrentDemo.Targets[0]);
var scene = new NeuralNetworkScene(CurrentDemo.NeuralNetwork);
await _game.Start(scene);
}
private void BackPropagate(params double[] targets)
{
var i = 0;
OutputLayer.ForEach(a => a.CalculateGradient(targets[i++]));
HiddenLayers.Reverse();
//HiddenLayers.ForEach(a => a.ForEach(b => b.CalculateGradient()));
HiddenLayers.ForEach(a =>
Parallel.ForEach(a, (b) =>
{
b.CalculateGradient();
})
);
//HiddenLayers.ForEach(a => a.ForEach(b => b.UpdateWeights(LearnRate, Momentum)));
HiddenLayers.ForEach(a =>
Parallel.ForEach(a, (b) =>
{
b.UpdateWeights(LearnRate, Momentum);
})
);
HiddenLayers.Reverse();
//OutputLayer.ForEach(a => a.UpdateWeights(LearnRate, Momentum));
Parallel.ForEach(OutputLayer, (on) =>
{
on.UpdateWeights(LearnRate, Momentum);
});
}
protected void CreateNeurons(int inputSize, int[] hiddenSizes, int outputSize)
{
for (var i = 0; i < inputSize; i++)
{
InputLayer.Add(new Neuron());
}
var firstHiddenLayer = new List <Neuron>();
for (var i = 0; i < hiddenSizes[0]; i++)
{
firstHiddenLayer.Add(new Neuron(InputLayer, HiddenActivationType));
}
HiddenLayers.Add(firstHiddenLayer);
for (var i = 1; i < hiddenSizes.Length; i++)
{
var hiddenLayer = new List <Neuron>();
for (var j = 0; j < hiddenSizes[i]; j++)
{
hiddenLayer.Add(new Neuron(HiddenLayers[i - 1], HiddenActivationType));
}
HiddenLayers.Add(hiddenLayer);
}
for (var i = 0; i < outputSize; i++)
{
OutputLayer.Add(new Neuron(HiddenLayers.Last(), OutputActivationType));
}
}
public void AddNeuron()
{
if (!AllSynapses.Any())
{
AddSynapse();
return;
}
//Debug.Log("Poczatek add neuron");
int tmp = RandomGenerator.Next(AllSynapses.Count);
Synapse oldSyn = AllSynapses.ToList()[tmp].Value;
AllSynapses.Remove(oldSyn.InnovationNo);
oldSyn.InputNeuron.OutputSynapses.Remove(oldSyn);
oldSyn.OutputNeuron.InputSynapses.Remove(oldSyn);
Neuron neuron = new Neuron(NeuronInnovationNo);
Synapse newSyn1 = new Synapse(oldSyn.InputNeuron, neuron, SynapseInnovationNo);
newSyn1.Weight = 1;
Synapse newSyn2 = new Synapse(neuron, oldSyn.OutputNeuron, SynapseInnovationNo);
newSyn2.Weight = oldSyn.Weight;
HiddenLayers.Add(neuron.InnovationNo, neuron);
AllSynapses.Add(newSyn1.InnovationNo, newSyn1);
AllSynapses.Add(newSyn2.InnovationNo, newSyn2);
}
public bool Train(List <double> input, List <double> idealOutput)
{
if ((input.Count != Layers.First().Size) || (idealOutput.Count != Layers.Last().Size))
{
return(false);
}
Dropout();
Run(input);
OutputLayer.InitDelta(idealOutput);
foreach (var layer in HiddenLayers.Reverse())
{
layer.CalcDelta();
}
foreach (var layer in Layers.Skip(1))
{
layer.UpdateWeights();
}
ClearDropout();
return(true);
}
public object Clone()
{
var clone = Of(InputLayer.ColsCount, OutputLayer.ColsCount, ActivationsFunctions);
var cloneWeights = new List <Matrix>();
foreach (var weight in Weights)
{
var currentWeight = new Matrix(weight.RowsCount, weight.ColsCount);
for (var rowI = 0; rowI < currentWeight.RowsCount; rowI++)
{
for (var colJ = 0; colJ < currentWeight.ColsCount; colJ++)
{
currentWeight[rowI, colJ] = weight[rowI, colJ];
}
}
cloneWeights.Add(currentWeight);
}
var cloneBiases = new List <double>(Biases);
clone.Weights = cloneWeights;
clone.Biases = cloneBiases;
var neuronsInHiddenLayers = HiddenLayers.Select(layer => layer.ColsCount).ToArray();
clone.InitializeHiddenLayers(neuronsInHiddenLayers);
return(clone);
}
private void BackPropagate(params double[] targets)
{
NumCalc++;
int actual = targets.ToList().IndexOf(targets.Max());
double[] outputs = OutputLayer.Select(a => a.Value).ToArray();
int predicted = outputs.ToList().IndexOf(outputs.Max());
if (actual == predicted)
{
Accuracy += 1;
}
int i = 0;
OutputLayer.ForEach(a => a.CalculateGradient(targets[i++]));
HiddenLayers.Reverse();
HiddenLayers.ForEach(a => a.AsParallel().ForAll(b => b.CalculateGradient()));
HiddenLayers.ForEach(a => a.AsParallel().ForAll(b => b.UpdateWeights(LearnRate, Momentum)));
HiddenLayers.Reverse();
OutputLayer.AsParallel().ForAll(a => a.UpdateWeights(LearnRate, Momentum));
i = 0;
double error = OutputLayer.Sum(a => Math.Abs(a.CalculateError(targets[i++])));
Error += error;
if (NumCalc % 1000 == 0)
{
Console.WriteLine($"Error: {Error / 1000 / 10} NumCalc: {NumCalc} Accuracy: {Accuracy / 10.0}");
Error = 0;
Accuracy = 0;
}
}
private void BindKochonenNet()
{
AlltoAllBinding(InputLayer, HiddenLayers[0]);
if (HiddenLayers.Count > 1)
{
for (int i = 0; i < HiddenLayers.Count - 1; i++)
{
AlltoAllBinding(HiddenLayers[i], HiddenLayers[i + 1]);
}
}
OnetoOneBinding(HiddenLayers.Last(), OutputLayer);
double koordQ = InputLayer.neurons.Count;
Random a = new Random();
foreach (var s in HiddenLayers[0].neurons)
{
foreach (var inl in s.inLinks)
{
inl.w = 0.5 + (a.NextDouble() - 0.5) / koordQ;
}
foreach (var outl in s.outLinks)
{
outl.w = 1d;
}
}
}
private void ForwardPropagate(params double[] inputs)
{
int i = 0;
InputLayer.ForEach(a => a.Value = inputs[i++]);
HiddenLayers.ForEach(a => a.AsParallel().ForAll(b => b.CalculateValue()));
OutputLayer.AsParallel().ForAll(a => a.CalculateValue());
}
private IEnumerator UpdateWeights()
{
OutputLayer.ForEach(n => n.InputSynapses.ForEach(s => s.Weight = s.WeightDelta));
HiddenLayers.ForEach(l => l.ForEach(n => n.InputSynapses.ForEach(s => s.Weight = s.WeightDelta)));
yield return(new WaitForSeconds(1));
Debug.Log("End BP");
}
public NeuralNetwork(int inputNeurons, int hiddenNeurons, int outputNeurons)
{
InputLayer = new InputLayer(inputNeurons);
HiddenLayers.Add(new HiddenLayer(hiddenNeurons));
OutputLayer = new OutputLayer(outputNeurons);
Generate();
CreateSubscribes();
}
//Obliczenie wartości wyjściowej sieci neuronowej dla pojedyńczego elementu
private void ForwardPropagate(double[] inputs)
{
var i = 0;
InputLayer.ForEach(a => a.Value = inputs[i++]);
HiddenLayers.ForEach(a => a.ForEach(b => b.CalculateValue()));
OutputLayer.ForEach(a => a.CalculateValue());
}
public HiddenLayer CreateHiddenLayer()
{
HiddenLayer hiddenLayer;
hiddenLayer = new HiddenLayer();
HiddenLayers.Add(hiddenLayer);
return(hiddenLayer);
}
public NeuralNet Crossover(NeuralNet partner)
{
OutputLayer.Crossover(partner.OutputLayer);
foreach (var layer in HiddenLayers.Zip(partner.HiddenLayers))
{
layer.Key.Crossover(layer.Value);
}
return(this);
}
public NeuralNetworkGene GetGenes()
{
return(new NeuralNetworkGene
{
InputGene = InputLayer.GetGenes(),
HiddenGenes = HiddenLayers.Select(l => l.GetGenes()).ToList(),
OutputGene = OutputLayer.GetGenes()
});
}
private void BackPropagate(params double[] targets)
{
var i = 0;
OutputLayer.ForEach(a => a.CalculateGradient(targets[i++]));
HiddenLayers.AsEnumerable().Reverse().ToList().ForEach(a => a.ForEach(b => b.CalculateGradient()));
HiddenLayers.AsEnumerable().Reverse().ToList().ForEach(a => a.ForEach(b => b.UpdateWeights(LearnRate, Momentum)));
OutputLayer.ForEach(a => a.UpdateWeights(LearnRate, Momentum));
}
public void BuildFromDNA(string dna)
{
string[] parts = dna.Split(new[] { "||" }, StringSplitOptions.None);
int inputCount = int.Parse(parts[0]);
int outputCount = int.Parse(parts[1]);
int depth = 0;
int hiddenNeuronsPerLayer = 0;
if (parts.Length > 2)
{
depth = int.Parse(parts[2]);
}
if (parts.Length > 3)
{
hiddenNeuronsPerLayer = int.Parse(parts[3]);
}
InputLayer = new NeuronsLayer(0, inputCount);
InputLayer.BuildDendrites(1, 1);
HiddenLayers = Enumerable.Range(1, depth).Select(i => new NeuronsLayer(i, hiddenNeuronsPerLayer)).ToList();
OutputLayer = new NeuronsLayer(1 + depth, outputCount);
HiddenLayers.ForEach(h => h.BuildDendrites(h == HiddenLayers.First() ? inputCount : hiddenNeuronsPerLayer, 0));
OutputLayer.BuildDendrites(hiddenNeuronsPerLayer, 0);
if (parts.Length > 4)
{
int weightCounter = 4;
foreach (NeuronsLayer nl in HiddenLayers)
{
foreach (Neuron n in nl.Neurons)
{
foreach (Dendrite d in n.Dendrites)
{
d.Weight = double.Parse(parts[weightCounter++]);
}
}
}
foreach (Neuron n in OutputLayer.Neurons)
{
foreach (Dendrite d in n.Dendrites)
{
d.Weight = double.Parse(parts[weightCounter++]);
}
}
}
AllLayers = new List <NeuronsLayer>();
AllLayers.Add(InputLayer);
AllLayers.AddRange(HiddenLayers);
AllLayers.Add(OutputLayer);
}
public void RandomizeWeights()
{
var random = new Random();
RandomizeLayer(InputLayer, (HiddenLayers.FirstOrDefault() ?? OutputLayer).Count(), random);
for (int i = 0; i < HiddenLayers.Count; i++)
{
RandomizeLayer(HiddenLayers[i], (HiddenLayers.ElementAtOrDefault(i + 1) ?? OutputLayer).Count, random);
}
}
private void BackPropagation(params double[] goal)
{
var i = 0;
ExitLayer.Neurons.ForEach(x => x.CalculateGradient(goal[i++]));
HiddenLayers.Reverse();
HiddenLayers.ForEach(x => x.Neurons.ForEach(y => y.CalculateGradient()));
HiddenLayers.ForEach(x => x.Neurons.ForEach(y => y.UpdateWeight(LearningRate, Momentum)));
HiddenLayers.Reverse();
ExitLayer.Neurons.ForEach(x => x.UpdateWeight(LearningRate, Momentum));
}
private void ForwardPropagation(params double[] entryValue)
{
var i = 0;
for (int j = 0; j < EntryLayer.Neurons.Count; j++)
{
EntryLayer.Neurons[i].Value = entryValue[i++];
}
HiddenLayers.ForEach(x => x.Neurons.ForEach(y => y.CalculateEntry()));
ExitLayer.Neurons.ForEach(x => x.CalculateEntry());
}
//Obliczenie gradientów i zaktualizowanie wag
private void BackPropagate(double[] targets)
{
var i = 0;
OutputLayer.ForEach(a => a.CalculateGradient(targets[i++]));
HiddenLayers.Reverse();
HiddenLayers.ForEach(a => a.ForEach(b => b.CalculateGradient()));
HiddenLayers.ForEach(a => a.ForEach(b => b.UpdateWeights(LearningRate, Momentum)));
HiddenLayers.Reverse();
OutputLayer.ForEach(a => a.UpdateWeights(LearningRate, Momentum));
}
public void InitializeHiddenLayers(int[] hiddenNeuronCount)
{
InputLayer.Clear();
HiddenLayers.Clear();
OutputLayer.Clear();
foreach (var neuronsCount in hiddenNeuronCount)
{
var newHiddenLayer = new Matrix(1, neuronsCount);
HiddenLayers.Add(newHiddenLayer);
}
}
private void BackPropagate(params double[] targets)
{
var i = 0;
OutputLayer.ForEach(a => a.CalculateGradient(targets[i++]));
foreach (var layer in HiddenLayers.AsEnumerable <List <Neuron> >().Reverse())
{
layer.ForEach(a => a.CalculateGradient());
layer.ForEach(a => a.UpdateWeights(LearnRate, Momentum));
}
OutputLayer.ForEach(a => a.UpdateWeights(LearnRate, Momentum));
}
//[JsonRequired]
//public BrainConfiguration Configuration { get; set; }
public void InitLayers(BrainConfiguration configuration)
{
//Configuration = configuration;
foreach (IBrainLayer layer in this)
{
layer.InitLayer(configuration);
layer.InitFiredNeurons();
}
globals.CachedNeuronCount = HiddenLayers.Sum(l => l.Count);
}
private void BackPropagate(params double[] targets)
{
var i = 0;
OutputLayer.ForEach(a => a.CalculateGradient(targets[i++])); //Ably CalculateGradient() function to all output values which adjust the actual error to meet the desired error(MinimumError)
foreach (var layer in HiddenLayers.AsEnumerable <List <Neuron> >().Reverse()) //go to the opposite direction from output to the hidden layer
{
layer.ForEach(a => a.CalculateGradient()); //Ably the CalculateGradient() to hiddenLayers list which adjust the actual error to meet the desired error(MinimumError)
layer.ForEach(a => a.UpdateWeights(LearnRate, Momentum)); //Ably the UpdateWeights() to hiddenLayers list which update the weight and bias for every node
}
OutputLayer.ForEach(a => a.UpdateWeights(LearnRate, Momentum)); //Ably the UpdateWeights() to output list which update the weight and bias for every output
}
public void DeleteHiddenLayer(LayerViewModel l)
{
if (HiddenLayers.Contains(l))
{
HiddenLayers.Remove(l);
for (int i = 0; i < HiddenLayers.Count; i++)
{
HiddenLayers[i].Number = i + 1;
}
}
CanCreateChanged?.Invoke();
}
private void SetHiddenLayerNeuronsErrors()
{
foreach (var layer in HiddenLayers.Reverse())
{
foreach (var neuron in layer.Neurons)
{
var deltaSum = neuron.OutConnections.Sum(connection
=> connection.Destination.Error * connection.Weight.Value);
neuron.Error = GetDerivative(neuron) * deltaSum;
}
}
}
public void SetSimSettings(SimulationSettings simSettings)
{
if (simSettings != null)
{
this.simSettings = simSettings;
SimType = simSettings.SimType;
Sessions = simSettings.Sessions;
Hours = simSettings.Hours;
Score = simSettings.Score;
chkSimDisplay.IsChecked = simSettings.EnableSimDisplay;
if (!simSettings.EncogSelected)
{
grpEncogSettings.Visibility = Visibility.Collapsed;
this.Height -= grpEncogSettings.Height;
}
else
{
HiddenLayers = simSettings.HiddenLayers;
txtHiddenLayers.Text = HiddenLayers.ToString();
HiddenLayerNeurons = (simSettings.HiddenLayerNeurons <= 0) ? simSettings.NumSlots * simSettings.NumShelves : simSettings.HiddenLayerNeurons;
txtHiddenLayerNeurons.Text = HiddenLayerNeurons.ToString();
}
calculateMaxScore();
simScoreSlider.Value = simSettings.DefaultScorePercentage;
simScoreSliderLbl.Content = simScoreSlider.Value + "%";
switch (SimType)
{
case SimulationType.Sessions:
rdbSessions.IsChecked = true;
txtSimInput.Text = Sessions.ToString();
showScoreSlider(false);
break;
case SimulationType.Time:
rdbTime.IsChecked = true;
txtSimInput.Text = Hours.ToString();
showScoreSlider(false);
break;
default:
rdbScore.IsChecked = true;
txtSimInput.Text = Score.ToString();
showScoreSlider(true);
break;
}
}
}
private void BindClassicNet()
{
AlltoAllBinding(InputLayer, HiddenLayers[0]);
if (HiddenLayers.Count > 1)
{
for (int i = 0; i < HiddenLayers.Count - 1; i++)
{
AlltoAllBinding(HiddenLayers[i], HiddenLayers[i + 1]);
}
}
AlltoAllBinding(HiddenLayers.Last(), OutputLayer);
}