public PlanogramOptimizerEncog(Item[] items, SimulationSettings simSettings, UpdateUINonRLMCallback updateUI = null, UpdateStatusCallback updateStatus = null, SimulationCsvLogger logger = null, bool anneal = true) { updateStatus?.Invoke("Initializing..."); //this.items = items; this.simSettings = simSettings; this.logger = logger; this.updateUI = updateUI; this.updateStatus = updateStatus; network = CreateNetwork(); planogramScore = new PlanogramScore() { SimSettings = simSettings, Items = items, UpdateUI = updateUI, Logger = logger }; if (anneal) { train = new NeuralSimulatedAnnealing(network, planogramScore, 10, 2, (simSettings.SimType == SimulationType.Sessions) ? 1 : 10); // todo make the # of cycles an input for users? } else { train = new MLMethodGeneticAlgorithm(() => { ((IMLResettable)network).Reset(); return(network); }, planogramScore, 500); } }
/// <summary> /// Train the network, using the specified training algorithm, and send the /// output to the console. /// </summary> /// <param name="train">The training method to use.</param> /// <param name="network">The network to train.</param> /// <param name="trainingSet">The training set.</param> /// <param name="seconds">The second to train for.</param> public static void TrainConsole(IMLTrain train, BasicNetwork network, IMLDataSet trainingSet, double seconds) { int epoch = 1; double remaining; Console.WriteLine(@"Beginning training..."); long start = Environment.TickCount; do { train.Iteration(); double current = Environment.TickCount; double elapsed = (current - start) / 1000; remaining = seconds - elapsed; Console.WriteLine(@"Iteration #" + Format.FormatInteger(epoch) + @" Error:" + Format.FormatPercent(train.Error) + @" elapsed time = " + Format.FormatTimeSpan((int)elapsed) + @" time left = " + Format.FormatTimeSpan((int)remaining)); epoch++; } while (remaining > 0 && !train.TrainingDone); train.FinishTraining(); }
void Start() { double[][] x = { new[] { 0.0, 0.0 }, new[] { 0.0, 1.0 }, new[] { 1.0, 0.0 }, new[] { 1.0, 1.0 } }; double[][] y = { new[] { 0.0 }, new[] { 1.0 }, new[] { 1.0 }, new[] { 0.0 } }; basicNetwork = new BasicNetwork(); basicNetwork.AddLayer(new BasicLayer(inputLayer)); for (int i = 0; i < hiddenLayer.Length; i++) { basicNetwork.AddLayer(new BasicLayer(hiddenLayer[i])); } basicNetwork.AddLayer(new BasicLayer(outputLayer)); basicNetwork.Structure.FinalizeStructure(); basicNetwork.Reset(); dataPairs = new BasicMLDataSet(x, y); backpropagation = new ResilientPropagation(basicNetwork, dataPairs, 0.4, 0.12); }
public static void MyTrainConsole(IMLTrain train, BasicNetwork network, IMLDataSet trainingSet, int minutes, FileInfo networkFile, FileInfo trainFile) { int epoch = 1; long remaining; Console.WriteLine(@"Beginning training..."); long start = Environment.TickCount; do { train.Iteration(); long current = Environment.TickCount; long elapsed = (current - start) / 1000; remaining = minutes - elapsed / 60; Console.WriteLine($@"Iteration #{Format.FormatInteger(epoch)} Error:{Format.FormatPercent(train.Error)} elapsed time = {Format.FormatTimeSpan((int)elapsed)} time left = {Format.FormatTimeSpan((int)remaining * 60)}"); epoch++; EncogDirectoryPersistence.SaveObject(networkFile, network); TrainingContinuation cont = train.Pause(); EncogDirectoryPersistence.SaveObject(trainFile, cont); train.Resume(cont); foreach (var x in cont.Contents) { Console.WriteLine($"{x.Key}: {((double[])x.Value).Average()}"); } }while (remaining > 0 && !train.TrainingDone && !Console.KeyAvailable); Console.WriteLine("Finishing."); train.FinishTraining(); }
public void Process(String methodName, String methodArchitecture, String trainerName, String trainerArgs, int outputNeurons) { // first, create the machine learning method var methodFactory = new MLMethodFactory(); IMLMethod method = methodFactory.Create(methodName, methodArchitecture, 2, outputNeurons); // second, create the data set IMLDataSet dataSet = new BasicMLDataSet(XORInput, XORIdeal); // third, create the trainer var trainFactory = new MLTrainFactory(); IMLTrain train = trainFactory.Create(method, dataSet, trainerName, trainerArgs); // reset if improve is less than 1% over 5 cycles if (method is IMLResettable && !(train is ManhattanPropagation)) { train.AddStrategy(new RequiredImprovementStrategy(500)); } // fourth, train and evaluate. EncogUtility.TrainToError(train, 0.01); method = train.Method; EncogUtility.Evaluate((IMLRegression)method, dataSet); // finally, write out what we did Console.WriteLine(@"Machine Learning Type: " + methodName); Console.WriteLine(@"Machine Learning Architecture: " + methodArchitecture); Console.WriteLine(@"Training Method: " + trainerName); Console.WriteLine(@"Training Args: " + trainerArgs); }
/// <summary> /// Perform the training. /// </summary> /// <param name="train">The training method.</param> /// <param name="method">The ML method.</param> /// <param name="trainingSet">The training set.</param> private void PerformTraining(IMLTrain train, IMLMethod method, IMLDataSet trainingSet) { ValidateNetwork.ValidateMethodToData(method, trainingSet); double targetError = Prop.GetPropertyDouble( ScriptProperties.MlTrainTargetError); Analyst.ReportTrainingBegin(); int maxIteration = Analyst.MaxIteration; if (train.ImplementationType == TrainingImplementationType.OnePass) { train.Iteration(); Analyst.ReportTraining(train); } else { do { train.Iteration(); Analyst.ReportTraining(train); } while ((train.Error > targetError) && !Analyst.ShouldStopCommand() && !train.TrainingDone && ((maxIteration == -1) || (train.IterationNumber < maxIteration))); } train.FinishTraining(); Analyst.ReportTrainingEnd(); }
/// <summary> /// Perform the training option. /// </summary> public void Train() { // first, create the machine learning method var methodFactory = new MLMethodFactory(); IMLMethod method = methodFactory.Create(Config.MethodType, Config.MethodArchitecture, Config.InputWindow, 1); // second, create the data set string filename = FileUtil.CombinePath(new FileInfo(_path), Config.FilenameTrain).ToString(); IMLDataSet dataSet = EncogUtility.LoadEGB2Memory(new FileInfo(filename)); // third, create the trainer var trainFactory = new MLTrainFactory(); IMLTrain train = trainFactory.Create(method, dataSet, Config.TrainType, Config.TrainParams); // reset if improve is less than 1% over 5 cycles if (method is IMLResettable && !(train is ManhattanPropagation)) { train.AddStrategy(new RequiredImprovementStrategy(500)); } // fourth, train and evaluate. EncogUtility.TrainToError(train, Config.TargetError); method = train.Method; EncogDirectoryPersistence.SaveObject(FileUtil.CombinePath(new FileInfo(_path), Config.MethodName), method); // finally, write out what we did Console.WriteLine(@"Machine Learning Type: " + Config.MethodType); Console.WriteLine(@"Machine Learning Architecture: " + Config.MethodArchitecture); Console.WriteLine(@"Training Method: " + Config.TrainType); Console.WriteLine(@"Training Args: " + Config.TrainParams); }
/// <summary> /// Report training. /// </summary> /// <param name="train">The trainer.</param> public void ReportTraining(IMLTrain train) { foreach (IAnalystListener listener in _listeners) { listener.ReportTraining(train); } }
/// <inheritdoc /> public void Init(IMLTrain theTrain) { _train = theTrain; _calc = (IMLError)_train.Method; _stop = false; _lastCheck = 0; _lastValidationError = _calc.CalculateError(_validationSet); }
/// <summary> /// Initialize this strategy. /// </summary> /// /// <param name="train_0">The training algorithm.</param> public void Init(IMLTrain train_0) { _train = train_0; _setter = (IMomentum)train_0; _ready = false; _setter.Momentum = 0.0d; _currentMomentum = 0; }
public void Init(IMLTrain train_0) { this._xd87f6a9c53c2ed9f = train_0; this._x6947f9fc231e17e8 = (IMomentum) train_0; this._x6c7711ed04d2ac90 = false; this._x6947f9fc231e17e8.Momentum = 0.0; this._xd02ba004f6c6d639 = 0.0; }
public void Init(IMLTrain train) { basicTrainSOM = train as BasicTrainSOM; if (basicTrainSOM == null) { throw new ArgumentException( String.Format("Argument shoud be of {0} type.", typeof(BasicTrainSOM)), "train"); } }
public virtual void Init(IMLTrain train) { this._xd87f6a9c53c2ed9f = train; while (!(train.Method is IMLResettable)) { throw new TrainingError("To use the reset strategy the machine learning method must support MLResettable."); } this._x1306445c04667cc7 = (IMLResettable) this._xd87f6a9c53c2ed9f.Method; }
/// <summary> /// Train, using the specified training method, display progress to a dialog /// box. /// </summary> /// <param name="train">The training method to use.</param> /// <param name="network">The network to train.</param> /// <param name="trainingSet">The training set to use.</param> public static void TrainDialog(IMLTrain train, BasicNetwork network, IMLDataSet trainingSet) { var dialog = new TrainingDialog { Train = train }; dialog.ShowDialog(); }
/// <inheritdoc/> public void Init(IMLTrain theTrain) { _train = theTrain; _calc = (IMLError)_train.Method; _eOpt = Double.PositiveInfinity; _stripOpt = Double.PositiveInfinity; _stop = false; _lastCheck = 0; }
/// <summary> /// /// </summary> /// public void ReportTraining(IMLTrain train) { Console.Out.WriteLine("Iteration #" + Format.FormatInteger(train.IterationNumber) + " Error:" + Format.FormatPercent(train.Error) + " elapsed time = " + Format.FormatTimeSpan((int)(_stopwatch.ElapsedMilliseconds / Format.MiliInSec))); }
public void StartTrain(Action <double, int> trainCallback = null, int reportEach = 5) { // initialize input and output values var inputs = new double[_learnLength][]; var outputs = new double[_learnLength][]; var i0 = TrainStartIndex(); var sourceArray = GetSource().ToArray(); var window = new Queue <double>(sourceArray.Skip(i0).Take(_windowSize).Select(d => d.Val[(byte)_wantedInput])); for (var i = 0; i < _learnLength; i++) { // берем _windowSize предыдущих значений для _learnLength значений начиная с выбранной даты var innerArray = window.ToArray(); inputs[i] = NormalizeInput(innerArray); window.Dequeue(); window.Enqueue(sourceArray[i0 + i + _windowSize].Val[(byte)_wantedInput]); var ouputArray = sourceArray.Skip(i + _windowSize).Take(_layers.Last()).Select(d => d.Val[(byte)_wantedOutput]).ToArray(); outputs[i] = NormalizeOutput(ouputArray); } if (_network != null) { var trainingSet = new BasicMLDataSet(inputs, outputs); IMLTrain teacher = _trainMethod == TrainMethod.Specific ? (IMLTrain) new LevenbergMarquardtTraining(_network, trainingSet) : _trainMethod == TrainMethod.BackProp ? (IMLTrain) new Backpropagation(_network, trainingSet) : _trainMethod == TrainMethod.Resilent ? (IMLTrain) new ResilientPropagation(_network, trainingSet) : _trainMethod == TrainMethod.Genetic ? (IMLTrain) new NeuralGeneticAlgorithm( _network, new Encog.MathUtil.Randomize.NguyenWidrowRandomizer(), new TrainingSetScore(trainingSet), _population, _mutationPercent / 100.0, _matePercent / 100.0) : null; if (teacher == null) { return; } _stop = false; for (int i = 1; !_stop; i++) { teacher.Iteration(); if (teacher is NeuralGeneticAlgorithm) { _network = (teacher as NeuralGeneticAlgorithm).Genetic.Population.Best.Organism as BasicNetwork; } if (i % reportEach == 0 && trainCallback != null) { trainCallback(teacher.Error, i); } } } }
/// <summary> /// Create a hybrid strategy. /// </summary> /// /// <param name="altTrain">The alternate training algorithm.</param> /// <param name="minImprovement">The minimum improvement to switch algorithms.</param> /// <param name="tolerateMinImprovement"></param> /// <param name="alternateCycles"></param> public HybridStrategy(IMLTrain altTrain, double minImprovement, int tolerateMinImprovement, int alternateCycles) { _altTrain = altTrain; _ready = false; _lastHybrid = 0; _minImprovement = minImprovement; _tolerateMinImprovement = tolerateMinImprovement; _alternateCycles = alternateCycles; }
public void CreateNetwork() { FeedImages(); double[][] a = { new[] { 0.0, 0.0 }, new[] { 0.0, 1.0 }, new[] { 1.0, 0.0 }, new[] { 1.0, 1.0 } }; double[][] b = { new[] { 0.0 }, new[] { 1.0 }, new[] { 1.0 }, new[] { 0.0 } }; basicNetwork = new BasicNetwork(); basicNetwork.AddLayer(new BasicLayer(inputLayer)); for (int i = 0; i < hiddenLayer.Length; i++) { basicNetwork.AddLayer(new BasicLayer(hiddenLayer[i])); } basicNetwork.AddLayer(new BasicLayer(outputLayer)); basicNetwork.Structure.FinalizeStructure(); basicNetwork.Reset(); dataPairs = new BasicMLDataSet(x, y); backpropagation = new ResilientPropagation(basicNetwork, dataPairs); //backpropagation = new Backpropagation(basicNetwork, dataPairs, learningRate, momentum); //backpropagation.AddStrategy(new ResetStrategy(0.5, 50)); epoch = 0; maximumEpoch.interactable = false; minimumError.interactable = false; if (maximumEpoch.text == "") { maximumEpoch.text = "1000"; } if (minimumError.text == "") { minimumError.text = "0.01"; } coroutine = Train(); StartCoroutine(coroutine); }
/// <summary> /// Initialize this strategy. /// </summary> /// /// <param name="train">The training algorithm.</param> public void Init(IMLTrain train) { _train = train; _ready = false; _setter = (ILearningRate)train; _trainingSize = train.Training.Count; _currentLearningRate = 1.0d / _trainingSize; EncogLogging.Log(EncogLogging.LevelDebug, "Starting learning rate: " + _currentLearningRate); _setter.LearningRate = _currentLearningRate; }
/// <summary> /// Initialize this strategy. /// </summary> /// /// <param name="train">The training algorithm.</param> public void Init(IMLTrain train) { _train = train; _ready = false; _setter = (ILearningRate) train; _trainingSize = train.Training.Count; _currentLearningRate = 1.0d/_trainingSize; EncogLogging.Log(EncogLogging.LevelDebug, "Starting learning rate: " + _currentLearningRate); _setter.LearningRate = _currentLearningRate; }
public HybridStrategy(IMLTrain altTrain, double minImprovement, int tolerateMinImprovement, int alternateCycles) { if (((((uint) minImprovement) | 2) != 0) && (0 == 0)) { this._xa45232be281da68a = altTrain; this._x6c7711ed04d2ac90 = false; } this._x123e81b4d1593407 = 0; this._x75deb38bfba59a18 = minImprovement; this._x671aa26bb37ef7df = tolerateMinImprovement; this._x2801df77d59cbd36 = alternateCycles; }
public RedNeuronal() { trainingSet = new BasicMLDataSet(neuralInput, neuralOutput); this.network = new BasicNetwork(); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 72)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 216)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 144)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 12)); network.Structure.FinalizeStructure(); network.Reset(); train = new ResilientPropagation(network, trainingSet); }
/// <summary> /// Initialize this strategy. /// </summary> /// /// <param name="train">The training algorithm.</param> public virtual void Init(IMLTrain train) { _train = train; if (!(train.Method is IMLResettable)) { throw new TrainingError( "To use the required improvement strategy the machine learning method must support MLResettable."); } _method = (IMLResettable)_train.Method; }
/// <summary> /// Construct a cross validation trainer. /// </summary> /// /// <param name="train">The training</param> /// <param name="k">The number of folds.</param> public CrossValidationKFold(IMLTrain train, int k) : base(train.Method, (FoldedDataSet) train.Training) { _train = train; Folded.Fold(k); _flatNetwork = ((BasicNetwork) train.Method).Structure.Flat; _networks = new NetworkFold[k]; for (int i = 0; i < _networks.Length; i++) { _networks[i] = new NetworkFold(_flatNetwork); } }
/// <summary> /// Create a trainer. /// </summary> /// <param name="method">The method to train.</param> /// <param name="dataset">The dataset.</param> /// <returns>The trainer.</returns> private IMLTrain CreateTrainer(IMLMethod method, IMLDataSet dataset) { if (_trainingType == null) { throw new EncogError( "Please call selectTraining first to choose how to train."); } var trainFactory = new MLTrainFactory(); IMLTrain train = trainFactory.Create(method, dataset, _trainingType, _trainingArgs); return(train); }
/// <summary> /// Construct a cross validation trainer. /// </summary> /// /// <param name="train">The training</param> /// <param name="k">The number of folds.</param> public CrossValidationKFold(IMLTrain train, int k) : base(train.Method, (FoldedDataSet)train.Training) { _train = train; Folded.Fold(k); _flatNetwork = ((BasicNetwork)train.Method).Structure.Flat; _networks = new NetworkFold[k]; for (int i = 0; i < _networks.Length; i++) { _networks[i] = new NetworkFold(_flatNetwork); } }
/// <summary> /// Le constructeur qui le réseau de neurones. /// </summary> public IndicatorEncog(int nbPasse, int nbHidden) { // Initialisation des données. NbPasse = nbPasse; NbHidden = nbHidden; // Initialisation du réseau. ErrorCalculation.Mode = ErrorCalculationMode.RMS; Reseau = new BasicNetwork(); Reseau.AddLayer(new BasicLayer(null, true, NbNeuronesEntre * NbPasse)); Reseau.AddLayer(new BasicLayer(new ActivationTANH(), true, NbHidden)); //Reseau.AddLayer(new BasicLayer(new ActivationTANH(), true, NbHidden / 2)); //Reseau.AddLayer(new BasicLayer(new ActivationTANH(), true, NbHidden / 4)); //Reseau.AddLayer(new BasicLayer(new ActivationStep(0,0,1), false, 1)); Reseau.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); Reseau.Structure.FinalizeStructure(); Reseau.Reset(); // Initialisation des listes. DonneesEntreesTest = new List <List <double> >(); DonneesSortiesTest = new List <List <double> >(); DonneesEntreesValidation = new List <List <double> >(); DonneesSortiesValidation = new List <List <double> >(); //// Récupère les données d'entrées et de sorties pour toutes les monnaies. Donnees = new Donnees(MonnaieBTC.XRP); this.AggregationDonnees(Donnees); // Création du set d'entrainement. double[][] donneesEntreesTest = this.DonneesEntreesTest.Select(a => a.ToArray()).ToArray(); double[][] donneesSortiesTest = this.DonneesSortiesTest.Select(a => a.ToArray()).ToArray(); TrainingSet = new BasicMLDataSet(donneesEntreesTest, donneesSortiesTest); // Création du set de validation. double[][] donneesEntreesValidation = this.DonneesEntreesValidation.Select(a => a.ToArray()).ToArray(); double[][] donneesSortiesValidation = this.DonneesSortiesValidation.Select(a => a.ToArray()).ToArray(); ValidationSet = new BasicMLDataSet(donneesEntreesValidation, donneesSortiesValidation); // Création du type d'entrainement. //train = new Backpropagation(Reseau, TrainingSet, 0.001, 0.01); train = new ResilientPropagation(Reseau, TrainingSet); // Initialise les listes d'erreurs et les erreurs ListeErreurEntrainement = new List <double>(); ListeErreurValidation = new List <double>(); ErreurOptimaleEntrainement = 100; ErreurOptimaleValidation = 100; }
/// <summary> /// Initialize this strategy. /// </summary> /// /// <param name="train">The training algorithm.</param> public virtual void Init(IMLTrain train) { _train = train; _ready = false; if (!(train.Method is IMLEncodable)) { throw new TrainingError( "To make use of the Greedy strategy the machine learning method must support MLEncodable."); } _method = ((IMLEncodable)train.Method); _lastNetwork = new double[_method.EncodedArrayLength()]; }
/// <summary> /// Initialize this strategy. /// </summary> /// /// <param name="train">The training algorithm.</param> public virtual void Init(IMLTrain train) { _train = train; _ready = false; if (!(train.Method is IMLEncodable)) { throw new TrainingError( "To make use of the Greedy strategy the machine learning method must support MLEncodable."); } _method = ((IMLEncodable) train.Method); _lastNetwork = new double[_method.EncodedArrayLength()]; }
public static void TestTraining(IMLTrain train, double requiredImprove) { train.Iteration(); double error1 = train.Error; for (int i = 0; i < 10; i++) train.Iteration(); double error2 = train.Error; double improve = (error1 - error2) / error1; Assert.IsTrue(improve >= requiredImprove,"Improve rate too low for " + train.GetType().Name + ",Improve=" + improve + ",Needed=" + requiredImprove); }
/// <summary> /// Fit the model using cross validation. /// </summary> /// <param name="k">The number of folds total.</param> /// <param name="foldNum">The current fold.</param> /// <param name="fold">The current fold.</param> private void FitFold(int k, int foldNum, DataFold fold) { IMLMethod method = CreateMethod(); IMLTrain train = CreateTrainer(method, fold.Training); if (train.ImplementationType == TrainingImplementationType.Iterative) { var earlyStop = new SimpleEarlyStoppingStrategy( fold.Validation); train.AddStrategy(earlyStop); var line = new StringBuilder(); while (!train.TrainingDone) { train.Iteration(); line.Length = 0; line.Append("Fold #"); line.Append(foldNum); line.Append("/"); line.Append(k); line.Append(": Iteration #"); line.Append(train.IterationNumber); line.Append(", Training Error: "); line.Append(Format.FormatDouble(train.Error, 8)); line.Append(", Validation Error: "); line.Append(Format.FormatDouble(earlyStop.ValidationError, 8)); Report.Report(k, foldNum, line.ToString()); } fold.Score = earlyStop.ValidationError; fold.Method = method; } else if (train.ImplementationType == TrainingImplementationType.OnePass) { train.Iteration(); double validationError = CalculateError(method, fold.Validation); Report.Report(k, k, "Trained, Training Error: " + train.Error + ", Validatoin Error: " + validationError); fold.Score = validationError; fold.Method = method; } else { throw new EncogError("Unsupported training type for EncogModel: " + train.ImplementationType); } }
public virtual void Init(IMLTrain train) { this._xd87f6a9c53c2ed9f = train; this._x6c7711ed04d2ac90 = false; while (!(train.Method is IMLEncodable)) { throw new TrainingError("To make use of the Greedy strategy the machine learning method must support MLEncodable."); } do { this._x1306445c04667cc7 = (IMLEncodable) train.Method; } while (2 == 0); this._x8ca12f17f1ae2b01 = new double[this._x1306445c04667cc7.EncodedArrayLength()]; }
public PSO() { network = new BasicNetwork(); network.AddLayer(new BasicLayer(5)); network.AddLayer(new BasicLayer(1)); network.AddLayer(new BasicLayer(1)); network.Structure.FinalizeStructure(); network.Reset(); IMLDataSet dataSet = new BasicMLDataSet(); dataSet.Add(new BasicMLData(new double[] { 1.0, 4.0, 3.0, 4.0, 5.0 }), new BasicMLData(new double[] { 2.0, 4.0, 6.0, 8.0, 10 })); train = new NeuralPSO(network, new RangeRandomizer(0, 10), new TrainingSetScore(dataSet), 5); }
public PSO() { network = new BasicNetwork(); network.AddLayer(new BasicLayer(5)); network.AddLayer(new BasicLayer(1)); network.AddLayer(new BasicLayer(1)); network.Structure.FinalizeStructure(); network.Reset(); IMLDataSet dataSet = new BasicMLDataSet(); dataSet.Add(new BasicMLData(new double[] { 1.0, 4.0, 3.0, 4.0, 5.0}) , new BasicMLData(new double[] { 2.0, 4.0, 6.0 , 8.0, 10} )); train = new NeuralPSO(network, new RangeRandomizer(0, 10), new TrainingSetScore(dataSet),5); }
/// <summary> /// Train to a specific error, using the specified training method, send the /// output to the console. /// </summary> /// /// <param name="train">The training method.</param> /// <param name="error">The desired error level.</param> public static void TrainToError(IMLTrain train, double error) { int epoch = 1; Console.Out.WriteLine(@"Beginning training..."); do { train.Iteration(); Console.Out.WriteLine(@"Iteration #" + Format.FormatInteger(epoch) + @" Error:" + Format.FormatPercent(train.Error) + @" Target Error: " + Format.FormatPercent(error)); epoch++; } while ((train.Error > error) && !train.TrainingDone); train.FinishTraining(); }
/// <summary> /// Create a trainer. /// </summary> /// /// <param name="method">The method to train.</param> /// <param name="training">The training data.</param> /// <param name="type">Type type of trainer.</param> /// <param name="args">The training args.</param> /// <returns>The new training method.</returns> public IMLTrain Create(IMLMethod method, IMLDataSet training, String type, String args) { foreach (EncogPluginBase plugin in EncogFramework.Instance.Plugins) { if (plugin is IEncogPluginService1) { IMLTrain result = ((IEncogPluginService1)plugin).CreateTraining( method, training, type, args); if (result != null) { return(result); } } } throw new EncogError("Unknown training type: " + type); }
public static void TestTraining(IMLTrain train, double requiredImprove) { train.Iteration(); double error1 = train.Error; for (int i = 0; i < 10; i++) { train.Iteration(); } double error2 = train.Error; double improve = (error1 - error2) / error1; Assert.IsTrue(improve >= requiredImprove, "Improve rate too low for " + train.GetType().Name + ",Improve=" + improve + ",Needed=" + requiredImprove); }
public void Init(IMLTrain train) { Method = (MLMethodGeneticAlgorithm)train; Adversaries = new List <Adversaries>(); var r = new RangeRandomizer(-1, 1); for (int i = 0; i < 6; i++) { Adversaries.Add(new Adversaries() { PlayerStart = r.NextDouble() >= 0.5 ? 1.0 : -1.0, Player = new PlayerVertical(i) }); Adversaries.Add(new Adversaries() { PlayerStart = r.NextDouble() >= 0.5 ? 1.0 : -1.0, Player = new PlayerHorizontal(i) }); } BaseAdversaries = Adversaries.ToList(); }
private void TrainCommand() { String methodFile = _cmd.Args[0]; String trainingFile = _cmd.Args[1]; String type = _cmd.PromptString("type", "rprop"); String args = _cmd.PromptString("args", ""); double maxError = _cmd.PromptDouble("maxError", 0.01); var dataSet = new BufferedMLDataSet(trainingFile); var method = (IMLMethod)EncogDirectoryPersistence.LoadObject(new FileInfo(methodFile)); var factory = new MLTrainFactory(); IMLTrain train = factory.Create(method, dataSet, type, args); _sw.Start(); EncogUtility.TrainToError(train, maxError); Console.WriteLine(@"Saving machine learning method"); EncogDirectoryPersistence.SaveObject(new FileInfo(methodFile), method); }
public void Init(IMLTrain train) { this._xd87f6a9c53c2ed9f = train; while (true) { this._x6c7711ed04d2ac90 = false; this._x6947f9fc231e17e8 = (ILearningRate) train; this._x985befeef351542c = train.Training.Count; this._x6300a707dc67f3a2 = 1.0 / ((double) this._x985befeef351542c); EncogLogging.Log(0, "Starting learning rate: " + this._x6300a707dc67f3a2); do { this._x6947f9fc231e17e8.LearningRate = this._x6300a707dc67f3a2; } while (-2147483648 == 0); if (0 == 0) { return; } } }
public CrossValidationKFold(IMLTrain train, int k) : base(train.Method, (FoldedDataSet) train.Training) { int num; if ((((uint) k) | 1) != 0) { this._xd87f6a9c53c2ed9f = train; base.Folded.Fold(k); goto Label_0083; } if (0xff != 0) { goto Label_0083; } Label_0039: num = 0; while (num < this._x5f6ed0047d99f4b6.Length) { this._x5f6ed0047d99f4b6[num] = new NetworkFold(this._xef94864849922d07); if (((uint) k) >= 0) { } num++; } if (((uint) num) <= uint.MaxValue) { return; } Label_0083: this._xef94864849922d07 = ((BasicNetwork) train.Method).Structure.Flat; this._x5f6ed0047d99f4b6 = new NetworkFold[k]; if (8 == 0) { return; } goto Label_0039; }
private void x0d87de1eb44df41c(IMLTrain xd87f6a9c53c2ed9f, IMLMethod x1306445c04667cc7, IMLDataSet x1c9e132f434262d8) { int maxIteration; ValidateNetwork.ValidateMethodToData(x1306445c04667cc7, x1c9e132f434262d8); double propertyDouble = base.Prop.GetPropertyDouble("ML:TRAIN_targetError"); base.Analyst.ReportTrainingBegin(); if ((((uint) maxIteration) & 0) == 0) { if (2 == 0) { goto Label_0038; } maxIteration = base.Analyst.MaxIteration; if (0xff != 0) { goto Label_0038; } } Label_001B: if (!xd87f6a9c53c2ed9f.TrainingDone && ((maxIteration == -1) || (xd87f6a9c53c2ed9f.IterationNumber < maxIteration))) { goto Label_0038; } Label_0023: xd87f6a9c53c2ed9f.FinishTraining(); base.Analyst.ReportTrainingEnd(); return; Label_0038: xd87f6a9c53c2ed9f.Iteration(); base.Analyst.ReportTraining(xd87f6a9c53c2ed9f); if ((xd87f6a9c53c2ed9f.Error <= propertyDouble) || base.Analyst.ShouldStopCommand()) { goto Label_0023; } goto Label_001B; }
/// <summary> /// Construct a hybrid strategy with the default minimum improvement /// and toleration cycles. /// </summary> /// /// <param name="altTrain">The alternative training strategy.</param> public HybridStrategy(IMLTrain altTrain) : this(altTrain, DefaultMinImprovement, DefaultTolerateCycles, DefaultAlternateCycles) { }
/// <summary> /// /// </summary> /// public virtual void Init(IMLTrain train) { _train = train; _shouldStop = false; _ready = false; }
public virtual void Init(IMLTrain train) { this._xaca68f1d554d41ca = true; this._x6befdef5133de63a = DateTime.Now.Millisecond; }
/// <inheritdoc/> public void Init(IMLTrain theTrain) { _train = theTrain; _calc = (IMLError) _train.Method; _eOpt = Double.PositiveInfinity; _stripOpt = Double.PositiveInfinity; _stop = false; _lastCheck = 0; }
/// <summary> /// Train, using the specified training method, display progress to a dialog /// box. /// </summary> /// <param name="train">The training method to use.</param> /// <param name="network">The network to train.</param> /// <param name="trainingSet">The training set to use.</param> public static void TrainDialog(IMLTrain train, BasicNetwork network, IMLDataSet trainingSet) { var dialog = new TrainingDialog {Train = train}; dialog.ShowDialog(); }
/// <summary> /// Initialize this strategy. /// </summary> /// /// <param name="train_0">The training algorithm.</param> public void Init(IMLTrain train_0) { _train = train_0; _setter = (IMomentum) train_0; _ready = false; _setter.Momentum = 0.0d; _currentMomentum = 0; }
/// <inheritdoc/> public virtual void Init(IMLTrain train) { _started = true; _startedTime = DateTime.Now.Millisecond; }
/// <summary> /// /// </summary> /// public void ReportTraining(IMLTrain train) { Console.Out.WriteLine("Iteration #" + Format.FormatInteger(train.IterationNumber) + " Error:" + Format.FormatPercent(train.Error) + " elapsed time = " + Format.FormatTimeSpan((int) (_stopwatch.ElapsedMilliseconds/Format.MiliInSec))); }
/// <inheritdoc/> public virtual void Init(IMLTrain train) { _started = true; _startedTime = DateTime.Now.Ticks; }
/// <summary> /// Initialize this strategy. /// </summary> /// /// <param name="train">The training algorithm.</param> public virtual void Init(IMLTrain train) { _train = train; if (!(train.Method is IMLResettable)) { throw new TrainingError( "To use the reset strategy the machine learning method must support MLResettable."); } _method = (IMLResettable) _train.Method; }
/// <summary> /// Report training. /// </summary> /// /// <param name="train">The trainer.</param> public void ReportTraining(IMLTrain train) { foreach (IAnalystListener listener in _listeners) { listener.ReportTraining(train); } }
/// <summary> /// Train the network, using the specified training algorithm, and send the /// output to the console. /// </summary> /// <param name="train">The training method to use.</param> /// <param name="network">The network to train.</param> /// <param name="trainingSet">The training set.</param> /// <param name="minutes">The number of minutes to train for.</param> public static void TrainConsole(IMLTrain train, BasicNetwork network, IMLDataSet trainingSet, int minutes) { int epoch = 1; long remaining; Console.WriteLine(@"Beginning training..."); long start = Environment.TickCount; do { train.Iteration(); long current = Environment.TickCount; long elapsed = (current - start)/1000; remaining = minutes - elapsed/60; Console.WriteLine(@"Iteration #" + Format.FormatInteger(epoch) + @" Error:" + Format.FormatPercent(train.Error) + @" elapsed time = " + Format.FormatTimeSpan((int) elapsed) + @" time left = " + Format.FormatTimeSpan((int) remaining*60)); epoch++; } while (remaining > 0 && !train.TrainingDone); train.FinishTraining(); }
/// <summary> /// /// </summary> /// public virtual void Init(IMLTrain train_0) { _train = train_0; }
/// <summary> /// Initialize this strategy. /// </summary> /// /// <param name="train">The training algorithm.</param> public virtual void Init(IMLTrain train) { _mainTrain = train; }