private void estimate_internal(Matrix y, Matrix x) { try { final no.uib.cipr.matrix.DenseMatrix mjtX = new no.uib.cipr.matrix.DenseMatrix(x.getArray()); no.uib.cipr.matrix.SVD svd; svd = no.uib.cipr.matrix.SVD.factorize(mjtX); final Matrix u = MatrixUtils.convert(svd.getU(), svd.getU().numRows(), svd.getS().length); final Matrix v = MatrixUtils.convert(svd.getVt(), svd.getS().length, svd.getVt().numColumns()).transpose(); final Matrix d = MatrixUtils.diag(svd.getS()); weights = v.times(MatrixUtils.pseudoInverse(d)).times(u.transpose()).times(y); } catch (final NotConvergedException e) { throw new RuntimeException(e.getMessage()); } }
/** * Compute the covariance matrix of the given samples (assumed each sample is a * row). * * @param m * the samples matrix * @return the covariance matrix */ public static Matrix covariance(Matrix m) { final int N = m.getRowDimension(); return times(m.transpose().times(m), 1.0 / (N > 1 ? N - 1 : N)); }
private IndependentPair<Matrix, Matrix> decorrelate(Matrix meanCentredX) { final Matrix C = MatrixUtils.covariance(meanCentredX.transpose()); final Matrix CC = MatrixUtils.invSqrtSym(C); return IndependentPair.pair(CC.times(meanCentredX), CC); }
final double[] classMean = classMeans[i]; Matrix zeroCentred = MatrixUtils.minusRow(classData, classMean); MatrixUtils.plusEquals(Sw, zeroCentred.transpose().times(zeroCentred)); MatrixUtils.plusEquals(Sb, MatrixUtils.times(diff.transpose().times(diff), meanData.numInstances));
final Matrix hypTan = MatrixUtils.tanh(Z.transpose().times(W)); W = MatrixUtils.times(Z.times(hypTan), 1.0 / N).minus(weight); W = W.times(MatrixUtils.invSqrtSym(WtW)); final Matrix delta = WXmean.times(MatrixUtils.ones(1, N)); icasig = W.times(X).plus(delta);
ThinSingularValueDecomposition A1SVD = new ThinSingularValueDecomposition(A1, incSVD.updateK); A1SVD.U.print(5, 5); MatrixUtils.diag(A1SVD.S).print(5, 5); incSVD.Sdiag.print(5, 5); System.out.println("From Thinsvd: "); ThinSingularValueDecomposition A1A2SVD = new ThinSingularValueDecomposition(MatrixUtils.hstack(A1,A2), incSVD.updateK); A1A2SVD.U.print(5, 5); MatrixUtils.diag(A1A2SVD.S).print(5, 5); ThinSingularValueDecomposition ASVD = new ThinSingularValueDecomposition(A, incSVD.updateK); ASVD.U.print(5, 5); MatrixUtils.diag(ASVD.S).print(5, 5);
final double[] W = MatrixUtils.solveHomogeneousSystem(A); MatrixUtils.times(homography, 1.0 / homography.get(2, 2));
@Override protected void mstep(EMGMM gmm, GaussianMixtureModelEM learner, Matrix X, Matrix responsibilities, Matrix weightedXsum, double[] norm) { final Matrix avgX2uw = responsibilities.transpose().times(X.arrayTimes(X)); for (int i = 0; i < gmm.gaussians.length; i++) { final Matrix weightedXsumi = new Matrix(new double[][] { weightedXsum.getArray()[i] }); final Matrix avgX2uwi = new Matrix(new double[][] { avgX2uw.getArray()[i] }); final Matrix avgX2 = avgX2uwi.times(norm[i]); final Matrix mu = ((AbstractMultivariateGaussian) gmm.gaussians[i]).mean; final Matrix avgMeans2 = MatrixUtils.pow(mu, 2); final Matrix avgXmeans = mu.arrayTimes(weightedXsumi).times(norm[i]); final Matrix covar = MatrixUtils.plus(avgX2.minus(avgXmeans.times(2)).plus(avgMeans2), learner.minCovar); ((SphericalMultivariateGaussian) gmm.gaussians[i]).variance = MatrixUtils.sum(covar) / X.getColumnDimension(); } } },
}); cMat = MatrixUtils.sqrt(cMat);
@Override public Matrix getCovariance() { return MatrixUtils.diag(variance); }
@Override public Matrix refine(Matrix initial, List<? extends IndependentPair<? extends Point2d, ? extends Point2d>> data) { final LevenbergMarquardtOptimizer lm = new LevenbergMarquardtOptimizer(); final RealVector start = new ArrayRealVector(initial.getRowPackedCopy()); final RealVector observed = toRealVector(data); final int maxEvaluations = 1000; final int maxIterations = 1000; final MultivariateVectorFunction value = getValueFunction(data); final MultivariateMatrixFunction jacobian = getJacobianFunction(data); final MultivariateJacobianFunction model = LeastSquaresFactory.model(value, jacobian); final Optimum result = lm.optimize(LeastSquaresFactory.create(model, observed, start, null, maxEvaluations, maxIterations)); final Matrix improved = MatrixUtils.fromRowPacked(result.getPoint().toArray(), 3); MatrixUtils.times(improved, 1.0 / improved.get(2, 2)); return improved; } };
@Override public Double aggregate(DoubleSynchronisedTimeSeriesCollection series) { Matrix squarediffs = null; for (DoubleTimeSeries ds: series.allseries()) { if(squarediffs == null){ squarediffs = new Matrix(new double[][]{ds.getData()}); } else{ squarediffs = squarediffs.minus(new Matrix(new double[][]{ds.getData()})); squarediffs = squarediffs.arrayTimes(squarediffs ); } } return MatrixUtils.sum(squarediffs); }
final double[] W = MatrixUtils.solveHomogeneousSystem(A); Matrix fundamental = new Matrix(3, 3); fundamental.set(0, 0, W[0]); fundamental.set(2, 2, W[8]); fundamental = MatrixUtils.reduceRank(fundamental, 2); return fundamental;
/** * Solves the system <code>Ax = 0</code>, returning the vector x as an array. * Internally computes the least-squares solution using the SVD of * <code>A</code>. * * @param A * the matrix describing the system * @return the solution vector */ public static double[] solveHomogeneousSystem(double[][] A) { return solveHomogeneousSystem(new DenseMatrix(A)); }
@Override protected void mstep(EMGMM gmm, GaussianMixtureModelEM learner, Matrix X, Matrix responsibilities, Matrix weightedXsum, double[] norm) { final Matrix avgX2uw = responsibilities.transpose().times(X.arrayTimes(X)); for (int i = 0; i < gmm.gaussians.length; i++) { final Matrix weightedXsumi = new Matrix(new double[][] { weightedXsum.getArray()[i] }); final Matrix avgX2uwi = new Matrix(new double[][] { avgX2uw.getArray()[i] }); final Matrix avgX2 = avgX2uwi.times(norm[i]); final Matrix mu = ((AbstractMultivariateGaussian) gmm.gaussians[i]).mean; final Matrix avgMeans2 = MatrixUtils.pow(mu, 2); final Matrix avgXmeans = mu.arrayTimes(weightedXsumi).times(norm[i]); final Matrix covar = MatrixUtils.plus(avgX2.minus(avgXmeans.times(2)).plus(avgMeans2), learner.minCovar); ((DiagonalMultivariateGaussian) gmm.gaussians[i]).variance = covar.getArray()[0]; } } },
/** * Convert a {@link DenseMatrix} to a {@link Matrix}. * * @param mjt * {@link DenseMatrix} to convert * @return converted matrix. */ public static Matrix convert(DenseMatrix mjt) { return convert(mjt, mjt.numRows(), mjt.numColumns()); }
final Matrix QmInvSqrt = MatrixUtils.invSqrtSym(Qm); final Matrix R = Mm.times(QmInvSqrt);
/** * @param rowDimension * @param columnDimension * @return matrix of dimensions filled with ones */ public static Matrix ones(int rowDimension, int columnDimension) { final Matrix ret = new Matrix(rowDimension, columnDimension); return plus(ret, 1); }