public NeuralNetwork(NeuralNetworkParameters parameters, IContinuousDistribution rng) { NetworkParameters = parameters; HiddenWeights = CreateMatrix.Random <float>(NetworkParameters.HiddenLayerNeuronCount, NetworkParameters.InputCount, rng); HiddenBiases = CreateVector.Random <float>(NetworkParameters.HiddenLayerNeuronCount, rng); OutputWeights = CreateMatrix.Random <float>(NetworkParameters.OutputCount, NetworkParameters.HiddenLayerNeuronCount, rng); OutputBiases = CreateVector.Random <float>(NetworkParameters.OutputCount, rng); }
public void Reset() { mBias = CreateVector.Random <double>(mBias.Count, new Normal(0.0, 1.0)); if (mWeights != null) { mWeights = CreateMatrix.Random <double>(mWeights.RowCount, mWeights.ColumnCount, new Normal(0.0, 1.0 / Math.Sqrt(mWeights.ColumnCount))); } }
public SimplePerceptron(int N, double learningRate, Func <double, double> activationFunction, Func <double, double> activationFunctionDerivative, bool adaptiveLearningRate) { this.N = N; this.W = CreateVector.Random <double>(N + 1, new ContinuousUniform(-1d, 1d)); this.ActivationFunction = activationFunction; this.ActivationFunctionDerivative = activationFunctionDerivative; this.LearningRate = learningRate; this.AdaptiveLearningRate = adaptiveLearningRate; }
public OjaNetwork(double learningRate, int epochs, List <Vector <double> > values) { this.epochs = epochs; var columns = CreateMatrix.DenseOfRowVectors(values).EnumerateColumns(); var mean = CreateVector.DenseOfEnumerable(columns.Select(Statistics.Mean)); var std = CreateVector.DenseOfEnumerable(columns.Select(Statistics.StandardDeviation)); this.values = values.Select(v => (v - mean) / std).ToList(); this.variables = values[1].Count; this.W = CreateVector.Random <double>(variables, new ContinuousUniform(-1, 1)); this.LearningRate = learningRate; }
public KohonenNetwork(List <Vector <double> > values, int n, bool weightEntries) { this.values = Normalize(values); W = new Vector <double> [n, n]; N = n; inputLength = this.values[0].Count; var indexes = MathNet.Numerics.Combinatorics.GenerateVariationWithRepetition(this.values.Count, n * n); var current = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { W[i, j] = !weightEntries?CreateVector.Random <double>(inputLength, new ContinuousUniform(0, 1)) : this.values[indexes[current++]]; } } }
public void Learn( Vector <double>[] trainingInput, Vector <double>[] trainingOutput, Vector <double>[] testInput, Vector <double>[] testOutput, int batch, double minError, int epochs) { Contract.Requires(trainingInput.Length == trainingOutput.Length); Contract.Requires(testInput.Length == testOutput.Length); Contract.Requires(trainingInput[0].Count == N + 1); Contract.Requires(testInput[0].Count == N + 1); double[] desiredTrainingOutput = trainingOutput.Select(o => o.At(0)).ToArray(); double[] desiredTestOutput = trainingOutput.Select(o => o.At(0)).ToArray(); //Agrego el valor 1 al principio del input. Vector <double>[] input = new Vector <double> [trainingInput.Length]; for (int i = 0; i < input.Length; i++) { input[i] = Vector <double> .Build.DenseOfEnumerable(new double[] { 1 }.Concat(trainingInput[i])); } int p = input.Length; Vector <double> w = CreateVector.Random <double>(N + 1, new ContinuousUniform(-1d, 1d)); Vector <double> deltaW = null; double error = 1, error_min = p * 2; Vector <double> w_min = w; for (int i = 0, n = 0; i < epochs && error_min > minError; i++, n++) { if (n > 100 * p) { w = CreateVector.Random <double>(N + 1, new ContinuousUniform(-1d, 1d)); n = 0; } int[] rand = Combinatorics.GeneratePermutation(input.Length); double lr = this.AdaptiveLearningRate ? optimizing(w, input, desiredTrainingOutput, batch, rand) : LearningRate; int j; for (j = 0; j < input.Length; j++) { int ix = rand[j]; double h = input[ix] * w; double act = ActivationFunction(h); Vector <double> delta = lr * (desiredTrainingOutput[ix] - act) * input[ix] * ActivationFunctionDerivative(h); deltaW = deltaW == null ? delta : deltaW + delta; if (j % batch == 0) { w += deltaW; deltaW = null; error = CalculateError(input, desiredTrainingOutput, w); if (error < error_min) { error_min = error; w_min = w; } } } if (j % batch != 0) { w += deltaW; deltaW = null; error = CalculateError(input, desiredTrainingOutput, w); if (error < error_min) { error_min = error; w_min = w; } } } W = w_min; }
public Layer(int size, int sizeofPreviousLayer) : this(CreateVector.Random <double>(size, new Normal(0.0, 1.0)), sizeofPreviousLayer > 0 ? CreateMatrix.Random <double>(size, sizeofPreviousLayer, new Normal(0.0, 1.0 / Math.Sqrt(sizeofPreviousLayer))) : null) { }