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>
 /// 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;
 }

        /// <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);
            }
        }

        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>
        /// 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 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 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>
        ///     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>
 /// 
 /// </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)));
 }

 /// <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;
 }

 /// <summary>
 /// 
 /// </summary>
 ///
 public virtual void Init(IMLTrain train)
 {
     _train = train;
     _shouldStop = false;
     _ready = false;
 }

 /// <inheritdoc/>
 public virtual void Init(IMLTrain train)
 {
     _started = true;
     _startedTime = DateTime.Now.Ticks;
 }

        /// <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>
        /// 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>
 /// 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();
 }