private static void Step3() { Console.WriteLine("Step 3: Normalize Training and Evaluation Data"); //Analyst var analyst = new EncogAnalyst(); //Wizard var wizard = new AnalystWizard(analyst); wizard.Wizard(Config.BaseFile, true, AnalystFileFormat.DecpntComma); //Norm for Training var norm = new AnalystNormalizeCSV(); norm.Analyze(Config.TrainingFile, true, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; norm.Normalize(Config.NormalizedTrainingFile); //Norm for evaluation norm.Analyze(Config.EvaluateFile, true, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; norm.Normalize(Config.NormalizedEvaluateFile); analyst.Save(Config.AnalystFile); }
/// <see cref="INetwork.Normalize"/> public INetwork Normalize() { //Analyst var analyst = new EncogAnalyst(); //Wizard var wizard = new AnalystWizard(analyst); wizard.Wizard(BaseFile, true, AnalystFileFormat.DecpntComma); // Configure normalized fields ConfigureNormalizedFields(analyst); //Norm for Trainng var norm = new AnalystNormalizeCSV(); norm.Analyze(TrainingFile, true, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; norm.Normalize(NormalizedTrainingFile); //Norm of evaluation norm.Analyze(EvaluateFile, true, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; norm.Normalize(NormalizedEvaluateFile); //Save the analyst file analyst.Save(AnalystFile); return(this); }
/// <summary> /// Program entry point. /// </summary> /// <param name="app">Holds arguments and other info.</param> public void Execute(IExampleInterface app) { Console.WriteLine("Running wizard..."); var analyst = new EncogAnalyst(); var wizard = new AnalystWizard(analyst); wizard.TargetFieldName = "field:1"; wizard.Wizard(sourceCSV, false, AnalystFileFormat.DecpntComma); // customer id analyst.Script.Normalize.NormalizedFields[0].Action = Encog.Util.Arrayutil.NormalizationAction.PassThrough; var norm = new AnalystNormalizeCSV(); norm.Report = new ConsoleStatusReportable(); Console.WriteLine("Analyze for normalize..."); norm.Analyze(sourceCSV, false, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; Console.WriteLine("Normalize..."); norm.Normalize(targetCSV); analyst.Save(scriptEGA); }
public static void NormalizeData() { var toNormalize = new FileInfo(csvPath); var Normalized = new FileInfo(csvPathNormalized); var analyst = new EncogAnalyst(); var wizard = new AnalystWizard(analyst); wizard.Wizard(toNormalize, true, AnalystFileFormat.DecpntComma); var norm = new AnalystNormalizeCSV(); norm.Analyze(toNormalize, true, CSVFormat.English, analyst); foreach (AnalystField field in analyst.Script.Normalize.NormalizedFields) { field.NormalizedHigh = 1; field.NormalizedLow = -1; field.Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; if (field.Name == "cls") { field.Action = Encog.Util.Arrayutil.NormalizationAction.PassThrough; } } norm.ProduceOutputHeaders = true; norm.Normalize(Normalized); }
public void Execute(IExampleInterface app) { if (app.Args.Length != 2) { Console.WriteLine(@"Note: This example assumes that headers are present in the CSV files."); Console.WriteLine(@"NormalizeFile [input file] [target file]"); } else { var sourceFile = new FileInfo(app.Args[0]); var targetFile = new FileInfo(app.Args[1]); var analyst = new EncogAnalyst(); var wizard = new AnalystWizard(analyst); wizard.Wizard(sourceFile, true, AnalystFileFormat.DecpntComma); DumpFieldInfo(analyst); var norm = new AnalystNormalizeCSV(); norm.Analyze(sourceFile, true, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; norm.Normalize(targetFile); EncogFramework.Instance.Shutdown(); } }
static void EncogAnalyst() { var sourceFile = new FileInfo("RawFile.csv"); var targetFile = new FileInfo("NormalizedFile.csv"); var analyst = new EncogAnalyst(); var wizard = new AnalystWizard(analyst); wizard.Wizard(sourceFile, true, AnalystFileFormat.DecpntComma); var norm = new AnalystNormalizeCSV(); norm.Analyze(sourceFile, true, CSVFormat.DecimalComma, analyst); norm.Normalize(targetFile); }
static void Step3() { Console.WriteLine("Step 3: Normalize Training and Evaluation Data"); //Analyst var analyst = new EncogAnalyst(); //Wizard var wizard = new AnalystWizard(analyst); wizard.Wizard(Config.BaseFile, true, AnalystFileFormat.DecpntComma); //Cylinders analyst.Script.Normalize.NormalizedFields[0].Action = Encog.Util.Arrayutil.NormalizationAction.Equilateral; // multivalued discreste field type //displacement analyst.Script.Normalize.NormalizedFields[1].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; // continues //HorsePower analyst.Script.Normalize.NormalizedFields[2].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //weight analyst.Script.Normalize.NormalizedFields[3].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //Acceleration analyst.Script.Normalize.NormalizedFields[4].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //year analyst.Script.Normalize.NormalizedFields[5].Action = Encog.Util.Arrayutil.NormalizationAction.Equilateral; // multivalued discreste field type //Origin analyst.Script.Normalize.NormalizedFields[6].Action = Encog.Util.Arrayutil.NormalizationAction.Equilateral; // multivalued discreste field type //Name analyst.Script.Normalize.NormalizedFields[7].Action = Encog.Util.Arrayutil.NormalizationAction.Ignore; // will not use //mpg analyst.Script.Normalize.NormalizedFields[8].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; // contniues //Norm for Trainng var norm = new AnalystNormalizeCSV(); norm.ProduceOutputHeaders = true; norm.Analyze(Config.TrainingFile, true, CSVFormat.English, analyst); norm.Normalize(Config.NormalizedTrainingFile); //Norm of evaluation norm.Analyze(Config.EvaluateFile, true, CSVFormat.English, analyst); norm.Normalize(Config.NormalizedEvaluateFile); //save the analyst file analyst.Save(Config.AnalystFile); }
/// <summary> /// Analyze the data. This counts the records and prepares the data to be /// processed. /// </summary> /// /// <param name="theAnalyst">The analyst to use.</param> /// <param name="inputFile">The input file to analyze.</param> /// <param name="headers">True, if the input file has headers.</param> /// <param name="format">The format of the input file.</param> public void Analyze(EncogAnalyst theAnalyst, FileInfo inputFile, bool headers, CSVFormat format) { InputFilename = inputFile; ExpectInputHeaders = headers; InputFormat = format; Analyzed = true; _analyst = theAnalyst; if (OutputFormat == null) { OutputFormat = InputFormat; } _data = new BasicMLDataSet(); ResetStatus(); int recordCount = 0; int outputLength = _analyst.DetermineTotalColumns(); var csv = new ReadCSV(InputFilename.ToString(), ExpectInputHeaders, InputFormat); ReadHeaders(csv); _analystHeaders = new CSVHeaders(InputHeadings); while (csv.Next() && !ShouldStop()) { UpdateStatus(true); var row = new LoadedRow(csv, 1); double[] inputArray = AnalystNormalizeCSV.ExtractFields( _analyst, _analystHeaders, csv, outputLength, true); var input = new ClusterRow(inputArray, row); _data.Add(input); recordCount++; } RecordCount = recordCount; Count = csv.ColumnCount; ReadHeaders(csv); csv.Close(); ReportDone(true); }
private void Normalize() { //Analyst var analyst = new EncogAnalyst(); //Wizard var wizard = new AnalystWizard(analyst); wizard.Wizard(Config.BaseFile, true, AnalystFileFormat.DecpntComma); //Cylinders analyst.Script.Normalize.NormalizedFields[0].Action = Encog.Util.Arrayutil.NormalizationAction.Equilateral; //displacement analyst.Script.Normalize.NormalizedFields[1].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //HorsePower analyst.Script.Normalize.NormalizedFields[2].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //weight analyst.Script.Normalize.NormalizedFields[3].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //Acceleration analyst.Script.Normalize.NormalizedFields[4].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //year analyst.Script.Normalize.NormalizedFields[5].Action = Encog.Util.Arrayutil.NormalizationAction.Equilateral; //Origin analyst.Script.Normalize.NormalizedFields[6].Action = Encog.Util.Arrayutil.NormalizationAction.Equilateral; //Name analyst.Script.Normalize.NormalizedFields[7].Action = Encog.Util.Arrayutil.NormalizationAction.Ignore; //mpg analyst.Script.Normalize.NormalizedFields[8].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //Norm for Trainng var norm = new AnalystNormalizeCSV(); norm.ProduceOutputHeaders = true; norm.Analyze(Config.TrainingFile, true, CSVFormat.English, analyst); norm.Normalize(Config.NormalizedTrainingFile); //Norm of Cross Validation norm.Analyze(Config.CrossValidationFile, true, CSVFormat.English, analyst); norm.Normalize(Config.NormalizedCrossValidationFile); //Norm of evaluation norm.Analyze(Config.EvaluateFile, true, CSVFormat.English, analyst); norm.Normalize(Config.NormalizedEvaluateFile); //save the analyst file analyst.Save(Config.AnalystFile); }
public void Normalize(FileInfo baseFile, FileInfo trainingFile, FileInfo normalizedTrainingFile, FileInfo evaluateFile, FileInfo normalizedEvaluateFile, FileInfo analystFile) { var encogAnalyst = new EncogAnalyst(); var analystWizard = new AnalystWizard(encogAnalyst); analystWizard.Wizard(baseFile, true, AnalystFileFormat.DecpntComma); var normalizer = new AnalystNormalizeCSV(); normalizer.Analyze(trainingFile, true, CSVFormat.English, encogAnalyst); normalizer.ProduceOutputHeaders = true; normalizer.Normalize(normalizedTrainingFile); normalizer.Analyze(evaluateFile, true, CSVFormat.English, encogAnalyst); normalizer.Normalize(normalizedEvaluateFile); encogAnalyst.Save(analystFile); }
/// <summary> /// Metodo responsavel por normalizar as informacoes para adequar a execucao da rede neural /// </summary> private static void Normalization() { var analyst = new EncogAnalyst(); var wizard = new AnalystWizard(analyst); wizard.Wizard(Config.ClassificationFile, true, AnalystFileFormat.DecpntComma); var norm = new AnalystNormalizeCSV(); norm.Analyze(Config.TrainingClassificationFile, true, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; norm.Normalize(Config.NormalizedTrainingClassificationFile); norm.Analyze(Config.EvaluateClassificationFile, true, CSVFormat.English, analyst); norm.Normalize(Config.NormalizedEvaluateClassificationFile); analyst.Save(Config.AnalystClassificationFile); }
/// <summary> /// Metodo responsavel por normalizar as informacoes para adequar a execucao da rede neural /// </summary> private static void Normalization() { var analyst = new EncogAnalyst(); //Wizard var wizard = new AnalystWizard(analyst); wizard.Wizard(Config.RegressionFile, true, AnalystFileFormat.DecpntComma); //Cilindros analyst.Script.Normalize.NormalizedFields[0].Action = Encog.Util.Arrayutil.NormalizationAction.Equilateral; //displacement analyst.Script.Normalize.NormalizedFields[1].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //HorsePower analyst.Script.Normalize.NormalizedFields[2].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //Peso analyst.Script.Normalize.NormalizedFields[3].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //Aceleração analyst.Script.Normalize.NormalizedFields[4].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; //Ano analyst.Script.Normalize.NormalizedFields[5].Action = Encog.Util.Arrayutil.NormalizationAction.Equilateral; //Origem analyst.Script.Normalize.NormalizedFields[6].Action = Encog.Util.Arrayutil.NormalizationAction.Equilateral; //Nome analyst.Script.Normalize.NormalizedFields[7].Action = Encog.Util.Arrayutil.NormalizationAction.Ignore; //MPG analyst.Script.Normalize.NormalizedFields[8].Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; var norm = new AnalystNormalizeCSV(); norm.ProduceOutputHeaders = true; norm.Analyze(Config.TrainingRegressionFile, true, CSVFormat.English, analyst); norm.Normalize(Config.NormalizedTrainingRegressionFile); //Norm of evaluation norm.Analyze(Config.EvaluateRegressionFile, true, CSVFormat.English, analyst); norm.Normalize(Config.NormalizedEvaluateRegressionFile); //save the analyst file analyst.Save(Config.AnalystRegressionFile); }
public void NormalizeData(string normalPath, string normalizedPath) { var toNormalizeTraining = new FileInfo(normalPath); var NormalizedTest = new FileInfo(normalizedPath); var analyst = new EncogAnalyst(); var wizard = new AnalystWizard(analyst); if (isRegression) { wizard.TargetFieldName = "y"; } else { wizard.TargetFieldName = "cls"; } //toNormalize. wizard.Wizard(toNormalizeTraining, true, AnalystFileFormat.DecpntComma); var norm = new AnalystNormalizeCSV(); norm.Analyze(toNormalizeTraining, true, CSVFormat.English, analyst); foreach (AnalystField field in analyst.Script.Normalize.NormalizedFields) { field.NormalizedHigh = 1; field.NormalizedLow = 0; field.Action = Encog.Util.Arrayutil.NormalizationAction.Normalize; if (field.Name == "cls") { field.Action = Encog.Util.Arrayutil.NormalizationAction.PassThrough; } } norm.ProduceOutputHeaders = true; norm.Normalize(NormalizedTest); }
/// <inheritdoc/> public override sealed bool ExecuteCommand(String args) { // get filenames String sourceID = Prop.GetPropertyString( ScriptProperties.NormalizeConfigSourceFile); String targetID = Prop.GetPropertyString( ScriptProperties.NormalizeConfigTargetFile); FileInfo sourceFile = Script.ResolveFilename(sourceID); FileInfo targetFile = Script.ResolveFilename(targetID); EncogLogging.Log(EncogLogging.LevelDebug, "Beginning normalize"); EncogLogging.Log(EncogLogging.LevelDebug, "source file:" + sourceID); EncogLogging.Log(EncogLogging.LevelDebug, "target file:" + targetID); // mark generated Script.MarkGenerated(targetID); // get formats CSVFormat inputFormat = Script .DetermineInputFormat(sourceID); CSVFormat outputFormat = Script.DetermineOutputFormat(); // prepare to normalize var norm = new AnalystNormalizeCSV { Script = Script }; Analyst.CurrentQuantTask = norm; norm.Report = new AnalystReportBridge(Analyst); bool headers = Script.ExpectInputHeaders(sourceID); norm.Analyze(sourceFile, headers, inputFormat, Analyst); norm.OutputFormat = outputFormat; norm.ProduceOutputHeaders = true; norm.Normalize(targetFile); Analyst.CurrentQuantTask = null; return(norm.ShouldStop()); }
private void Normalize(FileInfo BaseFile, FileInfo TrainingFile, FileInfo NormalizedTrainingFile, FileInfo EvaluateFile, FileInfo NormalizedEvaluateFile, FileInfo AnalystFile) { //Analyst var analyst = new EncogAnalyst(); //Wizard var wizard = new AnalystWizard(analyst); wizard.Wizard(BaseFile, true, AnalystFileFormat.DecpntComma); //Norm for Trainng var norm = new AnalystNormalizeCSV(); norm.Analyze(TrainingFile, true, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; norm.Normalize(NormalizedTrainingFile); //Norm of evaluation norm.Analyze(EvaluateFile, true, CSVFormat.English, analyst); norm.Normalize(NormalizedEvaluateFile); //save the analyst file analyst.Save(AnalystFile); }
public void Normalize(FileInfo baseFile, FileInfo trainingFile, FileInfo normalizedTrainingFile, FileInfo evaluateFile, FileInfo normalizedEvaluateFile, FileInfo analystFile) { var encogAnalyst = new EncogAnalyst(); var analystWizard = new AnalystWizard(encogAnalyst); analystWizard.Wizard(baseFile, true, AnalystFileFormat.DecpntComma); //Cylinders: encogAnalyst.Script.Normalize.NormalizedFields[0].Action = NormalizationAction.Equilateral; //Displacement: encogAnalyst.Script.Normalize.NormalizedFields[1].Action = NormalizationAction.Normalize; //Horsepower: encogAnalyst.Script.Normalize.NormalizedFields[2].Action = NormalizationAction.Normalize; //Weight: encogAnalyst.Script.Normalize.NormalizedFields[3].Action = NormalizationAction.Normalize; //Acceleration: encogAnalyst.Script.Normalize.NormalizedFields[4].Action = NormalizationAction.Normalize; //Year: encogAnalyst.Script.Normalize.NormalizedFields[5].Action = NormalizationAction.Equilateral; //Origin: encogAnalyst.Script.Normalize.NormalizedFields[6].Action = NormalizationAction.Equilateral; //Name: encogAnalyst.Script.Normalize.NormalizedFields[7].Action = NormalizationAction.Ignore; //Mpg: encogAnalyst.Script.Normalize.NormalizedFields[8].Action = NormalizationAction.Normalize; var normalizer = new AnalystNormalizeCSV(); normalizer.Analyze(trainingFile, true, CSVFormat.English, encogAnalyst); normalizer.ProduceOutputHeaders = true; normalizer.Normalize(normalizedTrainingFile); normalizer.Analyze(evaluateFile, true, CSVFormat.English, encogAnalyst); normalizer.Normalize(normalizedEvaluateFile); encogAnalyst.Save(analystFile); }
/// <summary> /// Process the file. /// </summary> /// /// <param name="outputFile">The output file.</param> /// <param name="method">THe method to use.</param> public void Process(FileInfo outputFile, IMLMethod method) { var csv = new ReadCSV(InputFilename.ToString(), ExpectInputHeaders, Format); IMLData output; foreach (AnalystField field in _analyst.Script.Normalize.NormalizedFields) { field.Init(); } int outputLength = _analyst.DetermineTotalInputFieldCount(); StreamWriter tw = PrepareOutputFile(outputFile); ResetStatus(); while (csv.Next()) { UpdateStatus(false); var row = new LoadedRow(csv, _outputColumns); double[] inputArray = AnalystNormalizeCSV.ExtractFields(_analyst, _analystHeaders, csv, outputLength, true); if (_series.TotalDepth > 1) { inputArray = _series.Process(inputArray); } if (inputArray != null) { IMLData input = new BasicMLData(inputArray); // evaluation data if ((method is IMLClassification) && !(method is IMLRegression)) { // classification only? var tmp = new BasicMLData(1); tmp[0] = ((IMLClassification)method).Classify(input); output = tmp; } else { // regression output = ((IMLRegression)method).Compute(input); } // skip file data int index = _fileColumns; int outputIndex = 0; // display output foreach (AnalystField field in _analyst.Script.Normalize.NormalizedFields) { if (_analystHeaders.Find(field.Name) != -1) { if (field.Output) { if (field.Classify) { // classification ClassItem cls = field.DetermineClass( outputIndex, output); outputIndex += field.ColumnsNeeded; if (cls == null) { row.Data[index++] = "?Unknown?"; } else { row.Data[index++] = cls.Name; } } else { // regression double n = output[outputIndex++]; n = field.DeNormalize(n); row.Data[index++] = Format .Format(n, Precision); } } } } } WriteRow(tw, row); } ReportDone(false); tw.Close(); csv.Close(); }
/// <summary> Predict network outputs. </summary> private void NetworkBtn_Click(object sender, EventArgs e) { if (networkSaveDataList.Count == 0) { MessageBox.Show("You must select a network file first. If you do not have one you can create one in the network creater window", "No Network File Error"); return; } notIncluded.Clear(); //Setup network. NeuralNetwork network; //Switch to set network type based on type stored in json file. switch (networkSaveDataList[selectedNetwork].NetworkType) { case "EncogNeuralNetwork": { network = new EncogNeuralNetwork(); break; } case "EncogDeepNeuralNetwork": { network = new EncogDeepNeuralNetwork(); break; } case "AccordNeuralNetwork": { network = new AccordNeuralNetwork(); break; } default: { network = new AccordDeepNeuralNetwork(); break; } } //Initialize variables info = new Data(); string dataFile = networkSaveDataList[selectedNetwork].CsvFile; string path = networkSaveDataList[selectedNetwork].Path; double[][] answers; if (!Directory.Exists(path + "normal")) { MessageBox.Show("You have no \"normal\" folder, please ensure that you are selecting the same csv as the one used in network creation. It may also be the case that you have moved the working directory of the csv file without also moving its dependant folders.", "File Access Error"); return; } if (!Directory.Exists(path + "networks")) { MessageBox.Show("You have no \"networks\" folder, please ensure that you have created at least one network. It may also be the case that you have moved the working directory of the csv file without also moving its dependant folders.", "File Access Error"); return; } //Load analyst from earlier. analyst = new EncogAnalyst(); analyst.Load(new FileInfo(path + @"normal\normalizationData" + dataFile.Replace(".csv", ".ega"))); FileInfo sourcefile = new FileInfo(path + dataFile); AnalystNormalizeCSV norm = new AnalystNormalizeCSV(); //norm.InputHeadings = networkSaveDataList[selectedNetwork].Headings.ToArray(); network.Load(networkSaveDataList[selectedNetwork].NetworkFile); List <bool> vb = new List <bool>(); foreach (string heading in networkSaveDataList[selectedNetwork].InputHeadings) { vb.Add(false); } notIncluded.Add(vb); if (!csvBox.Checked) { string outString = ""; for (int i = 0; i < items[selectedNetwork].Count; i++) { notIncluded[0][i] = string.IsNullOrWhiteSpace(items[selectedNetwork][i]); outString += items[selectedNetwork][i] + ","; } outString += ","; outString.Remove(outString.Length - 1); if (File.Exists(path + dataFile.Replace(".csv", "Temp.csv"))) { File.Delete(path + dataFile.Replace(".csv", "Temp.csv")); } using (var sw = new StreamWriter(path + dataFile.Replace(".csv", "Temp.csv"), true)) { for (int i = 0; i < networkSaveDataList[selectedNetwork].InputHeadings.Count; i++) { sw.Write(networkSaveDataList[selectedNetwork].InputHeadings[i] + ","); } for (int i = 0; i < networkSaveDataList[selectedNetwork].OutputHeadings.Count; i++) { if (i != networkSaveDataList[selectedNetwork].OutputHeadings.Count - 1) { sw.Write(networkSaveDataList[selectedNetwork].OutputHeadings[i] + ","); } else { sw.Write(networkSaveDataList[selectedNetwork].OutputHeadings[i]); } } sw.WriteLine(); sw.WriteLine(outString); } var inputFile = new FileInfo(path + dataFile.Replace(".csv", "Temp.csv")); var inputFileNorm = new FileInfo(path + @"normal\" + dataFile.Replace(".csv", "TempNormal.csv")); norm.Analyze(inputFile, true, CSVFormat.English, analyst); try { norm.Normalize(inputFileNorm); } catch (Exception ex) { MessageBox.Show(ex.Message + "\n\nThe inputs you have entered do not correctly follow the current normalisation data. This may because you " + "have entered values above or below the currently stored highs and lows for numbers. It is also possible you have " + "entered a textual word that has not been used before. Finally it is possible that you are have not used the correct " + "case for a word as they are case sensitive.", "Normalisation Failure"); return; } info = info.ReturnInfo(path + @"normal\" + dataFile.Replace(".csv", "TempNormal.csv"), networkSaveDataList[selectedNetwork].OutputHeadings, 0, true); answers = Data.CreateArray <double>(1, info.OutputNumber); } else { //Reset paths. path = null; dataFile = null; //Get csv path. openFileDialog1.Filter = "csv files (*.csv)|*.csv"; DialogResult dialogResult = openFileDialog1.ShowDialog(); //Exit function if file selection was cancelled. if (dialogResult == DialogResult.Cancel) { output.Text += "Cancelling File Selection. . .\n"; return; } //Check the file is .csv format. if (!openFileDialog1.SafeFileName.EndsWith(".csv")) { MessageBox.Show("The file you have selected is not in the correct format (.csv)", "File Access Error"); return; } //Setup paths from file. dataFile = openFileDialog1.SafeFileName; path = openFileDialog1.FileName.Replace(openFileDialog1.SafeFileName, ""); var sourceFile = new FileInfo(openFileDialog1.FileName); var normalFile = new FileInfo(openFileDialog1.FileName.Replace(openFileDialog1.SafeFileName, @"normal\" + openFileDialog1.SafeFileName.Replace(".csv", "Normal.csv"))); output.Text += "Loading File: " + dataFile + ". . .\n"; Data.Normalise(sourceFile, normalFile, path, dataFile, networkSaveDataList[selectedNetwork].OutputHeadings.Count, false); norm.Analyze(sourceFile, true, CSVFormat.English, analyst); try { norm.Normalize(normalFile); } catch (Exception ex) { MessageBox.Show(ex.Message + "\n\nThe inputs you have entered do not correctly follow the current normalisation data. This may because you " + "have entered values above or below the currently stored highs and lows for numbers. It is also possible you have " + "entered a textual word that has not been used before. Finally it is possible that you are have not used the correct" + "case for a word as they are case sensitive.", "Normalisation Failure"); return; } info = info.ReturnInfo(path + @"normal\" + dataFile.Replace(".csv", "Normal.csv"), networkSaveDataList[selectedNetwork].OutputHeadings, 0, true); answers = Data.CreateArray <double>(info.InputData.Length, networkSaveDataList[selectedNetwork].OutputHeadings.Count); //Get length of CSV, Inputs and Outputs. using (var reader = new StreamReader(openFileDialog1.FileName)) { reader.ReadLine(); int lineNo = 0; while (!reader.EndOfStream) { var line = reader.ReadLine(); var values = line.Split(','); if (lineNo > 0) { notIncluded.Add(new List <bool>(vb)); } for (int i = 0; i < notIncluded[0].Count; i++) { notIncluded[lineNo][i] = string.IsNullOrWhiteSpace(values[i]); } lineNo++; } } } //Compute network predictions. for (int i = 0; i < answers.Length; i++) { //Switch to set network type based on type stored in json file. switch (networkSaveDataList[selectedNetwork].NetworkType) { case "AccordNeuralNetwork": { answers[i] = network.AccordNetwork.Compute(info.InputData[i]); break; } case "AccordDeepNeuralNetwork": { answers[i] = network.DeepAccordNetwork.Compute(info.InputData[i]); break; } default: { network.EncogNetwork.Compute(info.InputData[i], answers[i]); break; } } } info.Prediction = answers; //Output answers to text box. output.Text += network.Display(answers, analyst, networkSaveDataList[selectedNetwork].OutputHeadings, path + @"normal\" + dataFile.Replace(".csv", "Normal.csv")); }
/// <summary> /// Create normalised traning, testing files with encoh analist file /// </summary> /// <param name="baseFile"></param> /// <param name="trainingFile"></param> /// <param name="testingFile"></param> /// <param name="normalisedTrainingFile"></param> /// <param name="normalisedTestingFile"></param> /// <param name="analystFile"></param> public void Normalise(FileInfo baseFile, FileInfo trainingFile, FileInfo testingFile, FileInfo normalisedTrainingFile, FileInfo normalisedTestingFile, FileInfo analystFile) { try { //Analyst var analyst = new EncogAnalyst(); //Wizard var wizard = new AnalystWizard(analyst); wizard.Wizard(baseFile, true, AnalystFileFormat.DecpntComma); // inputs // 1 - fixed acidity analyst.Script.Normalize.NormalizedFields[0].Action = NormalizationAction.Normalize; // contniues // 2 - volatile acidity analyst.Script.Normalize.NormalizedFields[1].Action = NormalizationAction.Normalize; // contniues // 3 - citric acid analyst.Script.Normalize.NormalizedFields[2].Action = NormalizationAction.Normalize; // contniues // 4 - residual sugar analyst.Script.Normalize.NormalizedFields[3].Action = NormalizationAction.Normalize; // contniues // 5 - chlorides analyst.Script.Normalize.NormalizedFields[4].Action = NormalizationAction.Normalize; // contniues // 6 - free sulfur dioxide analyst.Script.Normalize.NormalizedFields[5].Action = NormalizationAction.Normalize; // discrete // 7 - total sulfur dioxide analyst.Script.Normalize.NormalizedFields[6].Action = NormalizationAction.Normalize; // discrete // 8 - density analyst.Script.Normalize.NormalizedFields[7].Action = NormalizationAction.Normalize; // contniues // 9 - pH analyst.Script.Normalize.NormalizedFields[8].Action = NormalizationAction.Normalize; // contniues // 10 - sulphates analyst.Script.Normalize.NormalizedFields[9].Action = NormalizationAction.Normalize; // contniues // 11 - alcohol analyst.Script.Normalize.NormalizedFields[10].Action = NormalizationAction.Normalize; // contniues // output // 12 - quality analyst.Script.Normalize.NormalizedFields[11].Action = NormalizationAction.Equilateral; // discrete //Norm for Trainng var norm = new AnalystNormalizeCSV { ProduceOutputHeaders = true }; norm.Analyze(trainingFile, true, CSVFormat.English, analyst); norm.Normalize(normalisedTrainingFile); //Norm of evaluation norm.Analyze(Config.TestingFile, true, CSVFormat.English, analyst); norm.Normalize(normalisedTestingFile); //save the analyst file analyst.Save(analystFile); } catch (Exception e) { Console.WriteLine(e); throw; } }
/// <summary> need comments </summary> public static List <string> Normalise(FileInfo sourceFile, FileInfo normalFile, string path, string dataFile, int outputs, bool inputs) { List <string> titles = new List <string>(); //Setup analyst with orignal csv. var analyst = new EncogAnalyst(); var wizard = new AnalystWizard(analyst); //Additional validation to check that the file is not empty. try { wizard.Wizard(sourceFile, true, AnalystFileFormat.DecpntComma); } catch (Exception) { MessageBox.Show("The file you have selected is empty.", "File Access Error"); return(null); } if (analyst.Script.Fields.Length - 1 < outputs) { MessageBox.Show("You have specified " + outputs + " outputs but there are only " + analyst.Script.Fields.Length + " headings in the file.", "Too Many Outputs Error"); return(null); } //Setup max and min range for normalization. foreach (AnalystField field in analyst.Script.Normalize.NormalizedFields) { field.NormalizedHigh = 1; field.NormalizedLow = -1; //field.Action = Encog.Util.Arrayutil.NormalizationAction.OneOf; //Use this to change normalizaiton type. } analyst.Script.Normalize.MissingValues = new NegateMissing(); //Normalization. var norm = new AnalystNormalizeCSV(); norm.Analyze(sourceFile, true, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; try { norm.Normalize(normalFile); } catch (Exception ex) { MessageBox.Show(ex.Message + "\n\nUnknown application failure, please report this bug with a screenshot of" + " the message to the relevant engineer.", "Normalisation Failure"); return(null); } if (!inputs) { for (int i = outputs; i + analyst.Script.Fields.Length > analyst.Script.Fields.Length; i--) { titles.Add(analyst.Script.Fields[analyst.Script.Fields.Length - i].Name); } } else { for (int i = 0; i < analyst.Script.Fields.Length - outputs; i++) { titles.Add(analyst.Script.Fields[i].Name); } } //Save configuration to be used later. analyst.Save(new FileInfo(path + @"\normal\" + "normalizationData" + dataFile.Replace(".csv", ".ega"))); return(titles); }
/// <summary> Button to save current network settings </summary> private void NetworkSaveBtn_Click(object sender, EventArgs e) { //Setup paths and lists. string dataFile = ""; string path = ""; //Normalise file. List <string> outputTitles = GetFile(false, ref path, ref dataFile, (int)(outputsUpDown.Value)); List <string> inputTitles = new List <string>(); if (outputTitles == null) { return; } if (nameTxt.Text?.Length == 0) { MessageBox.Show("You must give your network a name.", "No Network Name."); return; } char[] dirty = Path.GetInvalidFileNameChars(); foreach (char c in dirty) { if (nameTxt.Text.Contains(c.ToString())) { MessageBox.Show("Your name contains invalid characters. Error at character " + c, "Invalid Network Name."); return; } } //False when percentage split, true when cross validation. const bool validation = true; //Setup dataset. Data info = new Data(); info = info.ReturnInfo(path + @"normal\" + dataFile.Replace(".csv", "Normal.csv"), outputTitles, 0, validation); //Load analyst from earlier. var analyst = new EncogAnalyst(); analyst.Load(new FileInfo(path + @"normal\" + "normalizationData" + dataFile.Replace(".csv", "") + ".ega")); var sourcefile = new FileInfo(path + dataFile); var norm = new AnalystNormalizeCSV(); norm.Analyze(sourcefile, true, CSVFormat.English, analyst); //Store input headings from analyst. for (int i = 0; i < analyst.Script.Fields.Length - outputTitles.Count; i++) { inputTitles.Add(analyst.Script.Fields[i].Name); } //Setup network. NeuralNetwork network; //If to decide which network type to use. if (radBtnEncog.Checked) { if (!deepNetworkBox.Checked) { output.Text += "\n@Encog:\n\n"; network = new EncogNeuralNetwork(); } else { output.Text += "\n@Deep Encog:\n\n"; network = new EncogDeepNeuralNetwork(); } } else { if (!deepNetworkBox.Checked) { output.Text += "\n@Accord:\n\n"; network = new AccordNeuralNetwork(); } else { output.Text += "\n@Deep Accord:\n\n"; network = new AccordDeepNeuralNetwork(); } } //Create network. network.Create(info.InputNumber, layersBar.Value, neuronsBar.Value, info.OutputNumber); //Save network to file. if (!Directory.Exists(path + "networks")) { Directory.CreateDirectory(path + "networks"); } //network.Save(path + @"networks\" + nameTxt.Text); if ((path + @"networks\" + nameTxt.Text)?.Length < 260) { network.Save(path + @"networks\" + nameTxt.Text); } else { MessageBox.Show("Your file name or total file path is too long for the windows limit of 260.", "Invalid Network Name Size."); return; } //Save network data to object. NetworkSaveData networkSave = new NetworkSaveData { NetworkFile = path + @"networks\" + nameTxt.Text, NetworkType = network.GetType().ToString().Replace("ENP1.", ""), //"ENP1" must change to reflect solution name (name.) if ever changed. AnalystFile = path + @"normal\" + "normalizationData.ega", CsvFile = dataFile, Path = path, InputHeadings = inputTitles, OutputHeadings = outputTitles, Name = nameTxt.Text, //Train network. Inaccuracy = Math.Round(network.Train(info, (float)(learningRateBar.Value) / 10, (float)(momentumBar.Value) / 10), 5).ToString() }; //Write network object to json file. using (var sw = new StreamWriter(path + @"networks\networks.json", true)) { using (var jsw = new JsonTextWriter(sw)) { //jsw.Formatting = Formatting.Indented; JsonSerializer serial = new JsonSerializer(); serial.Serialize(jsw, networkSave); sw.WriteLine(); } } output.Text += "Successfully saved network " + nameTxt.Text + " with a training inaccuracy of: " + networkSave.Inaccuracy; }
/// <summary> Button to test network settings. </summary> private void NetworkBtn_Click(object sender, EventArgs e) { //Setup paths and lists. string dataFile = ""; string path = ""; //Normalise file. List <string> outputTitles = GetFile(false, ref path, ref dataFile, (int)(outputsUpDown.Value)); if (outputTitles == null) { return; } //False when percentage split, true when cross validation. bool validation = !radBtnSplit.Checked; //Setup training dataset. Data info = new Data(); info = info.ReturnInfo(path + @"normal\" + dataFile.Replace(".csv", "Normal.csv"), outputTitles, sampleBar.Value, validation); if (info == null) { return; } //Load analyst from earlier. var analyst = new EncogAnalyst(); analyst.Load(new FileInfo(path + @"normal\" + "normalizationData" + dataFile.Replace(".csv", "") + ".ega")); var sourcefile = new FileInfo(path + dataFile); var norm = new AnalystNormalizeCSV(); norm.Analyze(sourcefile, true, CSVFormat.English, analyst); //Setup network. NeuralNetwork network; //If to decide which network type to use. if (radBtnEncog.Checked) { if (!deepNetworkBox.Checked) { output.Text += "\n@Encog:\n\n"; network = new EncogNeuralNetwork(); } else { output.Text += "\n@Deep Encog:\n\n"; network = new EncogDeepNeuralNetwork(); } } else { if (!deepNetworkBox.Checked) { output.Text += "\n@Accord:\n\n"; network = new AccordNeuralNetwork(); } else { output.Text += "\n@Deep Accord:\n\n"; network = new AccordDeepNeuralNetwork(); } } //If using cross-validation. if (validation) { //Setup pool size. decimal tmpPoolSize = info.InputData.Length * decimal.Divide(sampleBar.Value, 100); int poolSize = (int)tmpPoolSize; double[][] arrayIn = info.InputData; double[][] arrayOut = info.OutputData; info.InputData = Data.CreateArray <double>(poolSize, info.InputData[0].Length); info.OutputData = Data.CreateArray <double>(poolSize, info.OutputData[0].Length); //Random to randomise pool selection. Random rnd = new Random(); int[] index = new int[poolSize]; //Radomly allocate items for training pool. for (int j = 0; j < info.InputData.Length; j++) { index[j] = rnd.Next(0, arrayIn.Length); info.InputData[j] = arrayIn[index[j]]; info.OutputData[j] = arrayOut[index[j]]; } //Remove pooled items from array. arrayIn = Data.RemoveFromArray(arrayIn, index, poolSize); arrayOut = Data.RemoveFromArray(arrayOut, index, poolSize); //Start allocating sample pools. for (int i = 0; i <= arrayIn.Length / poolSize; i++) { info.InputDataSample = Data.CreateArray <double>(poolSize, arrayIn[0].Length); info.OutputDataSample = Data.CreateArray <double>(poolSize, arrayOut[0].Length); //Radomly allocate items for [i] sample pool. for (int j = 0; j < info.InputDataSample.Length; j++) { index[j] = rnd.Next(0, arrayIn.Length); info.InputDataSample[j] = arrayIn[index[j]]; info.OutputDataSample[j] = arrayOut[index[j]]; } arrayIn = Data.RemoveFromArray(arrayIn, index, poolSize); arrayOut = Data.RemoveFromArray(arrayOut, index, poolSize); //Create network. network.Create(info.InputNumber, layersBar.Value, neuronsBar.Value, info.OutputNumber); output.Text += "Training complete with an inaccuracy of: " + Math.Round(network.Train(info, (float)(learningRateBar.Value) / 10, (float)(momentumBar.Value) / 10), 10) + "\n\n"; double[][] answers = Data.CreateArray <double>(poolSize, info.InputData[0].Length); //Compute outputs. for (int j = 0; j < answers.Length; j++) { if (radBtnAccord.Checked) { if (!deepNetworkBox.Checked) { answers[j] = network.AccordNetwork.Compute(info.InputDataSample[j]); } else if (deepNetworkBox.Checked) { answers[j] = network.DeepAccordNetwork.Compute(info.InputDataSample[j]); } } else { network.EncogNetwork.Compute(info.InputDataSample[j], answers[j]); } } //Display network. output.Text += network.Display(answers, analyst, info, outputTitles, path + @"normal\" + dataFile.Replace(".csv", "Normal.csv")); } } //Else percentage split. else { //Create network. network.Create(info.InputNumber, layersBar.Value, neuronsBar.Value, info.OutputNumber); output.Text += "Training complete with an inaccuracy of: " + Math.Round(network.Train(info, (float)(learningRateBar.Value) / 10, (float)(momentumBar.Value) / 10), 5) + "\n\n"; double[][] answers = Data.CreateArray <double>(info.InputDataSample.Length, info.InputDataSample[0].Length); //Compute outputs. for (int i = 0; i < answers.Length; i++) { if (radBtnAccord.Checked) { if (!deepNetworkBox.Checked) { answers[i] = network.AccordNetwork.Compute(info.InputDataSample[i]); } else if (deepNetworkBox.Checked) { answers[i] = network.DeepAccordNetwork.Compute(info.InputDataSample[i]); } } else { network.EncogNetwork.Compute(info.InputDataSample[i], answers[i]); } } //Display network. output.Text += network.Display(answers, analyst, info, outputTitles, path + @"normal\" + dataFile.Replace(".csv", "Normal.csv")); } }
public static int epoch; // to be provided by user private static void Main(string[] args) { Console.WriteLine("Press 1 for selecting Regresssion and 2 for classification"); int whatToperform = int.Parse(Console.ReadLine()); Console.WriteLine("Please provide number of layers assuming first layer is input layer and last is output layer"); int numberOfLayers = int.Parse(Console.ReadLine()); var network = new BasicNetwork(); for (int i = 1; i <= numberOfLayers; i++) { Console.WriteLine("Please select the activation function for layer- {0}", i); // Activtion function Input Console.WriteLine("Press 1 for ActivationBiPolar "); Console.WriteLine("Press 2 for ActivationCompetitive "); Console.WriteLine("Press 3 for ActivationLinear "); Console.WriteLine("Press 4 for ActivationLog "); Console.WriteLine("Press 5 for ActivationSigmoid "); Console.WriteLine("Press 6 for ActivationSoftMax "); Console.WriteLine("Press 7 for ActivationTanh "); Console.WriteLine("Press 8 for default "); int whichActivation = int.Parse(Console.ReadLine()); Console.WriteLine("Please the bias for this layer : 1 for True and 0 for false "); // Bias input int whichBias = int.Parse(Console.ReadLine()); Console.WriteLine("Please the enter the neuron count for this layer"); // Neuron count input int countNeuron = int.Parse(Console.ReadLine()); switch (whichActivation) // building the network { case 1: network.AddLayer(new BasicLayer(new ActivationBiPolar(), Convert.ToBoolean(whichBias), countNeuron)); break; case 2: network.AddLayer(new BasicLayer(new ActivationCompetitive(), Convert.ToBoolean(whichBias), countNeuron)); break; case 3: network.AddLayer(new BasicLayer(new ActivationLinear(), Convert.ToBoolean(whichBias), countNeuron)); break; case 4: network.AddLayer(new BasicLayer(new ActivationLOG(), Convert.ToBoolean(whichBias), countNeuron)); break; case 5: network.AddLayer(new BasicLayer(new ActivationSigmoid(), Convert.ToBoolean(whichBias), countNeuron)); break; case 6: network.AddLayer(new BasicLayer(new ActivationSoftMax(), Convert.ToBoolean(whichBias), countNeuron)); break; case 7: network.AddLayer(new BasicLayer(new ActivationTANH(), Convert.ToBoolean(whichBias), countNeuron)); break; case 8: network.AddLayer(new BasicLayer(null, Convert.ToBoolean(whichBias), countNeuron)); break; default: Console.WriteLine("Wrong data entered - Application will stop "); break; } } network.Structure.FinalizeStructure(); //complete the newtork settings network.Reset(); Console.WriteLine("Please enter the learning rate "); // learning rate input learningRate = double.Parse(Console.ReadLine()); Console.WriteLine("Please enter the momentum value"); // Momentum input UMomentum = double.Parse(Console.ReadLine()); Console.WriteLine("Please the enter the number of epochs "); // epoch input epoch = int.Parse(Console.ReadLine()); // For Regression we do this piece of code if (whatToperform == 1) { var sourceFile = new FileInfo(@"C:\Users\smandia\Desktop\Attachments_20161015\regression_train.csv"); //fetch training file var targetFile = new FileInfo(@"C:\Users\smandia\Desktop\Attachments_20161015\Attachments_20161029\Result\khicharNormClassificationTrainData.csv"); //save train normalized file var sourceFileTest = new FileInfo(@"C:\Users\smandia\Desktop\Attachments_20161015\regression_train.csv"); //fetch testing file var targetFileTest = new FileInfo(@"C:\Users\smandia\Desktop\Attachments_20161015\Attachments_20161029\Result\khicharNormClassificationTestData.csv"); //Save test normalized file //Analyst var analyst = new EncogAnalyst(); //Wizard var wizard = new AnalystWizard(analyst); wizard.TargetFieldName = "y"; //set the output variable for regression . it is not necessary when using mutliple attributes wizard.Wizard(sourceFile, true, AnalystFileFormat.DecpntComma); //norm for Training var norm = new AnalystNormalizeCSV(); norm.Analyze(sourceFile, true, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; norm.Normalize(targetFile); //norm for testing norm.Analyze(sourceFileTest, true, CSVFormat.English, analyst); norm.Normalize(targetFileTest); analyst.Save(new FileInfo("stt.ega")); var trainingset1 = EncogUtility.LoadCSV2Memory(targetFile.ToString(), network.InputCount, network.OutputCount, true, CSVFormat.English, false); var train = new Backpropagation(network, trainingset1); int epo = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epo + @" Error:" + train.Error); epo++; if (epo > epoch) { break; } } while (train.Error > 0.05); var evaluationSet = EncogUtility.LoadCSV2Memory(targetFileTest.ToString(), network.InputCount, network.OutputCount, true, CSVFormat.English, false); List <Tuple <double, double> > inputExcel = new List <Tuple <double, double> >(); foreach (var item in evaluationSet) { var output = network.Compute(item.Input); inputExcel.Add(new Tuple <double, double>(item.Input[0], output[0])); } PlotRegressionTest(inputExcel); Console.WriteLine("----------------Execution over - check the Regression output excel ------------------------------------"); Console.ReadKey(); EncogFramework.Instance.Shutdown(); } //End of Regression // For classification we do this piece of code if (whatToperform == 2) { // fetch train file var sourceFile = new FileInfo(@"C:\Users\smandia\Desktop\Attachments_20161015\Attachments_20161029\data.circles.test.1000.csv"); var targetFile = new FileInfo(@"C:\Users\smandia\Desktop\Attachments_20161015\Attachments_20161029\result\khicharNormClassificationTrainData.csv"); ///fetch test file var sourceFileTest = new FileInfo(@"C:\Users\smandia\Desktop\Attachments_20161015\Attachments_20161029\data.circles.test.1000.csv"); var targetFileTest = new FileInfo(@"C:\Users\smandia\Desktop\Attachments_20161015\Attachments_20161029\result\khicharNormClassificationTestData.csv"); //Analyst var analyst = new EncogAnalyst(); //Wizard var wizard = new AnalystWizard(analyst); wizard.Wizard(sourceFile, true, AnalystFileFormat.DecpntComma); //norm for Training var norm = new AnalystNormalizeCSV(); norm.Analyze(sourceFile, true, CSVFormat.English, analyst); norm.ProduceOutputHeaders = true; norm.Normalize(targetFile); //norm for testing norm.Analyze(sourceFileTest, true, CSVFormat.English, analyst); norm.Normalize(targetFileTest); analyst.Save(new FileInfo("stt.ega")); var trainingset1 = EncogUtility.LoadCSV2Memory(targetFile.ToString(), network.InputCount, network.OutputCount, true, CSVFormat.English, false); var train = new Backpropagation(network, trainingset1); int epo = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epo + @" Error:" + train.Error); epo++; if (epo > epoch) { break; } } while (train.Error > 0.05); var evaluationSet = EncogUtility.LoadCSV2Memory(targetFileTest.ToString(), network.InputCount, network.OutputCount, true, CSVFormat.English, false); int count = 0; int CorrectCount = 0; List <Tuple <double, double, double> > inputExcel = new List <Tuple <double, double, double> >(); foreach (var item in evaluationSet) { count++; var output = network.Compute(item.Input); // int classCount = analyst.Script.Normalize.NormalizedFields[4].Classes.Count; int classCount = analyst.Script.Normalize.NormalizedFields[2].Classes.Count; double normalizationHigh = analyst.Script.Normalize.NormalizedFields[2].NormalizedHigh; double normalizationLow = analyst.Script.Normalize.NormalizedFields[2].NormalizedLow; var eq = new Encog.MathUtil.Equilateral(classCount, normalizationHigh, normalizationLow); var predictedClassInt = eq.Decode(output); var predictedClass = analyst.Script.Normalize.NormalizedFields[2].Classes[predictedClassInt].Name; var idealClassInt = eq.Decode(item.Ideal); var idealClass = analyst.Script.Normalize.NormalizedFields[2].Classes[idealClassInt].Name; if (predictedClassInt == idealClassInt) { CorrectCount++; } inputExcel.Add(new Tuple <double, double, double>(item.Input[0], item.Input[1], Convert.ToDouble(predictedClass))); } Console.WriteLine("Total Test Count : {0}", count); Console.WriteLine("Total Correct Prediction Count : {0}", CorrectCount); Console.WriteLine("% Success : {0}", ((CorrectCount * 100.0) / count)); PlotClassificationTest(inputExcel); Console.WriteLine("----------------Execution over - check the Classification output excel ------------------------------------"); Console.ReadKey(); EncogFramework.Instance.Shutdown(); } //End of classification }