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)); }