/** * Creates a new, empty {@link FactorizationMachine} of the given * input dimensionality (d) and factor count (k). It initializes the * internal d-dimensional weight vector and k-by-d factor matrix based on * these sizes. All values are initialized to 0. * * @param dimensionality * The input dimensionality (d). Cannot be negative. * @param factorCount * The number of factors for pairwise interactions (k). Cannot be * negative. */ public FactorizationMachine( final int dimensionality, final int factorCount) { this(0.0, VectorFactory.getDenseDefault().createVector(dimensionality), MatrixFactory.getDenseDefault().createMatrix( factorCount, dimensionality)); }
/** * Creates a new instance of MultivariateGaussianMeanBayesianEstimator * @param dimensionality * Dimensionality of the Vectors */ public MultivariateGaussianMeanBayesianEstimator( int dimensionality ) { this( MatrixFactory.getDefault().createIdentity(dimensionality,dimensionality) ); }
/** * Creates a new matrix by copying the given set of row vectors. * * @param rows * The row vectors to create a matrix from. Must all be the same * dimensionality. * @return * A new matrix whose rows are equal to the given set of rows. */ public MatrixType copyRowVectors( Vectorizable ... rows ) { return this.copyRowVectors(Arrays.asList(rows)); }
@Override public Matrix init(int rows, int cols) { return MatrixFactory.getSparseDefault().createMatrix(rows, cols); }
@Override public Matrix init(int rows, int cols) { final SparseMatrix rand = (SparseMatrix) smf.createUniformRandom(rows, cols, min, max, random); final Matrix ret = smf.createMatrix(rows, cols); for (int i = 0; i < rows; i++) { if (this.random.nextDouble() > sparcity) { ret.setRow(i, rand.getRow(i)); } } return ret; } }
public Matrix getValue() { final int dim = this.conditionalDistribution.getInputDimensionality(); Matrix parameter = MatrixFactory.getDefault().createMatrix(dim, dim+1); parameter.setColumn(0, this.conditionalDistribution.getMean() ); parameter.setSubMatrix(0,1, this.conditionalDistribution.getCovariance() ); return parameter; }
int nextNum = nodesPerLayer.get(i + 1); Matrix w = MatrixFactory.getDefault().createUniformRandom(nextNum, currentNum, -range, range, random); DifferentiableGeneralizedLinearModel layer = new DifferentiableGeneralizedLinearModel(
MatrixFactory.getDiagonalDefault().createIdentity( dataSize, dataSize); centeringTerm.scaleEquals(1.0 / dataSize); final Matrix components = MatrixFactory.getDenseDefault().createMatrix( realComponentCount, dataSize); for (int i = 0; i < realComponentCount; i++)
private Matrix prepareMatrix(Vector y) { final Matrix Y = DMF.createMatrix(1, y.getDimensionality() + 1); Y.setElement(0, 0, 1); Y.setSubMatrix(0, 1, DMF.copyRowVectors(y)); return Y.transpose(); }
@Override public Matrix init(int rows, int cols) { final Matrix ret = smf.createMatrix(rows, cols); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { if (this.random.nextDouble() > sparcity) ret.setElement(i, j, 1d); } } return ret; }
this.getMatrixFactory().copyColumnVectors(documents); this.getMatrixFactory().createMatrix(termCount, termCount);
private Matrix prepareMatrix(double[] y) { final Matrix Y = DMF.createMatrix(1, y.length + 1); Y.setElement(0, 0, 1); Y.setSubMatrix(0, 1, DMF.copyArray(new double[][] { y })); return Y.transpose(); }
covariance = MatrixFactory.getDenseDefault().createIdentity( dimensionality, dimensionality);
Matrix u = learner.getU(); Matrix w = learner.getW(); Matrix bias = MatrixFactory.getDenseDefault().copyMatrix(learner.getBias()); BilinearEvaluator eval = new RootMeanSumLossEvaluator(); eval.setLearner(learner);
/** * Stack matrices vertically * * @param matricies * matrices to stack * @return matrix created from the stacking */ public static Matrix vstack(Matrix... matricies) { return vstack(MatrixFactory.getDefault(), matricies); }
/** * Creates a Matrix with ones (1) on the diagonal, and zeros (0) elsewhere * @param numRowsAndColumns number of rows and columns in the Matrix * @return Identity Matrix with ones on the diagonal and zeros elsewhere */ public MatrixType createIdentity( int numRowsAndColumns ) { return this.createIdentity( numRowsAndColumns, numRowsAndColumns ); }
/** * Creates a new matrix by copying the given set of column vectors. * * @param columns * The column vectors to create a matrix from. Must all be the same * dimensionality. * @return * A new matrix whose columns are equal to the given set of columns. */ public MatrixType copyColumnVectors( Vectorizable ... columns ) { return this.copyColumnVectors(Arrays.asList(columns)); }
@Override public Matrix init(int rows, int cols) { return smf.createUniformRandom(rows, cols, min, max, random); }
public Matrix getMean() { Matrix C = this.inverseWishart.getMean(); Vector mean = this.gaussian.getMean(); final int d = this.getInputDimensionality(); Matrix R = MatrixFactory.getDefault().createMatrix(d, d+1); R.setColumn(0, mean); R.setSubMatrix(0, 1, C); return R; }
Matrix gradient = MatrixFactory.getSparseDefault().createMatrix( M, M * N );