public void TestTanhNetwork() { NNetwork n = NNetwork.HyperbolicNetwork(new int[] { 2, 4, 4, 2 }); INeuron[][] neurons = n.Neurons; Assert.IsInstanceOf(typeof(TanhNeuron), neurons[2][2]); }
public void TestTanhDerivative() { // SO-SO test =( NNetwork n = NNetwork.HyperbolicNetwork(new int[] { 2, 2, 1 }); n.RandomizeWeights(-1, 10); Random random = new Random(); double x; double y; double z; x = random.NextDouble(); y = random.NextDouble(); z = some_function(x, y); n.SetInput(new double[] { x, y }); n.SetAnswers(new double[] { z }); n.BackPropagate(); double[] ders = n.Derivatives(); double[] ests = n.Estimation(0.0001); var koeff = ests[0] / ders[0]; for (int i = 0; i < ders.Length; i++) { MyAssert.CloseTo(ests[i] / ders[i], koeff, 0.00001); } }
private NNetwork[] PickBestPopulation() { NNetwork[] newPopulation = new NNetwork[initialPopulation]; for (int i = 0; i < bestAgentSelection; i++) { newPopulation[naturallySelected] = population[i].InitialiseCopy(controller.LAYER, controller.NEURON); newPopulation[naturallySelected].performance = 0; naturallySelected++; int f = Mathf.RoundToInt(population[i].performance * 10); for (int c = 0; c < f; c++) { genePool.Add(i); } } for (int i = 0; i < worstAgentSelection; i++) { int last = population.Length - 1; last -= i; int f = Mathf.RoundToInt(population[last].performance * 10); for (int c = 0; c < f; c++) { genePool.Add(last); } } return(newPopulation); }
private void buttonCreateNetwork_Click(object sender, EventArgs e) { String[] layers_string = textLayers.Text.Split(";".ToCharArray()); int[] layers = new int[layers_string.Length]; for (int i = 0; i < layers_string.Length; i++) { layers[i] = int.Parse(layers_string[i]); } if (radioHyperbolic.Checked) { network = NNetwork.HyperbolicNetwork(layers); is_hyperbolic = true; is_sigmoid = false; } if (radioSigmoid.Checked) { network = NNetwork.SigmoidNetwork(layers); is_hyperbolic = false; is_sigmoid = true; } if (radioCombined.Checked) { network = NNetwork.CombinedNetwork(layers); is_hyperbolic = false; is_sigmoid = true; } bool two_steps = network.OutputCount() >= 2; bool three_steps = network.OutputCount() >= 3; checkTrain2.Enabled = two_steps; checkTest2.Enabled = two_steps; checkTrain3.Enabled = three_steps; checkTest3.Enabled = three_steps; groupWeights.Enabled = true; }
public void TestTanhLearningOnSinus() { NNetwork network = NNetwork.HyperbolicNetwork(new int[] { 1, 2, 1 }); network.RandomizeWeights(1, 2); NetworkTrainer trainer = new NetworkTrainer(network); double[][] inputs = SinusTrainSet()[0]; double[][] outputs = SinusTrainSet()[1]; double error = 1; double delta = 1; int j = 0; for (; error > 0.01 && !(delta <= 0.000001) || j == 1; j++) { trainer.TrainClassification(inputs, outputs); double new_cost = trainer.GetError(); delta = error - new_cost; error = new_cost; } double[][] input_test = SinusTrainSet(20)[0]; double[][] output_test = SinusTrainSet(20)[1]; trainer.IsLearning = false; trainer.TrainClassification(input_test, output_test); error = trainer.GetError(); Assert.Less(error, 0.53); }
static void Main(string[] args) { // создание экземпляра функции активации Sigmoid sigmoid = new Sigmoid(); network = new NNetwork(sigmoid, new int[] { 2, 4, 2 }); TrainNetwork(); TestNetwork(); Console.WriteLine(); Console.WriteLine("Save Load Test"); NNetworkSaver saver = new NNetworkSaver(network); saver.SaveNetwork("network.nwk"); NNetworkLoader loader = new NNetworkLoader("network.nwk", new ConsoleLogger()); network = loader.LoadNNetwork(sigmoid); TestNetwork(); Console.ReadLine(); }
public static void TestTanhLearningOnSinus() { NNetwork network = NNetwork.HyperbolicNetwork(new int[] { 1, 2, 1 }); network.RandomizeWeights(1, 2); NetworkTrainer trainer = new NetworkTrainer(network); double[][] inputs = SinusTrainSet()[0]; double[][] outputs = SinusTrainSet()[1]; double error = 1; double delta = 1; int j = 0; for (; error > 0.01 && !(delta <= 0.000001) || j == 1; j++) { trainer.TrainClassification(inputs, outputs); double new_cost = trainer.GetError(); delta = error - new_cost; error = new_cost; } double[][] input_test = SinusTrainSet(20)[0]; double[][] output_test = SinusTrainSet(20)[1]; trainer.IsLearning = false; trainer.TrainClassification(input_test, output_test); error = trainer.GetError(); Console.Out.WriteLine(error); for (int i = 0; i < input_test.Length; i++) { network.SetInput(input_test[i]); Show(new [] { input_test[i][0], network.GetOutput()[0], Math.Sin(input_test[i][0]) }); } }
public void TestAlternativeMatrix() { double[][] from_l1 = new double[][] { new double[] { -30, 20, 20 }, new double[] { 10, -20, -20 } }; double[][] from_l2 = new double[][] { new double[] { -10, 20, 20 } }; double[][][] weights = new double[][][] { from_l1, from_l2 }; NNetwork n = NNetwork.SigmoidNetwork(new int[] { 2, 2, 1 }); n.SetWeightMatrix(weights); double[] from_l1_expected = new double[] { -30, 20, 20, 10, -20, -20 }; double[] from_l2_expected = new double[] { -10, 20, 20 }; double[][] weights_expected = new double[][] { from_l1_expected, from_l2_expected }; Assert.AreEqual(weights_expected, n.GetWeightMatrix()); }
public NNetwork InitialiseCopy(int hiddenLayerCount, int hiddenNeuronCoint) { NNetwork n = new NNetwork(); List <Matrix <float> > newWeights = new List <Matrix <float> >(); for (int i = 0; i < this.weights.Count; i++) { Matrix <float> currentWeight = Matrix <float> .Build.Dense(weights[i].RowCount, weights[i].ColumnCount); for (int x = 0; x < currentWeight.RowCount; x++) { for (int y = 0; y < currentWeight.ColumnCount; y++) { currentWeight[x, y] = weights[i][x, y]; } } newWeights.Add(currentWeight); } List <float> newBisaes = new List <float>(); newBisaes.AddRange(biases); n.weights = newWeights; n.biases = newBisaes; n.InitialiseHidden(hiddenLayerCount, hiddenNeuronCoint); return(n); }
public void TestDimensions() { int[] neurons_in_layers = new int[] { 3, 4, 2, 1 }; NNetwork network = NNetwork.SigmoidNetwork(neurons_in_layers); Assert.AreEqual(network.LayerCount, neurons_in_layers.Length); Assert.AreEqual(network.NeuronsInLayersWithoutBias, neurons_in_layers); }
private void FillPopulationWithRandomValues(NNetwork[] newPopulation, int startingIndex) { while (startingIndex < initialPopulation) { newPopulation[startingIndex] = new NNetwork(); newPopulation[startingIndex].Initialise(controller.LAYER, controller.NEURON); startingIndex++; } }
private void Awake() { SP = transform.position; SR = transform.eulerAngles; EnvironmentControler = GetComponent <NNetwork>(); EnvironmentControler.Initialise(LAYER, NEURON); }
public void TrainPrediction() { NNetwork network = NNetwork.SigmoidNetwork(new int[] { 5, 2, 2 }); NetworkTrainer trainer = new NetworkTrainer(network); double[] train_set = new double[] { 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1 }; trainer.TrainPrediction(train_set); //todo }
public void TestInputEqualsOutput() { NNetwork n = NNetwork.SigmoidNetwork(new int[] { 1 }); n.SetWeightMatrix(new double[][] { new double[] { 1, 1 } }); n.SetInput(new double[] { 9 }); Assert.AreEqual(n.GetOutput()[0], 9); }
public void Death(float performance, NNetwork network) { if (currentGenome < population.Length - 1) { population[currentGenome].performance = performance; currentGenome++; ResetToCurrentGenome(); } else { RePopulate(); } }
public void TestBackPropWithKnownValues() { NNetwork n = NetworkTest.XorNetwork(); n.SetInput(new double[] { 1, 1 }); n.SetAnswers(new double[] { 0 }); n.BackPropagate(); double[] deltas = n.GetDeltasForLayer(2); Assert.AreNotEqual(deltas[0], 0); Assert.AreNotEqual(deltas[1], 0); MyAssert.CloseTo(deltas[0], 0, 0.001); MyAssert.CloseTo(deltas[1], 0, 0.001); }
public void IfInputNeuronsWereChangedThanBeforeCalculatingOutputInvalidateCache() { NNetwork n = XorNetwork(); n.CacheEnabled = true; n.SetInput(new double[] { 0, 0 }); var first = n.GetOutput(); n.SetInput(new double[] { 1, 0 }); var second = n.GetOutput(); Assert.AreNotEqual(first, second); }
public void ActivateCachingAcrossAllNetwork() { NNetwork n = XorNetwork(); n.CacheEnabled = false; n.SetInput(new double[] { 0, 0 }); long without_cache = MyAssert.MeasureMethod(() => n.GetOutput(), 400); n.CacheEnabled = true; long with_cache = MyAssert.MeasureMethod(() => n.GetOutput(), 400); Assert.Greater(without_cache / with_cache, 1.9); }
public static NNetwork XorNetwork() { double[] from_l1 = new double[] { -30, 20, 20, 10, -20, -20 }; double[] from_l2 = new double[] { -10, 20, 20 }; double[][] weights = new double[][] { from_l1, from_l2 }; NNetwork xor_network = NNetwork.SigmoidNetwork(new int[] { 2, 2, 1 }); xor_network.SetWeightMatrix(weights); return(xor_network); }
public void CanApplyTrainingForWholeNetwork() { NNetwork n = NNetwork.SigmoidNetwork(new int[] { 1, 2, 2, 1 }); n.SetInput(new double[] { 0.3 }); n.SetAnswers(new double[] { 0.8 }); n.BackPropagate(); var output_before = n.GetOutput(); n.ApplyTraining(); var output_after = n.GetOutput(); Assert.AreNotEqual(output_after, output_before); }
public void TestWeightMatrix() { double[] from_l1 = new double[] { -30, 20, 20, 10, -20, -20 }; double[] from_l2 = new double[] { -10, 20, 20 }; double[][] weights = new double[][] { from_l1, from_l2 }; NNetwork n = NNetwork.SigmoidNetwork(new int[] { 2, 2, 1 }); n.SetWeightMatrix(weights); Assert.AreEqual(n.GetWeightMatrix(), weights); }
public void DimensionTestCheck() { NNetwork network = NNetwork.SigmoidNetwork(new int[] { 2, 4, 3 }); NetworkTrainer trainer = new NetworkTrainer(network); double[][] incorrect_input = new double[1][] { new double[3] }; double[][] correct_input = new double[1][] { new double[2] }; double[][] incorrect_output = new double[1][] { new double[4] }; double[][] correct_output = new double[1][] { new double[3] }; Assert.Throws(typeof(IncorrectInputDimensionException), () => trainer.TrainClassification(incorrect_input, correct_output)); Assert.Throws(typeof(IncorrectOutputDimensionException), () => trainer.TrainClassification(correct_input, incorrect_output)); }
public void TestCostFunctionAccumulation() { NNetwork network = NNetwork.SigmoidNetwork(new int[] { 2, 4, 3 }); NetworkTrainer trainer = new NetworkTrainer(network); double[] train_set = new[] { 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1 }; Assert.Throws(typeof(NoErrorInfoYetException), () => trainer.GetError()); double error; trainer.TrainPrediction(train_set); error = trainer.GetError(); Assert.AreNotEqual(error, 0); trainer.TrainPrediction(train_set); Assert.AreNotEqual(error, trainer.GetError()); }
private void SortPopulation() { for (int i = 0; i < population.Length; i++) { for (int j = i; j < population.Length; j++) { if (population[i].performance < population[j].performance) { NNetwork temp = population[i]; population[i] = population[j]; population[j] = temp; } } } }
public void TestSimplestConnection() { NNetwork n = NNetwork.SigmoidNetwork(new int[] { 1, 1 }); n.SetWeightMatrix(new double[][] { new double[] { 1, 1 }, new double[] { 1, 1 } }); n.SetInput(new double[] { 1 }); var output = n.GetOutput()[0]; var desired = 1 / (1 + Math.Pow(Math.E, -2)); MyAssert.CloseTo(output, desired); }
public void TestNetworkSetAnswerAndGetDelta() { NNetwork n = NNetwork.SigmoidNetwork(new int[] { 2, 3, 2 }); n.SetInput(new double[] { 0, 0 }); double[] outputs = n.GetOutput(); double[] answers = new double[] { 0.1, 0.9 }; n.SetAnswers(answers); n.BackPropagate(); double[] deltas = n.GetDeltasForLayer(3); for (int i = 0; i < answers.Length; i++) { MyAssert.CloseTo(deltas[i], answers[i] - outputs[i]); } }
public void TestRandomInit() { NNetwork n = NNetwork.SigmoidNetwork(new int[] { 2, 3, 2 }); n.RandomizeWeights(seed: 0); var first = n.GetWeightMatrix(); n.RandomizeWeights(seed: 0); var equal = n.GetWeightMatrix(); Assert.AreEqual(first, equal); n.RandomizeWeights(seed: 1); var not_equal = n.GetWeightMatrix(); Assert.AreNotEqual(first, not_equal); }
public static void Main(string[] args) { var numberOfInputNeurons = 2; var numberOfOutputNeurons = 1; var network = new NNetwork(numberOfInputNeurons, numberOfOutputNeurons, 1); var layerFactory = new NeuralLayerFactory(); //// TODO: Mix these 2 lines. eliminate the foreach //var inputLayer = layerFactory.CreateNeuralLayer(numberOfInputNeurons, new RectifiedActivationFuncion()); //foreach (var x in inputLayer.Neurons) //{ // x.AddInputSynapse(0); //} //network.AddLayer(inputLayer); //network.AddLayer(layerFactory.CreateNeuralLayer(3, new SigmoidActivationFunction(0.7))); //network.AddLayer(layerFactory.CreateNeuralLayer(1, new SigmoidActivationFunction(0.7))); //network.PushExpectedValues( // new double[][] { // new double[] { 0 }, // new double[] { 1 }, // new double[] { 1 }, // new double[] { 1 }, // }); //network.Train( // new double[][] { // new double[] { 0, 0}, // new double[] { 0, 1}, // new double[] { 1, 0}, // new double[] { 1, 1}, // }, 10000); //network.PushInputValues(new double[] { 1, 1 }); //var outputs = network.GetOutput(); //foreach (var output in outputs) //{ // System.Console.WriteLine(output); //} }
public static void TestTanhDerivative() { NNetwork n = NNetwork.HyperbolicNetwork(new int[] { 2, 2, 1 }); n.RandomizeWeights(-1, 10); Random random = new Random(); double x; double y; double z; x = random.NextDouble(); y = random.NextDouble(); z = some_function(x, y); n.SetInput(new double[] { x, y }); n.SetAnswers(new double[] { z }); n.BackPropagate(); double[] ders = n.Derivatives(); double[] ests = n.Estimation(0.0001); for (int i = 0; i < ders.Length; i++) { Show(new[] { ders[i], ests[i], ests[i] / ders[i] }); } }
// public static void Main() // { // TrainPrediction(); //// Sinus(); //// TestTanhLearningOnSinus(); //// TestTanhDerivative(); // // } public static void TrainPrediction() { NNetwork network = NNetwork.SigmoidNetwork(new int[] { 5, 1 }); network.RandomizeWeights(-1, 20); NetworkTrainer trainer = new NetworkTrainer(network); List <double> tr = new List <double>(); for (double i = 0; i <= 1; i = i + 0.05) { tr.Add(i); } double[] train_set = tr.ToArray();//new double[] { 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1 }; double error = 1; double delta = 1; int j = 0; for (; error > 0.01 && !(delta <= 0.00001) || j == 1; j++) { trainer.TrainPrediction(train_set, 0.0001, 0.2); double new_cost = trainer.GetError(); delta = error - new_cost; error = new_cost; } Console.Out.WriteLine(j + ": " + error); for (double i = 0; i <= 0.5; i = i + 0.05) { network.SetInput(new double[] { i + 0.0, i + 0.1, i + 0.2, i + 0.3, i + 0.4 }); Show(new double[] { i + 0.5, network.GetOutput()[0], // network.GetOutput()[1] }); } }
public BackPropagationLearningAlgorithm(NNetwork nn) : base(nn) { }
public GeneticLearningAlgorithm(NNetwork nn) : base(nn) { }
public LearningAlgorithm(NNetwork nn, Perform per) : this(nn) { Per = Performance.Create(per); }
public LearningAlgorithm(NNetwork nn) { Error = 1; this.NN = nn; }