/// <summary> /// Factorize a nonnegative matrix A into two nonnegative matrices B and C so that A is nearly equal to B*C. /// Tikhonovs the nm f3. /// </summary> /// <param name="A">Matrix to factorize.</param> /// <param name="r">The number of factors.</param> /// <param name="B0">Original B matrix. Can be null.</param> /// <param name="C0">Original C matrix. Can be null.</param> /// <param name="oldalpha">The oldalpha.</param> /// <param name="oldbeta">The oldbeta.</param> /// <param name="gammaB">The gamma b.</param> /// <param name="gammaC">The gamma c.</param> /// <param name="maxiter">The maxiter.</param> /// <param name="tol">The tol.</param> public static void TikhonovNMF3( IMatrix <double> A, int r, IMatrix <double> B0, IMatrix <double> C0, IVector <double> oldalpha, IVector <double> oldbeta, IMatrix <double> gammaB, IMatrix <double> gammaC, int maxiter, double tol) { // The converged version of the algorithm // Use complementary slackness as stopping criterion // format long; // Check the input matrix if (null == A) { throw new ArgumentNullException(nameof(A)); } if (MatrixMath.Min(A) < 0) { throw new ArgumentException("Input matrix must not contain negative elements", nameof(A)); } int m = A.RowCount; int n = A.ColumnCount; // Check input arguments //if ˜exist(’r’) if (null == B0) { B0 = DoubleMatrix.Random(m, r); } if (null == C0) { C0 = DoubleMatrix.Random(r, n); } if (null == oldalpha) { oldalpha = new DoubleVector(n); } if (null == oldbeta) { oldbeta = new DoubleVector(m); } if (null == gammaB) { gammaB = new DoubleMatrix(m, 1); gammaB.SetMatrixElements(0.1); // small values lead to better convergence property } if (null == gammaC) { gammaC = new DoubleMatrix(n, 1); gammaC.SetMatrixElements(0.1); // small values lead to better convergence property } if (0 == maxiter) { maxiter = 1000; } if (double.IsNaN(tol) || tol <= 0) { tol = 1.0e-9; } var B = B0; B0 = null; var C = C0; C0 = null; var newalpha = oldalpha; var newbeta = oldbeta; var AtA = new DoubleMatrix(n, n); MatrixMath.MultiplyFirstTransposed(A, A, AtA); double trAtA = MatrixMath.Trace(AtA); var olderror = new DoubleVector(maxiter + 1); var BtA = new DoubleMatrix(r, n); MatrixMath.MultiplyFirstTransposed(B, A, BtA); var CtBtA = new DoubleMatrix(n, n); MatrixMath.MultiplyFirstTransposed(C, BtA, CtBtA); var BtB = new DoubleMatrix(r, r); MatrixMath.MultiplyFirstTransposed(B, B, BtB); var BtBC = new DoubleMatrix(r, n); MatrixMath.Multiply(BtB, C, BtBC); var CtBtBC = new DoubleMatrix(n, n); MatrixMath.MultiplyFirstTransposed(C, BtBC, CtBtBC); var BtDgNewbeta = new DoubleMatrix(r, m); MatrixMath.MultiplyFirstTransposed(B, DoubleMatrix.Diag(newbeta), BtDgNewbeta); var BtDgNewbetaB = new DoubleMatrix(r, r); // really rxr ? MatrixMath.Multiply(BtDgNewbeta, B, BtDgNewbetaB); var CDgNewalpha = new DoubleMatrix(r, n); MatrixMath.Multiply(C, DoubleMatrix.Diag(newalpha), CDgNewalpha); var CtCDgNewalpha = new DoubleMatrix(n, n); MatrixMath.MultiplyFirstTransposed(C, CDgNewalpha, CtCDgNewalpha); olderror[0] = 0.5 * trAtA - MatrixMath.Trace(CtBtA) + 0.5 * MatrixMath.Trace(CtBtBC) + 0.5 * MatrixMath.Trace(BtDgNewbetaB) + 0.5 * MatrixMath.Trace(CtCDgNewalpha); double sigma = 1.0e-9; double delta = sigma; for (int iteration = 1; iteration <= maxiter; ++iteration) { var CCt = new DoubleMatrix(r, r); MatrixMath.MultiplySecondTransposed(C, C, CCt); var gradB = new DoubleMatrix(m, r); var tempMR = new DoubleMatrix(m, r); //gradB = B*CCt - A*C’ +diag(newbeta)*B; MatrixMath.Multiply(B, CCt, gradB); MatrixMath.MultiplySecondTransposed(A, C, tempMR); MatrixMath.Add(gradB, tempMR, gradB); MatrixMath.Multiply(DoubleMatrix.Diag(newbeta), B, tempMR); MatrixMath.Add(gradB, tempMR, gradB); // Bm = max(B, (gradB < 0) * sigma); var sigMR = new DoubleMatrix(m, r); sigMR.SetMatrixElements((i, j) => gradB[i, j] < 0 ? sigma : 0); var Bm = new DoubleMatrix(m, r); Bm.SetMatrixElements((i, j) => Math.Max(B[i, j], sigMR[i, j])); } }
/// <summary> /// Execution of the fast nonnegative least squares algorithm. The algorithm finds a vector x with all elements xi>=0 which minimizes |X*x-y|. /// </summary> /// <param name="XtX">X transposed multiplied by X, thus a square matrix.</param> /// <param name="Xty">X transposed multiplied by Y, thus a matrix with one column and same number of rows as X.</param> /// <param name="isRestrictedToPositiveValues">Function that takes the parameter index as argument and returns true if the parameter at this index is restricted to positive values; otherwise the return value must be false.</param> /// <param name="tolerance">Used to decide if a solution element is less than or equal to zero. If this is null, a default tolerance of tolerance = MAX(SIZE(XtX)) * NORM(XtX,1) * EPS is used.</param> /// <param name="x">Output: solution vector (matrix with one column and number of rows according to dimension of X.</param> /// <param name="w">Output: Lagrange vector. Elements which take place in the fit are set to 0. Elements fixed to zero contain a negative number.</param> /// <remarks> /// <para> /// Literature: Rasmus Bro and Sijmen De Jong, 'A fast non-negativity-constrained least squares algorithm', Journal of Chemometrics, Vol. 11, 393-401 (1997) /// </para> /// <para> /// Algorithm modified by Dirk Lellinger 2015 to allow a mixture of restricted and unrestricted parameters. /// </para> /// </remarks> public static void Execution(IROMatrix <double> XtX, IROMatrix <double> Xty, Func <int, bool> isRestrictedToPositiveValues, double?tolerance, out IMatrix <double> x, out IMatrix <double> w) { if (null == XtX) { throw new ArgumentNullException(nameof(XtX)); } if (null == Xty) { throw new ArgumentNullException(nameof(Xty)); } if (null == isRestrictedToPositiveValues) { throw new ArgumentNullException(nameof(isRestrictedToPositiveValues)); } if (XtX.RowCount != XtX.ColumnCount) { throw new ArgumentException("Matrix should be a square matrix", nameof(XtX)); } if (Xty.ColumnCount != 1) { throw new ArgumentException(nameof(Xty) + " should be a column vector (number of columns should be equal to 1)", nameof(Xty)); } if (Xty.RowCount != XtX.ColumnCount) { throw new ArgumentException("Number of rows in " + nameof(Xty) + " should match number of columns in " + nameof(XtX), nameof(Xty)); } var matrixGenerator = new Func <int, int, DoubleMatrix>((rows, cols) => new DoubleMatrix(rows, cols)); // if nargin < 3 // tol = 10 * eps * norm(XtX, 1) * length(XtX); // end double tol = tolerance.HasValue ? tolerance.Value : 10 * DoubleConstants.DBL_EPSILON * MatrixMath.Norm(XtX, MatrixNorm.M1Norm) * Math.Max(XtX.RowCount, XtX.ColumnCount); // [m, n] = size(XtX); int n = XtX.ColumnCount; // P = zeros(1, n); // Z = 1:n; var P = new bool[n]; // POSITIVE SET: all indices which are currently not fixed are marked with TRUE (Negative set is simply this, but inverted) bool initializationOfSolutionRequired = false; for (int i = 0; i < n; ++i) { bool isNotRestricted = !isRestrictedToPositiveValues(i); P[i] = isNotRestricted; initializationOfSolutionRequired |= isNotRestricted; } // x = P'; x = matrixGenerator(n, 1); // w = Xty-XtX*x; w = matrixGenerator(n, 1); MatrixMath.Copy(Xty, w); var helper_n_1 = matrixGenerator(n, 1); MatrixMath.Multiply(XtX, x, helper_n_1); MatrixMath.Subtract(w, helper_n_1, w); // set up iteration criterion int iter = 0; int itmax = 30 * n; // outer loop to put variables into set to hold positive coefficients // while any(Z) & any(w(ZZ) > tol) while (initializationOfSolutionRequired || (P.Any(ele => false == ele) && w.Any((r, c, ele) => false == P[r] && ele > tol))) { if (initializationOfSolutionRequired) { initializationOfSolutionRequired = false; } else { // [wt, t] = max(w(ZZ)); // t = ZZ(t); int t = -1; // INDEX double wt = double.NegativeInfinity; for (int i = 0; i < n; ++i) { if (!P[i]) { if (w[i, 0] > wt) { wt = w[i, 0]; t = i; } } } // P(1, t) = t; // Z(t) = 0; P[t] = true; } // z(PP')=(Xty(PP)'/XtX(PP,PP)'); var subXty = Xty.SubMatrix(P, 0, matrixGenerator); // Xty(PP)' var subXtX = XtX.SubMatrix(P, P, matrixGenerator); var solver = new DoubleLUDecomp(subXtX); var subSolution = solver.Solve(subXty); var z = matrixGenerator(n, 1); for (int i = 0, ii = 0; i < n; ++i) { z[i, 0] = P[i] ? subSolution[ii++, 0] : 0; } // C. Inner loop (to remove elements from the positive set which no longer belong to) while (z.Any((r, c, ele) => true == P[r] && ele <= tol && isRestrictedToPositiveValues(r)) && iter < itmax) { ++iter; // QQ = find((z <= tol) & P'); //alpha = min(x(QQ)./ (x(QQ) - z(QQ))); double alpha = double.PositiveInfinity; for (int i = 0; i < n; ++i) { if ((z[i, 0] <= tol && true == P[i] && isRestrictedToPositiveValues(i))) { alpha = Math.Min(alpha, x[i, 0] / (x[i, 0] - z[i, 0])); } } // x = x + alpha * (z - x); for (int i = 0; i < n; ++i) { x[i, 0] += alpha * (z[i, 0] - x[i, 0]); } // ij = find(abs(x) < tol & P' ~= 0); // Z(ij) = ij'; // P(ij) = zeros(1, length(ij)); for (int i = 0; i < n; ++i) { if (Math.Abs(x[i, 0]) < tol && P[i] == true && isRestrictedToPositiveValues(i)) { P[i] = false; } } //PP = find(P); //ZZ = find(Z); //nzz = size(ZZ); //z(PP) = (Xty(PP)'/XtX(PP,PP)'); subXty = Xty.SubMatrix(P, 0, matrixGenerator); subXtX = XtX.SubMatrix(P, P, matrixGenerator); solver = new DoubleLUDecomp(subXtX); subSolution = solver.Solve(subXty); for (int i = 0, ii = 0; i < n; ++i) { z[i, 0] = P[i] ? subSolution[ii++, 0] : 0; } } // end inner loop MatrixMath.Copy(z, x); MatrixMath.Copy(Xty, w); MatrixMath.Multiply(XtX, x, helper_n_1); MatrixMath.Subtract(w, helper_n_1, w); } }