public RunEpoch ( double input, double output ) : double | ||
input | double | Array of input vectors. |
output | double | Array of output vectors. |
return | double |
public void CreateActivationNetworkTest() { double[][] inputs = { new double[] { 1,1,1,0,0,0 }, new double[] { 1,0,1,0,0,0 }, new double[] { 1,1,1,0,0,0 }, new double[] { 0,0,1,1,1,0 }, new double[] { 0,0,1,1,0,0 }, new double[] { 0,0,1,1,1,0 } }; double[][] outputs = { new double[] { 0 }, new double[] { 0 }, new double[] { 0 }, new double[] { 1 }, new double[] { 1 }, new double[] { 1 }, }; RestrictedBoltzmannMachine network = createNetwork(inputs); ActivationNetwork ann = network.ToActivationNetwork(new SigmoidFunction(1), outputs: 1); ParallelResilientBackpropagationLearning teacher = new ParallelResilientBackpropagationLearning(ann); for (int i = 0; i < 100; i++) { teacher.RunEpoch(inputs, outputs); } double[] actual = new double[outputs.Length]; for (int i = 0; i < inputs.Length; i++) actual[i] = ann.Compute(inputs[i])[0]; Assert.AreEqual(0, actual[0], 1e-10); Assert.AreEqual(0, actual[1], 1e-10); Assert.AreEqual(0, actual[2], 1e-10); Assert.AreEqual(1, actual[3], 1e-10); Assert.AreEqual(1, actual[4], 1e-10); Assert.AreEqual(1, actual[5], 1e-10); }
public void CreateActivationNetworkTest() { double[][] inputs = { new double[] { 1,1,1,0,0,0 }, new double[] { 1,0,1,0,0,0 }, new double[] { 1,1,1,0,0,0 }, new double[] { 0,0,1,1,1,0 }, new double[] { 0,0,1,1,0,0 }, new double[] { 0,0,1,1,1,0 } }; double[][] outputs = { new double[] { 0 }, new double[] { 0 }, new double[] { 0 }, new double[] { 1 }, new double[] { 1 }, new double[] { 1 }, }; DeepBeliefNetwork network = createNetwork(inputs); ParallelResilientBackpropagationLearning teacher = new ParallelResilientBackpropagationLearning(network); for (int i = 0; i < 100; i++) { teacher.RunEpoch(inputs, outputs); } double[] actual = new double[outputs.Length]; for (int i = 0; i < inputs.Length; i++) actual[i] = network.Compute(inputs[i])[0]; Assert.AreEqual(0, actual[0], 1e-10); Assert.AreEqual(0, actual[1], 1e-10); Assert.AreEqual(0, actual[2], 1e-10); Assert.AreEqual(1, actual[3], 1e-10); Assert.AreEqual(1, actual[4], 1e-10); Assert.AreEqual(1, actual[5], 1e-10); }
public void RunEpochTest1() { Accord.Math.Tools.SetupGenerator(0); double[][] input = { new double[] { -1, -1 }, new double[] { -1, 1 }, new double[] { 1, -1 }, new double[] { 1, 1 } }; double[][] output = { new double[] { -1 }, new double[] { 1 }, new double[] { 1 }, new double[] { -1 } }; //Neuron.RandGenerator = new ThreadSafeRandom(0); ActivationNetwork network = new ActivationNetwork( new BipolarSigmoidFunction(2), 2, 2, 1); var teacher = new ParallelResilientBackpropagationLearning(network); double error = 1.0; while (error > 1e-5) error = teacher.RunEpoch(input, output); for (int i = 0; i < input.Length; i++) { double actual = network.Compute(input[i])[0]; double expected = output[i][0]; Assert.AreEqual(expected, actual, 0.01); Assert.IsFalse(Double.IsNaN(actual)); } }
static void NeuralNetworkAccompanimentTest() { // initialize input and output values double[][] input = new double[4][] { new double[] {0, 0}, new double[] {0, 1}, new double[] {1, 0}, new double[] {1, 1} }; double[][] output = new double[4][] { new double[] {0}, new double[] {1}, new double[] {1}, new double[] {0} }; SigmoidFunction sig = new SigmoidFunction(); Accord.Neuro.Networks.RestrictedBoltzmannMachine boltz = new Accord.Neuro.Networks.RestrictedBoltzmannMachine(200, 200); // create neural network ActivationNetwork network = new ActivationNetwork( new SigmoidFunction(2), 200, 20, 200); //BackPropagationLearning teacher = new BackPropagationLearning(network); //LevenbergMarquardtLearning teacher = new LevenbergMarquardtLearning(network); Accord.Neuro.Learning.ParallelResilientBackpropagationLearning teacher = new ParallelResilientBackpropagationLearning(network); Accord.Neuro.Networks.DeepBeliefNetwork dpn = new Accord.Neuro.Networks.DeepBeliefNetwork(200, 20); // teacher.IncreaseFactor = 1.01; Composition c = Composition.LoadFromMIDI("test/other/ff7tifa.mid"); MusicPlayer player = new MusicPlayer(); //player.Play(c.Tracks[0]); List<double[]> inputs = new List<double[]>(); List<double[]> outputs = new List<double[]>(); inputs.Add(GetDoublesFromNotes((c.Tracks[0].GetMainSequence() as MelodySequence).ToArray())); outputs.Add(GetDoublesFromNotes((c.Tracks[1].GetMainSequence() as MelodySequence).ToArray())); // inputs.Add(GetDoublesFromNotes((c.Tracks[1].GetMainSequence() as MelodySequence).ToArray())); // outputs.Add(GetDoublesFromNotes((c.Tracks[2].GetMainSequence() as MelodySequence).ToArray())); // inputs.Add(GetDoublesFromNotes((c.Tracks[0].GetMainSequence() as MelodySequence).ToArray())); // outputs.Add(GetDoublesFromNotes((c.Tracks[3].GetMainSequence() as MelodySequence).ToArray())); int its = 0; while (its++ < 10000) { double error = teacher.RunEpoch(inputs.ToArray(), outputs.ToArray()); Console.WriteLine("{0}: Error - {1}", its, error); } var input_melody = (c.Tracks[0].GetMainSequence() as MelodySequence); var new_notes = network.Compute(GetDoublesFromNotes(input_melody.ToArray())); var new_mel = GetMelodyFromDoubles(new_notes); player.Play(new_mel); Console.ReadLine(); }
// Worker thread void SearchSolution() { // number of learning samples int samples = data.Length - predictionSize - windowSize; // data transformation factor double factor = 1.7 / chart.RangeY.Length; double yMin = chart.RangeY.Min; // prepare learning data double[][] input = new double[samples][]; double[][] output = new double[samples][]; for (int i = 0; i < samples; i++) { input[i] = new double[windowSize]; output[i] = new double[1]; // set input for (int j = 0; j < windowSize; j++) { input[i][j] = (data[i + j] - yMin) * factor - 0.85; } // set output output[i][0] = (data[i + windowSize] - yMin) * factor - 0.85; } // create multi-layer neural network ActivationNetwork network = new ActivationNetwork( new BipolarSigmoidFunction(sigmoidAlphaValue), windowSize, windowSize * 2, 1); // create teacher var teacher = new ParallelResilientBackpropagationLearning(network); teacher.Reset(initialStep); // run at least one backpropagation epoch //teacher2.RunEpoch(input, output); // iterations int iteration = 1; // solution array int solutionSize = data.Length - windowSize; double[,] solution = new double[solutionSize, 2]; double[] networkInput = new double[windowSize]; // calculate X values to be used with solution function for (int j = 0; j < solutionSize; j++) { solution[j, 0] = j + windowSize; } // loop while (!needToStop) { // run epoch of learning procedure double error = teacher.RunEpoch(input, output) / samples; // calculate solution and learning and prediction errors double learningError = 0.0; double predictionError = 0.0; // go through all the data for (int i = 0, n = data.Length - windowSize; i < n; i++) { // put values from current window as network's input for (int j = 0; j < windowSize; j++) { networkInput[j] = (data[i + j] - yMin) * factor - 0.85; } // evalue the function solution[i, 1] = (network.Compute(networkInput)[0] + 0.85) / factor + yMin; // calculate prediction error if (i >= n - predictionSize) { predictionError += Math.Abs(solution[i, 1] - data[windowSize + i]); } else { learningError += Math.Abs(solution[i, 1] - data[windowSize + i]); } } // update solution on the chart chart.UpdateDataSeries("solution", solution); // set current iteration's info SetText(currentIterationBox, iteration.ToString()); SetText(currentLearningErrorBox, learningError.ToString("F3")); SetText(currentPredictionErrorBox, predictionError.ToString("F3")); // increase current iteration iteration++; // check if we need to stop if ((iterations != 0) && (iteration > iterations)) break; } // show new solution for (int j = windowSize, k = 0, n = data.Length; j < n; j++, k++) { AddSubItem(dataList, j, solution[k, 1].ToString()); } // enable settings controls EnableControls(true); }
public void MulticlassTest1() { Accord.Math.Tools.SetupGenerator(0); // Suppose we would like to teach a network to recognize // the following input vectors into 3 possible classes: // double[][] inputs = { new double[] { 0, 1, 1, 0 }, // 0 new double[] { 0, 1, 0, 0 }, // 0 new double[] { 0, 0, 1, 0 }, // 0 new double[] { 0, 1, 1, 0 }, // 0 new double[] { 0, 1, 0, 0 }, // 0 new double[] { 1, 0, 0, 0 }, // 1 new double[] { 1, 0, 0, 0 }, // 1 new double[] { 1, 0, 0, 1 }, // 1 new double[] { 0, 0, 0, 1 }, // 1 new double[] { 0, 0, 0, 1 }, // 1 new double[] { 1, 1, 1, 1 }, // 2 new double[] { 1, 0, 1, 1 }, // 2 new double[] { 1, 1, 0, 1 }, // 2 new double[] { 0, 1, 1, 1 }, // 2 new double[] { 1, 1, 1, 1 }, // 2 }; int[] classes = { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, }; // First we have to convert this problem into a way that the neural // network can handle. The first step is to expand the classes into // indicator vectors, where a 1 into a position signifies that this // position indicates the class the sample belongs to. // double[][] outputs = Statistics.Tools.Expand(classes, -1, +1); // Create an activation function for the net var function = new BipolarSigmoidFunction(); // Create an activation network with the function and // 4 inputs, 5 hidden neurons and 3 possible outputs: var network = new ActivationNetwork(function, 4, 5, 3); // Randomly initialize the network new NguyenWidrow(network).Randomize(); // Teach the network using parallel Rprop: var teacher = new ParallelResilientBackpropagationLearning(network); double error = 1.0; while (error > 1e-5) error = teacher.RunEpoch(inputs, outputs); // Checks if the network has learned for (int i = 0; i < inputs.Length; i++) { double[] answer = network.Compute(inputs[i]); int expected = classes[i]; int actual; answer.Max(out actual); Assert.AreEqual(expected, actual, 0.01); } }
// Worker thread void SearchSolution() { // number of learning samples int samples = data.GetLength(0); // data transformation factor double yFactor = 1.7 / chart.RangeY.Length; double yMin = chart.RangeY.Min; double xFactor = 2.0 / chart.RangeX.Length; double xMin = chart.RangeX.Min; // prepare learning data double[][] input = new double[samples][]; double[][] output = new double[samples][]; for (int i = 0; i < samples; i++) { input[i] = new double[1]; output[i] = new double[1]; // set input input[i][0] = (data[i, 0] - xMin) * xFactor - 1.0; // set output output[i][0] = (data[i, 1] - yMin) * yFactor - 0.85; } // create multi-layer neural network ActivationNetwork network = new ActivationNetwork( new BipolarSigmoidFunction(sigmoidAlphaValue), 1, neuronsInFirstLayer, 1); if (useNguyenWidrow) { NguyenWidrow initializer = new NguyenWidrow(network); initializer.Randomize(); } // create teacher var teacher = new ParallelResilientBackpropagationLearning(network); // iterations int iteration = 1; // solution array double[,] solution = new double[50, 2]; double[] networkInput = new double[1]; // calculate X values to be used with solution function for (int j = 0; j < 50; j++) { solution[j, 0] = chart.RangeX.Min + (double)j * chart.RangeX.Length / 49; } // loop while (!needToStop) { // run epoch of learning procedure double error = teacher.RunEpoch(input, output) / samples; // calculate solution for (int j = 0; j < 50; j++) { networkInput[0] = (solution[j, 0] - xMin) * xFactor - 1.0; solution[j, 1] = (network.Compute(networkInput)[0] + 0.85) / yFactor + yMin; } chart.UpdateDataSeries("solution", solution); // calculate error double learningError = 0.0; for (int j = 0, k = data.GetLength(0); j < k; j++) { networkInput[0] = input[j][0]; learningError += Math.Abs(data[j, 1] - ((network.Compute(networkInput)[0] + 0.85) / yFactor + yMin)); } // set current iteration's info SetText(currentIterationBox, iteration.ToString()); SetText(currentErrorBox, learningError.ToString("F3")); // increase current iteration iteration++; // check if we need to stop if ((iterations != 0) && (iteration > iterations)) break; } // enable settings controls EnableControls(true); }
// Worker thread void SearchSolution() { // number of learning samples int samples = data.GetLength(0); // prepare learning data DoubleRange unit = new DoubleRange(-1, 1); double[][] input = Tools.Scale(from: xRange, to: unit, x: data.GetColumn(0)).ToArray(); double[][] output = Tools.Scale(from: yRange, to: unit, x: data.GetColumn(1)).ToArray(); // create multi-layer neural network ActivationNetwork network = new ActivationNetwork( new BipolarSigmoidFunction(sigmoidAlphaValue), 1, neuronsInFirstLayer, 1); if (useNguyenWidrow) { new NguyenWidrow(network).Randomize(); } // create teacher var teacher = new ParallelResilientBackpropagationLearning(network); // iterations int iteration = 1; // solution array double[,] solution = new double[samples, 2]; // loop while (!needToStop) { // run epoch of learning procedure double error = teacher.RunEpoch(input, output) / samples; // calculate solution for (int j = 0; j < samples; j++) { double x = input[j][0]; double y = network.Compute(new[] { x })[0]; solution[j, 0] = Tools.Scale(from: unit, to: xRange, x: x); solution[j, 1] = Tools.Scale(from: unit, to: yRange, x: y); } chart.UpdateDataSeries("solution", solution); // calculate error double learningError = 0.0; for (int j = 0; j < samples; j++) { double x = input[j][0]; double expected = data[j, 1]; double actual = network.Compute(new[] { x })[0]; learningError += Math.Abs(expected - actual); } // set current iteration's info SetText(currentIterationBox, iteration.ToString()); SetText(currentErrorBox, learningError.ToString("F3")); // increase current iteration iteration++; // check if we need to stop if ((iterations != 0) && (iteration > iterations)) break; } // enable settings controls EnableControls(true); }
public static void Optimize( FsdParser inputParser, string outputFileName, int[][] layers, double minThreshold, double maxThreshold, double thresholdStepSize, int minTrades, int iterations, int randomize, FsdParser[] validationParsers) { HashSet<int[]> layerCombinations; getLayerCombinations(layers, out layerCombinations); Network bestNetwork = null; double bestThreshold = double.NaN; double bestMinWinRate = double.NegativeInfinity; int cursorLeft = Console.CursorLeft; int cursorTop = Console.CursorTop; int numTotalIterations = (int)(layerCombinations.Count * ((maxThreshold - minThreshold) / thresholdStepSize + 1) * iterations); int numIterations = 0; foreach (int[] layerCombination in layerCombinations) { ActivationNetwork network = new ActivationNetwork( new SigmoidFunction(), inputParser.InputVectors[0].Length, layerCombination); network.Randomize(); ParallelResilientBackpropagationLearning teacher = new ParallelResilientBackpropagationLearning(network); for (double threshold = minThreshold; threshold <= maxThreshold; threshold += thresholdStepSize) { for (int iteration = 1; iteration <= iterations; iteration++) { numIterations++; Console.CursorLeft = cursorLeft; Console.CursorTop = cursorTop; Console.Write(new string(' ', Console.BufferWidth * 10)); Console.CursorLeft = cursorLeft; Console.CursorTop = cursorTop; Console.Write("layerCombination[]: { "); for (int layerComponentIdx = 0; layerComponentIdx < layerCombination.Length; layerComponentIdx++) { Console.Write(layerCombination[layerComponentIdx]); if (layerComponentIdx < layerCombination.Length - 1) Console.Write(", "); } Console.WriteLine(" }"); Console.WriteLine("threshold: {0:0.00}", threshold); Console.WriteLine("iteration: {0}", iteration); Console.WriteLine("bestMinWinRate: {0:0.00}%", bestMinWinRate); Console.WriteLine(""); Console.WriteLine("Progress: {0:0.00}%", (double)numIterations / numTotalIterations * 100.0); if (randomize > 0 && (iteration - 1) % randomize == 0) network.Randomize(); teacher.RunEpoch(inputParser.InputVectors, inputParser.OutputVectors); bool validData = true; double minWinRate = double.PositiveInfinity; foreach (FsdParser validationParser in validationParsers) { int numTradesWon, numTradesLost; double tradeWinRate; getStatistics(network, validationParser, threshold, out numTradesWon, out numTradesLost, out tradeWinRate); if (numTradesWon + numTradesLost < minTrades) { validData = false; break; } minWinRate = Math.Min(minWinRate, tradeWinRate); if (minWinRate < bestMinWinRate) { validData = false; break; } } if (validData) { bestNetwork = network; bestThreshold = threshold; bestMinWinRate = minWinRate; network.Save(outputFileName); // Konfigurationsinformationen speichern string configuration = ""; configuration += "layerCombination[]: { "; for (int layerComponentIdx = 0; layerComponentIdx < layerCombination.Length; layerComponentIdx++) { configuration += layerCombination[layerComponentIdx]; if (layerComponentIdx < layerCombination.Length - 1) configuration += ", "; } configuration += " }\r\n"; configuration += string.Format("threshold: {0:0.00}\r\n", threshold); configuration += string.Format("iteration: {0}\r\n", iteration); configuration += string.Format("bestMinWinRate: {0:0.00}%\r\n", bestMinWinRate); File.WriteAllText(outputFileName + ".txt", configuration); } } } } }
// Worker thread void SearchSolution( ) { // initialize input and output values double[][] input = null; double[][] output = null; if ( sigmoidType == 0 ) { // unipolar data input = new double[4][] { new double[] {0, 0}, new double[] {0, 1}, new double[] {1, 0}, new double[] {1, 1} }; output = new double[4][] { new double[] {0}, new double[] {1}, new double[] {1}, new double[] {0} }; } else { // bipolar data input = new double[4][] { new double[] {-1, -1}, new double[] {-1, 1}, new double[] { 1, -1}, new double[] { 1, 1} }; output = new double[4][] { new double[] {-1}, new double[] { 1}, new double[] { 1}, new double[] {-1} }; } // create neural network ActivationNetwork network = new ActivationNetwork( ( sigmoidType == 0 ) ? (IActivationFunction) new SigmoidFunction( sigmoidAlphaValue ) : (IActivationFunction) new BipolarSigmoidFunction( sigmoidAlphaValue ), 2, 2, 1 ); // create teacher var teacher = new ParallelResilientBackpropagationLearning(network); // set learning rate and momentum teacher.Reset(initialStep); // iterations int iteration = 0; // statistic files StreamWriter errorsFile = null; try { // check if we need to save statistics to files if ( saveStatisticsToFiles ) { // open files errorsFile = File.CreateText( "errors.csv" ); } // erros list ArrayList errorsList = new ArrayList( ); // loop while ( !needToStop ) { // run epoch of learning procedure double error = teacher.RunEpoch( input, output ); errorsList.Add( error ); // save current error if ( errorsFile != null ) { errorsFile.WriteLine( error ); } // show current iteration & error SetText( currentIterationBox, iteration.ToString( ) ); SetText( currentErrorBox, error.ToString( ) ); iteration++; // check if we need to stop if ( error <= learningErrorLimit ) break; } // show error's dynamics double[,] errors = new double[errorsList.Count, 2]; for ( int i = 0, n = errorsList.Count; i < n; i++ ) { errors[i, 0] = i; errors[i, 1] = (double) errorsList[i]; } errorChart.RangeX = new Range( 0, errorsList.Count - 1 ); errorChart.UpdateDataSeries( "error", errors ); } catch ( IOException ) { MessageBox.Show( "Failed writing file", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); } finally { // close files if ( errorsFile != null ) errorsFile.Close( ); } // enable settings controls EnableControls( true ); }
static void main(String[] args) { int[] electrode_list; int[] power_bands; if (args == null || args.Length == 0) { electrode_list = new int[19]; for (int i = 0; i < 19; i++) { electrode_list[i] = i; } power_bands = new int[] { 0, 1, 2, 3, 4, 5 }; } else if (args.Length == 1) { String ls = args[0]; electrode_list = ls.Split(',').Select(e => int.Parse(e)).ToArray(); power_bands = new int[] { 0, 1, 2, 3, 4, 5 }; } else { String ls = args[0]; electrode_list = ls.Split(',').Select(e => int.Parse(e)).ToArray(); ls = args[1]; power_bands = ls.Split(',').Select(e => int.Parse(e)).ToArray(); } /* power bands: * 0 = delta (2 - 4) * 1 = theta (5 - 7) * 2 = alpha (8 - 15) * 3 = beta (16 - 31) * 4 = gamma (32 - 49) * 5 = gamma (50 - 120) */ load_inputs(electrode_list, power_bands); //Console.WriteLine("starting training;"); // var nb = new NaiveBayesLearning<NormalDistribution>(); // naive bayes init // var classifier = nb.Learn(classifier_inputs, classifier_tags); // naive bayes shuffle_inputs(new Random()); double[][] outputs = new double[classifier_tags.Length][]; for (int i = 0; i < classifier_tags.Length; i++) { outputs[i] = new double[] { (double)classifier_tags[i] }; } // LinearDiscriminantAnalysis lda = new LinearDiscriminantAnalysis(); // lda init // var classifier = lda.Learn(classifier_inputs, classifier_tags); // lda // neural net /* * var network = new ActivationNetwork(new BipolarSigmoidFunction(), inputsCount: classifier_inputs[0].Length, neuronsCount: new[] { 30, 30, 1 }); * var teacher = new Accord.Neuro.Learning.ParallelResilientBackpropagationLearning(network); * //var teacher = new Accord.Neuro.Learning.LevenbergMarquardtLearning(network); * GaussianWeights initializer = new GaussianWeights(network); * initializer.Randomize(); * * * * * var y = outputs; */ // Iterate until stop criteria is met //double error = double.PositiveInfinity; /* * * for (int i = 0; i <25 ; i++) * { * error = teacher.RunEpoch(classifier_inputs, y); * * } */ //Console.WriteLine("done training;"); //int[] answers = classifier_inputs.Apply(network.Compute).GetColumn(0).Apply(System.Math.Sign); // get input set score /* * int correct = 0; * int wrong = 0; * int total = classifier_tags.Length; */ /* * for (var i = 0; i < classifier_inputs.Length; i++) * { * int cls = classifier.Decide(classifier_inputs[i]); * Console.Write("expected: "); * Console.Write(classifier_tags[i]); * Console.Write(" : received: "); * Console.Write(Convert.ToInt32(cls)); * Console.WriteLine(""); * * if (cls == classifier_tags[i]) correct++; * else wrong++; * } */ /* * for (int i = 0; i < classifier_tags.Length; i++) * { * * var ans = (int)Math.Round(network.Compute(classifier_inputs[i])[0]); * * if (ans == classifier_tags[i]) * { * correct++; * } * else wrong++; * } * double acc = (double)correct / (double)total; // training set accuracy */ // cross validation code starts here var cross_validation_accuracies = new List <double>(); List <double[]> arr = classifier_inputs.ToList(); List <double[]> outarr = outputs.ToList(); int folds = 10; int fold_size = classifier_inputs.Length / folds; int cross_correct_total = 0; int cross_wrong_total = 0; int cross_total_total = 0; for (int i = 0; i < folds; i++) { var training_set = new List <double[]>(); var training_tags = new List <double[]>(); var validation_set = new List <double[]>(); var validation_tags = new List <double[]>(); training_set.AddRange(arr.Take(i * fold_size)); training_tags.AddRange(outarr.Take(i * fold_size)); validation_set.AddRange(arr.Skip(i * fold_size).Take(fold_size)); validation_tags.AddRange(outarr.Skip(i * fold_size).Take(fold_size)); training_set.AddRange(arr.Skip(i * fold_size + fold_size)); training_tags.AddRange(outarr.Skip(i * fold_size + fold_size)); var training_array = training_set.ToArray(); var training_array_tags = training_tags.ToArray(); var validation_array = validation_set.ToArray(); var validation_array_tags = validation_tags.ToArray(); var cross_network = new ActivationNetwork(new BipolarSigmoidFunction(), inputsCount: training_array[0].Length, neuronsCount: new[] { 30, 1 }); var cross_teacher = new Accord.Neuro.Learning.ParallelResilientBackpropagationLearning(cross_network); //var teacher = new Accord.Neuro.Learning.LevenbergMarquardtLearning(network); GaussianWeights cross_initializer = new GaussianWeights(cross_network); cross_initializer.Randomize(); var z = training_array_tags; double cross_error = double.PositiveInfinity; // training network for (int t = 0; t < 25; t++) { cross_error = cross_teacher.RunEpoch(training_array, z); } // network trained - calculate accuracy. int cross_correct = 0; int cross_wrong = 0; int cross_total = validation_array_tags.Length; for (int t = 0; t < validation_array_tags.Length; t++) { var ans = (int)Math.Round(cross_network.Compute(validation_array[t])[0]); if (ans == validation_array_tags[t][0]) { cross_correct++; } else { cross_wrong++; } } cross_correct_total += cross_correct; cross_wrong_total += cross_wrong; cross_total_total += cross_total; double cross_acc = (double)cross_correct / (double)cross_total; cross_validation_accuracies.Add(cross_acc); } var acc = cross_validation_accuracies.Average(); // write cross_validation_accuracies to a file. Console.WriteLine(cross_validation_accuracies.ToString()); Dictionary <string, object> collection = new Dictionary <string, object>() { { "Accuracy", acc }, { "Fold_Accuracies", cross_validation_accuracies.ToArray() } }; JObject Result = new JObject( new JProperty("metrics", JObject.FromObject(collection) ) ); Console.WriteLine("BEGIN METRICS"); Console.WriteLine(Result.ToString()); Console.WriteLine("END METRICS"); Console.ReadKey(); }
public List<double> Treino(string path) { double learningUtheil = 0.0; double learningError = 0.0; double validationError = 0.0; double validationUtheil = 0.0; double validationMAPE = 0.0; //setando o erro de comparação da validação em um valor extremo menoresErros[2] = 1000; //variável que conta a quantidade de iterações int iteration; //variável auxiliar que define quando o processo de treino acaba bool needToStop = false; //fator de normalização fatorNormal = 2.0 / (Serie.Max - Serie.Min); //lista contendo todos os ids de 1 a 52 List<int> ids = Serie.Ids; //variavel que possuirá o id binário int[] id = new int[6]; // número de amostras para a aprendizagem int samples = dadosTreino.Count - windowSize - predictionSize; // preparação dos dados para a aprendizagem double[][] input = new double[samples][];//vetor de entrada double[][] output = new double[samples][];//vetor de saída for (int i = 0; i < samples; i++) { //define o tamanho da entrada input[i] = new double[windowSize + predictionSize * 6]; //define o tamanho da saída output[i] = new double[predictionSize]; // configura a entrada com os dados formatados for (int j = 0; j < windowSize + predictionSize * 6; j++) { if (j < windowSize) { input[i][j] = (dadosTreino[i + j] - Serie.Min) * fatorNormal - 1.0; } else { if (j == windowSize) id = CUtil.ConversaoBinario(ids[i + windowSize]); input[i][j] = id[j - windowSize]; } }// fim do for interno // configura os dados de saída com os dados transformados for (int k = 0; k < predictionSize; k++) { output[i][k] = (dadosTreino[i + k + windowSize] - Serie.Min) * fatorNormal - 1; } }//fim do for externo //cria o "Professor" da rede neural ParallelResilientBackpropagationLearning teacher = new ParallelResilientBackpropagationLearning(network); //Variável para contar o número de iterações iteration = 1; //vetor que armazena a solução encontrada pela rede neural int solutionSize = dadosTreino.Count - windowSize; double[] solution = new double[solutionSize]; //Vetor auxiliar que seta as entrada a serem computadas pela rede neural double[] networkInput = new double[windowSize + predictionSize * 6]; // loop que efetua as iterações while (!needToStop) { learningError = 0.0; learningUtheil = 0.0; //roda uma iteração do processo de aprendizagem retornando o erro obtido double error = teacher.RunEpoch(input, output) / samples; //variaveis auxiliares para calculo do utheil double somaY = 0.0; double somaF = 0.0; //variavel auxiliar para calcular os erros int amostra = 0; //variavel auxiliar para o id binário int contador = 0; // computa as saídas através de toda a lista de dados, armazena os valores de saída da rede em solution for (int i = 0, n = dadosTreino.Count - windowSize - predictionSize + 1; i < n; i++) { int a = windowSize; contador = 0; // seta os valores da atual janela de previsão como entrada da rede neural for (int j = 0; j < windowSize + predictionSize; j++) { if (j < windowSize) { //entrada tem de ser formatada networkInput[j] = (dadosTreino[i + j] - Serie.Min) * fatorNormal - 1.0; } else { id = CUtil.ConversaoBinario(ids[i + a]); a++; for (int c = 0; c < 6; c++) { networkInput[windowSize + contador] = id[c]; contador++; } }//fim do else }//fim do for interno //computa a saída da rede e armazena o dado solution diferenca for (int k = 0; k < network.Compute(networkInput).Length; k++) { double diferenca = (network.Compute(networkInput)[k] + 1.0) / fatorNormal + Serie.Min; if ((i + k) < solutionSize) solution[i + k] = (diferenca) + Serie.Dados[windowSize + i, 1]; } //calcula o erro de aprendizagem amostra++; //variaveis auxiliares do u theil somaY += ((Serie.Dados[windowSize + i, 1]) * (Serie.Dados[windowSize + i, 1])); somaF += ((solution[i] * solution[i])); learningError += ((solution[i] - Serie.Dados[windowSize + i + 1, 1]) * (solution[i] - Serie.Dados[windowSize + i, 1])); }//fim do for externo learningError = (learningError) / amostra; somaF = somaF / amostra; somaY = somaY / amostra; learningUtheil = Math.Sqrt(learningError) / (Math.Sqrt(somaY) + Math.Sqrt(somaF)); // validação if (iteration >= 30) Validacao(); // incrementa a iteração atual iteration++; // confere se precisamos ou não parar, fator de parada é o número de iterações if (iteration > 400) break; }//fim do while validationError = menoresErros[0]; validationMAPE = menoresErros[1]; validationUtheil = menoresErros[2]; return solution.ToList(); }