static void Main(string[] args) { int[] array = { 2, 8, 4 }; string str = File.ReadAllText("TD1.txt"); float[][] vs1 = JsonConvert.DeserializeObject <float[][]>(str); NNModel model = new NNModel(array); BackPropagation backPropagation = new BackPropagation(); backPropagation.Learn(model, vs1); for (int i = 0; i < vs1.Length; i += 2) { var inp = vs1[i]; Array.ForEach(model.Compute(inp).Neurons, x => { Console.WriteLine(x.Value + " "); }); Console.WriteLine(); } Console.ReadKey(); }
public void Process() { Console.WriteLine("Please wait, reading MNIST training data."); var dir = AppDomain.CurrentDomain.BaseDirectory; var trainingReader = LearnDigitsBackprop.LoadMNIST(dir, true, MNIST_DEPTH); var validationReader = LearnDigitsBackprop.LoadMNIST(dir, false, MNIST_DEPTH); Console.WriteLine("Training set size: " + trainingReader.NumImages); Console.WriteLine("Validation set size: " + validationReader.NumImages); var inputCount = trainingReader.Data[0].Input.Length; var outputCount = trainingReader.Data[0].Ideal.Length; var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, inputCount)); network.AddLayer(new BasicLayer(new ActivationReLU(), true, 100)); network.AddLayer(new DropoutLayer(new ActivationReLU(), true, 50, 0.5)); network.AddLayer(new BasicLayer(new ActivationReLU(), true, 25)); network.AddLayer(new BasicLayer(new ActivationSoftMax(), false, outputCount)); network.FinalizeStructure(); network.Reset(); // train the neural network Console.WriteLine("Training neural network."); var train = new BackPropagation(network, trainingReader.Data, 1e-4, 0.9); train.L1 = 0; train.L2 = 1e-11; PerformIterationsClassifyEarlyStop(train, network, validationReader.Data, 5); }
public ConfigurationFile() { // Retrieve instances annComp = NinjectBinding.GetKernel.Get <AnnBuild>(); backPropComp = NinjectBinding.GetKernel.Get <BackPropagation>(); rPropComp = NinjectBinding.GetKernel.Get <ResilientPropagation>(); }
public void TrainNetwork() { List <int> list = new List <int>(); foreach (int layer in layers) { list.Add(layer); } Stream stream = assets.Open("Classroom_Occupation_Data.csv", Access.Random); StreamReader sr = new StreamReader(stream); string content = sr.ReadToEnd(); StreamWriter destinationStream = new StreamWriter(basePath + "/Classroom_Occupation_Data.csv", false); destinationStream.Write(content); destinationStream.Flush(); network = new MultiLayerPerceptron(TransferFunctionType.Sigmoid, list.ToArray()); trainingSet = new TrainingSet(inputSize, outputSize); trainingSet = TrainingSet.CreateFromFile(basePath + "/Classroom_Occupation_Data.csv", inputSize, outputSize, ","); BackPropagation learningRule = new BackPropagation(); network.LearningRule = learningRule; network.Learn(trainingSet); network.Save(basePath + "/TrainTest.nnet"); destinationStream.Close(); destinationStream.Dispose(); }
public BackPropagationPerformanceComparisonContainer() { var neuralNetworkUnderTest = NeuralNetwork .For(NeuralNetworkContext.MaximumPrecision) .WithInputLayer(neuronCount: 5, activationType: ActivationType.Sigmoid) .WithHiddenLayer(neuronCount: 100, activationType: ActivationType.Sigmoid) .WithHiddenLayer(neuronCount: 70, activationType: ActivationType.TanH) .WithHiddenLayer(neuronCount: 40, activationType: ActivationType.TanH) .WithHiddenLayer(neuronCount: 100, activationType: ActivationType.Sigmoid) .WithOutputLayer(neuronCount: 2, activationType: ActivationType.Sigmoid) .Build(); trainingData = new[] { TrainingDataSet.For(new [] { 0.78, 0.99, 0.67, 0.72, 0.22 }, new [] { 0.12, 0.14 }) }; multiThreadedController = TrainingController.For( BackPropagation .WithConfiguration(neuralNetworkUnderTest, ParallelOptionsExtensions.UnrestrictedMultiThreadedOptions)); singleThreadedController = TrainingController.For( BackPropagation .WithConfiguration(neuralNetworkUnderTest, ParallelOptionsExtensions.SingleThreadedOptions)); }
static void Testing() { int[] array = { 10, 20, 2 }; string str = File.ReadAllText("TD1.txt"); double[][] vs1 = JsonConvert.DeserializeObject <double[][]>(str); NNModel model = new NNModel(array); Console.Beep(); var watch = System.Diagnostics.Stopwatch.StartNew(); BackPropagation backPropagation = new BackPropagation(); backPropagation.Learn(model, vs1); watch.Stop(); Console.WriteLine(watch.ElapsedMilliseconds); string str1 = File.ReadAllText("TD2.txt"); double[][] vs2 = JsonConvert.DeserializeObject <double[][]>(str1); for (int i = 0; i < vs2.Length; i++) { model.Compute(NNModel.ReculcArray(vs2[i])).Neurons.ForEach(x => { Console.WriteLine(x.Value + " "); }); Console.WriteLine(); } Console.WriteLine("_______"); model.Save(); Console.Beep(); Console.ReadKey(); }
static void NewNN(string[] args) { int[] array = new int[args.Length - 1]; for (int i = 1; i < args.Length; i++) { if (Int32.TryParse(args[i], out int res)) { array[i] = res; } else { return; } } string str = File.ReadAllText(args[0]); double[][] vs1 = JsonConvert.DeserializeObject <double[][]>(str); NNModel model = new NNModel(array); BackPropagation backPropagation = new BackPropagation(); backPropagation.Learn(model, vs1); for (int i = 0; i < vs1.Length; i += 2) { var inp = vs1[i]; model.Compute(inp).Neurons.ForEach(x => { Console.WriteLine(x.Value + " "); }); Console.WriteLine(); } Console.ReadKey(); }
public static void Main(string[] args) { //create training set from Data.DIGITS DataSet dataSet = generateTraining(); int inputCount = Data.CHAR_HEIGHT * Data.CHAR_WIDTH; int outputCount = Data.DIGITS.Length; int hiddenNeurons = 19; //create neural network MultiLayerPerceptron neuralNet = new MultiLayerPerceptron(inputCount, hiddenNeurons, outputCount); //get backpropagation learning rule from network BackPropagation learningRule = neuralNet.LearningRule; learningRule.LearningRate = 0.5; learningRule.MaxError = 0.001; learningRule.MaxIterations = 5000; //add learning listener in order to print out training info learningRule.addListener(new LearningEventListenerAnonymousInnerClassHelper()); //train neural network neuralNet.learn(dataSet); //train the network with training set testNeuralNetwork(neuralNet, dataSet); }
public static bool Test4() { var xorinput = new[] { new[] { 0.0, 0.0 }, new[] { 1.0, 0.0 }, new[] { 0.0, 1.0 }, new[] { 1.0, 1.0 } }; var xoroutput = new[] { new[] { 0.0 }, new[] { 1.0 }, new[] { 1.0 }, new[] { 0.0 } }; var mlp = new MLP(2, 4, 1); var stsp = new StandardTrainingSetProvider(xorinput, xoroutput); stsp.Split(); var gdbp = new BackPropagation(mlp, stsp); ((GD)gdbp.Solver).Criterion = LearningCriterion.CrossEntropy; //((GD)gdbp.Solver).LearningRate = .01; ((GD)gdbp.Solver).AdaGrad = true; var minerr = double.MaxValue; gdbp.ReportReady += optimizer => { Console.WriteLine("Epoch = {0}, Error = {1}", optimizer.CurrentEpoch, optimizer.TrainingSetProvider.TrainError); minerr = Math.Min(minerr, optimizer.Solver.Error); if (optimizer.Done) { Console.ReadLine(); } }; gdbp.RunAsync().Wait(); return(true); }
/// <summary> /// The entry point for this example. If you would like to make this example /// stand alone, then add to its own project and rename to Main. /// </summary> /// <param name="args">Not used.</param> public static void ExampleMain(string[] args) { var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 5)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); network.FinalizeStructure(); network.Reset(); var trainingData = BasicData.ConvertArrays(XOR_INPUT, XOR_IDEAL); // train the neural network var train = new BackPropagation(network, trainingData, 0.7, 0.9); var epoch = 1; do { train.Iteration(); Console.WriteLine("Epoch #" + epoch + " Error:" + train.LastError); epoch++; } while (train.LastError > 0.01); // test the neural network Console.WriteLine("Neural Network Results:"); for (var i = 0; i < XOR_INPUT.Length; i++) { var output = network.ComputeRegression(XOR_INPUT[i]); Console.WriteLine(string.Join(",", XOR_INPUT[i]) + ", actual=" + string.Join(",", output) + ",ideal=" + string.Join(",", XOR_IDEAL[i])); } }
public virtual void handleLearningEvent(LearningEvent @event) { BackPropagation bp = (BackPropagation)@event.Source; Console.WriteLine("Current iteration: " + bp.CurrentIteration); Console.WriteLine("Error: " + bp.TotalNetworkError); }
static void TestANNMiner(Dataset dataset) { IClassificationMeasure measure = new AccuracyMeasure(); ILearningMethod learningMethod = new BackPropagation(0.1, 10, 0.9, false); int hiddenUnitCount = dataset.Metadata.Attributes.Length * dataset.Metadata.Target.Length; IActivationFunction activationFunction = new SigmoidActivationFunction(); ISolutionQualityEvaluator <ConnectionDC> evaluator = new NNClassificationQualityEvaluator(measure, learningMethod, hiddenUnitCount, activationFunction); IHeuristicsCalculator <ConnectionDC> calculator = new DefaultHeuristicCalculator <ConnectionDC>(); ILocalSearch <ConnectionDC> localSearch = new DefaultRemovalLocalSearch <ConnectionDC>(evaluator); IComponentInvalidator <ConnectionDC> invalidator = new NNConnectorInvalidator(); Problem <ConnectionDC> problem = new Problem <ConnectionDC>(invalidator, calculator, evaluator, localSearch); NeuralNetwork network_before = null; NeuralNetwork network_final = SingleTest.CreateNeuralNet_ANNMiner(problem, hiddenUnitCount, true, false, dataset, ref network_before); double quilty_before = SingleTest.TestClassifier(network_before, dataset, measure); double quilty_final = SingleTest.TestClassifier(network_final, dataset, measure); Console.WriteLine("ANN -" + quilty_before); Console.WriteLine("ANN -" + quilty_final); }
void Start() { backpro = new BackPropagation(NumInput, NumHidden, NumOutput); if (trained == false) { Train(); } }
public void CreateBackPropagationTrainingAlgorithm(AnnBuild annComp, BackPropagation prop) { errorTarget = annComp.ErrorTarget; network.InstantiateBackPropagationAlgorithm( errorTarget, annComp.MaxEpochs, prop.LearningRate, prop.Beta); network.BuildStatsListener(); }
static void Main(string[] args) { int[] layerSizes = new int[3] { 2, 2, 1 }; TransferFunction[] tFuncs = new TransferFunction[3] { TransferFunction.None, TransferFunction.Sigmoid, TransferFunction.Linear }; BackPropagation bpn = new BackPropagation(layerSizes, tFuncs); double[][] input, output; input = new double[4][]; output = new double[4][]; for (int i = 0; i < 4; i++) { input[i] = new double[2]; output[i] = new double[1]; } input[0][0] = 0.0; input[0][1] = 0.0; output[0][0] = 0.0; // Case 1 F xor F = F input[1][0] = 1.0; input[1][1] = 0.0; output[1][0] = 1.0; // Case 2 T xor F = T input[2][0] = 0.0; input[2][1] = 1.0; output[2][0] = 1.0; // Case 3 F xor T = T input[3][0] = 1.0; input[3][1] = 1.0; output[3][0] = 0.0; // Case 4 T xor T = F // Train double error = 0.0; int max_count = 10000, count = 0; do { // Prepare training epoch count++; error = 0.0; // Train for (int i = 0; i < 4; i++) { // TrainRate and Momentm picked arbitrarilly error += bpn.Train(ref input[i], ref output[i], 0.15, 0.10); } // Show Progress if (count % 100 == 0) { Console.WriteLine("Epoch {0} completed with error {1:0.0000}", count, error); } } while (error > 0.0001 && count <= max_count); // Display results double[] networkOutput = new double[1]; for (int i = 0; i < 4; i++) { bpn.Run(ref input[i], out networkOutput); Console.WriteLine("Case {3}: {0:0.0} xor {1:0.0} = {2:0.0000}", input[i][0], input[i][1], networkOutput[0], i + 1); } // End Program Console.WriteLine("Press Enter ..."); Console.ReadLine(); }
//creates an instance of the backpropagation with corresponding number of nodes and weights void Start() { bpro = new BackPropagation(NumInput, NumHidden, NumOutput); pass = false; weights = new double[2451]; tint = GameObject.Find("playerInputs").GetComponent <throwinputs>(); Debug.Log("tssss"); }
public virtual void handleLearningEvent(LearningEvent @event) { BackPropagation bp = (BackPropagation)@event.Source; if (@event.EventType != LearningEvent.Type.LEARNING_STOPPED) { Console.WriteLine(bp.CurrentIteration + ". iteration : " + bp.TotalNetworkError); } }
String GetCommandFromBackPropagation(int[,] sensorData, int sensorType) { int[,] processedSensorData = GetProcessedSensorData(sensorData); var robotCommand = BackPropagation.Driver("Command", _sensorTypeString[sensorType], convertToOneDimensionalDouble(processedSensorData)); return(robotCommand); }
private void BtnEntrenar_Click(object sender, EventArgs e) { if (TxtTipoRed.SelectedItem.ToString().Equals("Perceptrón Multicapa")) { percetronMulticapa = new PercetronMulticapa(); percetronMulticapa.NumeroEntradas = entradas; percetronMulticapa.NumeroSalidas = salidas; percetronMulticapa.NumeroPatrones = patrones; percetronMulticapa.NumeroCapas = NumeroDeCapas; percetronMulticapa.NumeroNeuronasCapas = ListaNumeroNeuronasCapas; percetronMulticapa.FuncionesActivacionCapas = FuncionActivacionCapas; percetronMulticapa.NumeroIteraciones = Convert.ToInt32(TxtNumeroIteraciones.Value.ToString()); percetronMulticapa.RataAprendizaje = Convert.ToDouble(TxtRataAprendizaje.Value.ToString()); percetronMulticapa.ErrorMaximoPermitido = Convert.ToDouble(TxtErrorMaximoPermitido.Value.ToString()); percetronMulticapa.FuncionActivacionCapaSalida = CbxFuncionActivacionCapaSalida.SelectedItem.ToString(); percetronMulticapa.Umbrales = arraydeumbrales; percetronMulticapa.Pesos = arraydematrizdepesos; } else { backPropagation = new BackPropagation(); backPropagation.NumeroEntradas = entradas; backPropagation.NumeroSalidas = salidas; backPropagation.NumeroSalidas = patrones; backPropagation.NumeroCapas = NumeroDeCapas; backPropagation.NumeroNeuronasCapas = ListaNumeroNeuronasCapas; backPropagation.FuncionesActivacionCapas = FuncionActivacionCapas; backPropagation.NumeroIteraciones = Convert.ToInt32(TxtNumeroIteraciones.Value.ToString()); backPropagation.RataAprendizaje = Convert.ToDouble(TxtRataAprendizaje.Value.ToString()); backPropagation.ErrorMaximoPermitido = Convert.ToDouble(TxtErrorMaximoPermitido.Value.ToString()); backPropagation.FuncionActivacionCapaSalida = CbxFuncionActivacionCapaSalida.SelectedItem.ToString(); backPropagation.Umbrales = arraydeumbrales; backPropagation.Pesos = arraydematrizdepesos; MessageBox.Show("Numero entradas: " + backPropagation.NumeroEntradas.ToString() + "" + "NumeroSalidas: " + backPropagation.NumeroSalidas.ToString() + "" + "NumeroPatrones: " + backPropagation.NumeroPatrones.ToString() + "" + "NumeroCapas: "******"" + "NumeroNeuronasCapas: "******"" + "FuncionActivacionCapas: "******"" + "NumeroIteraciones: " + backPropagation.NumeroIteraciones.ToString() + "" + "RataAprendizaje: " + backPropagation.RataAprendizaje.ToString() + "" + "ErrorMaximoPermitido: " + backPropagation.ErrorMaximoPermitido.ToString() + "" + "FuncionActivacionCapaSalida: " + backPropagation.FuncionActivacionCapaSalida.ToString() + "" + "Umbrales: " + backPropagation.Umbrales[0].ToString() + "" + "Pesos: " + backPropagation.Pesos[0, 0].ToString() + "", "algo"); } }
public double Train(double[] input, double[] output, BackPropagation trainer) { // Run the given input throug the network in order to obtain output m_Network.Run (input); // Calculate network error between the generated output and the expected output double error = CalculateError (output); // Update the network to remedy the calculated error Update (input, trainer.LearningRate, trainer.Momentum); return error; }
private void testWithParametr(AlgorithmConfig configuration, Vector[] learnVectors, int classes) { neuronsCount = null; int layersCount = (int)hiddenLayers.Value + 1; switch (layersCount) { case 2: { neuronsCount = new int[1]; neuronsCount[0] = (int)firstLayerNeurons.Value; } break; case 3: { neuronsCount = new int[2]; neuronsCount[0] = (int)firstLayerNeurons.Value; neuronsCount[1] = (int)secondtLayerNeurons.Value; } break; case 4: { neuronsCount = new int[3]; neuronsCount[0] = (int)firstLayerNeurons.Value; neuronsCount[1] = (int)secondtLayerNeurons.Value; neuronsCount[2] = (int)thirdtLayerNeurons.Value; } break; } beta = 0.7; myNet = new NeuralNetwork(layersCount, neuronsCount, learnVectors[0].input.Length, classes, beta); List <Vector> data = new List <Vector>(learnVectors.Length); data.AddRange(learnVectors); switch (algorithmBox.SelectedIndex) { case 0: { BackPropagation method = new BackPropagation(configuration); method.RaiseMessageEvent += AddMessage; method.Train(myNet, data); break; } case 1: { QuickProp method = new QuickProp(configuration); method.RaiseMessageEvent += AddMessage; method.Train(myNet, data); break; } } }
public BackPropagationTester QueueTrainingEpoch( Action <TrainingEpochTester <BackPropagation> > action, ParallelOptions parallelOptions) { var backPropagationTrainer = BackPropagation.WithConfiguration(targetNeuralNetwork, parallelOptions, learningRate, momentum); var epochTester = TrainingEpochTester <BackPropagation> .For(backPropagationTrainer); action.Invoke(epochTester); trainingStates.Add(epochTester); return(this); }
public virtual void handleLearningEvent(LearningEvent @event) { BackPropagation bp = (BackPropagation)@event.Source; LOG.info("Epoch no#: [{}]. Error [{}]", bp.CurrentIteration, bp.TotalNetworkError); LOG.info("Epoch execution time: {} sec", (DateTimeHelperClass.CurrentUnixTimeMillis() - start) / 1000.0); // neuralNetwork.save(bp.getCurrentIteration() + "_MNIST_CNN-MIC.nnet"); start = DateTimeHelperClass.CurrentUnixTimeMillis(); // if (bp.getCurrentIteration() % 5 == 0) // Evaluation.runFullEvaluation(neuralNetwork, testSet); }
public BackPropagation GetLearningMethod(object owner, IContextLookup globalVars, BasicNetwork theNetwork, IList <BasicData> data) { double theLearningRate = LearningRate.GetValue(owner, globalVars); double theMomentum = Momentum.GetValue(owner, globalVars); var theL1 = L1.GetValue(owner, globalVars); var theL2 = L2.GetValue(owner, globalVars); var toReturn = new BackPropagation(theNetwork, data, theLearningRate, theMomentum); toReturn.L1 = theL1; toReturn.L2 = theL2; return(toReturn); }
private void TrainNeuralNetworks(int algorithmType, int sensorType) { switch (algorithmType) { case (int)AlgorithmType.BackPropagation: BackPropagation.Driver("Train", _sensorTypeString[sensorType], null); break; case (int)AlgorithmType.FeedForward: forwardManager.GetDirectionFromFeedForward(_sensorTypeString[sensorType], new float[] { }, 0); break; } }
private void UczenieSieci_Click(object sender, RoutedEventArgs e) { myVector x = bow.GetVectorsList()[0]; BackPropagation.UczenieSieci(200, test.GetTrainingtVectors(), NeuralNetwork, classes); Console.Beep(); foreach (myVector testvector in test.GetTestVectors()) { int id = NeuralConstruction.SampleInput(testvector, NeuralNetwork); var output = NeuralNetwork.getNetwork().Where(o => o.type == 2).ToList(); } UczenieSieci.IsEnabled = false; }
public virtual void handleLearningEvent(LearningEvent @event) { BackPropagation bp = (BackPropagation)@event.Source; if (@event.EventType.Equals(LearningEvent.Type.LEARNING_STOPPED)) { double error = bp.TotalNetworkError; Console.WriteLine("Training completed in " + bp.CurrentIteration + " iterations, "); Console.WriteLine("With total error: " + formatDecimalNumber(error)); } else { Console.WriteLine("Iteration: " + bp.CurrentIteration + " | Network error: " + bp.TotalNetworkError); } }
public async Task TrainConfiguredNetworkForEpochs( int epochs, NeuralNetworkTrainingConfiguration trainingConfig) { var trainingData = dataProvider.TrainingData .Select(transaction => transaction.ToTrainingData()) .ToList(); await TrainingController.For(BackPropagation.WithConfiguration( networkAccessor.TargetNetwork, ParallelOptionsExtensions.MultiThreadedOptions(trainingConfig.ThreadCount), trainingConfig.LearningRate, trainingConfig.Momentum)) .TrainForEpochsOrErrorThresholdMet(trainingData, epochs, trainingConfig.MinimumErrorThreshold); }
public static NeuralNetwork CreateNeuralNet_BP(Dataset trainingset, int hiddenUnitCount, double positiveClassValue, double learningRate, int epochCount, IActivationFunction activationFunction) { counter = 0; //MSError measure = new MSError(); //AccuracyMeasure measure = new AccuracyMeasure(); Connection[] connections = NeuralNetwork.Create3LayerConnectedConnections(trainingset.Metadata, hiddenUnitCount); NeuralNetwork network = new NeuralNetwork(trainingset.Metadata, hiddenUnitCount, activationFunction, connections); BackPropagation BP = new BackPropagation(learningRate, epochCount, positiveClassValue, true); BP.OnPostEpoch += new EventHandler(OnPostEpoch); BP.TrainNetwork(network, trainingset); return(network); }
public async void CanSuccessfullySolveXorProblemTrainingForErrorThreshold() { var neuralNetwork = NeuralNetwork.For(NeuralNetworkContext.MaximumPrecision) .WithInputLayer(neuronCount: 2, activationType: ActivationType.Sigmoid) .WithHiddenLayer(neuronCount: 2, activationType: ActivationType.TanH) .WithOutputLayer(neuronCount: 1, activationType: ActivationType.Sigmoid) .Build(); await TrainingController .For(BackPropagation.WithConfiguration( neuralNetwork, ParallelOptionsExtensions.UnrestrictedMultiThreadedOptions, learningRate: 0.4, momentum: 0.9)) .TrainForErrorThreshold(XorTrainingData(), minimumErrorThreshold: 0.01); AssertPredictionsForTrainedNeuralNetwork(neuralNetwork); }
public async void CanSuccessfullySolveIrisProblemTrainingForEpochs() { var neuralNetwork = NeuralNetwork.For(NeuralNetworkContext.MaximumPrecision) .WithInputLayer(neuronCount: 4, activationType: ActivationType.Sigmoid) .WithHiddenLayer(neuronCount: 8, activationType: ActivationType.Sigmoid) .WithHiddenLayer(neuronCount: 5, activationType: ActivationType.Sigmoid) .WithOutputLayer(neuronCount: 3, activationType: ActivationType.TanH) .Build(); await TrainingController .For(BackPropagation.WithConfiguration( neuralNetwork, ParallelOptionsExtensions.UnrestrictedMultiThreadedOptions, learningRate: 1.15, momentum: 0.4)) .TrainForEpochs(IrisDataSet.TrainingData, maximumEpochs: 1000); AssertPredictionsForTrainedNeuralNetwork(neuralNetwork); }
IEnumerator Start() { m_Running = true; Debug.Log ("Starting test"); yield return null; Debug.Log ("Setup"); m_Network = new Network (InputCount, LayerCounts); if (m_Randomize) { m_Network.RandomizeWeights (); } BackPropagation teacher = new BackPropagation (m_Network) { LearningRate = this.LearningRate, Momentum = this.Momentum }; if (m_LearningCurve != null) { m_LearningCurve.Curve.keys = new Keyframe[] {}; } if (m_Step) { Debug.Break (); } yield return null; Debug.Log ("Start training"); while (m_Running && enabled && Application.isPlaying) { double error = teacher.TrainSet (Input, Output); LogResult ("Training run error: " + error); if (m_LearningCurve != null) { m_LearningCurve.Curve.AddKey (Time.time, (float)error); } if (error < m_TargetError) { Debug.Log (string.Format ("Achieved error {0}, beating target {1}", error, m_TargetError)); yield break; } if (m_Step) { Debug.Break (); } yield return null; } }