private double CalculateClassificationError(BasicNeuralDataSet trainingSet) { int errorCount = 0; foreach (var trainData in trainingSet) { IMLData output = _network.Compute(trainData.Input); IMLData ideal = trainData.Ideal; double maxValue = Double.MinValue; int maxIndex = 0; for (int i = 0; i < output.Count; ++i) { if (maxValue < output[i]) { maxValue = output[i]; maxIndex = i; } } if (Math.Abs(ideal[maxIndex] - 1) > 0.0001) { errorCount++; } } return((double)errorCount / trainingSet.Count); }
public void Predict(BasicNetwork network) { Console.WriteLine(@"Year Actual Predict Closed Loop Predict Denormalized Value Real Value"); for (var year = EvaluateStart; year < EvaluateEnd; year++) { // calculate based on actual data var input = new BasicMLData(WindowSize); for (var i = 0; i < input.Count; i++) { input[i] = _normalizedForexPair[(year - WindowSize) + i]; } IMLData output = network.Compute(input); var prediction = output[0]; _closedLoopForexPair[year] = prediction; // calculate "closed loop", based on predicted data for (var i = 0; i < input.Count; i++) { input[i] = _closedLoopForexPair[(year - WindowSize) + i]; } output = network.Compute(input); var closedLoopPrediction = output[0]; // display Console.WriteLine("{0} {1} {2} {3} Accuracy:{4} Denormalized:{5} Real value:{6}", (StartingYear + year), Format.FormatDouble(_normalizedForexPair[year], 5), Format.FormatDouble(prediction, 5), Format.FormatDouble(closedLoopPrediction, 5), Format.FormatDouble(_normalizedForexPair[year] - prediction, 5), array.Stats.DeNormalize(prediction), ForexPair[year]); } }
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); }
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 void Predict(BasicNetwork network) { Console.WriteLine(@"Year Actual Predict Closed Loop Predict"); for (int year = EvaluateStart; year < EvaluateEnd; year++) { // calculate based on actual data var input = new BasicMLData(WindowSize); for (var i = 0; i < input.Count; i++) { input[i] = _normalizedSunspots[(year - WindowSize) + i]; } IMLData output = network.Compute(input); double prediction = output[0]; _closedLoopSunspots[year] = prediction; // calculate "closed loop", based on predicted data for (var i = 0; i < input.Count; i++) { input[i] = _closedLoopSunspots[(year - WindowSize) + i]; } output = network.Compute(input); double closedLoopPrediction = output[0]; // display Console.WriteLine((StartingYear + year) + @" " + Format.FormatDouble(_normalizedSunspots[year], 2) + @" " + Format.FormatDouble(prediction, 2) + @" " + Format.FormatDouble(closedLoopPrediction, 2)); } }
public void Predict(BasicNetwork network) { Console.WriteLine(@"Year Actual Predict Closed Loop Predict Denormalized Value Real Value"); for (int year = EvaluateStart; year < EvaluateEnd; year++) { // calculate based on actual data IMLData input = new BasicMLData(WindowSize); for (var i = 0; i < input.Count; i++) { input.Data[i] = _normalizedSunspots[(year - WindowSize) + i]; } IMLData output = network.Compute(input); double prediction = output.Data[0]; _closedLoopSunspots[year] = prediction; // calculate "closed loop", based on predicted data for (var i = 0; i < input.Count; i++) { input.Data[i] = _closedLoopSunspots[(year - WindowSize) + i]; } output = network.Compute(input); double closedLoopPrediction = output.Data[0]; // display Console.WriteLine((StartingYear + year) + @" " + Format.FormatDouble(_normalizedSunspots[year], 5) + @" " + Format.FormatDouble(prediction, 5) + @" " + Format.FormatDouble(closedLoopPrediction, 5) + @" Accuracy:" + Format.FormatDouble(_normalizedSunspots[year] - prediction, 5) + " Denormalized:" + array.Stats.DeNormalize(prediction) + " Real value:" + Sunspots[year]); } }
/// <summary> /// Returns the prediction of the network for a given input. /// </summary> /// <param name="dataSource"></param> /// <returns></returns> public double[] getNetworkPrediction(NNDataSource dataSource) { double[] networkOutputs = new double[OUTPUT_NEURONS]; double[] networkInputs = new double[INPUT_NEURONS]; dataSource.returnInput(ref networkInputs); network.Compute(networkInputs, networkOutputs); if (networkOutputs.Length != OUTPUT_NEURONS) throw new Exception("Unexpected number of network ouputs."); return networkOutputs; }
/// <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]); } }
/// <summary> /// Process one training set element. /// </summary> /// <param name="errorCalc">The error calculation to use.</param> /// <param name="input">The network input.</param> /// <param name="ideal">The ideal values.</param> public void Process(IErrorCalculation errorCalc, double[] input, double[] ideal) { _network.Compute(input, _actual); errorCalc.UpdateError(_actual, ideal, 1.0); // Calculate error for the output layer. var outputLayerIndex = _network.Layers.Count - 1; var outputActivation = _network.Layers[outputLayerIndex].Activation; errorFunction.CalculateError( outputActivation, _layerSums, _layerOutput, ideal, _actual, _layerDelta, 0, 1.0); // Apply regularization, if requested. if (_owner.L1 > AIFH.DefaultPrecision || _owner.L1 > AIFH.DefaultPrecision) { var lp = new double[2]; CalculateRegularizationPenalty(lp); for (var i = 0; i < _actual.Length; i++) { var p = lp[0] * _owner.L1 + lp[1] * _owner.L2; _layerDelta[i] += p; } } // Propagate backwards (chain rule from calculus). for (var i = _network.Layers.Count - 1; i > 0; i--) { var layer = _network.Layers[i]; layer.ComputeGradient(this); } }
static void Main(string[] args) { INeuralDataSet trainingSet = new BasicNeuralDataSet(AndInput, AndIdeal); var network = new BasicNetwork(); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 1)); network.Structure.FinalizeStructure(); network.Reset(); ITrain train = new ResilientPropagation(network, trainingSet); int epoch = 1; do { train.Iteration(); Console.WriteLine($"Epoch no {epoch}. Error: {train.Error}"); epoch++; } while ((epoch < MaxEpoch) && (train.Error > AcceptableError)); Console.WriteLine("\nAnd function Results:"); foreach (IMLDataPair pair in trainingSet) { IMLData output = network.Compute(pair.Input); Console.WriteLine($"{pair.Input[0]} AND {pair.Input[1]} should be: {pair.Ideal[0]} actual value is: {output[0]}"); } Console.ReadKey(); }
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 LasPoint.ClassificationType[] Classify(LasFile file) { Stopwatch sw = Stopwatch.StartNew(); LasPointDataRecords points = file.LasPointDataRecords; LasPoint.ClassificationType[] output = new LasPoint.ClassificationType[points.Count]; Statistics stats = new Statistics(); stats.Count = points.Count; for (int i = 0; i < points.Count; i++) { LasPoint3Short point = (LasPoint3Short)points[i]; double green = point.Green - (point.Red + point.Blue) / 2; IMLData classed = Network.Compute( new BasicMLData(new double[] { file.LasHeader.ScaleZ(point.Z), point.Intensity, green })); output[i] = Utills.QuickClassess[classed.IndexOfMax()]; if (output[i] != points[i].Classification) { stats.ClassErrors[(int)points[i].Classification]++; } stats.PredictionMatrix[(int)points[i].Classification, (int)output[i]]++; stats.ClassCount[(int)output[i]]++; stats.ClassRealCount[(int)points[i].Classification]++; if (i % 1000 == 0) { Console.WriteLine(i); } } Console.Write(stats.ToString()); sw.Stop(); Console.WriteLine("Czas trwania [" + sw.Elapsed.TotalSeconds.ToString() + "s]"); stats.SaveMatrixAsCSV(); return(output); }
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]); } }
static void Main(string[] args) { Console.Write("Enter network ID: "); int networkID = int.Parse(Console.ReadLine()); FileInfo trainFile = new FileInfo("dataset.egb"); FileInfo networkFile = new FileInfo($"network{networkID}.nn"); IMLDataSet trainingSet = LoadDataSet(trainFile); BasicNetwork network = LoadNetwork(networkFile); using (var p = Process.GetCurrentProcess()) Console.WriteLine($"RAM usage: {p.WorkingSet64 / 1024 / 1024} MB."); foreach (var sample in trainingSet) { Console.WriteLine("------------"); for (int i = 0; i < sample.Ideal.Count; i++) { Console.Write(fmt, sample.Ideal[i]); } Console.WriteLine(); //Console.WriteLine(sample.Ideal.ToString()); IMLData res = network.Compute(sample.Input); for (int i = 0; i < sample.Ideal.Count; i++) { Console.Write(fmt, res[i]); } Console.WriteLine(); //Console.WriteLine(res.ToString()); Console.ReadKey(); } }
protected override TimeSeries _BuildOutput(TimeSeries simulatedData, object userState = null) { if (mModel == null) { mModel = BuildModel(simulatedData, out mScaleFactor); } TimeSeries preds = new TimeSeries(); for (int i = 0; i < simulatedData.Count; ++i) { double[] input = new double[mWindowSize]; for (int j = 0; j < mWindowSize; ++j) { int index = i - (mWindowSize - j); if (index >= 0) { input[j] = simulatedData[index] / mScaleFactor; } } double[] output = new double[1]; mModel.Compute(input, output); preds.Add(simulatedData.TimeStamp(i), output[0] * mScaleFactor, false); } return(preds); }
public TimeSeries Predict(BasicNetwork network, NormalizeArray norm, TimeSeries simulatedData) { double[] data = GenerateData(simulatedData); int data_count = simulatedData.Count; TimeSeries ts = new TimeSeries(); double input_val = 0; for (int idx = 0; idx < data_count; ++idx) { var input = new BasicMLData(WindowSize); for (var i = 0; i < WindowSize; i++) { int idx2 = (idx - WindowSize) + i; if (idx2 < 0) { input_val = 0; } else { input_val = norm.Stats.Normalize(data[idx2]); } input[i] = input_val; } IMLData output = network.Compute(input); double prediction = norm.Stats.DeNormalize(output[0]); ts.Add(simulatedData.TimeStamp(idx), prediction, false); } return(ts); }
double Evaluate(double[] input) { var output = new double[1]; _network.Compute(input, output); return(output[0]); }
public static void Main() { BasicNetwork network = new BasicNetwork(); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 2)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 6)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 1)); network.Structure.FinalizeStructure(); network.Reset(); INeuralDataSet trainingSet = new BasicNeuralDataSet(XorInput, XorIdeal); ITrain train = new ResilientPropagation(network, trainingSet); int epoch = 1; var timer = Stopwatch.StartNew(); do { train.Iteration(); epoch++; } while ((epoch < 50000) && (train.Error > 0.0001)); timer.Stop(); Console.WriteLine("Neural Network Results:"); 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]); } Console.WriteLine($"Completed {epoch} epochs in {timer.Elapsed} ({(float)timer.ElapsedMilliseconds / epoch} ms per epoch)"); Console.ReadLine(); }
public static void Main(string[] args) { var data = LoadData(); var label = LoadLabel(); var network = new BasicNetwork(); network.AddLayer(new BasicLayer(null, true, 4)); network.AddLayer(new BasicLayer(new ActivationReLU(), true, 8)); network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 3)); network.Structure.FinalizeStructure(); network.Reset(); var trainingSet = new BasicMLDataSet(data, label); network.Flat.Weights = LoadNetwork(); //Train(network, trainingSet); //SaveNetwork(network); var sum = 0; foreach (var pair in trainingSet) { var output = network.Compute(pair.Input); Console.WriteLine($"Input: {pair.Input} Actual: {output.ToOneHot()} Ideal: {pair.Ideal}"); if (CompareMLData(output.ToOneHot(), pair.Ideal)) { sum++; } } Console.WriteLine($"Result = {((float)sum / trainingSet.Count) * 100}"); }
public void Run() { 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(); 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 pair in trainingSet) { IMLData output = network.Compute(pair.Input); Console.WriteLine(pair.Input[0] + @" , " + pair.Input[1] + @" , actual = " + output[0] + @" , ideal = " + pair.Ideal[0]); } EncogFramework.Instance.Shutdown(); }
public int IdentifyMagic(double[] raw_input) { List <double> input; double max = 0; double[] op = new double[4]; int index = 0; for (int i = 0; i < magics.Count; i++) { input = raw_input.ToList(); input.AddRange(magics[i].baseline); IMLData inputData = new BasicMLData(input.ToArray()); IMLData output; output = network.Compute(inputData); op[i] = output[0]; if (max < output[0]) { max = output[0]; index = i; } } foreach (double o in op) { Debug.Log(o); } return((max > tolerance) ? index : -1); }
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 List <PredictionResults> Predict(DateTime predictFrom, DateTime predictTo) { List <PredictionResults> results = new List <PredictionResults>(); double[] present = new double[InputTuples * IndexesToConsider]; double[] actualOutput = new double[OutputSize]; int index = 0; foreach (var sample in _manager.Samples) { if (sample.Date.CompareTo(predictFrom) > 0 && sample.Date.CompareTo(predictTo) < 0) { var result = new PredictionResults(); _manager.GetInputData(index - InputTuples, present); _manager.GetOutputData(index - InputTuples, actualOutput); var data = new BasicNeuralData(present); var predict = _network.Compute(data); result.ActualLotos = actualOutput[0] * (_manager.MaxLotos - _manager.MinLotos) + _manager.MinLotos; result.PredictedLotos = predict[0] * (_manager.MaxLotos - _manager.MinLotos) + _manager.MinLotos; result.ActualPir = actualOutput[1] * (_manager.MaxPrimeRate - _manager.MinPrimeRate) + _manager.MinPrimeRate; result.PredictedPir = predict[1] * (_manager.MaxPrimeRate - _manager.MinPrimeRate) + _manager.MinPrimeRate; result.ActualOrlen = actualOutput[2] * (_manager.MaxOrlen - _manager.MinOrlen) + _manager.MinOrlen; result.PredictedOrlen = predict[2] * (_manager.MaxOrlen - _manager.MinOrlen) + _manager.MinOrlen; result.Date = sample.Date; var error = new ErrorCalculation(); error.UpdateError(actualOutput, predict.Data); result.Error = error.CalculateRMS(); results.Add(result); } index++; } return(results); }
public void GetResults() { foreach (Texture2D texture in OpenFile.Open()) { IMLDataPair pair = new BasicMLDataPair(new BasicMLData(Texture2List(texture).ToArray())); IMLData output = basicNetwork.Compute(pair.Input); string result = ""; float ideal = 0; if (output[0] < 0.25f) { result = "Normal"; } else if (output[0] > 0.25f && output[0] < 0.75f) { result = "Esquemico"; ideal = 0.5f; } else { result = "Hemorragico"; ideal = 1.0f; } Debug.Log("Isso parece ser: " + result + "\nEquivalência{ Imagem Testada: " + output[0] + " Imagem Original: " + ideal + " }"); debugText.text = ("Isso parece ser: " + result + "\nEquivalência{ Imagem Testada: " + output[0] + " Imagem Original: " + ideal + " }"); } }
private static void CalculateProfit(IMLDataSet trainingSet, BasicNetwork network, Results res) { foreach (var article in trainingSet) { bool tradeMade = false; var computed = network.Compute(article.Input); for (int i = 0; i < trainingSet.IdealSize; i++) { if (computed[i] > 0.2) { tradeMade = true; double reward = article.Ideal[i] * moneyPerTrade; if (reward > transactionFee) { res.win[i]++; } else { res.loss[i]++; } if (reward > 0) { res.goodDir[i]++; } else { res.badDir[i]++; } res.profit[i] += reward - transactionFee; } if (computed[i] < -0.2) { tradeMade = true; double reward = -article.Ideal[i] * moneyPerTrade; if (reward > transactionFee) { res.win[i]++; } else { res.loss[i]++; } if (reward > 0) { res.goodDir[i]++; } else { res.badDir[i]++; } res.profit[i] += reward - transactionFee; } } if (tradeMade) { res.articlesTraded++; } } }
public static double[] Compute(this BasicNetwork network, double[] input) { double[] retVal = new double[network.OutputCount]; network.Compute(input, retVal); return(retVal); }
/// <summary> /// Takes a state of the board and returns probability of /// first player win. /// </summary> /// <param name="vector"></param> /// <returns></returns> public double EvaluateState(Board board) { //IMLData input = ANNAdapter.Adapt(board); IMLData input = ANNAdapter.Adapt192(board); IMLData output = network.Compute(input); return(output[0]); }
//public double Travel(ref int timeout, out int movesCnt) public double Travel(int timerTimeout, out int movesCnt) { MazeGame game = new MazeGame(); game.InitGame(maze); game.traveler = this; game.traveler.location.X = maze.StartingPosition.X; game.traveler.location.Y = maze.StartingPosition.Y; var recentOutcome = new MazeCycleOutcome(); tmr.Interval = timerTimeout; tmr.Start(); timeout = 0; movesCnt = 0; while (!recentOutcome.GameOver && timeout == 0) { movesCnt++; var input = new BasicMLData(2); input[0] = xInput.Normalize(Convert.ToDouble(game.traveler.location.X)); input[1] = yInput.Normalize(Convert.ToDouble(game.traveler.location.Y)); IMLData output = network.Compute(input); double maxVal = double.MinValue; int direction = 0; for (int i = 0; i < output.Count; i++) { if (output[i] > maxVal) { direction = i; maxVal = output[i]; } } recentOutcome = game.CycleMaze(direction); MazeCycleComplete?.Invoke(game.traveler.location.X, game.traveler.location.Y, recentOutcome.BumpedIntoWall); } tmr.Stop(); var score = game.CalculateFinalScore(movesCnt); return(score); }
private void button2_Click(object sender, EventArgs e) { FeatureExtract Inputs = new FeatureExtract(); Inputs.dataMagnitude = dataMagnitude; Inputs.Feature(); feature = new double[7]; feature[0] = (Inputs.MAV - 18.231) * 2 / (131.22 - 18.231) - 1; feature[1] = (Inputs.RMS - 24.78176668) * 2 / (180.9976057 - 24.78176668) - 1; feature[2] = (Inputs.VAR - 575.07346) * 2 / (32723.06952 - 575.07346) - 1; feature[3] = (Inputs.SD - 23.98068931) * 2 / (180.8951893 - 23.98068931) - 1; feature[4] = (Inputs.WL - 411.76) * 2 / (1664.26 - 411.76) - 1; feature[5] = (Inputs.ZC - 1) * 2 / (12 - 1) - 1; feature[6] = (Inputs.SSC - 3) * 2 / (15 - 3) - 1; IMLData q = new BasicMLData(feature); BasicNetwork JST = new BasicNetwork(); openFileDialog1.Title = "Open Network File..."; openFileDialog1.FileName = ""; openFileDialog1.Filter = "EG (Encog Network)|*.eg|All Files|*.*"; if (openFileDialog1.ShowDialog() == DialogResult.Cancel) { MessageBox.Show("Choice Cancelled"); } else { JST = (BasicNetwork)EncogDirectoryPersistence.LoadObject(new FileInfo(openFileDialog1.FileName)); IMLData output = JST.Compute(q); if (output[0] > output[1] && output[0] > output[2] && output[0] > output[3]) { label2.Text = "Atas"; } else if (output[1] > output[0] && output[1] > output[2] && output[1] > output[3]) { label2.Text = "Bawah"; } else if (output[2] > output[1] && output[2] > output[0] && output[2] > output[3]) { label2.Text = "Kanan"; } else if (output[3] > output[1] && output[3] > output[2] && output[3] > output[0]) { label2.Text = "Kiri"; } else { label2.Text = "Tidak Terdefinisikan"; } label3.Text = "output" + "= " + output[0] + " " + output[1] + " " + output[2] + " " + output[3]; } }
public double TestSingle(double[] input) { double[] outPut = new double[1]; BasicNetwork network = (BasicNetwork)SerializeObject.Load(networkFile); network.Compute(input, outPut); //Console.Write("The chance of winning is: " + Math.Round(output[0]*100,2) + "% | "); return(outPut[0]); }