/// <summary> /// Insert a new row at a first row in a matrix /// </summary> /// <param name="matrix"></param> /// <param name="value"></param> /// <returns></returns> public static RealMatrix InsertRow(this RealMatrix matrix, int value) { var mat = new RealMatrix(matrix.Height + 1, matrix.Width); Parallel.For(0, matrix.Height, i => Parallel.For(0, matrix.Width, j => { mat[i + 1, j] = matrix[i, j]; })); Parallel.For(0, mat.Width, i => { mat[0, i] = value; }); return(mat); }
/// <summary> /// Update a certain axis in a matrix with a specific value /// </summary> /// <param name="matrix"></param> /// <param name="index">Offset point</param> /// <param name="value"></param> /// <param name="axis">0 -> left to right, 1 -> Up and down</param> /// <returns></returns> public static RealMatrix Update(this RealMatrix matrix, int index, int value, int axis) { var mat = new RealMatrix(matrix); if (axis == 0) { Parallel.For(0, matrix.Width, i => { mat[index, i] = value; }); } else { Parallel.For(0, matrix.Height, i => { mat[i, index] = value; }); } return(mat); }
/// <summary> /// Day dream - Reconstruct a randrom matrix (An interesting way of seeing strong features the machine has learnt) /// </summary> /// <param name="numberOfSamples">How many images/dreams</param> /// <returns>Array of Reconstructed dreams</returns> public double[][] DayDream(int numberOfSamples) { var data = RealMatrix.Ones(numberOfSamples, m_numVisibleElements + 1); data.Update(0, 1, Distributions.UniformRandromMatrixBool(1, m_numVisibleElements), 1); for (int i = 0; i < numberOfSamples; i++) { var visible = data.Submatrix(i, 0, 1).ToVector(); var hidden_activations = (visible * m_weights).ToVector(); var hidden_probs = ActivationFunctions.Logistic(hidden_activations); var hidden_states = hidden_probs > RVector.Random(m_numHiddenElements + 1); hidden_states[0] = 1; var visible_activations = (hidden_states * m_weights.Transpose).ToVector(); var visible_probs = ActivationFunctions.Logistic(visible_activations); var visible_states = visible_probs > RVector.Random(m_numVisibleElements + 1); data.Update(visible_states, 0, false, i, 0); } return(data.Submatrix(0, 1).ToArray()); }
public void Train(double[][] dataArray, int maxEpochs, out double error) { error = 0; var numExamples = dataArray.Length; var data = new RealMatrix(dataArray); data = data.InsertCol(1); Stopwatch sw = new Stopwatch(); for (int i = 0; i < maxEpochs; i++) { sw.Start(); var posHiddenActivations = data * m_weights; var posHiddenProbs = ActivationFunctions.Logistic(posHiddenActivations); var posHiddenStates = posHiddenProbs > Distributions.UniformRandromMatrix(numExamples, m_numHiddenElements + 1); var posAssociations = data.Transpose * posHiddenProbs; var negVisibleActivations = posHiddenStates * m_weights.Transpose; var negVisibleProbs = ActivationFunctions.Logistic(negVisibleActivations); negVisibleProbs = negVisibleProbs.Update(0, 1, 1); var negHiddenActivations = negVisibleProbs * m_weights; var negHiddenProbs = ActivationFunctions.Logistic(negHiddenActivations); var negAssociations = negVisibleProbs.Transpose * negHiddenProbs; m_weights = m_weights + (m_learningRate * ((posAssociations - negAssociations) / numExamples)); sw.Stop(); error = ((data - negVisibleProbs) ^ 2).Sum(); RaiseEpochEnd(i, error); Console.WriteLine("Epoch {0}: error is {1}, computation time (ms): {2}", i, error, sw.ElapsedMilliseconds); sw.Reset(); } RaiseTrainEnd(maxEpochs, error); }
/// <summary> /// Get the visible layer from a hidden layer /// </summary> /// <param name="dataArray"></param> /// <returns></returns> public double[][] GetVisibleLayer(double[][] dataArray) { var numExamples = dataArray.Length; // Create a matrix, where each row is to be the visible units (plus a bias unit) // sampled from a training example. var data = new RealMatrix(dataArray); // Insert bias units of 1 into the first column of data. data = data.InsertCol(1); // Calculate the activations of the visible units. var visibleActivations = data * m_weights.Transpose; // Calculate the probabilities of turning the visible units on. var visibleProbs = ActivationFunctions.Logistic(visibleActivations); // Turn the visible units on with their specified probabilities. var visibleStates = visibleProbs > Distributions.UniformRandromMatrix(numExamples, m_numVisibleElements + 1); // Ignore the bias units. visibleStates = visibleStates.RemoveFirstCol(); //visible_states[:,1:] return(visibleStates); }
public static RealMatrix Product(RealMatrix matrixA, RealMatrix matrixB) { int aRows = matrixA.Height; int aCols = matrixA.Width; int bRows = matrixB.Height; int bCols = matrixB.Width; if (aCols != bRows) { throw new Exception("xxxx"); } var result = new RealMatrix(aRows, bCols); Parallel.For(0, aRows, i => { for (int j = 0; j < bCols; ++j) { // each col of B for (int k = 0; k < aCols; ++k) // could use k < bRows { result[i, j] += matrixA[i, k] * matrixB[k, j]; } } } ); return(result); }
public RealMatrix(RealMatrix matrix) : base(matrix) { }
public RVector(RealMatrix mat) : base(mat) { }