Vector v1 = v0.assign(new Normal(0, 1, gen)); assertEquals(v0.get(12), v1.get(12), 0); v0.set(12, gen.nextDouble()); assertEquals(v0.get(12), v1.get(12), 0); Vector v2 = vectorToTest(20).assign(new Normal(0, 1, gen)); Vector dv1 = new DenseVector(v1); Vector dv2 = new DenseVector(v2); Vector sv1 = new RandomAccessSparseVector(v1); Vector sv2 = new RandomAccessSparseVector(v2); assertEquals(0, dv1.plus(dv2).getDistanceSquared(v1.plus(v2)), FUZZ);
@Test public void random() { Matrix m = new DenseMatrix(200, 30).assign(Functions.random()); Vector b = new DenseVector(200).assign(1); LSMR r = new LSMR(); Vector x1 = r.solve(m, b); // assertEquals(0, m.times(x1).minus(b).norm(2), 1.0e-2); double norm = new SingularValueDecomposition(m).getS().viewDiagonal().norm(2); double actual = m.transpose().times(m).times(x1).minus(m.transpose().times(b)).norm(2); System.out.printf("%.4f\n", actual / norm * 1.0e6); assertEquals(0, actual, norm * 1.0e-5); // and we need to check that the error estimates are pretty good. assertEquals(m.times(x1).minus(b).norm(2), r.getResidualNorm(), 1.0e-5); assertEquals(actual, r.getNormalEquationResidual(), 1.0e-9); }
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 Vector sample() { Vector v = new DenseVector(dimension).assign( new DoubleFunction() { @Override public double apply(double ignored) { return gen.nextGaussian(); } } ); if (mean != null) { if (scale != null) { return scale.times(v).plus(mean); } else { return v.plus(mean); } } else { if (scale != null) { return scale.times(v); } else { return v; } } }
@Test public void testNumNonZerosDense() { DenseVector vector = new DenseVector(10); vector.assign(1); vector.setQuick(3, 0); vector.set(5, 0); assertEquals(8, vector.getNumNonZeroElements()); }
@Override public DenseVector vectorToTest(int size) { DenseVector r = new DenseVector(size); r.assign(Functions.random()); return r; }
private void initializeM(Vector averageRatings) throws IOException { Random random = RandomUtils.getRandom(); FileSystem fs = FileSystem.get(pathToM(-1).toUri(), getConf()); SequenceFile.Writer writer = null; try { writer = new SequenceFile.Writer(fs, getConf(), new Path(pathToM(-1), "part-m-00000"), IntWritable.class, VectorWritable.class); IntWritable index = new IntWritable(); VectorWritable featureVector = new VectorWritable(); for (Vector.Element e : averageRatings.nonZeroes()) { Vector row = new DenseVector(numFeatures); row.setQuick(0, e.get()); for (int m = 1; m < numFeatures; m++) { row.setQuick(m, random.nextDouble()); } index.set(e.index()); featureVector.set(row); writer.append(index, featureVector); } } finally { Closeables.close(writer, false); } }
@Override protected void cleanup(Context context) throws IOException, InterruptedException { context.write(new IntWritable(context.getTaskAttemptID().getTaskID() .getId()), new VectorWritable(new DenseVector(mYtY.getData()))); } }
@Test public void testWrite() { DummyRecordWriter<IntWritable, VectorWritable> writer = new DummyRecordWriter<IntWritable, VectorWritable>(); IntWritable reusableIntWritable = new IntWritable(); VectorWritable reusableVectorWritable = new VectorWritable(); reusableIntWritable.set(0); reusableVectorWritable.set(new DenseVector(new double[] { 1, 2, 3 })); writer.write(reusableIntWritable, reusableVectorWritable); reusableIntWritable.set(1); reusableVectorWritable.set(new DenseVector(new double[] { 4, 5, 6 })); writer.write(reusableIntWritable, reusableVectorWritable); Assert.assertEquals( "The writer must remember the two keys that is written to it", 2, writer.getKeys().size()); } }
public static Pair<Matrix, Vector> loadModel(Configuration conf, Path... modelPaths) throws IOException { int numTopics = -1; int numTerms = -1; List<Pair<Integer, Vector>> rows = Lists.newArrayList(); for (Path modelPath : modelPaths) { for (Pair<IntWritable, VectorWritable> row : new SequenceFileIterable<IntWritable, VectorWritable>(modelPath, true, conf)) { rows.add(Pair.of(row.getFirst().get(), row.getSecond().get())); numTopics = Math.max(numTopics, row.getFirst().get()); if (numTerms < 0) { numTerms = row.getSecond().get().size(); } } } if (rows.isEmpty()) { throw new IOException(Arrays.toString(modelPaths) + " have no vectors in it"); } numTopics++; Matrix model = new DenseMatrix(numTopics, numTerms); Vector topicSums = new DenseVector(numTopics); for (Pair<Integer, Vector> pair : rows) { model.viewRow(pair.getFirst()).assign(pair.getSecond()); topicSums.set(pair.getFirst(), pair.getSecond().norm(1)); } return Pair.of(model, topicSums); }
@Test public void testVectorDistanceInvertedMapper() throws Exception { Mapper<WritableComparable<?>, VectorWritable, Text, VectorWritable>.Context context = EasyMock.createMock(Mapper.Context.class); Vector expectVec = new DenseVector(new double[]{Math.sqrt(2.0), 1.0}); context.write(new Text("other"), new VectorWritable(expectVec)); EasyMock.replay(context); Vector vector = new NamedVector(new RandomAccessSparseVector(2), "other"); vector.set(0, 2); vector.set(1, 2); VectorDistanceInvertedMapper mapper = new VectorDistanceInvertedMapper(); setField(mapper, "measure", new EuclideanDistanceMeasure()); Collection<NamedVector> seedVectors = Lists.newArrayList(); Vector seed1 = new RandomAccessSparseVector(2); seed1.set(0, 1); seed1.set(1, 1); Vector seed2 = new RandomAccessSparseVector(2); seed2.set(0, 2); seed2.set(1, 1); seedVectors.add(new NamedVector(seed1, "foo")); seedVectors.add(new NamedVector(seed2, "foo2")); setField(mapper, "seedVectors", seedVectors); mapper.map(new IntWritable(123), new VectorWritable(vector), context); EasyMock.verify(context); }
@Test public void testSave() throws Exception { Configuration conf = getConfiguration(); Writable key = new IntWritable(0); Vector value = new DenseVector(VECTOR); Path path = getTestTempDirPath("output"); // write the vector out VectorCache.save(key, value, path, conf, true, true); // can we read it from here? SequenceFileValueIterator<VectorWritable> iterator = new SequenceFileValueIterator<VectorWritable>(path, true, conf); try { VectorWritable old = iterator.next(); // test if the values are identical assertEquals("Saved vector is identical to original", old.get(), value); } finally { Closeables.close(iterator, true); } }
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();
@Override public Vector classify(Vector data, ClusterClassifier prior) { List<Cluster> models = prior.getModels(); int i = 0; Vector pdfs = new DenseVector(models.size()); for (Cluster model : models) { pdfs.set(i++, model.pdf(new VectorWritable(data))); } return pdfs.assign(new TimesFunction(), 1.0 / pdfs.zSum()); }
/** * Feeds forward from hidden to output * * @return Output unit activations. */ public DenseVector hiddenToOutput(Vector hiddenActivation) { DenseVector activations = new DenseVector(numOutput); for (int i = 0; i < numOutput; i++) { activations.setQuick(i, outputWeights[i].dot(hiddenActivation)); } activations.assign(outputBias, Functions.PLUS); return activations; }
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, hiddenSequence); isum += initialProbabilities.getQuick(i); initialProbabilities.setQuick(i, initialProbabilities.getQuick(i) / isum);
@Test public void testMax() { Vector vec1 = new RandomAccessSparseVector(3); double max = vec1.maxValue(); assertEquals(0, idx); vec1 = new RandomAccessSparseVector(3); vec1.setQuick(0, -1); assertEquals(1, idx); vec1 = new DenseVector(3); vec1.setQuick(0, -1); assertEquals(1, idx); vec1 = new DenseVector(3); max = vec1.maxValue(); assertEquals(0.0, max, EPSILON); assertEquals(Double.NEGATIVE_INFINITY, max, EPSILON); vec1 = new DenseVector(0); max = vec1.maxValue(); assertEquals(Double.NEGATIVE_INFINITY, max, EPSILON);
@Override public void map(IntWritable docId, VectorWritable doc, Context context) throws IOException, InterruptedException { int numTopics = getNumTopics(); Vector docTopics = new DenseVector(numTopics).assign(1.0 / numTopics); Matrix docModel = new SparseRowMatrix(numTopics, doc.get().size()); int maxIters = getMaxIters(); ModelTrainer modelTrainer = getModelTrainer(); for (int i = 0; i < maxIters; i++) { modelTrainer.getReadModel().trainDocTopicModel(doc.get(), docTopics, docModel); } topics.set(docTopics); context.write(docId, topics); }
@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); }
@Test public void testEnumeration() { double[] apriori = {0, 1, 2, 3, 4}; doTestEnumeration(apriori, new VectorView(new DenseVector(new double[]{ -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}), 2, 5)); doTestEnumeration(apriori, new DenseVector(new double[]{0, 1, 2, 3, 4})); Vector sparse = new RandomAccessSparseVector(5); sparse.set(0, 0); sparse.set(1, 1); sparse.set(2, 2); sparse.set(3, 3); sparse.set(4, 4); doTestEnumeration(apriori, sparse); sparse = new SequentialAccessSparseVector(5); sparse.set(0, 0); sparse.set(1, 1); sparse.set(2, 2); sparse.set(3, 3); sparse.set(4, 4); doTestEnumeration(apriori, sparse); }