private void ApplyPattern(double[] pattern)
{
BackpropagationLayer inputLayer = layers[0];
for (int x = 0; x < inputLayer.neurons.Count; x++)
{
inputLayer.neurons[x].SetValuePattern(pattern[x]);
}
}
private void CalculateErrorOut(double[] outPattern)
{
BackpropagationLayer outLayer = layers[layers.Count - 1];
for (int x = 0; x < outPattern.Count(); x++)
{
BackpropagationNeuron neuronOut = outLayer.neurons[x];
//Formula: Erro_saída[j] = (valor_desejado – valor_obtido)* valor_obtido * (1 – (valor_obtido))
neuronOut.valueError = (outPattern[x] - neuronOut.GetValuePattern()) * neuronOut.GetValuePattern() * (1 - neuronOut.GetValuePattern());
}
}
private double[] GetDoubleArrayOutput()
{
BackpropagationLayer outLayer = layers[layers.Count - 1];
double[] result = new double[outLayer.neurons.Count()];
for (int x = 0; x < outLayer.neurons.Count(); x++)
{
BackpropagationNeuron neuron = outLayer.neurons[x];
result[x] = neuron.GetValuePattern();
}
return(result);
}
private double CalculateStopError(double[] outPattern)
{
double result = 0;
BackpropagationLayer outLayer = layers[layers.Count - 1];
for (int x = 0; x < outPattern.Count(); x++)
{
//double value = outPattern[x];
//Formula: erro = 1/2 E (valor desejado - valor obtido)2
result += (outPattern[x] - outLayer.neurons[x].GetValuePattern()) * (outPattern[x] - outLayer.neurons[x].GetValuePattern());
}
return(result / 2);
}
public BackpropagationLayer(int layerSize, BackpropagationLayer fatherLayer)
{
neurons = new List <BackpropagationNeuron>();
for (int x = 0; x < layerSize; x++)
{
BackpropagationNeuron neuron = new BackpropagationNeuron();
neurons.Add(neuron);
foreach (BackpropagationNeuron fatherNeuron in fatherLayer.neurons)
{
neuron.listConnection.Add(new BackpropagationConnection(fatherNeuron));
}
}
}
private void DoBackPropagation(double[] outPattern)
{
//CALCULA ERRO NA CAMADA DE SAÍDA!
CalculateErrorOut(outPattern);
//Calcula o erro nas camadas intermediárias
//ErrorA = Output A (1 - Output A)(ErrorB WAB + ErrorC WAC)
//VEM PROPAGANDO DE TRÁS PARA FRENTE. COMEÇA NA PENÚLTIMA CAMADA E VAI ATÉ A PRIMEIRA
for (int x = layers.Count - 2; x >= 0; x--)
{
BackpropagationLayer layerL = layers[x];
BackpropagationLayer layerR = layers[x + 1];
//PARA CADA NEURÔNIO DA CAMADA DA ESQUERDA
for (int y = 0; y < layerL.neurons.Count; y++)
{
BackpropagationNeuron neuronL = layerL.neurons[y];
neuronL.valueError = 0;
//CALCULA O ERRO
double sum = 0;
for (int z = 0; z < layerR.neurons.Count; z++)
{
//para cada neurônio da camada da direita, pega ele e encontra a conexão entre os 2
BackpropagationNeuron neuronR = layerR.neurons[z];
for (int c = 0; c < neuronR.listConnection.Count; c++)
{
BackpropagationConnection connection = neuronR.listConnection[c];
if (connection.neuron == neuronL)
{
//acumula a soma do (erro do neuronio da direita * peso da ligacao)
sum += neuronR.valueError * connection.valueWeight;
//e
//atualiza peso da conexão
//WAB = WAB + (ErrorB x OutputA)
connection.valueWeight = connection.valueWeight + (neuronR.valueError * neuronL.valuePattern);
}
}
}
//ErrorA = Output A (1 - Output A)(ErrorB WAB + ErrorC WAC)
neuronL.valueError = neuronL.valuePattern * (1 - neuronL.valuePattern) * sum;
}
}
}
/*
* Define todas as camadas da rede
*/
public void SetLayers(List <BackpropagationLayer> layers)
{
bool incorrectDataFormat = false;
if (layers.Count == this.layers.Count)
{
for (int x = 0; x < layers.Count; x++)
{
if (layers[x].neurons.Count != this.layers[x].neurons.Count)
{
incorrectDataFormat = true;
}
}
}
else
{
incorrectDataFormat = true;
}
if (incorrectDataFormat)
{
throw new Exception("Incorrect data format!");
}
else
{
this.layers = layers;
//Redefinindo conexões
BackpropagationLayer lastLayer = null;
foreach (BackpropagationLayer layer in layers)
{
foreach (BackpropagationNeuron neuron in layer.neurons)
{
int connNumber = 0;
foreach (BackpropagationConnection conn in neuron.listConnection)
{
conn.neuron = lastLayer.neurons[connNumber];
connNumber++;
}
}
lastLayer = layer;
}
}
}
private void CalculateSum(BackpropagationLayer layer)
{
for (int x = 0; x < layer.neurons.Count; x++)
{
BackpropagationNeuron neuron = layer.neurons[x];
//CALCULA A SOMA PARA CADA NEURONIO DA CAMADA.
//PARA ISSO, APURA CADA RELAÇÃO DE SUA CONEXAO (BACKWARD).
double sum = 0;
for (int y = 0; y < neuron.listConnection.Count; y++)
{
BackpropagationConnection connection = neuron.listConnection[y];
// Formula: (E x*w)
sum += (connection.neuron.GetValuePattern() * connection.valueWeight);
}
//APLICA A FUNÇÃO DE TRANSFERÊNCIA.
neuron.SetValuePattern(TransferFunction(sum));
}
}
private void BuildBackpropagation(int inputLayerSize, int outputLayerSize, int[] hiddenLayerSizes)
{
this.ETA = 0.05;
this.Error = 0.005;
this.maxIterationNumber = 500000;
this.inputLayerSize = inputLayerSize;
this.outputLayerSize = outputLayerSize;
this.hiddenLayerSizes = hiddenLayerSizes;
layers = new List <BackpropagationLayer>();
BackpropagationLayer inputLayer = new BackpropagationLayer(inputLayerSize);
layers.Add(inputLayer);
BackpropagationLayer last = inputLayer;
foreach (int layerSize in hiddenLayerSizes)
{
BackpropagationLayer hiddenLayer = new BackpropagationLayer(layerSize, last);
layers.Add(hiddenLayer);
last = hiddenLayer;
}
layers.Add(new BackpropagationLayer(outputLayerSize, last));
}
