private void Backprop(double[,] result, double[,] expected) { int hs = hidden.Length; double[][,] DeltaHiddenWeights = new double[hs][, ]; DeltaHiddenWeights[hs - 1] = new double[1, output.GetLength(1)]; for (int i = hs - 2; i >= 0; i--) { DeltaHiddenWeights[i] = new double[1, hs]; } double[,] DeltaInputWeights = new double[1, hs]; var err = Error(result, expected); //вродь правильно DeltaHiddenWeights[hs - 1] = Elementwise.Multiply(sigmoid(output, true), err); //вродь правильно double[,] PreviousLayerError = DeltaHiddenWeights[hs - 1].Dot(hidden_weights[hs - 1].Transpose()); //вродь правильно for (int i = hs - 2; i >= 0; i--) { DeltaHiddenWeights[i] = Elementwise.Multiply(sigmoid(hidden[i + 1].RemoveColumn(hidden[i].Columns() - 1), true), PreviousLayerError); PreviousLayerError = DeltaHiddenWeights[i].Dot(hidden_weights[i].Transpose()); } DeltaInputWeights = Elementwise.Multiply(sigmoid(hidden[0].RemoveColumn(hidden[0].Columns() - 1), true), PreviousLayerError); for (int i = hs - 1; i >= 0; i--) { hidden_weights[i] = hidden_weights[i].Add(hidden[i].Transpose().Dot(DeltaHiddenWeights[i].Multiply(alpha))); } input_weights = input_weights.Add(input.Transpose().Dot(DeltaInputWeights.Multiply(alpha))); }
public void Learn(List <double[]> vectors, List <double> weights) { if (vectors.Count <= 2) { return; } Mean = new double[Mean.Length]; for (int index = 0; index < vectors.Count; index++) { var vector = vectors[index]; Mean = Mean.Add(vector.Multiply(weights[index])); } Mean = Mean.Divide(weights.Sum()); CovarianceMatrix = new double[vectors[0].Length, vectors[0].Length]; for (int index = 0; index < vectors.Count; index++) { var vector = vectors[index]; var diffVector = vector.Subtract(Mean).ToMatrix(); var covMatirix = diffVector.Transpose().Multiply(diffVector); CovarianceMatrix = CovarianceMatrix.Add(covMatirix.Multiply(weights[index])); } CovarianceMatrix = CovarianceMatrix.Divide(weights.Sum()); EigenMatrix = CovarianceMatrix.GetEigenMatrix(); Learned = true; }
public void Convolute_TestArrayWithModifiedKernel_EqualsInputArray(string pattern, string paddingMethod) { // Arrange testImg.New(pattern); for (int k = 0; k < 100; k += 10) { float e = (float)(0 + k * 0.000000001); // Random kernel int w = 5; kernel = new double[w, w]; Random r = new Random(); for (int i = 0; i < w; i++) { for (int j = 0; j < w; j++) { kernel[i, j] = r.Next(0, 1000); } } double[,] kernel2 = kernel.Add(e); // Second kernel with residual // Act double[,] convResult = Functions.Convolution2D(kernel, testImg.Image.ToDouble(), paddingMethod); double[,] convResult2 = Functions.Convolution2D(kernel2, testImg.Image.ToDouble(), paddingMethod); // Assert for (int i = 0; i < convResult.GetLength(0); i++) { for (int j = 0; j < convResult.GetLength(1); j++) { Assert.Equal(convResult[i, j], convResult2[i, j], 4); } } } }
public void Train(double[][] data, double[][] labels, double learningRate) { for (int i = 0; i < data.Length; i++) { var feedforward = Fetch(data[i]); var output = feedforward.output; var weightedSumOutput = feedforward.weightedSumOutput; var Labels = new double[][] { new double[] { 0 }, }; Labels[0][0] = GenerateXORLabel(data[i][0], data[i][1]); //This is basically the cost function var errors_output = Labels[0].Subtract(output); //How good is to output compared to the target /*--------------------------------------------------------------- * -- Calculate Delta of the weight between hidden and output -- * ---------------------------------------------------------------*/ var HiddenTransposed = Hidden.Transpose(); var deltaWeightOutput = HiddenTransposed.Dot(errors_output); double[,] deltaWeightOutput2D = Matrix.Create(deltaWeightOutput); //Convert to Matrix /*--------------------------------------------------------------- * -- Calculate Delta of the weight between input and hidden -- * ---------------------------------------------------------------*/ //First we have to calculate the Error in the hidden nodes ... //Transposed because we are going Backwards through the Network var WHOTransposed = WeightsHiddenOutput.Transpose(); //Moves the Error to the output layer var errors_hidden = WHOTransposed.Dot(errors_output); //Element Wise multiplication (schur product) var weightedSumHidden = feedforward.weightedSumHidden; weightedSumHidden = ApplyDerivativeReLU(weightedSumHidden); //Moves the Error backthrough the Neuron errors_hidden = errors_hidden.Multiply(weightedSumHidden); //... then we can Calculate the Delta var InputTransposed = Inputs.Transpose(); var deltaWeightHidden = InputTransposed.Dot(errors_hidden); double[,] deltaWeightHidden2D = Matrix.Create(deltaWeightHidden); //Convert to Matrix deltaWeightHidden2D = Inputs.Transpose().Dot(deltaWeightHidden2D); /*--------------------------------------------------------------- * -- Adjust Weights and Biases using the delta -- * ---------------------------------------------------------------*/ //The Biases just get adjusted by adding the Errors multiplied by the learning rate BiasOutput = BiasOutput.Add(errors_output.Multiply(learningRate)); //Output Bias WeightsHiddenOutput = WeightsHiddenOutput.Add(deltaWeightOutput2D.Multiply(learningRate)); BiasHidden = BiasHidden.Add(errors_hidden.Multiply(learningRate)); //Hidden Bias WeightsInputHidden = WeightsInputHidden.Add(deltaWeightHidden2D.Multiply(learningRate)); } }
// ---------------------------------------------------------------------------------------- // Helper function for updating weight values during backpropagation. private void UpdateWeigths(double[,] layer1, double[,] layer2, ref double[,] weigths, double[] errorList) { // Convert errors list (one-dimensional) to two-dimensional, one-column matrix. double[,] errors = Matrix.Create <double>(errorList.Length, 1); errors.SetColumn(0, errorList); // Calculate delta matrix (differences for updating weight values). double[,] deltas = Elementwise.Multiply(errors, layer2.Apply(x => x * (1 - x))) .Dot(layer1.Transpose()) .Apply(x => x * .1); // Apply delta matrix. weigths = weigths.Add(deltas); }
/// <summary> /// Registers the occurrence of a value. /// </summary> /// /// <param name="x">The x-coordinate of the value to be registered.</param> /// <param name="y">The y-coordinate of the value to be registered.</param> /// public void Push(double x, double y) { double[,] Qloc = { { x }, { y } }; // Predict next state Q_estimate = Matrix.Dot(A, Q_estimate).Add(B.Multiply(acceleration)); // Predict Covariances P = Matrix.Dot(A, P.DotWithTransposed(A)).Add(Ex); Aux = Matrix.Dot(C, P.DotWithTransposed(C)).Add(Ez).PseudoInverse(); // Kalman Gain K = P.Dot(C.TransposeAndDot(Aux)); Q_estimate = Q_estimate.Add(K.Dot(Qloc.Subtract(C.Dot(Q_estimate)))); // Update P (Covariances) P = Matrix.Dot(diagonal.Subtract(Matrix.Dot(K, C)), P); }
/// <summary> /// Registers the occurrence of a value. /// </summary> /// /// <param name="value">The value to be registered.</param> /// public void Push(DoublePoint value) { double[,] Qloc = { { value.X }, { value.Y } }; // Predict next state Q_estimate = Matrix.Dot(A, Q_estimate).Add(B.Multiply(acceleration)); // Predict Covariances P = Matrix.Dot(A, P.DotWithTransposed(A)).Add(Ex); Aux = Matrix.Dot(C, P.DotWithTransposed(C).Add(Ez)).PseudoInverse(); // Kalman Gain K = Matrix.Dot(Matrix.DotWithTransposed(P, C), Aux); Q_estimate = Q_estimate.Add(Matrix.Dot(K, Qloc.Subtract(Matrix.Dot(C, Q_estimate)))); // Update P (Covariances) P = Matrix.Dot(diagonal.Subtract(Matrix.Dot(K, C)), P); }
/// <summary> /// Method to standardize image grayscale values using previously defined inputs for gaussian kernels. /// Method string defines padding method. /// </summary> public void Standardize(ref double[,] image, string method) { // Get Gaussian kernels double[,] kernel1 = GaussianKernel(w1, s1), kernel2 = GaussianKernel(w2, s2); // Blurring with kernels double[,] blurredImage1 = Functions.Convolution2D(kernel1, image, method), blurredImage2 = Functions.Convolution2D(kernel2, image, method); // Alternative blurring, not used currently // Centering double[,] centered = image.Subtract(blurredImage1); // Standardization double[,] std = Functions.Convolution2D(kernel2, centered.Pow(2), method).Sqrt(); image = centered // This function standardizes and modifies original given image .Divide( std.Add(1E-09)); }
/// <summary> /// Registers the occurrence of a value. /// </summary> /// /// <param name="value">The value to be registered.</param> /// public void Push(DoublePoint value) { double[,] Qloc = { { value.X }, { value.Y } }; // Predict next state Q_estimate = (A.Multiply(Q_estimate)).Add(B.Multiply(acceleration)); // Predict Covariances P = (A.Multiply(P.Multiply(A.Transpose()))).Add(Ex); Aux = (C.Multiply(P.Multiply(C.Transpose())).Add(Ez)).PseudoInverse(); // Kalman Gain K = P.Multiply(C.Transpose().Multiply(Aux)); Q_estimate = Q_estimate.Add(K.Multiply(Qloc.Subtract(C.Multiply(Q_estimate)))); // Update P (Covariances) P = (diagonal.Subtract(K.Multiply(C))).Multiply(P); }
/// <summary> /// Apply Black-Litterman master formula /// http://www.blacklitterman.org/cookbook.html /// </summary> /// <param name="Π">Prior/Posterior mean array</param> /// <param name="Σ">Prior/Posterior covariance matrix</param> /// <param name="P">A matrix that identifies the assets involved in the views (size: K x N)</param> /// <param name="Q">A view vector (size: K x 1)</param> private void ApplyBlackLittermanMasterFormula(ref double[] Π, ref double[,] Σ, double[,] P, double[] Q) { // Create the diagonal covariance matrix of error terms from the expressed views var eye = Matrix.Diagonal(Q.GetLength(0), 1); var Ω = Elementwise.Multiply(P.Dot(Σ).DotWithTransposed(P).Multiply(_tau), eye); if (Ω.Determinant() != 0) { // Define matrices Στ and A to avoid recalculations var Στ = Σ.Multiply(_tau); var A = Στ.DotWithTransposed(P).Dot(P.Dot(Στ).DotWithTransposed(P).Add(Ω).Inverse()); // Compute posterior estimate of the mean: Black-Litterman "master equation" Π = Π.Add(A.Dot(Q.Subtract(P.Dot(Π)))); // Compute posterior estimate of the uncertainty in the mean var M = Στ.Subtract(A.Dot(P).Dot(Στ)); Σ = Σ.Add(M).Multiply(_delta); // Compute posterior weights based on uncertainty in mean var W = Π.Dot(Σ.Inverse()); } }
static void Main(string[] args) { #region 1. Declaring matrices // 1.1 Using standard .NET declaration double[,] A = { { 1, 2, 3 }, { 6, 2, 0 }, { 0, 0, 1 } }; double[,] B = { { 2, 0, 0 }, { 0, 2, 0 }, { 0, 0, 2 } }; { // 1.2 Using Accord extension methods double[,] Bi = Matrix.Identity(3).Multiply(2); double[,] Bj = Matrix.Diagonal(3, 2.0); // both are equal to B // 1.2 Using Accord extension methods with implicit typing var I = Matrix.Identity(3); } #endregion #region 2. Matrix Operations { // 2.1 Addition var C = A.Add(B); // 2.2 Subtraction var D = A.Subtract(B); // 2.3 Multiplication { // 2.3.1 By a scalar var halfM = A.Multiply(0.5); // 2.3.2 By a vector double[] m = A.Multiply(new double[] { 1, 2, 3 }); // 2.3.3 By a matrix var M = A.Multiply(B); // 2.4 Transposing var At = A.Transpose(); } } // 2.5 Elementwise operations // 2.5.1 Elementwise multiplication A.ElementwiseMultiply(B); // A.*B // 2.5.1 Elementwise division A.ElementwiseDivide(B); // A./B #endregion #region 3. Matrix characteristics { // 3.1 Calculating the determinant double det = A.Determinant(); // 3.2 Calculating the trace double tr = A.Trace(); // 3.3 Computing the sum vector { double[] sumVector = A.Sum(); // 3.3.1 Computing the total sum of elements double sum = sumVector.Sum(); // 3.3.2 Computing the sum along the rows sumVector = A.Sum(0); // Equivalent to Octave's sum(A, 1) // 3.3.2 Computing the sum along the columns sumVector = A.Sum(1); // Equivalent to Octave's sum(A, 2) } } #endregion #region 4. Linear Algebra { // 4.1 Computing the inverse var invA = A.Inverse(); // 4.2 Computing the pseudo-inverse var pinvA = A.PseudoInverse(); // 4.3 Solving a linear system (Ax = B) var x = A.Solve(B); } #endregion #region 5. Special operators { // 5.1 Finding the indices of elements double[] v = { 5, 2, 2, 7, 1, 0 }; int[] idx = v.Find(e => e > 2); // finding the index of every element in v higher than 2. // 5.2 Selecting elements by index double[] u = v.Submatrix(idx); // u is { 5, 7 } // 5.3 Converting between different matrix representations double[][] jaggedA = A.ToArray(); // from multidimensional to jagged array // 5.4 Extracting a column or row from the matrix double[] a = A.GetColumn(0); // retrieves the first column double[] b = B.GetRow(1); // retrieves the second row // 5.5 Taking the absolute of a matrix var absA = A.Abs(); // 5.6 Applying some function to every element var newv = v.Apply(e => e + 1); } #endregion #region 7. Vector operations { double[] u = { 1, 2, 3 }; double[] v = { 4, 5, 6 }; var w1 = u.InnerProduct(v); var w2 = u.OuterProduct(v); var w3 = u.CartesianProduct(v); double[] m = { 1, 2, 3, 4 }; double[,] M = Matrix.Reshape(m, 2, 2); } #endregion #region Decompositions { // Singular value decomposition { SingularValueDecomposition svd = new SingularValueDecomposition(A); var U = svd.LeftSingularVectors; var S = svd.Diagonal; var V = svd.RightSingularVectors; } // or (please see documentation for details) { SingularValueDecomposition svd = new SingularValueDecomposition(A.Transpose()); var U = svd.RightSingularVectors; var S = svd.Diagonal; var V = svd.LeftSingularVectors; } // Eigenvalue decomposition { EigenvalueDecomposition eig = new EigenvalueDecomposition(A); var V = eig.Eigenvectors; var D = eig.DiagonalMatrix; } // QR decomposition { QrDecomposition qr = new QrDecomposition(A); var Q = qr.OrthogonalFactor; var R = qr.UpperTriangularFactor; } // Cholesky decomposition { CholeskyDecomposition chol = new CholeskyDecomposition(A); var R = chol.LeftTriangularFactor; } // LU decomposition { LuDecomposition lu = new LuDecomposition(A); var L = lu.LowerTriangularFactor; var U = lu.UpperTriangularFactor; } } #endregion }
// update levenberg public layer lmupdate(double[] x) { output = (weights.Add(weightDelta)).Dot(x); return(this); }
public double KALMANOUT(double Input) { A[0, 0] = 1; A[0,1]= dt; A[1, 0] = 0; A[1, 1] = 1;//{ { 1, dt }, { 0, 1 } }; B[0, 0] = u * Math.Pow(dt, 2) / 2; B[1, 0] = u * dt; C[0, 0] = 1; C[0, 1] = 0; // XT[0, 0] = position; // XT[1, 0] = velocity; // double[,] B = { { u * Math.Pow(dt, 2) / 2 }, { u * dt } }; // double[,] C = { { 1 } , { 0 } }; // double[,] XT= { { position }, { velocity} }; // double[,] EX = { { Math.Pow(processNoise, 2) * (Math.Pow(dt, 4) / 4), Math.Pow(processNoise, 2) * (Math.Pow(dt, 3) / 2) }, { Math.Pow(processNoise, 2) * (Math.Pow(dt, 3) / 2), Math.Pow(processNoise, 2) * (Math.Pow(dt, 2)) } }; ; // double[,] AT = { { 1, 0 }, { dt, 1 } }; input = Input; A.Multiply(XT, tempX); // double[,] tempX=Accord.Math.Matrix.Multiply(A, XT); XT= tempX.Add(B); // double[,] XT=Accord.Math.Matrix.Add(tempX, B); C.Multiply(XT, ZT); A.Multiply(PT, AP); AP.Multiply(AT, APAT); PT=APAT.Add(EX); PT.Multiply(CT, tempPCT); C.Multiply(tempPCT, CPCT); S_ = 1 / (CPCT[0, 0] + measureNoise); tempPCT.Multiply(S_,K); error = Input - ZT[0, 0]; K.Multiply(error,tempK); XTT = XT.Add(tempK); XT = XTT; position = XT[0, 0]; velocity = XT[1, 0]; I_KC = 1 - K[0,0]; PT.Multiply(I_KC, PT); return XT[0, 0]; }