public void FeedForwardNeuralNetwork_LoadModelSparseMatrix() { var target = new FeedForwardNeuralNetwork <double>( new[] { 2L, 3L, 2L }); var parser = new DoubleParser <string>(); var matrix = TestsHelper.ReadMatrix( 5, 5, "[[-1.0, 1.0, 0.5, 0, 0], [1.0, -1.0, 0.5, 0, 0], [0, 0, 0, -1.0, 2.0], [0, 0, 0, 0.5, -1.5], [0, 0, 0, 1.0, -0.5]]", (i, j) => new SparseDictionaryMatrix <double>(i, j, 0), parser, true); var vector = TestsHelper.ReadVector( 5, "[-1.0, 0.0, 1.0, -0.5, 0.5]", new SparseDictionaryMathVectorFactory <double>(), parser, true); var model = new NeuralNetworkModel <double, SparseDictionaryMatrix <double>, IMathVector <double> >( matrix, vector); target.LoadModelSparse <SparseDictionaryMatrix <double>, ILongSparseMatrixLine <double>, IMathVector <double> >( model); this.AssertTargetFromMatrix( model, target); }
public void Initialize() { IForecastingModel model = null; Models = new List <IForecastingModel>(); AnnModelParameter annPara = new AnnModelParameter(); model = new NeuralNetworkModel(annPara); Models.Add(model); Heiflow.AI.SVM.Parameter p = new Heiflow.AI.SVM.Parameter(); model = new SVMModel(p); Models.Add(model); ModelParameter mp = new ModelParameter(); model = new MLRModel(mp); Models.Add(model); Recognizers = new List <IRecognizer>(); foreach (var mm in Models) { var recognizer = new ImageRecognizer(mm, _IImageSetsBuilder, _IColorClassification); Recognizers.Add(recognizer); } }
public static void ToTreeView(TreeView t, NeuralNetworkModel nn) { t.Nodes.Clear(); TreeNode root = new TreeNode("NeuralNetwork"); nn.Layers.ForEach((layer) => { TreeNode lnode = new TreeNode("Layer"); layer.Neurons.ForEach((neuron) => { TreeNode nnode = new TreeNode("Neuron"); nnode.Nodes.Add("Bias: " + neuron.Bias.ToString()); nnode.Nodes.Add("Delta: " + neuron.Delta.ToString()); nnode.Nodes.Add("Value: " + neuron.Value.ToString()); neuron.Dendrites.ForEach((dendrite) => { TreeNode dnode = new TreeNode("Dendrite"); dnode.Nodes.Add("Weight: " + dendrite.Weight.ToString()); nnode.Nodes.Add(dnode); }); lnode.Nodes.Add(nnode); }); root.Nodes.Add(lnode); }); //root.ExpandAll(); t.Nodes.Add(root); }
public NeuralNetworkFacade(double learningrate, int[] layers, char[] chardict) { this.neuralNet = new NeuralNetworkModel(learningrate, layers); this.validationReport = new ValidationReport(); this.chardict = chardict; this.inputnodes = layers[0]; }
/// <summary> /// Поиск аномалий на основе статистической модели. /// </summary> /// <returns>Список (возможно, пустой) сообщений об аномалиях.</returns> public List <string> SearchAnomaliesByNeuralNetwork() { var messages = new List <string>(); _neuralNetworkResult = new List <double>(); for (var i = 0; i < Samples.Count; i++) { var output = NeuralNetworkModel.Calculate(Samples[i])[0]; _neuralNetworkResult.Add(output); if (output > 0.5) { var probability = (output + 1) / 2; messages.Add($"№{i + 1}: обнаружена аномалия с вероятностью {probability}."); } } return(messages); }
public static void ToPictureBox(PictureBox p, NeuralNetworkModel nn, int X, int Y) { int neuronWidth = 30; int neuronDistance = 50; int layerDistance = 50; int fontSize = 8; Bitmap b = new Bitmap(p.Width, p.Height); Graphics g = Graphics.FromImage(b); g.FillRectangle(Brushes.White, g.ClipBounds); int y = Y; for (int l = 0; l < nn.Layers.Count; l++) { Layer layer = nn.Layers[l]; int x = X - (neuronDistance * (layer.Neurons.Count / 2)); for (int n = 0; n < layer.Neurons.Count; n++) { Neuron neuron = layer.Neurons[n]; for (int d = 0; d < neuron.Dendrites.Count; d++) { // TO DO: optionally draw dendrites between neurons } ; g.FillEllipse(Brushes.WhiteSmoke, x, y, neuronWidth, neuronWidth); g.DrawEllipse(Pens.Gray, x, y, neuronWidth, neuronWidth); g.DrawString(neuron.Value.ToString("0.00"), new Font("Arial", fontSize), Brushes.Black, x + 2, y + (neuronWidth / 2) - 5); x += neuronDistance; } ; y += layerDistance; } ; p.Image = b; }
/// <summary> /// Verifica se o modelo corresponde ao que se encontra armazenado /// na rede. /// </summary> /// <typeparam name="C">O tipo dos objectos que constituem os coeficientes.</typeparam> /// <typeparam name="M">O tipo dos objectos que constituem as matrizes.</typeparam> /// <typeparam name="V">O tipo dos objectos que constituem os vectores.</typeparam> /// <param name="expected">O model com os valores esperados.</param> /// <param name="actual">A rede que contém os valores a comparar.</param> private void AssertTargetFromMatrix <C, M, V>( NeuralNetworkModel <C, M, V> expected, FeedForwardNeuralNetwork <C> actual) where M : ILongMatrix <C> where V : IVector <C> { var actualTresholds = actual.InternalTresholds; var expectedTresholds = expected.Tresholds; Assert.AreEqual(expectedTresholds.LongLength, actualTresholds.LongLength); for (var i = 0; i < actualTresholds.LongLength; ++i) { Assert.AreEqual(expectedTresholds[i], actualTresholds[i]); } var expectedMatrix = expected.WeightsMatrix; var actualMatrix = actual.InternalWeights; Assert.AreEqual(expectedMatrix.GetLength(0), actualMatrix.LongLength); var pointer = 0; var currCol = 0L; var schema = actual.Schema; var currLine = schema[pointer + 1]; for (var i = 0; i < actualMatrix.LongLength; ++i) { if (i == currLine) { currCol += schema[pointer++]; currLine += schema[pointer + 1]; } var actualLine = actualMatrix[i]; for (var j = 0; j < actualLine.LongLength; ++j) { var actualVal = actualLine[j]; var expectedVal = expectedMatrix[i, currCol + j]; Assert.AreEqual(expectedVal, actualVal); } } }
public void FeedFrowardNeuralNetwork_InternalComputeOutputs() { var target = new FeedForwardNeuralNetwork <double>( new[] { 2L, 3L, 2L }); var parser = new DoubleParser <string>(); var matrix = TestsHelper.ReadMatrix( 5, 5, "[[-1.0, 1.0, 0.5, 0, 0], [1.0, -1.0, 0.5, 0, 0], [0, 0, 0, -1.0, 2.0], [0, 0, 0, 0.5, -1.5], [0, 0, 0, 1.0, -0.5]]", (i, j) => new SparseDictionaryMatrix <double>(i, j, 0), parser, true); var vector = TestsHelper.ReadVector( 5, "[0.5, 0.5, 0.5, 0.5, 0.5]", new SparseDictionaryMathVectorFactory <double>(), parser, true); var model = new NeuralNetworkModel <double, SparseDictionaryMatrix <double>, IMathVector <double> >( matrix, vector); target.LoadModel(model); var outputMatrix = target.InternalReserveOutput(); target.InternalComputeLayerOutputs( new ArrayMathVector <double>(new[] { 1.0, -1.0 }), outputMatrix, (d1, d2) => { if (d2 > d1) { return(1.0); } else { return(0.0); } }, (u, v, l) => { var result = 0.0; for (var i = 0L; i < l; ++i) { result += u[i] * v[i]; } return(result); }); Assert.AreEqual(target.Schema.LongCount() - 1L, outputMatrix.LongLength); var currOut = outputMatrix[0]; Assert.AreEqual(0.0, currOut[0]); Assert.AreEqual(1.0, currOut[1]); Assert.AreEqual(0.0, currOut[2]); currOut = outputMatrix[1]; Assert.AreEqual(0.0, currOut[0]); Assert.AreEqual(0.0, currOut[1]); }
public void FeedFrowardNeuralNetwork_RunSimpleMatrixTest() { var target = new FeedForwardNeuralNetwork <double>( new[] { 2L, 3L, 2L }); var parser = new DoubleParser <string>(); var matrix = TestsHelper.ReadMatrix( 5, 5, "[[-1.0, 1.0, 0.5, 0, 0], [1.0, -1.0, 0.5, 0, 0], [0, 0, 0, -1.0, 2.0], [0, 0, 0, 0.5, -1.5], [0, 0, 0, 1.0, -0.5]]", (i, j) => new SparseDictionaryMatrix <double>(i, j, 0), parser, true); var vector = TestsHelper.ReadVector( 5, "[0.5, 0.5, 0.5, 0.5, 0.5]", new SparseDictionaryMathVectorFactory <double>(), parser, true); var model = new NeuralNetworkModel <double, SparseDictionaryMatrix <double>, IMathVector <double> >( matrix, vector); target.LoadModel(model); var actual = target.Run( new[] { 1.0, 0.0 }, (u, v, l) => { var result = 0.0; for (var i = 0L; i < l; ++i) { result += u[i] * v[i]; } return(result); }, (d1, d2) => { if (d2 > d1) { return(1.0); } else { return(0.0); } }); var expected = new[] { 0.0, 0.0 }; CollectionAssert.AreEqual(expected, actual); actual = target.Run( new[] { 0.0, 1.0 }, (u, v, l) => { var result = 0.0; for (var i = 0L; i < l; ++i) { result += u[i] * v[i]; } return(result); }, (d1, d2) => { if (d2 > d1) { return(1.0); } else { return(0.0); } }); expected = new[] { 0.0, 1.0 }; CollectionAssert.AreEqual(expected, actual); actual = target.Run( new[] { 1.0, -1.0 }, (u, v, l) => { var result = 0.0; for (var i = 0L; i < l; ++i) { result += u[i] * v[i]; } return(result); }, (d1, d2) => { if (d2 > d1) { return(1.0); } else { return(0.0); } }); expected = new[] { 0.0, 0.0 }; CollectionAssert.AreEqual(expected, actual); }