/// <summary> /// Construct a BackpropagationLayer object that corresponds to a specific neuron layer. /// </summary> /// <param name="backpropagation">The back propagation training object.</param> /// <param name="layer">The layer that this object corresponds to.</param> public BackpropagationLayer(Backpropagation backpropagation, FeedforwardLayer layer) { this.backpropagation = backpropagation; this.layer = layer; int neuronCount = layer.NeuronCount; this.error = new double[neuronCount]; this.errorDelta = new double[neuronCount]; if (layer.Next != null) { this.accMatrixDelta = new Matrix.Matrix(layer.NeuronCount + 1, layer.Next.NeuronCount); this.matrixDelta = new Matrix.Matrix(layer.NeuronCount + 1, layer.Next.NeuronCount); this.biasRow = layer.NeuronCount; } }
/// <summary> /// Train the neural network for the specified pattern. The neural network /// can be trained for more than one pattern. To do this simply call the /// train method more than once. /// </summary> /// <param name="pattern">The pattern to train on.</param> public void Train(bool[] pattern) { if (pattern.Length != this.weightMatrix.Rows) { throw new NeuralNetworkError("Can't train a pattern of size " + pattern.Length + " on a hopfield network of size " + this.weightMatrix.Rows); } // Create a row matrix from the input, convert boolean to bipolar Matrix.Matrix m2 = Matrix.Matrix.CreateRowMatrix(BiPolarUtil .Bipolar2double(pattern)); // Transpose the matrix and multiply by the original input matrix Matrix.Matrix m1 = MatrixMath.Transpose(m2); Matrix.Matrix m3 = MatrixMath.Multiply(m1, m2); // matrix 3 should be square by now, so create an identity // matrix of the same size. Matrix.Matrix identity = MatrixMath.Identity(m3.Rows); // subtract the identity matrix Matrix.Matrix m4 = MatrixMath.Subtract(m3, identity); // now add the calculated matrix, for this pattern, to the // existing weight matrix. this.weightMatrix = MatrixMath.Add(this.weightMatrix, m4); }
/// <summary> /// Present a pattern to the neural network and receive the result. /// </summary> /// <param name="pattern">The pattern to be presented to the neural network.</param> /// <returns>The output from the neural network.</returns> public bool[] Present(bool[] pattern) { bool[] output = new bool[pattern.Length]; // convert the input pattern into a matrix with a single row. // also convert the boolean values to bipolar(-1=false, 1=true) Matrix.Matrix inputMatrix = Matrix.Matrix.CreateRowMatrix(BiPolarUtil .Bipolar2double(pattern)); // Process each value in the pattern for (int col = 0; col < pattern.Length; col++) { Matrix.Matrix columnMatrix = this.weightMatrix.GetCol(col); columnMatrix = MatrixMath.Transpose(columnMatrix); // The output for this input element is the dot product of the // input matrix and one column from the weight matrix. double dotProduct = MatrixMath.DotProduct(inputMatrix, columnMatrix); // Convert the dot product to either true or false. if (dotProduct > 0) { output[col] = true; } else { output[col] = false; } } return(output); }
/// <summary> /// Determine both the normalization factor and the synthetic input for the /// given input. /// </summary> /// <param name="input">The input to normalize.</param> protected void CalculateFactors(double[] input) { Matrix.Matrix inputMatrix = Matrix.Matrix.CreateColumnMatrix(input); double len = MatrixMath.vectorLength(inputMatrix); len = Math.Max(len, VERYSMALL); int numInputs = input.Length; if (this.type == NormalizationType.MULTIPLICATIVE) { this.normfac = 1.0 / len; this.synth = 0.0; } else { this.normfac = 1.0 / Math.Sqrt(numInputs); double d = numInputs - Math.Pow(len, 2); if (d > 0.0) { this.synth = Math.Sqrt(d) * this.normfac; } else { this.synth = 0; } } }
public void Train(double[] inputArray, double[] targetArray) { //Matrix.Matrix inputMatrix = new Matrix.Matrix(inputArray); FillHiddenNeurons(inputArray); //hiddenOutput.DisplayMatrix(); Matrix.Matrix outputsOutput = outputWeights * hiddenOutput; if (useBias) { outputsOutput += biasOutput; } Matrix.Matrix targetMatrix = new Matrix.Matrix(targetArray); Matrix.Matrix outputErrorsMatrix = targetMatrix - outputsOutput; // mapMatrixLinearry(outputsOutput); //!!! do zmiany w wariancie 2 na normalne mapowanie Matrix.Matrix gradients_output = outputErrorsMatrix * learningRate; //gradients_output.HadamardProduct(outputsOutput); //gradients_output.DisplayMatrix(); Matrix.Matrix hiddenTransposed = hiddenOutput.TransposeMatrix(); //hiddenTransposed.DisplayMatrix(); Matrix.Matrix outputs_deltas = gradients_output * hiddenTransposed; //outputs_deltas.DisplayMatrix(); outputWeights += outputs_deltas; biasOutput += gradients_output; outputWeights += momentumMatrixOutput; biasOutput += momentumMatrixOutputBias; momentumMatrixOutput = outputs_deltas * momentumRate; momentumMatrixOutputBias = gradients_output * momentumRate; }
private static void Init() { R = new Matrix.Matrix(10, 1); K = new Matrix.Matrix(10, 10); // 3 R[0, 0] = -4.0748217690E+00; R[1, 0] = -4.9251244659E+00; R[2, 0] = -5.3650596817E+00; R[3, 0] = -5.5725335790E+00; R[4, 0] = -5.6489380624E+00; R[5, 0] = -5.6516105985E+00; R[6, 0] = -5.6127699478E+00; R[7, 0] = -5.5501570365E+00; R[8, 0] = -5.4736066877E+00; R[9, 0] = -5.3882442310E+00; // 4 K[0, 0] = 1.6603723851E-09; K[1, 1] = 2.4255934705E-09; K[2, 2] = 2.8783795974E-09; K[3, 3] = 3.1052955589E-09; K[4, 4] = 3.1910050747E-09; K[5, 5] = 3.1940896540E-09; K[6, 6] = 3.1503514453E-09; K[7, 7] = 3.0804600582E-09; K[8, 8] = 2.9960384237E-09; K[9, 9] = 2.9035548030E-09; }
private static void Run(double x, double y, double eps) { Matrix.Matrix s, S1, S2, k1, M, L, dR, dQ, Tmp; double d1, d2; int kh = 0; s = new Matrix.Matrix(10, 1); S1 = new Matrix.Matrix(10, 2); S2 = new Matrix.Matrix(10, 2); M = new Matrix.Matrix(10, 2); dR = new Matrix.Matrix(10, 1); k1 = ~K; kh = 0; do { num_du_rungekutt(f, g, x, y, 0, ref s); num_du_rungekutt(f, g, x + d, y, 0, ref S1); num_du_rungekutt(f, g, x - d, y, 0, ref S2); num_du_rungekutt(f, g, x, y + d, 1, ref S1); num_du_rungekutt(f, g, x, y - d, 1, ref S2); M = (S1 - S2) / (2 * d); L = !M; dR = R - s; Tmp = L * k1; dQ = (~(Tmp * M)) * Tmp * dR; d1 = dQ[0, 0]; d2 = dQ[1, 0]; x += d1; y += d2; kh++; Console.WriteLine(kh + " : x1 = " + x + " x2 = " + y); } while ((Math.Abs(d1) > eps) && (Math.Abs(d2) > eps)); }
/// <summary> /// Determine the winner for the specified input. This is the number of the /// winning neuron. /// </summary> /// <param name="input">The input pattern.</param> /// <returns>The winning neuron.</returns> public int Winner(NormalizeInput input) { int win = 0; double biggest = Double.MinValue; for (int i = 0; i < this.outputNeuronCount; i++) { Matrix.Matrix optr = this.outputWeights.GetRow(i); this.output[i] = MatrixMath .DotProduct(input.InputMatrix, optr) * input.Normfac; this.output[i] = (this.output[i] + 1.0) / 2.0; if (this.output[i] > biggest) { biggest = this.output[i]; win = i; } if (this.output[i] < 0) { this.output[i] = 0; } if (this.output[i] > 1) { this.output[i] = 1; } } return(win); }
private static void num_du_rungekutt(function f, function g, double x0, double y0, int iColumn2Write, ref Matrix.Matrix Matr) { double t = 0, x1 = x0, y1 = y0; int j = 0; double k1, k2, k3, k4, m1, m2, m3, m4; for (int i = 1; i <= 500; i++) // max 5 { t += h_rungekutt; k1 = f(t, x1, y1); m1 = g(t, x1, y1); k2 = f(t + h_rungekutt / 2, x1 + h_rungekutt * k1 / 2, y1 + h_rungekutt * m1 / 2); m2 = g(t + h_rungekutt / 2, x1 + h_rungekutt * k1 / 2, y1 + h_rungekutt * m1 / 2); k3 = f(t + h_rungekutt / 2, x1 + h_rungekutt * k2 / 2, y1 + h_rungekutt * m2 / 2); m3 = g(t + h_rungekutt / 2, x1 + h_rungekutt * k2 / 2, y1 + h_rungekutt * m2 / 2); k4 = f(t + h_rungekutt, x1 + h_rungekutt * k3, y1 + h_rungekutt * m3); m4 = g(t + h_rungekutt, x1 + h_rungekutt * k3, y1 + h_rungekutt * m3); x1 = x1 + h_rungekutt * (k1 + 2 * k2 + 2 * k3 + k4) / 6; y1 = y1 + h_rungekutt * (m1 + 2 * m2 + 2 * m3 + m4) / 6; if ((i == 100) || (i == 200) || (i == 300) || (i == 400) || (i == 500) || (i == 600) || (i == 700) || (i == 800) || (i == 900) || (i == 1000)) // 5 { Matr[j++, iColumn2Write] = x1 + y1; // 2.3 } } }
public NeuralNetwork(int numberOfInputs, int numberOfHidden, int numberOfOutput, Matrix.Matrix inputs) { learningRate = 0.1; momentumRate = 0.5; numberOfHiddenNeurons = numberOfHidden; inp = inputs; hiddenOutput = new Matrix.Matrix(numberOfHidden, numberOfInputs); outputWeights = new Matrix.Matrix(numberOfOutput, numberOfHidden); centre = new Matrix.Matrix(numberOfHidden, numberOfInputs); range = new Matrix.Matrix(numberOfHidden, 1); //hiddenOutput.RandomizeMatrix(-1, 1); outputWeights.RandomizeMatrix(-5, 5); Random rnd = new Random(); for (int i = 0; i < numberOfHidden; ++i) { //wypełnianie macierzy c - centrów int index = rnd.Next(0, inputs.row); for (int j = 0; j < numberOfInputs; ++j) { centre.tab[i, j] = inputs.tab[index, j]; //Console.WriteLine(centre.tab[i, j]); } //wypełnianie macierzy r - zasięgu range.tab[i, 0] = rnd.NextDouble() * 1; } }
public Matrix.Matrix FeedForward(double[] input_x) { //Matrix.Matrix x = new Matrix.Matrix(input_x); FillHiddenNeurons(input_x); //fills hiddenNeurons matrix //hiddenOutput.DisplayMatrix(); Matrix.Matrix outputsOutput = outputWeights * hiddenOutput; return(outputsOutput); }
/// <summary> /// The constructor. /// </summary> /// <param name="inputCount">Number of input neurons.</param> /// <param name="outputCount">Number of output neurons.</param> /// <param name="normalizationType">The normalization type.</param> public SelfOrganizingMap(int inputCount, int outputCount, NormalizationType normalizationType) { this.inputNeuronCount = inputCount; this.outputNeuronCount = outputCount; this.outputWeights = new Matrix.Matrix(this.outputNeuronCount, this.inputNeuronCount + 1); this.output = new double[this.outputNeuronCount]; this.normalizationType = normalizationType; }
private void mapMatrixLinearry(Matrix.Matrix m) { for (int i = 0; i < m.row; ++i) { for (int j = 0; j < m.column; ++j) { m.tab[i, j] = 1; } } }
public void activationFunction(Matrix.Matrix m) { for (int i = 0; i < m.row; ++i) { for (int j = 0; j < m.column; ++j) { m.tab[i, j] = sigmoid(m.tab[i, j]); } } }
public void mapMatrix(Matrix.Matrix m) { for (int i = 0; i < m.row; ++i) { for (int j = 0; j < m.column; ++j) { m.tab[i, j] = dSigmoid(m.tab[i, j]); } } }
static void Main(string[] args) { var matrix = new Matrix.Matrix(); while (true) { matrix.Render(); matrix.Update(); Thread.Sleep(125); } }
public void WorldComplete(Matrix.Matrix <byte> world) { var img = world.ToBitmap(); Dispatcher.CurrentDispatcher.Invoke(() => { _modelView.Phase = "Complete"; _modelView.LastWorldUpdate = _frameNo; _modelView.WorldImage = img; }); }
public RotatedRectangle GetRectangle(Rectangle rectangle, float rotation) { Matrix.Matrix rotationMatrix = Matrix.Matrix.Rotation(rotation); Vector2 centreOffset = new Vector2(rectangle.Width / 2, rectangle.Height / 2); Vector2 centre = new Vector2(rectangle.X, rectangle.Y) + centreOffset; TopLeft = (rotationMatrix * new Matrix.Matrix2(centre.X - rectangle.Left, centre.Y - rectangle.Top)).ToVector2(); TopRight = (rotationMatrix * new Matrix.Matrix2(centre.X - rectangle.Right, centre.Y - rectangle.Top)).ToVector2(); BottomLeft = (rotationMatrix * new Matrix.Matrix2(centre.X - rectangle.Left, centre.Y - rectangle.Bottom)).ToVector2(); BottomRight = (rotationMatrix * new Matrix.Matrix2(centre.X - rectangle.Right, centre.Y - rectangle.Bottom)).ToVector2(); return(this); }
/// <summary> /// Normalize the specified row in the weight matrix. /// </summary> /// <param name="matrix">The weight matrix.</param> /// <param name="row">The row to normalize.</param> protected void NormalizeWeight(Matrix.Matrix matrix, int row) { double len = MatrixMath.vectorLength(matrix.GetRow(row)); len = Math.Max(len, VERYSMALL); len = 1.0 / len; for (int i = 0; i < this.inputNeuronCount; i++) { matrix[row, i] = matrix[row, i] * len; } matrix[row, this.inputNeuronCount] = 0; }
/// <summary> /// Fire a laser /// </summary> public void FireLaser() { foreach (Laser laser in Lasers) { if (laser.canFire) { Matrix.Matrix mat = Matrix.Matrix.Rotation(MathHelper.ToRadians(direction)); Vector2 firePos = position + (mat * new Matrix.Matrix2(19, 0)).ToVector2(); laser.Fire(firePos, direction); break; } } }
public void WorldFrame(int frameNo, Matrix.Matrix <byte> frame) { _frameNo = frameNo; var img = frame.ToBitmap(); Dispatcher.CurrentDispatcher.Invoke(() => { _modelView.Phase = "World"; _modelView.FrameNo = frameNo; _modelView.FrameImage = img; }); }
/// <summary> /// Create an input matrix that has enough space to hold the extra synthetic /// input. /// </summary> /// <param name="pattern">The input pattern to create.</param> /// <param name="extra">The synthetic input.</param> /// <returns>A matrix that contains the input pattern and the synthetic input.</returns> protected Matrix.Matrix CreateInputMatrix(double[] pattern, double extra) { Matrix.Matrix result = new Matrix.Matrix(1, pattern.Length + 1); for (int i = 0; i < pattern.Length; i++) { result[0, i] = pattern[i]; } result[0, pattern.Length] = extra; return(result); }
/// <summary> /// Force a win, if no neuron won. /// </summary> protected void ForceWin() { int best, which = 0; Matrix.Matrix outputWeights = this.som.OutputWeights; // Loop over all training sets. Find the training set with // the least output. double dist = Double.MaxValue; for (int tset = 0; tset < this.train.Length; tset++) { best = this.som.Winner(this.train[tset]); double[] output = this.som.Output; if (output[best] < dist) { dist = output[best]; which = tset; } } NormalizeInput input = new NormalizeInput(this.train[which], this.som.NormalizationType); best = this.som.Winner(input); double[] output2 = this.som.Output; dist = Double.MinValue; int i = this.outputNeuronCount; while ((i--) > 0) { if (this.won[i] != 0) { continue; } if (output2[i] > dist) { dist = output2[i]; which = i; } } for (int j = 0; j < input.InputMatrix.Cols; j++) { outputWeights[which, j] = input.InputMatrix[0, j]; } NormalizeWeight(outputWeights, which); }
/// <summary> /// Learn from the last error calculation. /// </summary> /// <param name="learnRate">The learning rate.</param> /// <param name="momentum">The momentum.</param> public void Learn(double learnRate, double momentum) { // process the matrix if (this.layer.HasMatrix()) { Matrix.Matrix m1 = MatrixMath.Multiply(this.accMatrixDelta, learnRate); Matrix.Matrix m2 = MatrixMath.Multiply(this.matrixDelta, momentum); this.matrixDelta = MatrixMath.Add(m1, m2); this.layer.LayerMatrix = (MatrixMath.Add(this.layer.LayerMatrix, this.matrixDelta)); this.accMatrixDelta.Clear(); } }
private Matrix.Matrix GetSimilarityMatrix(List<Vector> vectors) { var similarityMatrix = new Matrix.Matrix(vectors.Count); for (int i = 0; i < vectors.Count; i++) { for (int j = i + 1; j < vectors.Count; j++) { double similarity = vectors[i].GetGaussianKernelSimilarityTo(vectors[j]); similarityMatrix[i, j] = similarity; } } return similarityMatrix; }
/// <summary> /// Take a simple double array and turn it into a matrix that can be used to /// calculate the results of the input array. Also takes into account the /// threshold. /// </summary> /// <param name="pattern"></param> /// <returns></returns> private Matrix.Matrix CreateInputMatrix(double[] pattern) { Matrix.Matrix result = new Matrix.Matrix(1, pattern.Length + 1); for (int i = 0; i < pattern.Length; i++) { result[0, i] = pattern[i]; } // add a "fake" first column to the input so that the threshold is // always multiplied by one, resulting in it just being added. result[0, pattern.Length] = 1; return(result); }
public void WindowUpdate(int frameNo, Matrix.Matrix <byte> frame, Tuple <Tuple <int, int>, Tuple <int, int> > region, bool final) { Dispatcher.CurrentDispatcher.Invoke(() => { _modelView.Phase = "Window"; _modelView.FrameNo = frameNo; _modelView.FrameImage = frame.ToBitmap(); var((top, left), (bottom, right)) = region; _modelView.WindowTop = top; _modelView.WindowLeft = left; _modelView.WindowHeight = bottom - top; _modelView.WindowWidth = right - left; }); }
public static BitmapSource ToBitmap(this Matrix.Matrix <byte> raw) { var img = Image.c64ToRgb(raw); unsafe { fixed(int *buffer = img.Rep) { var bitmap = BitmapSource.Create(img.Width, img.Height, 96, 96, PixelFormats.Bgr32, null, (IntPtr)buffer, 4 * img.Width * img.Height, 4 * img.Width); bitmap.Freeze(); return(bitmap); } } }
public NeuroLayer(int id, int countIn, int countOut, LayerRole role) { sync = new object(); Role = role; LayerID = id; nucleus = new Dictionary <int, NeuroItem>(); input = new Dictionary <int, NeuroSignal>(); output = new Dictionary <int, NeuroSignal>(); weights = Role == LayerRole.Input ? Matrix.Matrix.One(countIn, countOut) : Role == LayerRole.Output ? Matrix.Matrix.Half(countIn, countOut) : Matrix.Matrix.Half(countIn, countOut); ActivationFooType activation = Role == LayerRole.Input ? ActivationFooType.Identity : ActivationFooType.Sigmoid; #region -> TMP if (id == 2) { weights[0, 0] = 0.9; weights[0, 1] = 0.3; weights[0, 2] = 0.4; weights[1, 0] = 0.2; weights[1, 1] = 0.8; weights[1, 2] = 0.2; weights[2, 0] = 0.1; weights[2, 1] = 0.5; weights[2, 2] = 0.6; } if (id == 3) { weights[0, 0] = 0.3; weights[0, 1] = 0.7; weights[0, 2] = 0.5; weights[1, 0] = 0.6; weights[1, 1] = 0.5; weights[1, 2] = 0.2; weights[2, 0] = 0.8; weights[2, 1] = 0.1; weights[2, 2] = 0.9; } #endregion for (int num = 0; num < countIn; num++) { input.Add(num, new NeuroSignal(num)); } for (int num = 0; num < countOut; num++) { NeuroItem ni = new NeuroItem(num, TransmitInput, activation); nucleus.Add(num, ni); output.Add(num, new NeuroSignal(num)); } }
public NeuralNetwork(int numberOfInputs, int numberOfHidden, int numberOfOutput, bool bias, Matrix.Matrix inputs) { learningRate = 0.001; momentumRate = 0.002; useBias = bias; numberOfHiddenNeurons = numberOfHidden; inp = inputs; hiddenOutput = new Matrix.Matrix(numberOfHidden, 1); outputWeights = new Matrix.Matrix(numberOfOutput, numberOfHidden); range = new Matrix.Matrix(numberOfHidden, 1); //hiddenOutput.RandomizeMatrix(-1, 1); outputWeights.RandomizeMatrix(-1, 1); Random rnd = new Random(); List <Kmeans.Point> Data = new List <Kmeans.Point>(); for (int i = 0; i < inputs.row; i++) { Data.Add(new Kmeans.Point(inputs.tab[i, 0], inputs.tab[i, 1], inputs.tab[i, 2], inputs.tab[i, 3])); } var km = new Kmeans.KMeans(numberOfHidden, Data, rnd); km.Train(); Console.WriteLine("centroids done"); centre = km.Centroids; for (int i = 0; i < numberOfHidden; ++i) { //wypełnianie macierzy r - zasięgu range.tab[i, 0] = setRange(centre[i]) * beta; } momentumMatrixOutput = new Matrix.Matrix(numberOfOutput, numberOfHidden); biasOutput = new Matrix.Matrix(numberOfOutput, 1); momentumMatrixOutputBias = new Matrix.Matrix(numberOfOutput, 1); biasOutput.RandomizeMatrix(-1, 1); }
public void LoadFromFile() { var fileStream_train = new FileStream(@"..\..\classification_files\classification_train.txt", FileMode.Open, FileAccess.Read); var fileStream_test = new FileStream(@"..\..\classification_files\classification_test.txt", FileMode.Open, FileAccess.Read); //var fileStream = new FileStream(@"D:\input2.txt", FileMode.Open, FileAccess.Read); int i = 0; string line; inputs = new Matrix.Matrix(90, 4); using (var streamReader = new StreamReader(fileStream_train, Encoding.UTF8)) { while ((line = streamReader.ReadLine()) != null) { classification_train[i][0] = Convert.ToDouble(line.Split(' ')[0]); classification_train[i][1] = Convert.ToDouble(line.Split(' ')[1]); classification_train[i][2] = Convert.ToDouble(line.Split(' ')[2]); classification_train[i][3] = Convert.ToDouble(line.Split(' ')[3]); classification_train[i][4] = Convert.ToDouble(line.Split(' ')[4]); inputs.tab[i, 0] = classification_train[i][0]; inputs.tab[i, 1] = classification_train[i][1]; inputs.tab[i, 2] = classification_train[i][2]; inputs.tab[i, 3] = classification_train[i][3]; i++; } } i = 0; using (var streamReader = new StreamReader(fileStream_test, Encoding.UTF8)) { while ((line = streamReader.ReadLine()) != null) { classification_test[i][0] = Convert.ToDouble(line.Split(' ')[0]); classification_test[i][1] = Convert.ToDouble(line.Split(' ')[1]); classification_test[i][2] = Convert.ToDouble(line.Split(' ')[2]); classification_test[i][3] = Convert.ToDouble(line.Split(' ')[3]); classification_test[i][4] = Convert.ToDouble(line.Split(' ')[4]); i++; } } }
static void Main(string[] args) { Matrix.Matrix<int> matr = new Matrix.Matrix<int>(2, 4); Console.WriteLine("Matrix"); Initialize(matr); matr = new Matrix.SquareMatrix<int>(4); Console.WriteLine("Square matrix"); Initialize(matr); matr = new Matrix.DiagonalMatrix<int>(5); Console.WriteLine("Diagonal matrix"); Initialize(matr); matr = new Matrix.SymmetricMatrix<int>(5); Console.WriteLine("Symmetric matrix"); Initialize(matr); Console.ReadKey(); }
/// <summary> /// Create an input matrix that has enough space to hold the extra synthetic /// input. /// </summary> /// <param name="pattern">The input pattern to create.</param> /// <param name="extra">The synthetic input.</param> /// <returns>A matrix that contains the input pattern and the synthetic input.</returns> protected Matrix.Matrix CreateInputMatrix(double[] pattern, double extra) { Matrix.Matrix result = new Matrix.Matrix(1, pattern.Length + 1); for (int i = 0; i < pattern.Length; i++) { result[0, i] = pattern[i]; } result[0, pattern.Length] = extra; return result; }
/// <summary> /// Normalize an input array into a matrix. The resulting matrix will have /// one extra column that will be occupied by the synthetic input. /// </summary> /// <param name="input">The input array to be normalized.</param> /// <param name="type">What type of normalization to use.</param> public NormalizeInput(double[] input, NormalizationType type) { this.type = type; CalculateFactors(input); this.inputMatrix = this.CreateInputMatrix(input, this.synth); }
/// <summary> /// Construct the trainer for a self organizing map. /// </summary> /// <param name="som">The self organizing map.</param> /// <param name="train">The training method.</param> /// <param name="learnMethod">The learning method.</param> /// <param name="learnRate">The learning rate.</param> public TrainSelfOrganizingMap(SelfOrganizingMap som, double[][] train, LearningMethod learnMethod, double learnRate) { this.som = som; this.train = train; this.totalError = 1.0; this.learnMethod = learnMethod; this.learnRate = learnRate; this.outputNeuronCount = som.OutputNeuronCount; this.inputNeuronCount = som.InputNeuronCount; this.totalError = 1.0; for (int tset = 0; tset < train.Length; tset++) { Matrix.Matrix dptr = Matrix.Matrix.CreateColumnMatrix(train[tset]); if (MatrixMath.vectorLength(dptr) < VERYSMALL) { throw (new System.Exception( "Multiplicative normalization has null training case")); } } this.bestnet = new SelfOrganizingMap(this.inputNeuronCount, this.outputNeuronCount, this.som.NormalizationType); this.won = new int[this.outputNeuronCount]; this.correc = new Matrix.Matrix(this.outputNeuronCount, this.inputNeuronCount + 1); if (this.learnMethod == LearningMethod.ADDITIVE) { this.work = new Matrix.Matrix(1, this.inputNeuronCount + 1); } else { this.work = null; } Initialize(); this.bestError = Double.MaxValue; }
/// <summary> /// Take a simple double array and turn it into a matrix that can be used to /// calculate the results of the input array. Also takes into account the /// threshold. /// </summary> /// <param name="pattern"></param> /// <returns></returns> private Matrix.Matrix CreateInputMatrix(double[] pattern) { Matrix.Matrix result = new Matrix.Matrix(1, pattern.Length + 1); for (int i = 0; i < pattern.Length; i++) { result[0, i] = pattern[i]; } // add a "fake" first column to the input so that the threshold is // always multiplied by one, resulting in it just being added. result[0, pattern.Length] = 1; return result; }
/// <summary> /// Construct a Hopfield neural network of the specified size. /// </summary> /// <param name="size">The number of neurons in the network.</param> public HopfieldNetwork(int size) { this.weightMatrix = new Matrix.Matrix(size, size); }