public static long BenchmarkEncog(double[][] input, double[][] output) { BasicNetwork network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, input[0].Length)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, HIDDEN_COUNT)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, output[0].Length)); network.Structure.FinalizeStructure(); network.Reset(); IMLDataSet trainingSet = new BasicMLDataSet(input, output); // train the neural network IMLTrain train = new Backpropagation(network, trainingSet, 0.7, 0.7); Stopwatch sw = new Stopwatch(); sw.Start(); // run epoch of learning procedure for (int i = 0; i < ITERATIONS; i++) { train.Iteration(); } sw.Stop(); return sw.ElapsedMilliseconds; }
public virtual void TrainNetwork() { var train = new Backpropagation(Network.Model, TrainingSet, Parameters.LearingCoefficient, Parameters.InertiaCoefficient) { BatchSize = 1 }; var iteration = 1; var errors = new List<double[]>(); do { train.Iteration(); var validationError = Network.Model.CalculateError(ValidationSet); errors.Add(new[] { iteration, train.Error, validationError }); Console.WriteLine( @"Iteration #" + iteration++ + @" Training error:" + String.Format("{0:N10}", train.Error) + @", Validation error:" + String.Format("{0:N10}", validationError)); } while ((iteration < Parameters.IterationsCount) && (train.Error > Parameters.AcceptedError)); train.FinishTraining(); ErrorSet = errors.ToArray(); }
public void TestBPROP() { IMLDataSet trainingData = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); BasicNetwork network = NetworkUtil.CreateXORNetworkUntrained(); IMLTrain bprop = new Backpropagation(network, trainingData, 0.7, 0.9); NetworkUtil.TestTraining(bprop, 0.01); }
public Predictor(String fileName, TextBox txtOutput, CSVData data, double percentValidation) { m_network = (BasicNetwork)EncogDirectoryPersistence.LoadObject(new FileInfo(fileName)); m_txtOutputWindow = txtOutput; m_data = data; // Populate the input and output arrays LoadData(percentValidation); m_train = new Backpropagation(m_network, new BasicMLDataSet(m_inputTraining, m_outputTraining)); }
/// <inheritDoc/> public override void CreateTrainer(OpenCLTrainingProfile profile, Boolean singleThreaded) { Propagation.Propagation train = new Backpropagation(Network, Training, profile, LearningRate, Momentum); if (singleThreaded) train.NumThreads = 1; foreach (IStrategy strategy in Strategies) { train.AddStrategy(strategy); } Train = train; }
public double[][] TrainModel(int iterations, double learningRate, double momentum, IMLDataSet trainingDataSet, IMLDataSet validationDataSet) { var training = new Backpropagation(Model, trainingDataSet, learningRate, momentum); training.BatchSize = 1; var errors = new List<double[]>(); for (int i = 0; i < iterations; ++i ) { training.Iteration(1); var validationError = Model.CalculateError(validationDataSet); errors.Add(new double[] { i, training.Error, validationError }); } return errors.ToArray(); }
/// <summary> /// /// </summary> /// <param name="learningRate">Stala uczenia (zwykle w okolicach 0.1)</param> /// <param name="epochNumber">Na ilu wybranych losowo przykladach uczyc siec</param> /// <param name="momentum">Współczynnik bezwładności.</param> /// <param name="dataSet">Dane do nauki sieci</param> public void Train(double learningRate, int epochNumber, double momentum, InputDataSet dataSet) { if (learningRate <= 0.0 || epochNumber <= 0) throw new PerceptronWrapperException("Invalid arguments"); if (_network.InputCount != dataSet.InputDataSize || _network.OutputCount != dataSet.OutputDataSize || dataSet.InputDataCount <= 0) throw new PerceptronWrapperException("Invalid data set size"); IMLDataSet data = new BasicMLDataSet(dataSet.InputSet, dataSet.OutputSet); var backprop = new Backpropagation(_network, data, learningRate, momentum); // Uczymy siec za pomoca backpropagation backprop.Iteration(epochNumber); // :) - Prosciej sie nie da }
public void Update(State s, double value) { var pair = new BasicMLDataPair(new BasicMLData(s.AsDoubles()), new BasicMLData(new double[] { value })); var trainingSet = new BasicMLDataSet(new[] { pair }); var train = new Encog.Neural.Networks.Training.Propagation.Back.Backpropagation(_network, trainingSet); train.BatchSize = 1; train.Iteration(2); if (train.Error > 0.01) { train.Iteration(3); } var error = train.Error; }
public Predictor(TextBox txtOutput, CSVData data, int hiddenNodes, double percentValidation) { m_txtOutputWindow = txtOutput; m_data = data; // Populate the input and output arrays LoadData(percentValidation); // Create Neural Network m_network = new BasicNetwork(); m_network.AddLayer(new BasicLayer(null, true, m_data.InputNodes)); m_network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, hiddenNodes)); m_network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, m_data.OutputNodes)); m_network.Structure.FinalizeStructure(); m_network.Reset(); m_train = new Backpropagation(m_network, new BasicMLDataSet(m_inputTraining, m_outputTraining)); }
public List<Tuple<int, double, double>> Train(int iterationCount, double learnRate, double momentum) { List<Tuple<int, double, double>> error = new List<Tuple<int, double, double>>(); var training = new Backpropagation(network, trainingData, learnRate, momentum); training.BatchSize = 1; for (int i = 0; i < iterationCount; ++i) { training.Iteration(1); network.CalculateError(validationData); double val_error = network.CalculateError(validationData); error.Add(new Tuple<int, double, double>(i, training.Error, val_error)); //if(i%100 == 0) //Console.WriteLine("{0}: [{1}; {2}]", i, training.Error, val_error); } training.FinishTraining(); return error.Skip(100).ToList(); }
private static void Main(string[] args) { // create a neural network, without using a factory var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 3)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); network.Structure.FinalizeStructure(); network.Reset(); // create training data IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal); // train the neural network IMLTrain train = new Backpropagation(network, trainingSet, 0.5, 0.2); int epoch = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.01); // test the neural network Console.WriteLine(@"Neural Network Results:"); foreach (IMLDataPair pair in trainingSet) { IMLData output = network.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @"," + pair.Input[1] + @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]); } Console.Read(); }
/// <summary> /// Program entry point. /// </summary> /// <param name="app">Holds arguments and other info.</param> public void Execute(IExampleInterface app) { // create a neural network, without using a factory var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 3)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); network.Structure.FinalizeStructure(); network.Reset(); // create training data IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal); // train the neural network using online (batch=1) Propagation train = new Backpropagation(network, trainingSet, 0.7, 0.3); train.BatchSize = 1; int epoch = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.01); // test the neural network Console.WriteLine(@"Neural Network Results:"); foreach (IMLDataPair pair in trainingSet) { IMLData output = network.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @"," + pair.Input[1] + @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]); } }
private void trainNetworkBackprop() { // IMLTrain train = new Backpropagation(this.network, this.input,this.ideal, 0.000001, 0.1); IMLDataSet aset = new BasicMLDataSet(input, ideal); int epoch = 1; // train the neural network ICalculateScore score = new TrainingSetScore(aset); IMLTrain trainAlt = new NeuralSimulatedAnnealing(network, score, 10, 2, 100); IMLTrain trainMain = new Backpropagation(network, aset, 0.001, 0.0); StopTrainingStrategy stop = new StopTrainingStrategy(); var pop = new NEATPopulation(INPUT_SIZE, OUTPUT_SIZE, 1000); // train the neural network var step = new ActivationStep(); step.Center = 0.5; pop.OutputActivationFunction = step; var train = new NEATTraining(score, pop); trainMain.AddStrategy(new Greedy()); trainMain.AddStrategy(new HybridStrategy(trainAlt)); trainMain.AddStrategy(stop); trainMain.AddStrategy(new HybridStrategy(train)); network.ClearContext(); while (!stop.ShouldStop()) { trainMain.Iteration(); train.Iteration(); Console.WriteLine(@"Training " + @"Epoch #" + epoch + @" Error:" + trainMain.Error+ @" Genetic iteration:"+trainAlt.IterationNumber+ @"neat iteration:"+train.IterationNumber ); epoch++; } }
private double TrainNetwork(String what, BasicNetwork network, IMLDataSet trainingSet) { // train the neural network ICalculateScore score = new TrainingSetScore(trainingSet); IMLTrain trainAlt = new NeuralSimulatedAnnealing( network, score, 10, 2, 100); IMLTrain trainMain = new Backpropagation(network, trainingSet, 0.00001, 0.0); var stop = new StopTrainingStrategy(); trainMain.AddStrategy(new Greedy()); trainMain.AddStrategy(new HybridStrategy(trainAlt)); trainMain.AddStrategy(stop); int epoch = 0; while (!stop.ShouldStop()) { trainMain.Iteration(); app.WriteLine("Training " + what + ", Epoch #" + epoch + " Error:" + trainMain.Error); epoch++; } return trainMain.Error; }
private double TrainNetwork(String what, BasicNetwork network, IMLDataSet trainingSet, string Method) { // train the neural network ICalculateScore score = new TrainingSetScore(trainingSet); IMLTrain trainAlt = new NeuralSimulatedAnnealing(network, score, 10, 2, 100); IMLTrain trainMain; if (Method.Equals("Leven")) { Console.WriteLine("Using LevenbergMarquardtTraining"); trainMain = new LevenbergMarquardtTraining(network, trainingSet); } else trainMain = new Backpropagation(network, trainingSet); var stop = new StopTrainingStrategy(); trainMain.AddStrategy(new Greedy()); trainMain.AddStrategy(new HybridStrategy(trainAlt)); trainMain.AddStrategy(stop); int epoch = 0; while (!stop.ShouldStop()) { trainMain.Iteration(); app.WriteLine("Training " + what + ", Epoch #" + epoch + " Error:" + trainMain.Error); epoch++; } return trainMain.Error; }
public static double TrainNetworks(BasicNetwork network, IMLDataSet minis) { Backpropagation trainMain = new Backpropagation(network, minis,0.0001,0.6); //set the number of threads below. trainMain.ThreadCount = 0; // train the neural network ICalculateScore score = new TrainingSetScore(minis); IMLTrain trainAlt = new NeuralSimulatedAnnealing(network, score, 10, 2, 100); // IMLTrain trainMain = new Backpropagation(network, minis, 0.0001, 0.01); StopTrainingStrategy stop = new StopTrainingStrategy(0.0001, 200); trainMain.AddStrategy(new Greedy()); trainMain.AddStrategy(new HybridStrategy(trainAlt)); trainMain.AddStrategy(stop); //prune strategy not in GIT!...Removing it. //PruneStrategy strategypruning = new PruneStrategy(0.91d, 0.001d, 10, network,minis, 0, 20); //trainMain.AddStrategy(strategypruning); EncogUtility.TrainConsole(trainMain,network,minis, 15.2); var sw = new Stopwatch(); sw.Start(); while (!stop.ShouldStop()) { trainMain.Iteration(); Console.WriteLine(@"Iteration #:" + trainMain.IterationNumber + @" Error:" + trainMain.Error + @" Genetic Iteration:" + trainAlt.IterationNumber); } sw.Stop(); Console.WriteLine(@"Total elapsed time in seconds:" + TimeSpan.FromMilliseconds(sw.ElapsedMilliseconds).Seconds); return trainMain.Error; }
private void CanItLearnRulesWith(IList<IMLDataPair> inputData, IList<IMLDataPair> verfData, int hiddenLayerCount, int neuronCount, IActivationFunction actFunc, double learnRate, double momentum, int batchSize, int maxEpochs) { var model = new DbModel(); var funcName = actFunc.GetType().Name; var tdCount = inputData.Count(); if (model.TicTacToeResult.Any(r => r.HiddenLayerCount == hiddenLayerCount && r.NeuronPerLayercount == neuronCount && r.ActivationFunction == funcName && r.LearningRate == learnRate && r.BatchSize == batchSize && r.Momentum == momentum && r.Name == Name && r.Epochs == maxEpochs && r.TrainingDataCount == tdCount)) return; var nn = CreateNetwork(inputData, hiddenLayerCount, neuronCount, actFunc); var train = new Backpropagation(nn, new BasicMLDataSet(inputData), learnRate, momentum); train.BatchSize = batchSize; int epoch = 1; do { train.Iteration(); epoch++; } while (epoch < maxEpochs); int good = verfData.Count(verf => { var output = nn.Compute(verf.Input); return Enumerable.Range(0, 9).All(i => Math.Round(output[i]) == Math.Round(verf.Ideal[i])); }); int bad = VerfDataCount - good; var result = new TicTacToeResult() { HiddenLayerCount = hiddenLayerCount, NeuronPerLayercount = neuronCount, ActivationFunction = funcName, Bad = bad, Good = good, TrainingDataCount = tdCount, Momentum = momentum, LearningRate = learnRate, BatchSize = batchSize, Epochs = epoch, Error = train.Error, Name = Name, }; model.TicTacToeResult.Add(result); model.SaveChanges(); }
public static double TrainNetworks(BasicNetwork network, IMLDataSet minis) { // train the neural network ICalculateScore score = new TrainingSetScore(minis); IMLTrain trainAlt = new NeuralSimulatedAnnealing(network, score, 10, 2, 100); IMLTrain trainMain = new Backpropagation(network, minis, 0.0001, 0.01); StopTrainingStrategy stop = new StopTrainingStrategy(0.0001, 200); trainMain.AddStrategy(new Greedy()); trainMain.AddStrategy(new HybridStrategy(trainAlt)); trainMain.AddStrategy(stop); var sw = new Stopwatch(); sw.Start(); while (!stop.ShouldStop()) { trainMain.Iteration(); Console.WriteLine(@"Iteration #:" + trainMain.IterationNumber + @" Error:" + trainMain.Error + @" Genetic Iteration:" + trainAlt.IterationNumber); } sw.Stop(); return trainMain.Error; }
/// <summary> /// Uczy sieć. /// </summary> /// <param name="learningRate">Stala uczenia (zwykle w okolicach 0.1)</param> /// <param name="epochNumber">Na ilu wybranych losowo przykladach uczyc siec</param> /// <param name="momentum">Współczynnik bezwładności.</param> /// <param name="inputData">The input into the neural network for training.</param> /// <param name="idealData">The idea into the neural network for training.</param> public void Train(double learningRate, int epochNumber, double momentum, double[][] inputData, double[][] idealData) { if (learningRate <= 0.0 || epochNumber <= 0) { throw new PerceptronWrapperException("Invalid arguments"); } if (inputData.Any(x => x.Length != basicNetwork.InputCount) || idealData.Any(x => x.Length != basicNetwork.OutputCount) || inputData.GetLength(0) <= 0) { throw new PerceptronWrapperException("Invalid data set size"); } IMLDataSet data = new BasicMLDataSet(inputData, idealData); var backprop = new Backpropagation(basicNetwork, data, learningRate, momentum); // Uczymy siec za pomoca backpropagation backprop.Iteration(epochNumber); // :) - Prosciej sie nie da }
public override void Run() { testNetwork = new BasicNetwork(); testNetwork.AddLayer(new BasicLayer(null, true, 2)); testNetwork.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 4)); testNetwork.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); testNetwork.Structure.FinalizeStructure(); testNetwork.Reset(); // create training data IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal); // train the neural network IMLTrain train = new Backpropagation(testNetwork, trainingSet); //IMLTrain train = new ResilientPropagation(testNetwork, trainingSet); //Encog manual says it is the best general one int epoch = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.0001); // test the neural network Console.WriteLine(@"Neural Network Results:"); foreach (IMLDataPair pair in trainingSet) { IMLData output = testNetwork.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @"," + pair.Input[1] + @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]); } }
public double[][] Train(int iterationsCount, double learningRate, double momentum) { var train = new Backpropagation(network, trainingData, learningRate, momentum); train.BatchSize = 1; double[][] errors = new double[2][]; errors[0] = new double[iterationsCount]; errors[1] = new double[iterationsCount]; for (int i = 0; i < iterationsCount; i++) { train.Iteration(1); errors[0][i] = train.Error; errors[1][i] = network.CalculateError(validationData); } train.FinishTraining(); return errors; }