Refine search
public static Matrix randomHierarchicalMatrix(int numRows, int numCols, boolean symmetric) { Matrix matrix = new DenseMatrix(numRows, numCols); // TODO rejigger tests so that it doesn't expect this particular seed Random r = new Random(1234L); for (int row = 0; row < numRows; row++) { Vector v = new DenseVector(numCols); for (int col = 0; col < numCols; col++) { double val = r.nextGaussian(); v.set(col, val); } v.assign(Functions.MULT, 1/((row + 1) * v.norm(2))); matrix.assignRow(row, v); } if (symmetric) { return matrix.times(matrix.transpose()); } return matrix; }
private Matrix orthes(Matrix x) { Vector ort = new DenseVector(n); Matrix hessenBerg = new DenseMatrix(n, n).assign(x); Vector hColumn = hessenBerg.viewColumn(m - 1).viewPart(m, high - m + 1); double scale = hColumn.norm(1); ort.viewPart(m, high - m + 1).assign(hColumn, Functions.plusMult(1 / scale)); double h = ort.viewPart(m, high - m + 1).getLengthSquared();
public static VectorIterable pairwiseInnerProducts(Iterable<MatrixSlice> basis) { DenseMatrix out = null; for (MatrixSlice slice1 : basis) { List<Double> dots = Lists.newArrayList(); for (MatrixSlice slice2 : basis) { dots.add(slice1.vector().dot(slice2.vector())); } if (out == null) { out = new DenseMatrix(dots.size(), dots.size()); } for (int i = 0; i < dots.size(); i++) { out.set(slice1.index(), i, dots.get(i)); } } return out; }
/** test A = USVt */ @Test public void testAEqualUSVt() { checkAEqualUSVt(new DenseMatrix(testSquare)); checkAEqualUSVt(new DenseMatrix(testNonSquare)); checkAEqualUSVt(new DenseMatrix(testNonSquare).transpose()); }
@Test public void testSwap() { Matrix m = new DenseMatrix(10, 10); for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { m.set(i, j, 10 * i + j); } } PivotedMatrix pm = new PivotedMatrix(m); pm.swap(3, 5); assertEquals(0, pm.viewDiagonal().minus( new DenseVector(new double[]{0, 11, 22, 55, 44, 33, 66, 77, 88, 99})).norm(1), 1.0e-10); pm.swap(2, 7); assertEquals(0, pm.viewDiagonal().minus( new DenseVector(new double[]{0, 11, 77, 55, 44, 33, 66, 22, 88, 99})).norm(1), 1.0e-10); pm.swap(5, 8); assertEquals(0, pm.viewColumn(4).minus( new DenseVector(new double[]{4.0,14.0,74.0,54.0,44.0,84.0,64.0,24.0,34.0,94.0})).norm(1), 1.0e-10); assertEquals(0, pm.viewDiagonal().minus( new DenseVector(new double[]{0, 11, 77, 55, 44, 88, 66, 22, 33, 99})).norm(1), 1.0e-10); } }
DenseMatrix transitionMatrix = new DenseMatrix(nrOfHiddenStates, nrOfHiddenStates); DenseMatrix emissionMatrix = new DenseMatrix(nrOfHiddenStates, nrOfOutputStates); DenseVector initialProbabilities = new DenseVector(nrOfHiddenStates); transitionMatrix.assign(pseudoCount); emissionMatrix.assign(pseudoCount); initialProbabilities.assign(pseudoCount); int[] observedSequence = observedSequenceIt.next(); initialProbabilities.setQuick(hiddenSequence[0], initialProbabilities .getQuick(hiddenSequence[0]) + 1); countTransitions(transitionMatrix, emissionMatrix, observedSequence, sum += transitionMatrix.getQuick(i, j); transitionMatrix.setQuick(i, j, transitionMatrix.getQuick(i, j) / sum); sum += emissionMatrix.getQuick(i, j); emissionMatrix.setQuick(i, j, emissionMatrix.getQuick(i, j) / sum);
@Test public void rank1() { Matrix x = new DenseMatrix(3, 3); x.viewRow(0).assign(new double[]{1, 2, 3}); x.viewRow(1).assign(new double[]{2, 4, 6}); x.viewRow(2).assign(new double[]{3, 6, 9}); OldQRDecomposition qr = new OldQRDecomposition(x); assertFalse(qr.hasFullRank()); assertEquals(0, new DenseVector(new double[]{3.741657, 7.483315, 11.22497}).aggregate(qr.getR().viewRow(0), Functions.PLUS, new DoubleDoubleFunction() { @Override public double apply(double arg1, double arg2) { return Math.abs(arg1) - Math.abs(arg2); } }), 1.0e-5); }
DenseMatrix transitionMatrix = new DenseMatrix(nrOfHiddenStates, nrOfHiddenStates); DenseMatrix emissionMatrix = new DenseMatrix(nrOfHiddenStates, nrOfOutputStates); transitionMatrix.assign(pseudoCount); emissionMatrix.assign(pseudoCount); DenseVector initialProbabilities = new DenseVector(nrOfHiddenStates); initialProbabilities.assign(1.0 / nrOfHiddenStates); sum += transitionMatrix.getQuick(i, j); transitionMatrix.setQuick(i, j, transitionMatrix.getQuick(i, j) / sum); sum += emissionMatrix.getQuick(i, j); emissionMatrix.setQuick(i, j, emissionMatrix.getQuick(i, j) / sum);
int inputDimension = this.layerSizeList.get(0) - 1; Vector inputInstance = new DenseVector(this.layerSizeList.get(0)); inputInstance.set(0, 1); // add bias for (int i = 0; i < inputDimension; ++i) { inputInstance.set(i + 1, trainingInstance.get(i)); weightUpdateMatrices[m] = new DenseMatrix(this.weightMatrixList.get(m).rowSize(), this.weightMatrixList.get(m).columnSize()); Vector deltaVec = new DenseVector(this.layerSizeList.get(this.layerSizeList.size() - 1)); Vector output = internalResults.get(internalResults.size() - 1);
@Test public void testProjection() { Vector v1 = new DenseVector(10).assign(Functions.random()); WeightedVector v2 = new WeightedVector(v1, v1, 31); assertEquals(v1.dot(v1), v2.getWeight(), 1.0e-13); assertEquals(31, v2.getIndex()); Matrix y = new DenseMatrix(10, 4).assign(Functions.random()); Matrix q = new QRDecomposition(y.viewPart(0, 10, 0, 3)).getQ(); Vector nullSpace = y.viewColumn(3).minus(q.times(q.transpose().times(y.viewColumn(3)))); WeightedVector v3 = new WeightedVector(q.viewColumn(0).plus(q.viewColumn(1)), nullSpace, 1); assertEquals(0, v3.getWeight(), 1.0e-13); Vector qx = q.viewColumn(0).plus(q.viewColumn(1)).normalize(); WeightedVector v4 = new WeightedVector(qx, q.viewColumn(0), 2); assertEquals(Math.sqrt(0.5), v4.getWeight(), 1.0e-13); WeightedVector v5 = WeightedVector.project(q.viewColumn(0), qx); assertEquals(Math.sqrt(0.5), v5.getWeight(), 1.0e-13); }
public EigenDecomposition(Matrix x, boolean isSymmetric) { n = x.columnSize(); d = new DenseVector(n); e = new DenseVector(n); v = new DenseMatrix(n, n); if (isSymmetric) { v.assign(x); // Tridiagonalize. tred2(); // Diagonalize. tql2(); } else { // Reduce to Hessenberg form. // Reduce Hessenberg to real Schur form. hqr2(orthes(x)); } }
public GlobalOnlineAuc() { int numCategories = 2; scores = new DenseMatrix(numCategories, HISTORY); scores.assign(Double.NaN); averages = new DenseVector(numCategories); averages.assign(0.5); samples = new DenseVector(numCategories); }
/** Y' (Cu - I) Y + λ I */ private Matrix getYtransponseCuMinusIYPlusLambdaI(Vector userRatings) { Preconditions.checkArgument(userRatings.isSequentialAccess(), "need sequential access to ratings!"); /* (Cu -I) Y */ OpenIntObjectHashMap<Vector> CuMinusIY = new OpenIntObjectHashMap<>(userRatings.getNumNondefaultElements()); for (Element e : userRatings.nonZeroes()) { CuMinusIY.put(e.index(), Y.get(e.index()).times(confidence(e.get()) - 1)); } Matrix YtransponseCuMinusIY = new DenseMatrix(numFeatures, numFeatures); /* Y' (Cu -I) Y by outer products */ for (Element e : userRatings.nonZeroes()) { for (Vector.Element feature : Y.get(e.index()).all()) { Vector partial = CuMinusIY.get(e.index()).times(feature.get()); YtransponseCuMinusIY.viewRow(feature.index()).assign(partial, Functions.PLUS); } } /* Y' (Cu - I) Y + λ I add lambda on the diagonal */ for (int feature = 0; feature < numFeatures; feature++) { YtransponseCuMinusIY.setQuick(feature, feature, YtransponseCuMinusIY.getQuick(feature, feature) + lambda); } return YtransponseCuMinusIY; }
int desiredRank) { int cols = corpus.numCols(); Matrix eigens = new DenseMatrix(desiredRank, cols); List<Double> eigenValues = new ArrayList<>(); log.info("Finding {} singular vectors of matrix with {} rows, via Hebbian", desiredRank, corpus.numRows()); Matrix corpusProjections = new DenseMatrix(corpus.numRows(), desiredRank); TrainingState state = new TrainingState(eigens, corpusProjections); for (int i = 0; i < desiredRank; i++) { Vector currentEigen = new DenseVector(cols); Vector previousEigen = null; while (hasNotConverged(currentEigen, corpus, state)) { previousEigen = currentEigen.clone(); } else { double dot = currentEigen.dot(previousEigen); if (dot > 0.0) { dot /= currentEigen.norm(2) * previousEigen.norm(2); currentEigen.assign(new TimesFunction(), 1 / currentEigen.norm(2)); eigens.assignRow(i, currentEigen); eigenValues.add(eigenValue);
public OnlineLogisticRegression(int numCategories, int numFeatures, PriorFunction prior) { this.numCategories = numCategories; this.prior = prior; updateSteps = new DenseVector(numFeatures); updateCounts = new DenseVector(numFeatures).assign(perTermAnnealingOffset); beta = new DenseMatrix(numCategories - 1, numFeatures); }
@Test public void testDotCorrelation() { final Normal gen = new Normal(); Matrix projection = new DenseMatrix(64, 10); projection.assign(gen); Vector query = new DenseVector(10); query.assign(gen); long qhash = HashedVector.computeHash64(query, projection); int count[] = new int[65]; Vector v = new DenseVector(10); for (int i = 0; i <500000; i++) { v.assign(gen); long hash = HashedVector.computeHash64(v, projection); final int bitDot = Long.bitCount(qhash ^ hash); count[bitDot]++; if (count[bitDot] < 200) { System.out.printf("%d, %.3f\n", bitDot, v.dot(query) / Math.sqrt(v.getLengthSquared() * query.getLengthSquared())); } } for (int i = 0; i < 65; ++i) { System.out.printf("%d, %d\n", i, count[i]); } } }
@Test public void testOmegaTRightMultiply() { final Random rnd = RandomUtils.getRandom(); final long seed = rnd.nextLong(); final int n = 2000; final int kp = 100; final Omega omega = new Omega(seed, kp); final Matrix materializedOmega = new DenseMatrix(n, kp); for (int i = 0; i < n; i++) for (int j = 0; j < kp; j++) materializedOmega.setQuick(i, j, omega.getQuick(i, j)); Vector xi = new DenseVector(n); xi.assign(new DoubleFunction() { @Override public double apply(double x) { return rnd.nextDouble() * 100; } }); Vector s_o = omega.mutlithreadedTRightMultiply(xi); Matrix xiVector = new DenseMatrix(n, 1); xiVector.assignColumn(0, xi); Vector s_o_control = materializedOmega.transpose().times(xiVector).viewColumn(0); assertEquals(0, s_o.minus(s_o_control).aggregate(Functions.PLUS, Functions.ABS), 1e-10); System.out.printf("s_omega=\n%s\n", s_o); System.out.printf("s_omega_control=\n%s\n", s_o_control); }
/** * Subclasses must override to return an appropriately sparse or dense result * * @param rows the row cardinality * @param columns the column cardinality * @return a Matrix */ @Override protected Matrix matrixLike(int rows, int columns) { return new DenseMatrix(rows, columns); }
static Matrix createRiIiMaybeTransposed(Vector ratingVector) { Preconditions.checkArgument(ratingVector.isSequentialAccess(), "Ratings should be iterable in Index or Sequential Order"); double[][] RiIiMaybeTransposed = new double[ratingVector.getNumNondefaultElements()][1]; int index = 0; for (Vector.Element elem : ratingVector.nonZeroes()) { RiIiMaybeTransposed[index++][0] = elem.get(); } return new DenseMatrix(RiIiMaybeTransposed, true); } }
.getLaserOfflineOutput(collection); Vector alpha = new DenseVector(ufDimension); for (int i = 0; i < ufDimension; i++) { alpha.set(i, z[i]); Vector beta = new DenseVector(adfDimension); for (int i = ufDimension; i < ufDimension + adfDimension; i++) { beta.set(i - ufDimension, z[i]); Matrix A = new DenseMatrix(ufDimension, adfDimension); for (int row = 0; row < A.numRows(); row++) { Vector v = A.viewRow(row); for (int col = 0; col < A.numCols(); col++) { v.set(col, z[row * adfDimension + col + ufDimension + adfDimension]);