/// <summary> /// Processes a double array of data of input and a second array of data for ideals /// you must input the input and output size. /// this typically builds a supervised IMLDatapair, which you must add to a IMLDataset. /// </summary> /// <param name="data">The data.</param> /// <param name="ideal">The ideal.</param> /// <param name="_inputWindow">The _input window.</param> /// <param name="_predictWindow">The _predict window.</param> /// <returns></returns> public static IMLDataPair ProcessPairs(double[] data, double[] ideal, int _inputWindow, int _predictWindow) { IMLDataSet result = new BasicMLDataSet(); for (int i = 0; i < data.Length; i++) { IMLData inputData = new BasicMLData(_inputWindow); IMLData idealData = new BasicMLData(_predictWindow); int index = i; // handle input window for (int j = 0; j < _inputWindow; j++) { inputData[j] = data[index++]; } index = 0; // handle predict window for (int j = 0; j < _predictWindow; j++) { idealData[j] = ideal[index++]; } IMLDataPair pair = new BasicMLDataPair(inputData, idealData); return(pair); } return(null); }
/// <summary> /// Program entry point. /// </summary> /// <param name="app">Holds arguments and other info.</param> public void Execute(IExampleInterface app) { IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal); FlatNetwork network = CreateNetwork(); Console.WriteLine(@"Starting Weights:"); DisplayWeights(network); Evaluate(network, trainingSet); var train = new TrainFlatNetworkResilient( network, trainingSet); for (int iteration = 1; iteration <= ITERATIONS; iteration++) { train.Iteration(); Console.WriteLine(); Console.WriteLine(@"*** Iteration #" + iteration); Console.WriteLine(@"Error: " + train.Error); Evaluate(network, trainingSet); Console.WriteLine(@"LastGrad:" + FormatArray(train.LastGradient)); Console.WriteLine(@"Updates :" + FormatArray(train.UpdateValues)); DisplayWeights(network); } }
/// <summary> /// Processes the specified double serie into an IMLDataset. /// To use this method, you must provide a formated double array with the input data and the ideal data in another double array. /// The number of points in the input window makes the input array , and the predict window will create the array used in ideal. /// This method will use ALL the data inputs and ideals you have provided. /// </summary> /// <param name="datainput">The datainput.</param> /// <param name="ideals">The ideals.</param> /// <param name="_inputWindow">The _input window.</param> /// <param name="_predictWindow">The _predict window.</param> /// <returns></returns> public static IMLDataSet ProcessDoubleSerieIntoIMLDataset(List <double> datainput, List <double> ideals, int _inputWindow, int _predictWindow) { IMLDataSet result = new BasicMLDataSet(); //int count = 0; ////lets check if there is a modulo , if so we move forward in the List of doubles in inputs.This is just a check ////as the data of inputs should be able to fill without having . //while (datainput.Count % _inputWindow !=0) //{ // count++; //} IMLData inputData = new BasicMLData(_inputWindow); IMLData idealData = new BasicMLData(_predictWindow); foreach (double d in datainput) { // handle input window for (int j = 0; j < _inputWindow; j++) { inputData[j] = d; } } foreach (double ideal in ideals) { // handle predict window for (int j = 0; j < _predictWindow; j++) { idealData[j] = ideal; } } IMLDataPair pair = new BasicMLDataPair(inputData, idealData); result.Add(pair); return(result); }
static void Main(string[] args) { var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, 4)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 4)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 5)); network.Structure.FinalizeStructure(); network.Reset(); IMLDataSet trainingSet = new BasicMLDataSet(SensoriInput, AttuatoriOutput); IMLTrain train = new ResilientPropagation(network, trainingSet); int epoch = 1; do { /* Avvia la redistribuzione dei pesi */ train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.001); /* Itera finche' non viene raggiunto un errore tollerabile */ /* Test la MLP */ Console.WriteLine("\r\n+------------------------------------+"); Console.WriteLine("|Neural Network Results: |"); Console.WriteLine("+------------------------------------+"); foreach (IMLDataPair pair in trainingSet) { IMLData output = network.Compute(pair.Input); Console.WriteLine("Input:" + pair.Input[0] + " - " + pair.Input[1] + " - " + pair.Input[2] + " - " + pair.Input[3] + "\tactual=" + Math.Round(output[0], 2) + " - " + Math.Round(output[1], 2) + " - " + Math.Round(output[2], 2) + " - " + Math.Round(output[3], 2) + " - " + Math.Round(output[4], 2) + "\tideal=" + pair.Ideal[0] + " - " + pair.Ideal[1] + " - " + pair.Ideal[2] + " - " + pair.Ideal[3] + " - " + pair.Ideal[4]); } Console.Read(); }
public void TestSOM() { // create the training set IMLDataSet training = new BasicMLDataSet( SOMInput, null); // Create the neural network. var network = new SOMNetwork(4, 2) { Weights = new Matrix(MatrixArray) }; var train = new BasicTrainSOM(network, 0.4, training, new NeighborhoodSingle()) { ForceWinner = true }; int iteration = 0; for (iteration = 0; iteration <= 100; iteration++) { train.Iteration(); } IMLData data1 = new BasicMLData( SOMInput[0]); IMLData data2 = new BasicMLData( SOMInput[1]); int result1 = network.Classify(data1); int result2 = network.Classify(data2); Assert.IsTrue(result1 != result2); }
static void Main(string[] args) { //create a neural network withtout using a factory var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); network.Structure.FinalizeStructure(); network.Reset(); IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal); IMLTrain train = new ResilientPropagation(network, trainingSet); int epoch = 1; do { train.Iteration(); Console.WriteLine($"Epoch #{epoch} Error: {train.Error}"); epoch++; } while (train.Error > 0.01); train.FinishTraining(); Console.WriteLine("Neural Network Results:"); foreach (IMLDataPair iPair in trainingSet) { IMLData output = network.Compute(iPair.Input); Console.WriteLine($"{iPair.Input[0]}, {iPair.Input[0]}, actual={output[0]}, ideal={iPair.Ideal[0]}"); } EncogFramework.Instance.Shutdown(); Console.ReadKey(); }
/// <summary> /// Load a CSV file into a memory dataset. /// </summary> /// /// <param name="format">The CSV format to use.</param> /// <param name="filename">The filename to load.</param> /// <param name="headers">True if there is a header line.</param> /// <param name="inputSize">The input size. Input always comes first in a file.</param> /// <param name="idealSize">The ideal size, 0 for unsupervised.</param> /// <returns>A NeuralDataSet that holds the contents of the CSV file.</returns> public static IMLDataSet LoadCSVTOMemory(CSVFormat format, String filename, bool headers, int inputSize, int idealSize) { var result = new BasicMLDataSet(); var csv = new ReadCSV(filename, headers, format); while (csv.Next()) { BasicMLData ideal = null; int index = 0; var input = new BasicMLData(inputSize); for (int i = 0; i < inputSize; i++) { double d = csv.GetDouble(index++); input[i] = d; } if (idealSize > 0) { ideal = new BasicMLData(idealSize); for (int i = 0; i < idealSize; i++) { double d = csv.GetDouble(index++); ideal[i] = d; } } IMLDataPair pair = new BasicMLDataPair(input, ideal); result.Add(pair); } return(result); }
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); }
private static void ZrobKlasyfikacje() { DaneKlasyfikacja doNauki = new DaneKlasyfikacja(); doNauki.Wczytaj(sciezkaKlasyfikacjaTreningowe); BasicNetwork siec = UtworzSiecDoKlasyfikacji(); IMLDataSet dataTrening = UczSiec(siec, doNauki); // testuje siec na danych treningowych for (int i = 0; i < dataTrening.Count; i++) { IMLData wynik = siec.Compute(dataTrening[i].Input); doNauki.klasyWy.Add(wynik[0]); } doNauki.EksportujDoPliku(sciezkaKlasyfikacjaTreningoweWyniki); // testuje siec na danych testowych DaneKlasyfikacja doTestow = new DaneKlasyfikacja(); doTestow.Wczytaj(sciezkaKlasyfikacjaTestowe); IMLDataSet dataTest = new BasicMLDataSet(doTestow.punkty.ToArray(), doTestow.klasyWej.ToArray()); for (int i = 0; i < dataTest.Count; i++) { IMLData wynik = siec.Compute(dataTest[i].Input); doTestow.klasyWy.Add(wynik[0]); } doTestow.EksportujDoPliku(sciezkaKlasyfikacjaTestoweWyniki); }
public void TestK2Structure() { String[] labels = { "available", "not" }; IMLDataSet data = new BasicMLDataSet(DATA, null); BayesianNetwork network = new BayesianNetwork(); BayesianEvent x1 = network.CreateEvent("x1", labels); BayesianEvent x2 = network.CreateEvent("x2", labels); BayesianEvent x3 = network.CreateEvent("x3", labels); network.FinalizeStructure(); TrainBayesian train = new TrainBayesian(network, data, 10); train.InitNetwork = BayesianInit.InitEmpty; while (!train.TrainingDone) { train.Iteration(); } train.Iteration(); Assert.IsTrue(x1.Parents.Count == 0); Assert.IsTrue(x2.Parents.Count == 1); Assert.IsTrue(x3.Parents.Count == 1); Assert.IsTrue(x2.Parents.Contains(x1)); Assert.IsTrue(x3.Parents.Contains(x2)); Assert.AreEqual(0.714, network.GetEvent("x2").Table.FindLine(1, new int[] { 1 }).Probability, 0.001); }
public IMLDataSet GetDataSet(DataTable dt) { inputNeurons = dt.AsEnumerable().Select(x => new[] { (double)x.Field <int>(0), (double)x.Field <int>(1), bid[x.Field <string>(2)], bid[x.Field <string>(3)], bid[x.Field <string>(4)], rank[x.Field <string>(5)], suit[x.Field <string>(6)], rank[x.Field <string>(7)], suit[x.Field <string>(8)], rank[x.Field <string>(9)], suit[x.Field <string>(10)], rank[x.Field <string>(11)], suit[x.Field <string>(12)], rank[x.Field <string>(13)], suit[x.Field <string>(14)], rank[x.Field <string>(15)], suit[x.Field <string>(16)] }).ToArray(); outputNeurons = dt.AsEnumerable().Select(x => new[] { bid[x.Field <string>(17)], suit[x.Field <string>(18)] }).ToArray(); IMLDataSet trainingSet = new BasicMLDataSet(inputNeurons, outputNeurons); return(trainingSet); }
private static void ZrobRegresje() { DaneRegresja doNauki = new DaneRegresja(); doNauki.Wczytaj(sciezkaRegresjaTreningowe); BasicNetwork siec = UtworzSiecDoRegresji(); IMLDataSet dataTrening = UczSiec(siec, doNauki); // testuje siec na danych treningowych for (int i = 0; i < dataTrening.Count; i++) { IMLData wynik = siec.Compute(dataTrening[i].Input); doNauki.otrzymaneY.Add(wynik[0]); } doNauki.EksportujDoPliku(sciezkaRegresjaTreningoweWyniki); // testuje siec na danych testowych DaneRegresja doTestow = new DaneRegresja(); doTestow.Wczytaj(sciezkaRegresjaTestowe); IMLDataSet dataTest = new BasicMLDataSet(doTestow.wejscioweX.ToArray(), doTestow.oczekiwaneY.ToArray()); for (int i = 0; i < dataTest.Count; i++) { IMLData wynik = siec.Compute(dataTest[i].Input); doTestow.otrzymaneY.Add(wynik[0]); } doTestow.EksportujDoPliku(sciezkaRegresjaTestoweWyniki); }
public static long BenchmarkEncog(double[][] input, double[][] output) { var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, input[0].Length)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, HIDDEN_COUNT)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, output[0].Length)); network.Structure.FinalizeStructure(); network.Reset(23); // constant seed for repeatable testing IMLDataSet trainingSet = new BasicMLDataSet(input, output); // train the neural network IMLTrain train = new Backpropagation(network, trainingSet, 0.7, 0.7); var sw = new Stopwatch(); sw.Start(); // run epoch of learning procedure for (int i = 0; i < ITERATIONS; i++) { train.Iteration(); } sw.Stop(); return(sw.ElapsedMilliseconds); }
/// <summary> /// Trains a random trainer. /// </summary> /// <param name="inputs">The inputs.</param> /// <param name="predictWindow">The predict window.</param> public static void RandomTrainerMethod(int inputs, int predictWindow) { double[] firstinput = MakeInputs(inputs); double[] SecondInput = MakeInputs(inputs); double[] ThirdInputs = MakeInputs(inputs); double[] FourthInputs = MakeInputs(inputs); var pair = SuperUtilsTrainer.ProcessPairs(firstinput, FourthInputs, inputs, predictWindow); var pair2 = SuperUtilsTrainer.ProcessPairs(SecondInput, FourthInputs, inputs, predictWindow); var pair3 = SuperUtilsTrainer.ProcessPairs(ThirdInputs, FourthInputs, inputs, predictWindow); var pair4 = SuperUtilsTrainer.ProcessPairs(FourthInputs, FourthInputs, inputs, predictWindow); BasicMLDataSet SuperSet = new BasicMLDataSet(); SuperSet.Add(pair); SuperSet.Add(pair2); SuperSet.Add(pair3); SuperSet.Add(pair4); SupportVectorMachine machine = Create(SuperSet, inputs); SVMTrain train = new SVMTrain(machine, SuperSet); /// var network = (BasicNetwork)CreateEval.CreateElmanNetwork(SuperSet.InputSize, SuperSet.IdealSize); //double error = CreateEval.TrainNetworks(machine, SuperSet); TrainSVM(train, machine); //Lets create an evaluation. // Console.WriteLine(@"Last error rate on random trainer:" + error); }
public static double EvaluateNetworks(BasicNetwork network, BasicMLDataSet set) { int count = 0; int correct = 0; foreach (IMLDataPair pair in set) { IMLData input = pair.Input; IMLData actualData = pair.Ideal; IMLData predictData = network.Compute(input); double actual = actualData[0]; double predict = predictData[0]; double diff = Math.Abs(predict - actual); Direction actualDirection = DetermineDirection(actual); Direction predictDirection = DetermineDirection(predict); if (actualDirection == predictDirection) correct++; count++; Console.WriteLine(@"Number" + @"count" + @": actual=" + Format.FormatDouble(actual, 4) + @"(" + actualDirection + @")" + @",predict=" + Format.FormatDouble(predict, 4) + @"(" + predictDirection + @")" + @",diff=" + diff); } double percent = correct / (double)count; Console.WriteLine(@"Direction correct:" + correct + @"/" + count); Console.WriteLine(@"Directional Accuracy:" + Format.FormatPercent(percent)); return percent; }
public BasicMLDataSet Convert(List <StockQuote> input) { var dataset = new BasicMLDataSet(); var list = input as List <StockQuote>; for (var i = 2; i < list?.Count; ++i) { var openChange = (list[i - 1].Open - list[i - 2].Open) / list[i - 2].Open; var highChange = (list[i - 1].High - list[i - 2].High) / list[i - 2].High; var lowChange = (list[i - 1].Low - list[i - 2].Low) / list[i - 2].Low; var closeChange = (list[i - 1].Close - list[i - 2].Close) / list[i - 2].Close; double avgVolatilityChange; if ((list[i - 2].High - list[i - 2].Low) == 0) { avgVolatilityChange = 0.0; } else { avgVolatilityChange = ((list[i - 1].High - list[i - 1].Low) - (list[i - 2].High - list[i - 2].Low)) / (list[i - 2].High - list[i - 2].Low); } //var volChange = list[i - 1].Close - list[i - 2].Close / list[i - 2].Close; var inputQuote = new BasicMLData(new[] { openChange, highChange, lowChange, closeChange, avgVolatilityChange }); var expValue = (list[i - 1].High - list[i - 1].Low) == 0.0 ? 0.0 : ((list[i].High - list[i].Low) - (list[i - 1].High - list[i - 1].Low)) / (list[i - 1].High - list[i - 1].Low); var expected = new BasicMLData(new double[] { expValue }); dataset.Add(inputQuote, expected); } return(dataset); }
private void BtnEntrenar_Click(object sender, EventArgs e) { this.con.Open(); var redN = new BasicNetwork(); redN.AddLayer(new BasicLayer(null, false, imagen0.Height * imagen0.Width)); redN.AddLayer(new BasicLayer(new ActivationLinear(), false, 2)); redN.AddLayer(new BasicLayer(new ActivationLinear(), true, 1)); redN.Structure.FinalizeStructure(); redN.Reset(); IMLDataSet Set = new BasicMLDataSet(E, IDEAL); IMLTrain train = new ResilientPropagation(redN, Set); do { CicloE++; train.Iteration(); cadena.Add(train.Error); cadena2.Add(CicloE); }while (train.Error > 0.01); timer1.Enabled = true; timer1.Start(); char i1; char i2; i1 = txtNombre.Text.ToUpper()[0]; i2 = txtApellido.Text.ToUpper()[0]; EncogDirectoryPersistence.SaveObject(new FileInfo(i1.ToString() + i2.ToString() + ".txt"), redN); }
public static long BenchmarkEncog(double[][] input, double[][] output) { BasicNetwork network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, input[0].Length)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, HIDDEN_COUNT)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, output[0].Length)); network.Structure.FinalizeStructure(); network.Reset(); IMLDataSet trainingSet = new BasicMLDataSet(input, output); // train the neural network IMLTrain train = new Backpropagation(network, trainingSet, 0.7, 0.7); Stopwatch sw = new Stopwatch(); sw.Start(); // run epoch of learning procedure for (int i = 0; i < ITERATIONS; i++) { train.Iteration(); } sw.Stop(); return sw.ElapsedMilliseconds; }
public void Run() { //Se crea la red neuronal con sus respectivas capas var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 3)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); network.Structure.FinalizeStructure(); network.Reset(); //Crear el conjunto de entrenamiento IMLDataSet conjuntoEntrenamiento = new BasicMLDataSet(entradas, salidas); //Entrenar IMLTrain train = new ResilientPropagation(network, conjuntoEntrenamiento); int epoch = 1; do { train.Iteration(); Console.WriteLine("Epoca #" + epoch + " Error:" + train.Error); epoch++; } while (train.Error > 0.01); // test the neural network Console.WriteLine("Resultados:"); foreach (IMLDataPair pair in conjuntoEntrenamiento) { IMLData output = network.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @"," + pair.Input[1] + @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]); } }
/// <summary> /// Generate a random training set. /// </summary> /// <param name="seed">The seed value to use, the same seed value will always produce /// the same results.</param> /// <param name="count">How many training items to generate.</param> /// <param name="inputCount">How many input numbers.</param> /// <param name="idealCount">How many ideal numbers.</param> /// <param name="min">The minimum random number.</param> /// <param name="max">The maximum random number.</param> /// <returns>The random training set.</returns> public static BasicMLDataSet Generate(long seed, int count, int inputCount, int idealCount, double min, double max) { var rand = new LinearCongruentialGenerator(seed); var result = new BasicMLDataSet(); for (int i = 0; i < count; i++) { var inputData = new BasicMLData(inputCount); for (int j = 0; j < inputCount; j++) { inputData[j] = rand.Range(min, max); } var idealData = new BasicMLData(idealCount); for (int j = 0; j < idealCount; j++) { idealData[j] = rand.Range(min, max); } var pair = new BasicMLDataPair(inputData, idealData); result.Add(pair); } return result; }
public void Execute(IExampleInterface app) { this.app = app; // Create the neural network. BasicLayer hopfield; var network = new HopfieldNetwork(4); // This pattern will be trained bool[] pattern1 = { true, true, false, false }; // This pattern will be presented bool[] pattern2 = { true, false, false, false }; IMLData result; var data1 = new BiPolarMLData(pattern1); var data2 = new BiPolarMLData(pattern2); var set = new BasicMLDataSet(); set.Add(data1); // train the neural network with pattern1 app.WriteLine("Training Hopfield network with: " + FormatBoolean(data1)); network.AddPattern(data1); // present pattern1 and see it recognized result = network.Compute(data1); app.WriteLine("Presenting pattern:" + FormatBoolean(data1) + ", and got " + FormatBoolean(result)); // Present pattern2, which is similar to pattern 1. Pattern 1 // should be recalled. result = network.Compute(data2); app.WriteLine("Presenting pattern:" + FormatBoolean(data2) + ", and got " + FormatBoolean(result)); }
public void TestSOM() { // create the training set IMLDataSet training = new BasicMLDataSet( SOMInput, null); // Create the neural network. var network = new SOMNetwork(4, 2) {Weights = new Matrix(MatrixArray)}; var train = new BasicTrainSOM(network, 0.4, training, new NeighborhoodSingle()) {ForceWinner = true}; int iteration = 0; for (iteration = 0; iteration <= 100; iteration++) { train.Iteration(); } IMLData data1 = new BasicMLData( SOMInput[0]); IMLData data2 = new BasicMLData( SOMInput[1]); int result1 = network.Classify(data1); int result2 = network.Classify(data2); Console.WriteLine(result1 + " result 2 :"+result2); Assert.IsTrue(result1 != result2); }
public void Execute(IExampleInterface app) { // create a neural network, without using a factory var svm = new SupportVectorMachine(1,true); // 1 input, & true for regression // create training data IMLDataSet trainingSet = new BasicMLDataSet(RegressionInput, RegressionIdeal); // train the SVM IMLTrain train = new SVMSearchTrain(svm, trainingSet); int epoch = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.01); // test the SVM Console.WriteLine(@"SVM Results:"); foreach (IMLDataPair pair in trainingSet) { IMLData output = svm.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]); } }
public void Execute(IExampleInterface app) { this.app = app; // Create the neural network. BasicLayer hopfield; var network = new HopfieldNetwork(4); // This pattern will be trained bool[] pattern1 = {true, true, false, false}; // This pattern will be presented bool[] pattern2 = {true, false, false, false}; IMLData result; var data1 = new BiPolarMLData(pattern1); var data2 = new BiPolarMLData(pattern2); var set = new BasicMLDataSet(); set.Add(data1); // train the neural network with pattern1 app.WriteLine("Training Hopfield network with: " + FormatBoolean(data1)); network.AddPattern(data1); // present pattern1 and see it recognized result = network.Compute(data1); app.WriteLine("Presenting pattern:" + FormatBoolean(data1) + ", and got " + FormatBoolean(result)); // Present pattern2, which is similar to pattern 1. Pattern 1 // should be recalled. result = network.Compute(data2); app.WriteLine("Presenting pattern:" + FormatBoolean(data2) + ", and got " + FormatBoolean(result)); }
public static IMLDataSet GenerateTraining() { var result = new BasicMLDataSet(); for (int i = 0; i < DIGITS.Length; i++) { var ideal = new BasicMLData(DIGITS.Length); // setup input IMLData input = Image2data(DIGITS[i]); // setup ideal for (int j = 0; j < DIGITS.Length; j++) { if (j == i) { ideal[j] = 1; } else { ideal[j] = -1; } } // add training element result.Add(input, ideal); } return(result); }
static void Main(string[] args) { var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 3)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); network.Structure.FinalizeStructure(); network.Reset(); var trainingSet = new BasicMLDataSet(XORInput, XORIdeal); var train = new ResilientPropagation(network, trainingSet); var epoch = 1; do { train.Iteration(); } while (train.Error > 0.01); train.FinishTraining(); foreach (var pair in trainingSet) { var output = network.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @", " + pair.Input[1] + @" , actual=" + output[0] + @", ideal=" + pair.Ideal[0]); } EncogFramework.Instance.Shutdown(); Console.ReadLine(); }
public static void TrainElmhanNetwork(ref IExampleInterface app) { BasicMLDataSet set = CreateEval.CreateEvaluationSetAndLoad(app.Args[1], CONFIG.STARTING_YEAR, CONFIG.TRAIN_END, CONFIG.INPUT_WINDOW, CONFIG.PREDICT_WINDOW); //create our network. BasicNetwork network = (BasicNetwork)CreateEval.CreateElmanNetwork(CONFIG.INPUT_WINDOW, CONFIG.PREDICT_WINDOW); //Train it.. double LastError = CreateEval.TrainNetworks(network, set); Console.WriteLine("NetWork Trained to :" + LastError); SuperUtils.SaveTraining(CONFIG.DIRECTORY, CONFIG.TRAINING_FILE, set); SuperUtils.SaveNetwork(CONFIG.DIRECTORY, CONFIG.NETWORK_FILE, network); Console.WriteLine("Network Saved to :" + CONFIG.DIRECTORY + " File Named :" + CONFIG.NETWORK_FILE); Console.WriteLine("Training Saved to :" + CONFIG.DIRECTORY + " File Named :" + CONFIG.TRAINING_FILE); MakeAPause(); }
public void TestSingleOutput() { BasicNetwork network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); network.Structure.FinalizeStructure(); (new ConsistentRandomizer(-1, 1)).Randomize(network); IMLDataSet trainingData = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); HessianFD testFD = new HessianFD(); testFD.Init(network, trainingData); testFD.Compute(); HessianCR testCR = new HessianCR(); testCR.Init(network, trainingData); testCR.Compute(); //dump(testFD, "FD"); //dump(testCR, "CR"); Assert.IsTrue(testCR.HessianMatrix.equals(testFD.HessianMatrix, 4)); }
/// <summary> /// Program entry point. /// </summary> /// <param name="app">Holds arguments and other info.</param> public void Execute(IExampleInterface app) { var network = new FlatNetwork(2, 4, 0, 1, false); network.Randomize(); IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal); var train = new TrainFlatNetworkResilient(network, trainingSet); int epoch = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.01); var output = new double[1]; // test the neural network Console.WriteLine(@"Neural Network Results:"); foreach (IMLDataPair pair in trainingSet) { double[] input = pair.Input.Data; network.Compute(input, output); Console.WriteLine(input[0] + @"," + input[1] + @":" + output[0]); } }
public static IMLDataSet LoadCSVToDataSet(FileInfo fileInfo, int inputCount, int outputCount, bool randomize = true, bool headers = true) { BasicMLDataSet result = new BasicMLDataSet(); CultureInfo CSVformat = new CultureInfo("en"); using (TextFieldParser parser = new TextFieldParser(fileInfo.FullName)) { parser.TextFieldType = FieldType.Delimited; parser.SetDelimiters(","); if (headers) parser.ReadFields(); while (!parser.EndOfData) { //Processing row string[] fields = parser.ReadFields(); var input = new BasicMLData(inputCount); for (int i = 0; i < inputCount; i++) input[i] = double.Parse(fields[i], CSVformat); var ideal = new BasicMLData(outputCount); for (int i = 0; i < outputCount; i++) ideal[i] = double.Parse(fields[i + inputCount], CSVformat); result.Add(input, ideal); } } var rand = new Random(DateTime.Now.Millisecond); return (randomize ? new BasicMLDataSet(result.OrderBy(r => rand.Next()).ToList()) : new BasicMLDataSet(result)); }
/// <summary> /// Processes the specified double serie into an IMLDataset. /// To use this method, you must provide a formated double array. /// The number of points in the input window makes the input array , and the predict window will create the array used in ideal. /// Example you have an array with 1, 2, 3 , 4 , 5. /// You can use this method to make an IMLDataset 4 inputs and 1 ideal (5). /// </summary> /// <param name="data">The data.</param> /// <param name="_inputWindow">The _input window.</param> /// <param name="_predictWindow">The _predict window.</param> /// <returns></returns> public static IMLDataSet ProcessDoubleSerieIntoIMLDataset(double[] data, int _inputWindow, int _predictWindow) { IMLDataSet result = new BasicMLDataSet(); int totalWindowSize = _inputWindow + _predictWindow; int stopPoint = data.Length - totalWindowSize; for (int i = 0; i < stopPoint; i++) { IMLData inputData = new BasicMLData(_inputWindow); IMLData idealData = new BasicMLData(_predictWindow); int index = i; // handle input window for (int j = 0; j < _inputWindow; j++) { inputData[j] = data[index++]; } // handle predict window for (int j = 0; j < _predictWindow; j++) { idealData[j] = data[index++]; } IMLDataPair pair = new BasicMLDataPair(inputData, idealData); result.Add(pair); } return(result); }
/// <summary> /// Load a CSV file into a memory dataset. /// </summary> /// /// <param name="format">The CSV format to use.</param> /// <param name="filename">The filename to load.</param> /// <param name="headers">True if there is a header line.</param> /// <param name="inputSize">The input size. Input always comes first in a file.</param> /// <param name="idealSize">The ideal size, 0 for unsupervised.</param> /// <returns>A NeuralDataSet that holds the contents of the CSV file.</returns> public static IMLDataSet LoadCSVTOMemory(CSVFormat format, String filename, bool headers, int inputSize, int idealSize) { var result = new BasicMLDataSet(); var csv = new ReadCSV(filename, headers, format); while (csv.Next()) { BasicMLData ideal = null; int index = 0; var input = new BasicMLData(inputSize); for (int i = 0; i < inputSize; i++) { double d = csv.GetDouble(index++); input[i] = d; } if (idealSize > 0) { ideal = new BasicMLData(idealSize); for (int i = 0; i < idealSize; i++) { double d = csv.GetDouble(index++); ideal[i] = d; } } IMLDataPair pair = new BasicMLDataPair(input, ideal); result.Add(pair); } return result; }
public void JustDoIt() { var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, false, 2)); network.AddLayer(new BasicLayer(new ActivationLinear(), false, 1)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); network.Structure.FinalizeStructure(); network.Reset(); IMLDataSet trainDataSet = new BasicMLDataSet(XORInput, XORIdeal); IMLTrain train = new ResilientPropagation(network, trainDataSet); int epoch = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.01); train.FinishTraining(); Console.WriteLine(@"Neural Network Results:"); foreach (IMLDataPair pair in trainDataSet) { IMLData output = network.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @"," + pair.Input[1] + @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]); } EncogFramework.Instance.Shutdown(); Console.ReadKey(); }
static void Main(string[] args) { // create a neural network, without using a factory var svm = new SupportVectorMachine(2, false); // 2 input, & false for classification // create training data IMLDataSet trainingSet = new BasicMLDataSet(ClassificationInput, ClassificationIdeal); // train the SVM IMLTrain train = new SVMSearchTrain(svm, trainingSet); int epoch = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.01); // test the SVM Console.WriteLine(@"SVM Results:"); foreach (IMLDataPair pair in trainingSet) { IMLData output = svm.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]); } Console.WriteLine("Done"); }
/// <summary> /// Evaluate memory. /// </summary> private void EvalMemory() { BasicMLDataSet training = RandomTrainingFactory.Generate( 1000, 10000, 10, 10, -1, 1); const long stop = (10 * Evaluate.Milis); int record = 0; IMLDataPair pair = BasicMLDataPair.CreatePair(10, 10); int iterations = 0; var watch = new Stopwatch(); watch.Start(); while (watch.ElapsedMilliseconds < stop) { iterations++; training.GetRecord(record++, pair); if (record >= training.Count) { record = 0; } } iterations /= 100000; _report.Report(Steps, Step2, "Memory dataset, result: " + Format.FormatInteger(iterations)); _memoryScore = iterations; }
/// <summary> /// Generate a random training set. /// </summary> /// <param name="seed">The seed value to use, the same seed value will always produce /// the same results.</param> /// <param name="count">How many training items to generate.</param> /// <param name="inputCount">How many input numbers.</param> /// <param name="idealCount">How many ideal numbers.</param> /// <param name="min">The minimum random number.</param> /// <param name="max">The maximum random number.</param> /// <returns>The random training set.</returns> public static BasicMLDataSet Generate(long seed, int count, int inputCount, int idealCount, double min, double max) { var rand = new LinearCongruentialGenerator(seed); var result = new BasicMLDataSet(); for (int i = 0; i < count; i++) { var inputData = new BasicMLData(inputCount); for (int j = 0; j < inputCount; j++) { inputData[j] = rand.Range(min, max); } var idealData = new BasicMLData(idealCount); for (int j = 0; j < idealCount; j++) { idealData[j] = rand.Range(min, max); } var pair = new BasicMLDataPair(inputData, idealData); result.Add(pair); } return(result); }
public void Execute(IExampleInterface app) { // create a neural network, without using a factory var svm = new SupportVectorMachine(1, true); // 1 input, & true for regression // create training data IMLDataSet trainingSet = new BasicMLDataSet(RegressionInput, RegressionIdeal); // train the SVM IMLTrain train = new SVMSearchTrain(svm, trainingSet); int epoch = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.01); // test the SVM Console.WriteLine(@"SVM Results:"); foreach (IMLDataPair pair in trainingSet) { IMLData output = svm.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]); } }
protected ProbabilitySupportVectorMachine TrainSVM(double C, double gamma, List <ISample> trainingSamples, Func <ISample, double> idealFunction) { // duplicate the training dataset for better cross validation by LIBSVM probability generator (see LIBSVM documentation) List <double[]> inputSamples = trainingSamples.Select(sample => sample.GetDimensions()).ToList(); inputSamples.AddRange(trainingSamples.Select(sample => sample.GetDimensions())); // account for imposter samples (identifier not in identifierMap) List <double[]> outputSamples = trainingSamples.Select(sample => new double[] { idealFunction.Invoke(sample) }).ToList(); outputSamples.AddRange(trainingSamples.Select(sample => new double[] { idealFunction.Invoke(sample) })); double[][] INPUT = inputSamples.ToArray(); double[][] IDEAL = outputSamples.ToArray(); // train the SVM classifier with the provided data IMLDataSet trainingData = new BasicMLDataSet(INPUT, IDEAL); ProbabilitySupportVectorMachine svmNetwork = new ProbabilitySupportVectorMachine(trainingSamples[0].GetDimensionCount(), false, 0.00000001); // train the SVM classifier with the provided C and gamma SVMTrain trainedSVM = new SVMTrain(svmNetwork, trainingData) { Fold = 0, Gamma = gamma, C = C }; trainedSVM.Iteration(); Console.WriteLine("SVM training error: " + trainedSVM.Error); return(svmNetwork); }
public static BasicMLDataSet CreateEvaluationSetAndLoad(string @fileName, int startLine, int HowMany, int WindowSize, int outputsize) { List <double> Opens = QuickCSVUtils.QuickParseCSV(fileName, "Open", startLine, HowMany); List <double> High = QuickCSVUtils.QuickParseCSV(fileName, "High", startLine, HowMany); // List<double> Low = QuickCSVUtils.QuickParseCSV(fileName, "Low", startLine, HowMany); List <double> Close = QuickCSVUtils.QuickParseCSV(fileName, "Close", startLine, HowMany); List <double> Volume = QuickCSVUtils.QuickParseCSV(fileName, 5, startLine, HowMany); double[] Ranges = NetworkUtility.CalculateRanges(Opens.ToArray(), Close.ToArray()); IMLDataPair aPairInput = TrainerHelper.ProcessPairs(NetworkUtility.CalculatePercents(Opens.ToArray()), NetworkUtility.CalculatePercents(Opens.ToArray()), WindowSize, outputsize); IMLDataPair aPairInput3 = TrainerHelper.ProcessPairs(NetworkUtility.CalculatePercents(Close.ToArray()), NetworkUtility.CalculatePercents(Close.ToArray()), WindowSize, outputsize); IMLDataPair aPairInput2 = TrainerHelper.ProcessPairs(NetworkUtility.CalculatePercents(High.ToArray()), NetworkUtility.CalculatePercents(High.ToArray()), WindowSize, outputsize); IMLDataPair aPairInput4 = TrainerHelper.ProcessPairs(NetworkUtility.CalculatePercents(Volume.ToArray()), NetworkUtility.CalculatePercents(Volume.ToArray()), WindowSize, outputsize); IMLDataPair aPairInput5 = TrainerHelper.ProcessPairs(NetworkUtility.CalculatePercents(Ranges.ToArray()), NetworkUtility.CalculatePercents(Ranges.ToArray()), WindowSize, outputsize); List <IMLDataPair> listData = new List <IMLDataPair>(); listData.Add(aPairInput); listData.Add(aPairInput2); listData.Add(aPairInput3); listData.Add(aPairInput4); listData.Add((aPairInput5)); var minitrainning = new BasicMLDataSet(listData); return(minitrainning); }
public static double EvaluateNetworks(BasicNetwork network, BasicMLDataSet set) { int count = 0; int correct = 0; foreach (IMLDataPair pair in set) { IMLData input = pair.Input; IMLData actualData = pair.Ideal; IMLData predictData = network.Compute(input); double actual = actualData[0]; double predict = predictData[0]; double diff = Math.Abs(predict - actual); Direction actualDirection = DetermineDirection(actual); Direction predictDirection = DetermineDirection(predict); if (actualDirection == predictDirection) { correct++; } count++; Console.WriteLine(@"Number" + @"count" + @": actual=" + Format.FormatDouble(actual, 4) + @"(" + actualDirection + @")" + @",predict=" + Format.FormatDouble(predict, 4) + @"(" + predictDirection + @")" + @",diff=" + diff); } double percent = correct / (double)count; Console.WriteLine(@"Direction correct:" + correct + @"/" + count); Console.WriteLine(@"Directional Accuracy:" + Format.FormatPercent(percent)); return(percent); }
/// <summary> /// Process the array. /// </summary> /// /// <param name="data">The array to process.</param> /// <returns>A neural data set that contains the time-series.</returns> public IMLDataSet Process(double[] data) { var result = new BasicMLDataSet(); int totalWindowSize = _inputWindow + _predictWindow; int stopPoint = data.Length - totalWindowSize; for (int i = 0; i < stopPoint; i++) { var inputData = new BasicMLData(_inputWindow); var idealData = new BasicMLData(_predictWindow); int index = i; // handle input window for (int j = 0; j < _inputWindow; j++) { inputData[j] = data[index++]; } // handle predict window for (int j = 0; j < _predictWindow; j++) { idealData[j] = data[index++]; } var pair = new BasicMLDataPair(inputData, idealData); result.Add(pair); } return(result); }
static void Main(string[] args) { // this form of ANN uses genetic algorithm to produce // hidden layer of neurons // A NEAT network starts with only an // input layer and output layer. The rest is evolved as the training progresses. // Connections inside of a NEAT neural network can be feedforward, recurrent, // or self - connected.All of these connection types will be tried by NEAT as it // attempts to evolve a neural network capable of the given task. IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal); NEATPopulation pop = new NEATPopulation(2, 1, 1000); pop.Reset(); pop.InitialConnectionDensity = 1.0; // not required, but speeds processing. ICalculateScore score = new TrainingSetScore(trainingSet); // train the neural network TrainEA train = NEATUtil.ConstructNEATTrainer(pop, score); EncogUtility.TrainToError(train, 0.01); NEATNetwork network = (NEATNetwork)train.CODEC.Decode(train.BestGenome); // TODO no persistance? no means to peek structure? // test the neural network Console.WriteLine(@"Neural Network Results:"); EncogUtility.Evaluate(network, trainingSet); }
/// <summary> /// Program entry point. /// </summary> /// <param name="app">Holds arguments and other info.</param> public void Execute(IExampleInterface app) { // create a neural network, without using a factory var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 3)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1)); network.Structure.FinalizeStructure(); network.Reset(); // create training data IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal); // train the neural network IMLTrain train = new ResilientPropagation(network, trainingSet); int epoch = 1; do { train.Iteration(); Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error); epoch++; } while (train.Error > 0.01); // test the neural network Console.WriteLine(@"Neural Network Results:"); foreach (IMLDataPair pair in trainingSet) { IMLData output = network.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @"," + pair.Input[1] + @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]); } }
private static SupportVectorMachine Create(IMLDataSet theset, int inputs) { IMLDataSet training = new BasicMLDataSet(theset); SupportVectorMachine result = new SupportVectorMachine(inputs, SVMType.EpsilonSupportVectorRegression, KernelType.Sigmoid); SVMTrain train = new SVMTrain(result, training); train.Iteration(); return result; }
public void TestManhattan() { IMLDataSet trainingData = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); BasicNetwork network = NetworkUtil.CreateXORNetworkUntrained(); IMLTrain bprop = new ManhattanPropagation(network, trainingData, 0.01); NetworkUtil.TestTraining(bprop, 0.01); }
public void TestRPROP() { IMLDataSet trainingData = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); BasicNetwork network = NetworkUtil.CreateXORNetworkUntrained(); IMLTrain rprop = new ResilientPropagation(network, trainingData); NetworkUtil.TestTraining(rprop, 0.03); }
public void TestLMA() { IMLDataSet trainingData = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); BasicNetwork network = NetworkUtil.CreateXORNetworkUntrained(); IMLTrain rprop = new LevenbergMarquardtTraining(network, trainingData); NetworkUtil.TestTraining(rprop, 0.03); }
public void TestAnneal() { IMLDataSet trainingData = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); BasicNetwork network = NetworkUtil.CreateXORNetworkUntrained(); ICalculateScore score = new TrainingSetScore(trainingData); NeuralSimulatedAnnealing anneal = new NeuralSimulatedAnnealing(network, score, 10, 2, 100); NetworkUtil.TestTraining(anneal, 0.01); }
private SupportVectorMachine Create() { IMLDataSet training = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); SupportVectorMachine result = new SupportVectorMachine(2, SVMType.EpsilonSupportVectorRegression, KernelType.RadialBasisFunction); SVMTrain train = new SVMTrain(result, training); train.Iteration(); return result; }
public void EvaluateNetwork(BasicNetwork trainedNetwork, BasicMLDataSet trainingData) { foreach (var trainingItem in trainingData) { var output = trainedNetwork.Compute(trainingItem.Input); Console.WriteLine("Input:{0}, {1} Ideal: {2} Actual : {3}", trainingItem.Input[0], trainingItem.Input[1], trainingItem.Ideal, output[0]); } Console.ReadKey(); }
/// <summary> /// Create a dataset from the clustered data. /// </summary> /// <returns>The dataset.</returns> public IMLDataSet CreateDataSet() { var result = new BasicMLDataSet(); foreach (IMLData dataItem in _data) { result.Add(dataItem); } return result; }
static void Main(string[] args) { var network = CreateNetwork(); var trainingData = new BasicMLDataSet(XORStatics.XorInputMatrix,XORStatics.XorIdealMatrix); var functions = new BasicNeuralNetFunctions(); var trainedNetwork = functions.TrainNetwork(network, trainingData); functions.EvaluateNetwork(network,trainingData); }
public void TestClassifyPNN() { PNNOutputMode mode = PNNOutputMode.Classification; BasicPNN network = new BasicPNN(PNNKernelType.Gaussian, mode, 2, 2); IMLDataSet trainingData = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); TrainBasicPNN train = new TrainBasicPNN(network, trainingData); train.Iteration(); XOR.VerifyXOR(network, 0.01); }
public void Execute(IExampleInterface app) { this.app = app; IMLDataSet trainingSet = new BasicMLDataSet(XOR_INPUT, XOR_IDEAL); BasicNetwork network = EncogUtility.SimpleFeedForward(2, 6, 0, 1, false); EncogUtility.TrainToError(network, trainingSet, 0.01); double error = network.CalculateError(trainingSet); EncogDirectoryPersistence.SaveObject(new FileInfo(FILENAME), network); double error2 = network.CalculateError(trainingSet); app.WriteLine("Error before save to EG: " + Format.FormatPercent(error)); app.WriteLine("Error before after to EG: " + Format.FormatPercent(error2)); }
public ResilientPropagation TrainNetwork(BasicNetwork network, BasicMLDataSet trainingData) { var trainedNetwork = new ResilientPropagation(network, trainingData); var epoch = 0; do { trainedNetwork.Iteration(); epoch++; Console.WriteLine("Epoch:{0}, Error{1}", epoch, trainedNetwork.Error); } while (trainedNetwork.Error > 0.01); return trainedNetwork; }
public static void ExportToExcel(BasicMLDataSet data, DataSetEditMode mode) { object obj2; int num; int num2; int num3; int num4; int num5; int num6; bool flag; Application application2 = (Application) Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid("00024500-0000-0000-C000-000000000046"))); goto Label_0FE4; Label_0028: num2++; using (IEnumerator<IMLDataPair> enumerator = data.GetEnumerator()) { IMLDataPair pair; goto Label_0040; Label_0039: num2++; Label_0040: flag = enumerator.MoveNext(); if (flag) { goto Label_0796; } if (((uint) flag) < 0) { goto Label_01D4; } return; Label_006A: num++; num4++; Label_0075: flag = num4 <= pair.ErrorArray.Length; Label_0087: if (flag) { goto Label_01DC; } if (((uint) num4) >= 0) { goto Label_07CA; } goto Label_01FF; Label_00A8:; <ExportToExcel>o__SiteContainer1.<>p__Site17 = CallSite<Func<CallSite, object, double, object>>.Create(Microsoft.CSharp.RuntimeBinder.Binder.SetMember(CSharpBinderFlags.None, "Value2", typeof(ExcelDataExport), new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null), CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null) })); Label_00E9: if (<ExportToExcel>o__SiteContainer1.<>p__Site18 == null) {
public void Execute(IExampleInterface app) { this.app = app; this.app = app; IMLDataSet trainingSet = new BasicMLDataSet(XOR_INPUT, XOR_IDEAL); BasicNetwork network = EncogUtility.SimpleFeedForward(2, 6, 0, 1, false); EncogUtility.TrainToError(network, trainingSet, 0.01); double error = network.CalculateError(trainingSet); SerializeObject.Save("encog.ser", network); network = (BasicNetwork) SerializeObject.Load("encog.ser"); double error2 = network.CalculateError(trainingSet); app.WriteLine("Error before save to ser: " + Format.FormatPercent(error)); app.WriteLine("Error before after to ser: " + Format.FormatPercent(error2)); }
private NEATPopulation Generate() { IMLDataSet trainingSet = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); ICalculateScore score = new TrainingSetScore(trainingSet); // train the neural network ActivationStep step = new ActivationStep(); step.Center = 0.5; IEvolutionaryAlgorithm train = NEATUtil.ConstructNEATTrainer( score, 2, 1, 10); return (NEATPopulation)train.Population; }
public BasicPNN create() { PNNOutputMode mode = PNNOutputMode.Regression; BasicPNN network = new BasicPNN(PNNKernelType.Gaussian, mode, 2, 1); BasicMLDataSet trainingSet = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); TrainBasicPNN train = new TrainBasicPNN(network, trainingSet); train.Iteration(); XOR.VerifyXOR(network, 0.001); return network; }
private NEATPopulation Generate() { IMLDataSet trainingSet = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal); ICalculateScore score = new TrainingSetScore(trainingSet); // train the neural network ActivationStep step = new ActivationStep(); step.Center = 0.5; NEATTraining train = new NEATTraining( score, 2, 1, 10); return (NEATPopulation)train.Population; }