public void ComputeSet(IMLDataSet setToCompute)
        {
            IOutput writer = MyCore.Resolve <IOutput>();

            foreach (IMLDataPair pair in setToCompute)
            {
                IMLData output = Network.Compute(pair.Input);
                if (!Regression)
                {
                    writer.Write(String.Format(@"{0},{1}, actual={2},ideal={3}", pair.Input[0], pair.Input[1], GetOutputFormat(output), GetClass(pair.Ideal)));
                }
                else
                {
                    writer.Write(String.Format(@"{0}, actual={1},ideal={2}", pair.Input[0], output, pair.Ideal));
                }
                AddToResults(pair, output);
            }
        }
        public void Run()
        {
            IOutput writer = MyCore.Resolve <IOutput>();

            if (csvPath == null)
            {
                writer.Write("Please load training set first!");
                return;
            }
            if (this.csvPathTest == null)
            {
                writer.Write("Please load test set first!");
                return;
            }

            InitializeDataAndNeurons();
            if (!UnipolarChecked)
            {
                Network.SetBiPolarActivation();
            }
            else
            {
                Network.SetSigmoidActivation();
            }
            Network.StartLearning(Iterations);
            LearningProcess = Network.learningProcess;
            DrawLearningRate();

            Network.ComputeSet(Network.TestSet);

            resultList = Network.resultList;
            if (!isRegression)
            {
                DrawGraph();
            }
            else
            {
                DrawRegressionFunction();
            }
        }
        public void StartLearning(int iterationCount)
        {
            this.resultList = new ResultsList();

            this.learningProcess = new List <IterationError>();

            this.Network.Structure.FinalizeStructure();
            Network.Reset();
            IOutput writer = MyCore.Resolve <IOutput>();

            Propagation train = new Backpropagation(this.Network, this.TrainingSet, this.LearningRate, this.TheMomentum);
            // train.BatchSize = 1;

            int epoch = 1;

            do
            {
                train.Iteration();
                writer.Write(String.Format(@"Epoch # {0} Error: {1}", epoch, train.Error));
                epoch++;
                this.learningProcess.Add(new IterationError(epoch, train.Error));
            } while (epoch < iterationCount);
        }