TrainingState(Matrix eigens, Matrix projections) { currentEigens = eigens; trainingProjections = projections; trainingIndex = 0; helperVector = new DenseVector(eigens.numRows()); firstPass = true; statusProgress = new ArrayList<>(); activationNumerator = 0; activationDenominatorSquared = 0; numEigensProcessed = 0; }
private static int viewSize(Matrix matrix, int row, int column, int rowStride, int columnStride) { if (rowStride != 0 && columnStride != 0) { int n1 = (matrix.numRows() - row) / rowStride; int n2 = (matrix.numCols() - column) / columnStride; return Math.min(n1, n2); } else if (rowStride > 0) { return (matrix.numRows() - row) / rowStride; } else { return (matrix.numCols() - column) / columnStride; } }
public TransposedMatrixView(Matrix m) { super(m.numCols(), m.numRows()); this.m = m; }
public static Vector mult(Matrix m, Vector v) { if (m.numRows() != v.size()) { throw new CardinalityException(m.numRows(), v.size()); } // Use a Dense Vector for the moment, Vector result = new DenseVector(m.numRows()); for (int i = 0; i < m.numRows(); i++) { result.set(i, m.viewRow(i).dot(v)); } return result; }
static Matrix addLambdaTimesNuiTimesE(Matrix matrix, double lambda, int nui) { Preconditions.checkArgument(matrix.numCols() == matrix.numRows(), "Must be a Square Matrix"); double lambdaTimesNui = lambda * nui; int numCols = matrix.numCols(); for (int n = 0; n < numCols; n++) { matrix.setQuick(n, n, matrix.getQuick(n, n) + lambdaTimesNui); } return matrix; }
private static void printMatrix(String name, Matrix m) { int rows = m.numRows(); int columns = m.numCols(); System.out.printf("%s - %d x %d\n", name, rows, columns); for (int i = 0; i < rows; i++) { for (int j = 0; j < columns; j++) { System.out.printf("%10.5f", m.get(i, j)); } System.out.printf("\n"); } System.out.printf("\n"); System.out.printf("\n"); }
private static void printMatrix(String name, Matrix m) { int rows = m.numRows(); int columns = m.numCols(); System.out.printf("%s - %d x %d\n", name, rows, columns); for (int i = 0; i < rows; i++) { for (int j = 0; j < columns; j++) { System.out.printf("%10.5f", m.get(i, j)); } System.out.printf("\n"); } System.out.printf("\n"); System.out.printf("\n"); }
public JacobiConditioner(Matrix a) { if (a.numCols() != a.numRows()) { throw new IllegalArgumentException("Matrix must be square."); } inverseDiagonal = new DenseVector(a.numCols()); for (int i = 0; i < a.numCols(); ++i) { inverseDiagonal.setQuick(i, 1.0 / a.getQuick(i, i)); } }
@Override public Matrix timesRight(Matrix that) { if (that.numRows() != diagonal.size()) { throw new IllegalArgumentException("Incompatible number of rows in the right operand of matrix multiplication."); } Matrix m = that.like(); for (int row = 0; row < diagonal.size(); row++) { m.assignRow(row, that.viewRow(row).times(diagonal.getQuick(row))); } return m; }
/** * Test for the error reported in https://issues.apache.org/jira/browse/MAHOUT-1146 */ @Test public void testColumnView() { Matrix matrix = new DenseMatrix(5, 3); Vector column2 = matrix.viewColumn(2); Matrix outerProduct = column2.cross(column2); assertEquals(matrix.numRows(), outerProduct.numRows()); assertEquals(matrix.numRows(), outerProduct.numCols()); }
public static void assertEigen(Matrix eigens, VectorIterable corpus, int numEigensToCheck, double errorMargin, boolean isSymmetric) { for (int i = 0; i < numEigensToCheck; i++) { Vector e = eigens.viewRow(i); assertEigen(i, e, corpus, errorMargin, isSymmetric); } }
private OpenIntObjectHashMap<Vector> asRowVectors(Matrix matrix) { OpenIntObjectHashMap<Vector> rows = new OpenIntObjectHashMap<>(); for (int row = 0; row < matrix.numRows(); row++) { rows.put(row, matrix.viewRow(row).clone()); } return rows; }
@Test public void testAggregateRows() { Vector v = test.aggregateRows(new VectorFunction() { @Override public double apply(Vector v) { return v.zSum(); } }); for (int i = 0; i < test.numRows(); i++) { assertEquals(test.viewRow(i).zSum(), v.get(i), EPSILON); } }
/** test dimensions */ @Test public void testDimensions() { Matrix matrix = new DenseMatrix(testSquare); int m = matrix.numRows(); int n = matrix.numCols(); SingularValueDecomposition svd = new SingularValueDecomposition(matrix); assertEquals(m, svd.getU().numRows()); assertEquals(m, svd.getU().numCols()); assertEquals(m, svd.getS().numCols()); assertEquals(n, svd.getS().numCols()); assertEquals(n, svd.getV().numRows()); assertEquals(n, svd.getV().numCols()); }
@Test public void testUniformView() { Matrix m1 = Matrices.uniformView(5, 6, 1234); Matrix m2 = Matrices.uniformView(5, 6, 1234); for (int row = 0; row < m1.numRows(); row++) { for (int col = 0; col < m1.numCols(); col++) { assertTrue(m1.getQuick(row, col) >= 0.0); assertTrue(m1.getQuick(row, col) < 1.0); } } Matrix diff = m1.minus(m2); assertEquals(0, diff.aggregate(Functions.PLUS, Functions.ABS), 1e-10); }
@Test public void testSymmetricUniformView() { Matrix m1 = Matrices.symmetricUniformView(5, 6, 1234); Matrix m2 = Matrices.symmetricUniformView(5, 6, 1234); for (int row = 0; row < m1.numRows(); row++) { for (int col = 0; col < m1.numCols(); col++) { assertTrue(m1.getQuick(row, col) >= -1.0); assertTrue(m1.getQuick(row, col) < 1.0); } } Matrix diff = m1.minus(m2); assertEquals(0, diff.aggregate(Functions.PLUS, Functions.ABS), 1e-10); }
@Test public void testEigen() { Matrix a = new DenseSymmetricMatrix(new double[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, false); Matrix b = new DenseMatrix(a.numRows(), a.numCols()); b.assign(a); assertEquals(0, a.minus(b).aggregate(Functions.PLUS, Functions.ABS), 1.0e-10); EigenDecomposition edA = new EigenDecomposition(a); EigenDecomposition edB = new EigenDecomposition(b); System.out.println(edA.getV()); assertEquals(0, edA.getV().minus(edB.getV()).aggregate(Functions.PLUS, Functions.ABS), 1.0e-10); assertEquals(0, edA.getRealEigenvalues().minus(edA.getRealEigenvalues()).aggregate(Functions.PLUS, Functions.ABS), 1.0e-10); }
@Test public void createRiIiMaybeTransposed() { Vector ratings = new SequentialAccessSparseVector(3); ratings.setQuick(1, 1.0); ratings.setQuick(3, 3.0); ratings.setQuick(5, 5.0); Matrix riIiMaybeTransposed = AlternatingLeastSquaresSolver.createRiIiMaybeTransposed(ratings); assertEquals(1, riIiMaybeTransposed.numCols(), 1); assertEquals(3, riIiMaybeTransposed.numRows(), 3); assertEquals(1.0, riIiMaybeTransposed.getQuick(0, 0), EPSILON); assertEquals(3.0, riIiMaybeTransposed.getQuick(1, 0), EPSILON); assertEquals(5.0, riIiMaybeTransposed.getQuick(2, 0), EPSILON); }