// Похідна функції активації public static double DerivativeEvaluate(TransferFunction tFunc, double input) { switch (tFunc) { case TransferFunction.Linear: return(linear_derivative(input)); case TransferFunction.Sigmoid: return(sigmoid_derivative(input)); case TransferFunction.BipolarSigmoid: return(bipolarsigmoid_derivative(input)); case TransferFunction.None: default: return(0.0); } }
public void Run(ref double[] input, out double[] output) { // Check if there is enough data if (input.Length != this.inputSize) { throw new ArgumentException("Input data is not of the correcft dimension."); } // Dimension the output array output = new double[this.layerSize[this.layerCount - 1]]; // Run the network for (int currentLayer = 0; currentLayer < this.layerCount; currentLayer++) { for (int currentNeuron = 0; currentNeuron < this.layerSize[currentLayer]; currentNeuron++) { double sum = 0.0; // Compute the sum of the products of the weights (connections) from all neurons // in the previous layer to the current neuron in the current layer // times the output from all nodes in the previous layer for (int prevLayerCurrentNeuron = 0; prevLayerCurrentNeuron < ((currentLayer == 0) ? inputSize : this.layerSize[currentLayer - 1]); prevLayerCurrentNeuron++) { sum += this.weight[currentLayer][prevLayerCurrentNeuron][currentNeuron] * ((currentLayer == 0) ? input[prevLayerCurrentNeuron] : this.layerOutput[currentLayer - 1][prevLayerCurrentNeuron]); } sum += this.bias[currentLayer][currentNeuron]; this.layerInput[currentLayer][currentNeuron] = sum; this.layerOutput[currentLayer][currentNeuron] = TransferFunction.GetSigmoid(this.transferFunction[currentLayer], sum); } } // Copy the output to the output array for (int i = 0; i < this.layerSize[this.layerCount - 1]; i++) { output[i] = this.layerOutput[layerCount - 1][i]; } }
public static double Evaluate(TransferFunction transferFunction, double input) { switch (transferFunction) { case TransferFunction.Sigmoid: return(Sigmoid(input)); case TransferFunction.Linear: return(Linear(input)); case TransferFunction.Gaussian: return(Gaussian(input)); case TransferFunction.RationalSigmoid: return(RationalSigmoid(input)); default: return(0.0); } }
public static double EvaluateDerivative(TransferFunction tFunc, double input) { switch (tFunc) { case TransferFunction.Sigmoid: return(sigmoidDerivative(input)); case TransferFunction.Linear: return(linearDerivative(input)); case TransferFunction.Gaussian: return(gaussianDerivative(input)); case TransferFunction.RationalSigmoid: return(rationalSigmoidDerivative(input)); case TransferFunction.None: default: return(0.0); } }
public static double EvaluateDerivative(TransferFunction tFunc, double input) { switch (tFunc) { case TransferFunction.Sigmoid: return(sigmoid_derivative(input)); case TransferFunction.Linear: return(linear_derivative(input)); case TransferFunction.Gaussian: return(gaussian_derivative(input)); case TransferFunction.RationalSigmoid: return(rationalsigmoid_derivative(input)); case TransferFunction.TangentHyperbolic: return(tangenthyperbolic_derivative(input)); case TransferFunction.None: default: return(0.0); } }
public BackPropagationNetwork(int[] inputLayerSizes, TransferFunction[] inputTransferFunctions) { if (inputTransferFunctions.Length != inputLayerSizes.Length) { throw new ArgumentException("There is not an equal number of layers and transfer functions."); } if (inputTransferFunctions[0] != TransferFunction.None) { throw new ArgumentException("The first transfer function must be None"); } LayerCount = inputLayerSizes.Length - 1; InputSize = inputLayerSizes[0]; LayerSize = new int[LayerCount]; for (int i = 0; i < LayerCount; i++) { LayerSize[i] = inputLayerSizes[i + 1]; } TransferFunctions = new TransferFunction[LayerCount]; for (int i = 0; i < LayerCount; i++) { TransferFunctions[i] = inputTransferFunctions[i + 1]; } Bias = new double[LayerCount][]; PreviousBiasDelta = new double[LayerCount][]; Delta = new double[LayerCount][]; LayerOutput = new double[LayerCount][]; LayerInput = new double[LayerCount][]; Weight = new double[LayerCount][][]; PreviousWeightDelta = new double[LayerCount][][]; for (int l = 0; l < LayerCount; l++) { Bias[l] = new double[LayerSize[l]]; PreviousBiasDelta[l] = new double[LayerSize[l]]; Delta[l] = new double[LayerSize[l]]; LayerOutput[l] = new double[LayerSize[l]]; LayerInput[l] = new double[LayerSize[l]]; Weight[l] = new double[l == 0 ? InputSize : LayerSize[l - 1]][]; PreviousWeightDelta[l] = new double[l == 0 ? InputSize : LayerSize[l - 1]][]; for (int i = 0; i < (l == 0 ? InputSize : LayerSize[l - 1]); i++) { Weight[l][i] = new double[LayerSize[l]]; PreviousWeightDelta[l][i] = new double[LayerSize[l]]; } } // Initialize the weights for (int l = 0; l < LayerCount; l++) { for (int j = 0; j < LayerSize[l]; j++) { Bias[l][j] = Gaussian.GetRandomGaussian(); PreviousBiasDelta[l][j] = 0; LayerOutput[l][j] = 0; LayerInput[l][j] = 0; Delta[l][j] = 0; } for (int i = 0; i < (l == 0 ? InputSize : LayerSize[l - 1]); i++) { for (int j = 0; j < LayerSize[l]; j++) { Weight[l][i][j] = Gaussian.GetRandomGaussian(); PreviousWeightDelta[l][i][j] = 0; } } } }
public void Load(string FilePath) { if (string.IsNullOrEmpty(FilePath)) { throw new ArgumentNullException("FilePath"); } _doc = new XmlDocument(); _doc.Load(FilePath); string basePath = ""; string nodePath = ""; double value; // Load from xml if (XPathValue("NeuralNetwork/@Type") != "BackPropagation") { return; } basePath = "NeuralNetwork/Parameters"; Name = XPathValue(basePath + "/Name"); int inputSize; int.TryParse(XPathValue(basePath + "/InputSize"), out inputSize); InputSize = inputSize; int layerCount; int.TryParse(XPathValue(basePath + "/LayerCount"), out layerCount); LayerCount = layerCount; LayerSize = new int[layerCount]; TransferFunctions = new TransferFunction[layerCount]; basePath += "/Layers/Layer"; for (int l = 0; l < layerCount; l++) { int layerSizeOfL; int.TryParse(XPathValue(basePath + "[@Index='" + l + "']/@Size"), out layerSizeOfL); LayerSize[l] = layerSizeOfL; TransferFunction transferFunctionOfL; Enum.TryParse(XPathValue(basePath + "[@Index='" + l + "']/@Type"), out transferFunctionOfL); TransferFunctions[l] = transferFunctionOfL; } // Parse Weights element for (int l = 0; l < LayerCount; l++) { basePath = "NeuralNetwork/Weights/Layer[@Index='" + l + "']/"; for (int j = 0; j < LayerSize[l]; j++) { nodePath = "Node[@Index='" + j + "']/@Bias"; double biasOfLJ; double.TryParse(XPathValue(basePath + nodePath), out biasOfLJ); Bias[l][j] = biasOfLJ; PreviousBiasDelta[l][j] = 0; LayerOutput[l][j] = 0; LayerInput[l][j] = 0; Delta[l][j] = 0; } for (int i = 0; i < (l == 0 ? InputSize : LayerSize[l - 1]); i++) { for (int j = 0; j < LayerSize[l]; j++) { nodePath = "Node[@Index='" + j + "']/Axon[@Index='" + i + "']"; double weightOfLij; double.TryParse(XPathValue(basePath + nodePath), out weightOfLij); Weight[l][i][j] = weightOfLij; PreviousWeightDelta[l][i][j] = 0; } } } // release _doc = null; }
/// <summary> /// Change the transfer function, by default Sigmoid /// </summary> /// <param name="transferFunction"></param> public void SetTransferFunction(TransferFunction.Function transferFunction) { func = TransferFunction.GetTransferFunction(transferFunction); }
public void Load(string FilePath) { if (FilePath == null) { return; } doc = new XmlDocument(); doc.Load(FilePath); string BasePath = "", NodePath = ""; double value; // Load from xml if (xPathValue("NeuralNetwork/@Type") != "BackPropagation") { return; } BasePath = "NeuralNetwork/Parameters/"; int.TryParse(xPathValue(BasePath + "inputSize"), out inputSize); int.TryParse(xPathValue(BasePath + "layerCount"), out layerCount); layerSize = new int[layerCount]; transferFunction = new TransferFunction[layerCount]; BasePath = "NeuralNetwork/Parameters/Layers/Layer"; for (int l = 0; l < layerCount; l++) { int.TryParse(xPathValue(BasePath + "[@Index='" + l.ToString() + "']/@Size"), out layerSize[l]); Enum.TryParse <TransferFunction>(xPathValue(BasePath + "[@Index='" + l.ToString() + "']/@Type"), out transferFunction[l]); } // Parse the Weights element // Start dimensioning arrays bias = new double[layerCount][]; previousBiasDelta = new double[layerCount][]; delta = new double[layerCount][]; layerOutput = new double[layerCount][]; layerInput = new double[layerCount][]; weight = new double[layerCount][][]; previousWeightDelta = new double[layerCount][][]; // Fill 2 dimensional arrays for (int l = 0; l < layerCount; l++) { bias[l] = new double[layerSize[l]]; previousBiasDelta[l] = new double[layerSize[l]]; delta[l] = new double[layerSize[l]]; layerOutput[l] = new double[layerSize[l]]; layerInput[l] = new double[layerSize[l]]; weight[l] = new double[l == 0 ? inputSize : layerSize[l - 1]][]; previousWeightDelta[l] = new double[l == 0 ? inputSize : layerSize[l - 1]][]; for (int i = 0; i < (l == 0 ? inputSize : layerSize[l - 1]); i++) { weight[l][i] = new double[layerSize[l]]; previousWeightDelta[l][i] = new double[layerSize[l]]; } } // Initialize the weights for (int l = 0; l < layerCount; l++) { BasePath = "NeuralNetwork/Weights/Layer[@Index='" + l.ToString() + "']/"; for (int j = 0; j < layerSize[l]; j++) { NodePath = "Node[@Index='" + j.ToString() + "']/@Bias"; double.TryParse(xPathValue(BasePath + NodePath), out value); bias[l][j] = value; previousBiasDelta[l][j] = 0.0; layerOutput[l][j] = 0.0; layerInput[l][j] = 0.0; delta[l][j] = 0.0; } for (int i = 0; i < (l == 0 ? inputSize : layerSize[l - 1]); i++) { for (int j = 0; j < layerSize[l]; j++) { NodePath = "Node[@Index='" + j.ToString() + "']/Axon[@Index='" + i.ToString() + "']"; double.TryParse(xPathValue(BasePath + NodePath), out value); weight[l][i][j] = value; previousWeightDelta[l][i][j] = 0.0; } } } // "release" doc = null; }
public BackPropagationNetwork(int[] layerSizes, TransferFunction[] transferFunctions) { // Validate the input data if (transferFunctions.Length != layerSizes.Length || transferFunctions[0] != TransferFunction.None) { throw new ArgumentException("Cannot construct a network with these parameters."); } // Initialize network layers layerCount = layerSizes.Length - 1; inputSize = layerSizes[0]; layerSize = new int[layerCount]; for (int i = 0; i < layerCount; i++) { layerSize[i] = layerSizes[i + 1]; } transferFunction = new TransferFunction[layerCount]; for (int i = 0; i < layerCount; i++) { transferFunction[i] = transferFunctions[i + 1]; } // Start dimensioning arrays bias = new double[layerCount][]; previousBiasDelta = new double[layerCount][]; delta = new double[layerCount][]; layerOutput = new double[layerCount][]; layerInput = new double[layerCount][]; weight = new double[layerCount][][]; previousWeightDelta = new double[layerCount][][]; // Fill 2 dimensional arrays for (int l = 0; l < layerCount; l++) { bias[l] = new double[layerSize[l]]; previousBiasDelta[l] = new double[layerSize[l]]; delta[l] = new double[layerSize[l]]; layerOutput[l] = new double[layerSize[l]]; layerInput[l] = new double[layerSize[l]]; weight[l] = new double[l == 0 ? inputSize : layerSize[l - 1]][]; previousWeightDelta[l] = new double[l == 0 ? inputSize : layerSize[l - 1]][]; for (int i = 0; i < (l == 0 ? inputSize : layerSize[l - 1]); i++) { weight[l][i] = new double[layerSize[l]]; previousWeightDelta[l][i] = new double[layerSize[l]]; } } // Initialize the weights for (int l = 0; l < layerCount; l++) { for (int j = 0; j < layerSize[l]; j++) { bias[l][j] = Gaussian.GetRandomGaussian(); previousBiasDelta[l][j] = 0.0; layerOutput[l][j] = 0.0; layerInput[l][j] = 0.0; delta[l][j] = 0.0; } for (int i = 0; i < (l == 0 ? inputSize : layerSize[l - 1]); i++) { for (int j = 0; j < layerSize[l]; j++) { weight[l][i][j] = Gaussian.GetRandomGaussian(); previousWeightDelta[l][i][j] = 0.0; } } } }