private double[] PowError(double[] v) { double[] result = new double[v.Length]; for (int i = 0; i < v.Count(); i++) { result[i] = Math.Pow(NeuronLayers.Last()[i] - v[i], 2) / 2; } return(result); }
public double AbsError(double[] v) { double result = 0; for (int i = 0; i < v.Count(); i++) { result += Math.Abs(NeuronLayers.Last()[i] - v[i]); } return(result); }
public double[] GetValues(double[] In) { function = Fce.Logistic; List <double> result = new List <double>(); NeuronLayers[0] = In; GetError(); foreach (var item in NeuronLayers.Last()) { result.Add(item); } return(result.ToArray()); }
/// <summary> /// Initalizes an ANeuralNetwork. /// </summary> /// <param name="passedNumberOfInputNeurons">The Number of Neurons in the Input Layer.</param> /// <param name="passedNumberOfNeuronsPerHiddenLayer">The Number of Neurons in the Hidden Layers.</param> /// <param name="passedNumberOfHiddenLayers">The Number of Hidden Layers.</param> /// <param name="passedNumberOfOutputNeurons">The Number of Neurons in the Output Layer.</param> /// <param name="passedNumberOfWeightsForInput">The Number of Weights for an Input Neuron.</param> /// <param name="passedActivationFunction">The Activation Function for all Neurons in the Network.</param> public ANeuralNetwork(uint passedNumberOfInputNeurons, uint passedNumberOfNeuronsPerHiddenLayer, uint passedNumberOfHiddenLayers, uint passedNumberOfOutputNeurons, uint passedNumberOfWeightsForInput, IActivationFunction passedActivationFunction) { //Initalize and Assign Input and Output Layers. INeuronLayer inputNeuronLayer = new NeuronLayer(passedNumberOfInputNeurons, passedNumberOfWeightsForInput, passedActivationFunction); INeuronLayer outputNeuronLayer = new NeuronLayer(passedNumberOfOutputNeurons, passedNumberOfNeuronsPerHiddenLayer, passedActivationFunction); IList <INeuronLayer> neuronLayers = new List <INeuronLayer>((int)(2 + passedNumberOfHiddenLayers)); neuronLayers.Add(inputNeuronLayer); for (int i = 1; i < passedNumberOfHiddenLayers; i++) { neuronLayers.Add(new NeuronLayer(passedNumberOfNeuronsPerHiddenLayer, neuronLayers[i - 1].NumberOfNeurons, passedActivationFunction)); } neuronLayers.Add(outputNeuronLayer); INeuronLayers l = new NeuronLayers(neuronLayers); }
/// <summary> /// An Enumerator of the INeuronLayers of the Hidden Layers. /// </summary> public INeuronLayers GetHiddenLayers() { IList <INeuronLayer> hiddenLayers = new List <INeuronLayer>(); IEnumerator <INeuronLayer> allNeuronLayerEnumerator = this._AllNeuronLayers.Values; //Skip the first element. allNeuronLayerEnumerator.MoveNext(); while (allNeuronLayerEnumerator.MoveNext()) { INeuronLayer current = allNeuronLayerEnumerator.Current; hiddenLayers.Add(current); } //remove the last element hiddenLayers.RemoveAt(hiddenLayers.Count - 1); INeuronLayers result = new NeuronLayers(hiddenLayers); return(result); }
public void GetError() { int weightIndex = 0; int Last = NeuronLayers.Count(); for (int i = 1; i < Last; i++) { int numberInLayer = NeuronLayers[i].Count(); for (int k = 0; k < numberInLayer; k++) { double currentValue = 0; for (int j = 0; j < NeuronLayers[i - 1].Count(); j++) { currentValue += ((double)Weight[weightIndex++] * (double)NeuronLayers[i - 1][j]); } //bias currentValue += Weight[weightIndex++]; NeuronLayers[i][k] = currentValue.Binary(function); } } }
private void GenerateWeight() { int Last = NeuronLayers.Count(); Weight = new List <double>(); for (int i = 1; i < Last; i++) { int numberInLayer = NeuronLayers[i].Count(); for (int k = 0; k < numberInLayer; k++) { for (int j = 0; j < NeuronLayers[i - 1].Count(); j++) { NeuronLayers[i - 1][j] = 1; double weight = r.Next(-1000000, 1000000) / 1000000.0; Weight.Add(weight); } //bias double w = r.Next(-1000000, 1000000) / 1000000.0; Weight.Add(w); } } }
public void TestData(List <double[]> I) { function = Fce.Binary; for (int x = 0; x < I.Count; x++) { NeuronLayers[0] = I[x]; GetError(); string result = "InPut:\t"; foreach (var item in I[x]) { result += item + " "; } string result2 = "Calculate:"; foreach (var item in NeuronLayers.Last()) { result2 += item + " "; } Console.WriteLine("{0} {1}", result, result2); } function = Fce.Logistic; }
public double LearnByBackPropagation(int Epoch, double Lambda) { GenerateWeight(); double GlobalError = 0; do { for (int x = 0; x < Input.Count; x++) { NeuronLayers[0] = Input[x]; GetError(); double[] Etotal = PowError(Output[x]); int weighIndex = Weight.Count() - 1; int Last = NeuronLayers.Count() - 1; double[] increment = new double[weighIndex + 1]; #region First Layer for (int i = NeuronLayers[Last].Count() - 1; i > -1; i--) { double curentWeight = 1; double err = NeuronLayers.Last()[i] - Output[x][i]; double log = NeuronLayers.Last()[i] * (1 - NeuronLayers.Last()[i]); double total = err * log * curentWeight; increment[weighIndex--] = total; for (int j = NeuronLayers[Last - 1].Count() - 1; j > -1; j--) { double curentWeight1 = NeuronLayers[NeuronLayers.Count() - 2][i]; double err1 = NeuronLayers.Last()[i] - Output[x][i]; double log1 = NeuronLayers.Last()[i] * (1 - NeuronLayers.Last()[i]); double total1 = err1 * log1 * curentWeight1; increment[weighIndex--] = total1; } } #endregion #region ErrorOutput int backIndex = weighIndex - 1; List <double> sumsError = new List <double>(); for (int w = 0; w < NeuronLayers[NeuronLayers.Count() - 2].Count(); w++) { List <double> er = new List <double>(); for (int i = 0; i < Output[x].Count(); i++) { double err = NeuronLayers.Last()[i] - Output[x][i]; double log = NeuronLayers.Last()[i] * (1 - NeuronLayers.Last()[i]); double ww = (Weight[backIndex]); double y = err * log * ww; er.Add(y); backIndex += Output[x].Count() + 1; } sumsError.Add(er.Sum()); backIndex = weighIndex; } #endregion #region Other Layers for (int yy = NeuronLayers.Count() - 2; yy > 0; yy--) { for (int i = NeuronLayers[yy].Count() - 1; i > -1; i--) { double curentWeight = 1; double err = sumsError[i]; double log = NeuronLayers[yy][i] * (1 - NeuronLayers[yy][i]); double total = err * log * curentWeight; increment[weighIndex--] = total; for (int j = NeuronLayers[yy - 1].Count() - 1; j > -1; j--) { double curentWeight1 = NeuronLayers[yy - 1][j]; double err1 = sumsError[i]; double log1 = NeuronLayers[yy][i] * (1 - NeuronLayers[yy][i]); double total1 = err1 * log1 * curentWeight1; increment[weighIndex--] = total1; } } #region Error Hidden Layers backIndex = weighIndex; List <double> NewSumError = new List <double>(); for (int w = 0; w < NeuronLayers[yy - 1].Count(); w++) { List <double> er = new List <double>(); for (int k = 0; k < NeuronLayers[yy].Count() - 1; k++) { double y = (sumsError[k]) * (Weight[++backIndex]); er.Add(y); } NewSumError.Add(er.Sum()); } sumsError.Clear(); sumsError.AddRange(NewSumError); #endregion } #endregion for (int i = 0; i < Weight.Count(); i++) { Weight[i] -= increment[i] * Lambda; } } //GlobalError = 0; //for (int x = 0; x < Input.Count; x++) //{ // NeuronLayers[0] = Input[x]; // GetError(); // GlobalError += AbsError(Output[x]); //} //Console.WriteLine("Epoch :{0} Global_Error:{1}", Epoch, GlobalError); } while (Epoch-- > 0); for (int x = 0; x < Input.Count; x++) { NeuronLayers[0] = Input[x]; GetError(); GlobalError += AbsError(Output[x]); } Console.WriteLine(" Global_Error:{0}", GlobalError); return(GlobalError); }
public Builder SetNeuronsForLayers(params uint[] neuronLayers) { NeuronLayers.AddRange(neuronLayers); return(this); }