// Start is called before the first frame update void Start() { network = new Neural(); network.learningRate = learningRate; ReadData(); }
private void btnLoad_Click(object sender, EventArgs e) { neural = new Neural(INPUT, HIDDEN, OUTPUT); using (StreamReader reader = new StreamReader(inputWeightsFile)) { INeuron[] inputNeuron = neural.InputNeurons; for (int i = 0; i < inputNeuron.Length; i++) { double[] weights = new double[HIDDEN]; for (int j = 0; j < weights.Length; j++) { weights[j] = Convert.ToDouble(reader.ReadLine()); } inputNeuron[i].LoadWeights(weights); } } using (StreamReader reader = new StreamReader(hiddenWeightsFile)) { HNeuron[] hiddenNeuron = neural.HiddenNeurons; for (int i = 0; i < hiddenNeuron.Length; i++) { double[] weights = new double[OUTPUT]; for (int j = 0; j < weights.Length; j++) { weights[j] = Convert.ToDouble(reader.ReadLine()); } hiddenNeuron[i].LoadWeights(weights); } } MessageBox.Show("Weights Loaded!"); }
void FixedUpdate() { if (ballCtrl.GetPosition().y - diskCtrl.GetPosition().y < -5 || Mathf.Abs(ballCtrl.GetPosition().x - diskCtrl.GetPosition().x) > 5 || Mathf.Abs(ballCtrl.GetPosition().z - diskCtrl.GetPosition().z) > 5) { Restart(); } switch (mode) { case EvaluationMode.Neural: OutputData neuralOutput = Neural.Evaluate(PrepareData()); diskCtrl.SetAngularVelocity(FloatToVector3(neuralOutput.outputDiskRotationSpeedVector)); break; case EvaluationMode.Fuzzy: OutputData fuzzyOutput = FuzzyLogic.Evaluate(PrepareData()); // fuzzyOutput.outputDiskRotationSpeedVector[2] = -fuzzyOutput.outputDiskRotationSpeedVector[2]; diskCtrl.SetAngularVelocity(FloatToVector3(fuzzyOutput.outputDiskRotationSpeedVector)); break; /* case EvaluationMode.TrainNeural: * OutputData neuralOutputExp = new OutputData(Vector3ToFloat(diskCtrl.GetAngularVelocity())); * if (diskCtrl.GetAngularVelocity() != Vector3.zero) * Neural.Train(PrepareData(), neuralOutputExp); * break;*/ } }
public NeuralDemo() { InitializeComponent(); neural = new Neural(INPUT, HIDDEN, OUTPUT); LoadXMLFiles(); lblEpoch.Text = string.Empty; lblCardName.Text = string.Empty; }
public void Neuron_With_Valid_Testdata(double[] ws, double[] ins, double output) { Func <double, double> a0 = x => x; Func <double, double> a1 = x => x * 2; Func <double, double> a2 = x => x - 10; Func <double, double> a3 = x => x * x - x * 4 + 23; Assert.Equal(a0(output), Neural.Neuron(a0, ws, ins)); Assert.Equal(a1(output), Neural.Neuron(a1, ws, ins)); Assert.Equal(a2(output), Neural.Neuron(a2, ws, ins)); Assert.Equal(a3(output), Neural.Neuron(a3, ws, ins)); }
public void BenchNeural() { NNetStruct t = new Neural(); t.loops = 1; t.adjust = 1; for (int i = 0; i < NeuralIterations; i++) { t.Run(); } }
public void FoldExpression_With_Testdata(double[] expressedGenes, uint[] config, int wsssLength) { double[][][] wsss = Neural.FoldExpression(expressedGenes, config); Assert.Equal(wsssLength, wsss.Length); for (int i = 0; i < wsssLength; i++) { Assert.Equal((int)config[i + 1], wsss[i].Length); for (int j = 0; j < wsss[i].Length; j++) { Assert.Equal((int)config[i] + 1, wsss[i][j].Length); } } }
static void Main(string[] args) { Learning.TrainingExample[] exs_pics = new Learning.TrainingExample[100]; for (int i = 1; i <= 50; i++) { exs_pics[i - 1] = new Learning.TrainingExample(readImage(new Bitmap($"{string.Format("o{00:00}.bmp", i)}")).Select(b => (double)b).ToArray(), new double[] { 0, 1 }); } for (int i = 1; i <= 50; i++) { exs_pics[i + 49] = new Learning.TrainingExample(readImage(new Bitmap($"{string.Format("x{00:00}.bmp", i)}")).Select(b => (double)b).ToArray(), new double[] { 1, 0 }); } uint[] config = new uint[] { 16 * 16, 30, 4, 2 }; //double[] solution = Learning.TrainNeuralNetworkRuleofTwo(exs_pics, config, Genetics.Hash, 1); double[] solution = Learning.TrainNeuralNetworkSelectiveBreeding(exs_pics, config, Genetics.Hash, 50); //double[] solution = Learning.TrainNeuralNetworkRoulette(exs_pics, config, Genetics.Hash, 1); double[][][] wsss = Neural.FoldExpression(solution, config); double[] cross = Neural.Network(Neural.Sigmoid, wsss, readImage(new Bitmap("test01o.bmp")).Select(b => (double)b)).ToArray(); double[] circle = Neural.Network(Neural.Sigmoid, wsss, readImage(new Bitmap("test11x.bmp")).Select(b => (double)b)).ToArray(); int nCorrects = 0; for (int i = 1; i <= 10; i++) { double[] outs = Neural.Network(Neural.Sigmoid, wsss, readImage(new Bitmap(string.Format("test{00:00}o.bmp", i))).Select(b => (double)b)).ToArray(); Console.WriteLine($"TESTING CROSS\n\tProbability of cross: {outs[0]}, Probability of circle: {outs[1]}"); if (outs[0] < outs[1]) { nCorrects++; } } for (int i = 11; i <= 20; i++) { double[] outs = Neural.Network(Neural.Sigmoid, wsss, readImage(new Bitmap(string.Format("test{00:00}x.bmp", i))).Select(b => (double)b)).ToArray(); Console.WriteLine($"TESTING CIRCLE\n\tProbability of cross: {outs[0]}, Probability of circle: {outs[1]}"); if (outs[0] > outs[1]) { nCorrects++; } } Console.WriteLine($"nCorrects={nCorrects}"); }
public NetworkPorts(Neural.Network network, IDictionary<int, IReceptiveField> upperNeurons, IDictionary<int, IReceptiveField> lowerNeurons, IDictionary<int, IReceptiveField> positionNeurons, IDictionary<int, IReceptiveField> speedNeurons ) { this.network = network; this.input = new double[network.NeuronCount]; this.output = new double[network.NeuronCount]; UpperTheta = new NetworkInputPort(input, upperNeurons); LowerTheta = new NetworkInputPort(input, lowerNeurons); Position = new NetworkInputPort(input, positionNeurons); Speed = new NetworkSumOutputPort(output, speedNeurons); }
//private double moduleValidation(double[] input, ) //{ // double testQuality = 0.0; // double validate = 0.0; // double[] res; // for (int count = 0; count < input.Length; count++) // { // res = network.Compute(input[count]); // double value = Math.Abs(trainClasses[count] - classesList[ANNUtils.max(res)]); // validate += value; // } // testQuality = (1 - (validate / input.Length)) * 100; // return testQuality; //} //валидация по модулю internal static double AbsValidation(Neural.ActivationNetwork network, double[][] input, double[] trainClasses, List<int> classes) { double testQuality = 0.0; double validate = 0.0; double[] res; for (int count = 0; count < input.Length; count++) { res = network.Compute(input[count]); var a = Common.Max(res); var b = classes[Common.Max(res)]; var c = trainClasses[count]; double value = Math.Abs(trainClasses[count] - classes[Common.Max(res)]); validate += value; } testQuality = (1 - (validate / input.Length)) * 100; return testQuality; }
public static void BenchNeural() { Setup(); NNetStruct t = new Neural(); t.loops = 1; t.adjust = 1; foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { for (int i = 0; i < NeuralIterations; i++) { t.Run(); } } } }
public void IsJagged_With_Jagged_Testdata() { double[][] arrays0 = new double[][] { new double[] { }, new double[] { 0 } }; double[][] arrays1 = new double[][] { new double[] { 0, 0 }, new double[] { 0 } }; double[][] arrays2 = new double[][] { new double[] { 0, 0 }, new double[] { 0, 0 }, new double[] { 0, 0, 0 }, new double[] { 0, 0 }, new double[] { 0, 0 } }; double[][] arrays3 = new double[][] { new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 }, new double[] { 0, 0 } }; double[][] arrays4 = new double[][] { new double[] { 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0 }, new double[] { }, new double[] { 0, 0, 0, 0 } }; Assert.True(Neural.IsJagged(arrays0)); Assert.True(Neural.IsJagged(arrays1)); Assert.True(Neural.IsJagged(arrays2)); Assert.True(Neural.IsJagged(arrays3)); Assert.True(Neural.IsJagged(arrays4)); }
public void ChangeNet(bool next) { selectedNet += next ? 1 : -1; if (selectedNet < 0) { selectedNet = maxNet; } if (selectedNet > maxNet) { selectedNet = 0; } Neural.CreateNetwork(netsSizes[selectedNet], netsWeights[selectedNet]); nn = Neural.GetNetwork(); netName.text = "Network Name\n" + netNames[selectedNet]; for (int i = 0; i < 4; i++) { biasSliders[i].value = nn.GetLayers()[0].GetNodes()[i].bias; } }
public void Network_With_Test_Data() { double[] ins = new double[] { 2.3, 4.8, 9.2 }; double[][][] wsss = new double[][][] { new double[][] { new double[] { 1.2, 0.8, 9.1, 2.9 }, new double[] { 9.3, 4.7, 8.3, 7.4 }, new double[] { 2.9, 3.8, 5.8, 9.2 } }, new double[][] { new double[] { 6.3, 5.6, 3.4, 4.3 }, new double[] { 3.4, 3.4, 5.6, 6.7 } } }; Func <double, double> fa = x => x * x; Func <double, double> fb = x => x * 3; double n00a = fa(2.3 * 1.2 + 4.8 * 0.8 + 9.2 * 9.1 + 2.9); double n01a = fa(2.3 * 9.3 + 4.8 * 4.7 + 9.2 * 8.3 + 7.4); double n02a = fa(2.3 * 2.9 + 4.8 * 3.8 + 9.2 * 5.8 + 9.2); double n00b = fb(2.3 * 1.2 + 4.8 * 0.8 + 9.2 * 9.1 + 2.9); double n01b = fb(2.3 * 9.3 + 4.8 * 4.7 + 9.2 * 8.3 + 7.4); double n02b = fb(2.3 * 2.9 + 4.8 * 3.8 + 9.2 * 5.8 + 9.2); double n10a = fa(n00a * 6.3 + n01a * 5.6 + n02a * 3.4 + 4.3); double n11a = fa(n00a * 3.4 + n01a * 3.4 + n02a * 5.6 + 6.7); double n10b = fb(n00b * 6.3 + n01b * 5.6 + n02b * 3.4 + 4.3); double n11b = fb(n00b * 3.4 + n01b * 3.4 + n02b * 5.6 + 6.7); double[] outputa = new double[] { n10a, n11a }; double[] outputb = new double[] { n10b, n11b }; Assert.Equal(outputa, Neural.Network(fa, wsss, ins)); Assert.Equal(outputb, Neural.Network(fb, wsss, ins)); }
public void Evolve(Neural from, float x) { for (int i = 0; i < Layer0; ++i) { bias0[i] = Random.Range(0.0f, 1.0f) < x ? from.bias0[i] : bias0[i]; } for (int i = 0; i < Layer1; ++i) { bias1[i] = Random.Range(0.0f, 1.0f) < x ? from.bias1[i] : bias1[i]; } for (int i = 0; i < Layer2; ++i) { bias2[i] = Random.Range(0.0f, 1.0f) < x ? from.bias2[i] : bias2[i]; } for (int i = 0; i < Layer0 * Layer1; ++i) { weights10[i] = Random.Range(0.0f, 1.0f) < x ? from.weights10[i] : weights10[i]; } for (int i = 0; i < Layer1 * Layer2; ++i) { weights21[i] = Random.Range(0.0f, 1.0f) < x ? from.weights21[i] : weights21[i]; } }
public void LerpTowards(Neural from, float x) { for (int i = 0; i < Layer0; ++i) { bias0[i] = Mathf.Lerp(bias0[i], from.bias0[i], x); } for (int i = 0; i < Layer1; ++i) { bias1[i] = Mathf.Lerp(bias1[i], from.bias1[i], x); } for (int i = 0; i < Layer2; ++i) { bias2[i] = Mathf.Lerp(bias2[i], from.bias2[i], x); } for (int i = 0; i < Layer0 * Layer1; ++i) { weights10[i] = Mathf.Lerp(weights10[i], from.weights10[i], x); } for (int i = 0; i < Layer1 * Layer2; ++i) { weights21[i] = Mathf.Lerp(weights21[i], from.weights21[i], x); } }
public void Layer_With_Valid_TestData() { double[] ins0 = new double[] { }; double[][] wss0 = new double[][] { }; double[] output0 = new double[] { }; double[] ins1 = new double[] { 1, 29, 19, 4 }; double[][] wss1 = new double[][] { new double[] { 23, 2, 3, 899 } }; double[] output1 = new double[] { 1 * 23 + 29 * 2 + 19 * 3 + 4 * 899 + 899 }; double[] ins2 = new double[] { -9, 3.4, 7, 8.94, 3 }; double[][] wss2 = new double[][] { new double[] { 2.03, 9, 8, 40.9, 0.2, -3 }, new double[] { 1.2, 1, -9, 8, 0, 1.2 }, new double[] { -9, 2, 3.9, 2.8, -8, 9.2 }, new double[] { 3.2, 8, 9, 2.3, 9, 8.29 } }; double[] output2 = new double[] { -9 * 2.03 + 3.4 * 9 + 7 * 8 + 8.94 * 40.9 + 3 * 0.2 - 3, -9 * 1.2 + 3.4 * 1 - 7 * 9 + 8.94 * 8 + 3 * 0 + 1.2, 9 * 9 + 3.4 * 2 + 7 * 3.9 + 8.94 * 2.8 - 3 * 8 + 9.2, -9 * 3.2 + 3.4 * 8 + 7 * 9 + 8.94 * 2.3 + 3 * 9 + 8.29 }; Assert.Equal(output0.Select(x => x).ToArray(), Neural.Layer(x => x, wss0, ins0)); Assert.Equal(output1.Select(x => x).ToArray(), Neural.Layer(x => x, wss1, ins1)); Assert.Equal(output2.Select(x => x).ToArray(), Neural.Layer(x => x, wss2, ins2)); Assert.Equal(output0.Select(x => x * 5).ToArray(), Neural.Layer(x => x * 5, wss0, ins0)); Assert.Equal(output1.Select(x => x * 5).ToArray(), Neural.Layer(x => x * 5, wss1, ins1)); Assert.Equal(output2.Select(x => x * 5).ToArray(), Neural.Layer(x => x * 5, wss2, ins2)); Assert.Equal(output0.Select(x => x * x + x - 10).ToArray(), Neural.Layer(x => x * x + x - 10, wss0, ins0)); Assert.Equal(output1.Select(x => x * x + x - 10).ToArray(), Neural.Layer(x => x * x + x - 10, wss1, ins1)); Assert.Equal(output2.Select(x => x * x + x - 10).ToArray(), Neural.Layer(x => x * x + x - 10, wss2, ins2)); }
public void Layer_With_Null_Arguments() { Assert.Throws <ArgumentNullException>(() => Neural.Layer(x => x, null, null)); //Assert.Throws<ArgumentNullException>(() => Neural.Layer(x => x, new double[][] { }, null)); Assert.Throws <ArgumentNullException>(() => Neural.Layer(x => x, null, new double[] { })); }
public void BiasUpdate(int i) { selectedBias = i; Neural.SetWeight(0, selectedBias, Neural.GetNetwork().firstLayerSize, biasSliders[selectedBias].value); }
private void InitData() { _trainDataSeries = new List<double>(); _testDataSeries = new List<double>(); _dataForTest = new List<double>(); _dataForForecast = new List<double>(); modelType = ModelType.SARIMA_ANN; isReadTrainData = false; isReadTestData = false; ARIMAModel = new ARIMA(); NeuralModel = new Neural(); }
/// <summary> /// Update the given data reader without changing the data storage tag. /// </summary> /// <param name="name">The name of the data reader to update</param> /// <param name="reader">The data reader configuration</param> public void UpdateReader(Neural.Data.DataReader reader, string name) { myManager.UpdateFile(name, reader); }
/// <summary> /// Add a new data reader to the vault. /// </summary> /// <param name="name">The name of the network</param> /// <param name="reader">The data reader</param> /// <param name="tag">The storage tag for this network</param> public void AddNetwork(Neural.Data.DataReader reader, DataStorageTag tag, string name) { myManager.AddObject(reader, tag, name); }
private double[,] ConvertNeural(double datasize) { int iter = 0, i = 0, j = 0, k = 0, l = 0, Gen = 0; char[] NeuralChar = Neural.ToCharArray(); double DataSize = datasize; double[,] Components = new double[14, 10], NeuralData = new double[Convert.ToInt32(datasize), 10]; while (iter < 14 && Gen < 300000) { for (i = 0; i < NeuralChar.Length; i++) { if ((NeuralChar[i] == ':')) { NeuralChar[i] = ','; } if (iter == 13) { Gen++; iter = 0; } if ((NeuralChar[i] == ',')) { iter++; //i++; j = 0; } switch (iter) { case 0: Components[0, j] = (int)Char.GetNumericValue(NeuralChar[i]); j++; break; case 1: Components[1, j] = (int)Char.GetNumericValue(NeuralChar[i]); j++; break; case 2: Components[2, j] = (int)Char.GetNumericValue(NeuralChar[i]); j++; break; case 3: F3[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[3, j] = F3[j]; j++; break; case 4: F4[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[4, j] = F4[j]; j++; break; case 5: F8[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[5, j] = F8[j]; j++; break; case 6: FC5[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[6, j] = FC5[j]; j++; break; case 7: FC6[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[7, j] = FC6[j]; j++; break; case 8: T7[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[8, j] = T7[j]; j++; break; case 9: T8[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[9, j] = T8[j]; j++; break; case 10: P7[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[10, j] = P7[j]; j++; break; case 11: P8[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[11, j] = P8[j]; j++; break; case 12: O1[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[12, j] = O1[j]; j++; break; case 13: O2[j] = (int)Char.GetNumericValue(NeuralChar[i]); Components[13, j] = O2[j]; j++; break; } if (iter == 13) { l = j; for (j = 0; ((j <= 13) && (Gen < 300000)); j++) { for (k = 0; (Components[j, k] != 0) || (k < 7); k++) { SortedData[0, Gen, j, k] = Components[j, k]; } } j = l; } } } return(NeuralData); }
public void InitNeural(NetworkParams serialized) { neural = new Neural(serialized); }
/// <summary> /// Add result sets to the vault. /// </summary> /// <param name="data">The result set</param> /// <param name="name">The name of the result set</param> public void AddInputData(Neural.ResultSet data, string name) { manager.AddObject(data, name); }
public static void BenchNeural() { Setup(); NNetStruct t = new Neural(); t.loops = 100; t.adjust = 0; foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { for (int i = 0; i < NeuralIterations; i++) { t.Run(); } } } }
public void IsJagged_With_Nonjagged_Testdata() { double[][] arrays0 = new double[][] { }; double[][] arrays1 = new double[][] { new double[] { } }; double[][] arrays2 = new double[][] { new double[] { 0 } }; double[][] arrays3 = new double[][] { new double[] { }, new double[] { } }; double[][] arrays4 = new double[][] { new double[] { 0, 0 }, new double[] { 0, 0 } }; double[][] arrays5 = new double[][] { new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 } }; double[][] arrays6 = new double[][] { new double[] { 0, 0 }, new double[] { 0, 0 }, new double[] { 0, 0 }, new double[] { 0, 0 } }; double[][] arrays7 = new double[][] { new double[] { 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0 } }; double[][] arrays8 = new double[][] { new double[] { 0 }, new double[] { 0 }, new double[] { 0 }, new double[] { 0 }, new double[] { 0 } }; Assert.False(Neural.IsJagged(arrays0)); Assert.False(Neural.IsJagged(arrays1)); Assert.False(Neural.IsJagged(arrays2)); Assert.False(Neural.IsJagged(arrays3)); Assert.False(Neural.IsJagged(arrays4)); Assert.False(Neural.IsJagged(arrays5)); Assert.False(Neural.IsJagged(arrays6)); Assert.False(Neural.IsJagged(arrays7)); Assert.False(Neural.IsJagged(arrays8)); }
public void Neuron_With_Null_Arguments(double[] ws, double[] ins) { Assert.Throws <ArgumentNullException>(() => Neural.Neuron(x => x, ws, ins)); }
/// <summary> /// Adds a result set to the vault with the given storage tag. /// </summary> /// <param name="data">The result set</param> /// <param name="name">The name of throws the result set</param> /// <param name="tag">The data storage tag</param> public void AddInputData(Neural.ResultSet data, DataStorageTag tag, string name) { manager.AddObject(data, tag, name); }
public void InitNeural() { neural = new Neural(new int[] { 9, 7, 5, 4, 2 }); }
private void btnNetworkClear_Click(object sender, EventArgs e) { NeuralModel = new Neural(); NeuralModel.SetData(_errorSeries); this.txtNumInput.Text = ""; this.txtNumHidden.Text = ""; this.txtNumInput.Enabled = true; this.txtNumHidden.Enabled = true; this.btnNetworkNew.Enabled = true; this.btnNetworkLoad.Enabled = true; this.btnNetworkSave.Enabled = false; this.btnNetworkClear.Enabled = false; this.btnTrainNeural.Enabled = false; this.btnTestNeural.Enabled = false; this.btnForecastNeural.Enabled = false; }
/// <summary> /// Update the data set in the vault with the data and name. /// </summary> /// <param name="data">The result set</param> /// <param name="name">The name of the result set</param> public void UpdateDataSet(Neural.ResultSet data, string name) { manager.UpdateFile(name, data); }
private void btnNetworkLoad_Click(object sender, EventArgs e) { OpenFileDialog fileDialog = new OpenFileDialog(); fileDialog.Title = "Load Network Config File"; fileDialog.DefaultExt = "xml"; DialogResult result = fileDialog.ShowDialog(); string dataFile = ""; if (result == System.Windows.Forms.DialogResult.OK) { dataFile = fileDialog.FileName; Neural temp = Neural.Import(dataFile); if (temp == null) { System.Windows.Forms.MessageBox.Show("The Input file is not correct format !!!", null, System.Windows.Forms.MessageBoxButtons.OK); } else { NeuralModel = temp; NeuralModel.SetData(_errorSeries); this.txtNumInput.Text = NeuralModel.m_iNumInputNodes.ToString(); this.txtNumHidden.Text = NeuralModel.m_iNumHiddenNodes.ToString(); this.btnNetworkNew.Enabled = false; this.btnNetworkLoad.Enabled = false; this.btnNetworkSave.Enabled = true; this.btnNetworkClear.Enabled = true; this.btnTrainNeural.Enabled = true; this.btnForecastNeural.Enabled = true; this.btnTestNeural.Enabled = true; this.btnForecast.Enabled = true; this.btnTest.Enabled = true; } } else return; }
/// <summary> /// Implements the listener interface and handles the end of epoch event. /// If ther number of training iterations is > the maximum iterations /// value, then training is stopped. /// </summary> /// <param name="evt">The epoch end event</param> public void EpochEnd(Neural.TrainingEpochEvent evt) { // TODO Auto-generated method stub Trainer t = evt.Trainer; if(t.EpochCount >= maxIterations) { t.RequestTermination(); } }
private void btnNetworkNew_Click(object sender, EventArgs e) { string numInputs = this.txtNumInput.Text; string numHiddens = this.txtNumHidden.Text; string numOutputs = this.txtNumOutput.Text; if (numInputs == "" || numHiddens == "" || numOutputs == "") { System.Windows.Forms.MessageBox.Show("Please insert the number of Input Nodes, Hidden Nodes, Output Nodes", null, System.Windows.Forms.MessageBoxButtons.OK); return; } try { NeuralModel = new Neural(Int32.Parse(numInputs), Int32.Parse(numHiddens), Int32.Parse(numOutputs)); NeuralModel.SetData(_errorSeries); System.Windows.Forms.MessageBox.Show("NetWork configuration successfull, You can train it"); this.txtNumOutput.Enabled = false; this.txtNumHidden.Enabled = false; this.txtNumInput.Enabled = false; this.btnNetworkNew.Enabled = false; this.btnNetworkLoad.Enabled = false; this.btnNetworkSave.Enabled = true; this.btnNetworkClear.Enabled = true; this.btnTrainNeural.Enabled = true; } catch (Exception exception) { System.Windows.Forms.MessageBox.Show(exception.Message); } }
/// <summary> /// Add a data reader to the vault, using the default data storage tag. /// </summary> /// <param name="name">The name of the network</param> /// <param name="reader">The data reader</param> public void AddNetwork(Neural.Data.DataReader reader, string name) { myManager.AddObject(reader, name); }
private void button1_Click(object sender, EventArgs e) { _errorSeries = _dataSeries.FindAll(item => true); NeuralModel = new Neural(); NeuralModel.SetData(_errorSeries); btnNetworkNew.Enabled = true; btnNetworkLoad.Enabled = true; btnPlotNeural.Enabled = true; this.txtNumOutput.Enabled = false; this.txtNumHidden.Enabled = true; this.txtNumInput.Enabled = true; }
/// <summary> /// Update the given data reader and the data storage tag. /// </summary> /// <param name="name">The name of the network</param> /// <param name="reader">The data reader configuration</param> /// <param name="tag">The storage tag to update</param> public void UpdateReader(Neural.Data.DataReader reader, DataStorageTag tag, string name) { myManager.UpdateFile(reader, tag, name); }
private void InitData() { _dataSeries = new List<double>(); _errorSeries = new List<double>(); ARIMAModel = new ARIMA(); NeuralModel = new Neural(); }
/// <summary> /// Update the result set in the vault with the given storage tag. /// </summary> /// <param name="data">The result set</param> /// <param name="name">The name of the storage tag</param> /// <param name="tag">The data storage tag</param> public void UpdateDataSet(Neural.ResultSet data, DataStorageTag tag, string name) { manager.UpdateFile(data, tag, name); }
public void NWeightsFromConfig_With_Testdata(uint[] config, uint length) { Assert.Equal(length, Neural.NWeightsFromConfig(config)); }
private void btnGetData_Click(object sender, EventArgs e) { _dataSeries = new List<double>(); System.IO.StreamReader file = null; string line = null; bool isFormatFileRight = true; int beginRow = Convert.ToInt32(this.txtTrainDataFromRow.Text); int endRow = Convert.ToInt32(this.txtTrainDataToRow.Text); int columnSelected = Convert.ToInt32(this.txtTrainDataColumn.Text); int idxRow = 0; try { file = new System.IO.StreamReader(m_TrainingDataFile); while ((line = file.ReadLine()) != null) { idxRow++; if (idxRow < beginRow || idxRow > endRow) continue; char[] delimiterChars = { ' ', ',' }; List<String> words = new List<string>(); words.AddRange(line.Split(delimiterChars)); words.RemoveAll(item => "" == item); if (columnSelected <= words.Count) { _dataSeries.Add(Double.Parse(words[columnSelected - 1])); } else { isFormatFileRight = false; break; } } if (!isFormatFileRight) { MessageBox.Show("Input is wrong format", null, MessageBoxButtons.OK, MessageBoxIcon.Error); _dataSeries = null; } } catch (System.OutOfMemoryException outOfMemory) { _dataSeries = null; MessageBox.Show("File does not found", null, MessageBoxButtons.OK, MessageBoxIcon.Error); } catch (System.IO.IOException io) { _dataSeries = null; MessageBox.Show("File does not found", null, MessageBoxButtons.OK, MessageBoxIcon.Error); } catch (System.Exception excp) { _dataSeries = null; MessageBox.Show("Input is wrong format", null, MessageBoxButtons.OK, MessageBoxIcon.Error); } finally { if (file != null) file.Close(); } if (_dataSeries != null) { SettingGetData(); ARIMAModel = new ARIMA(); NeuralModel = new Neural(); ARIMAModel.SetData(_dataSeries); } else { MessageBox.Show("Load data fail", null, MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public void Validation_With_Valid_Testdata() { double[] ins0 = new double[] { }; double[][][] wsss0 = new double[][][] { new double[][] { new double[] { 0 } } }; double[] ins1 = new double[] { 0 }; double[][][] wsss1 = new double[][][] { new double[][] { new double[] { 0, 0 } } }; double[] ins2 = new double[] { 0 }; double[][][] wsss2 = new double[][][] { new double[][] { new double[] { 0, 0 }, new double[] { 0, 0 } } }; double[] ins3 = new double[] { 0, 0 }; double[][][] wsss3 = new double[][][] { new double[][] { new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 } }, new double[][] { new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 } }, new double[][] { new double[] { 0, 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0, 0 } }, new double[][] { new double[] { 0, 0, 0, 0 } } }; double[] ins4 = new double[] { 0, 0, 0 }; double[][][] wsss4 = new double[][][] { new double[][] { new double[] { 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0 } }, new double[][] { new double[] { 0, 0, 0 }, new double[] { 0, 0, 0 } }, new double[][] { new double[] { 0, 0, 0 } }, new double[][] { new double[] { 0, 0 }, new double[] { 0, 0 }, new double[] { 0, 0 }, new double[] { 0, 0 }, new double[] { 0, 0 }, }, new double[][] { new double[] { 0, 0, 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0, 0, 0 }, new double[] { 0, 0, 0, 0, 0, 0 } }, new double[][] { new double[] { 0, 0, 0, 0, 0 } } }; Assert.True(Neural.Validation(wsss0, ins0)); Assert.True(Neural.Validation(wsss1, ins1)); Assert.True(Neural.Validation(wsss2, ins2)); Assert.True(Neural.Validation(wsss3, ins3)); Assert.True(Neural.Validation(wsss4, ins4)); }