@Override public boolean equals(Object o) { return o instanceof VectorWritable && vector.equals(((VectorWritable) o).get()); }
public static Vector mergeToVector(Iterator<VectorWritable> vectors) { Vector accumulator = vectors.next().get(); while (vectors.hasNext()) { VectorWritable v = vectors.next(); if (v != null) { for (Element nonZeroElement : v.get().nonZeroes()) { accumulator.setQuick(nonZeroElement.index(), nonZeroElement.get()); } } } return accumulator; }
public static Vector readVector(DataInput in, byte vectorFlags, int size) throws IOException { VectorWritable v = new VectorWritable(); v.readFields(in, vectorFlags, size); return v.get(); }
public static Vector readVector(DataInput in) throws IOException { VectorWritable v = new VectorWritable(); v.readFields(in); return v.get(); }
private static void doTestVectorWritableEquals(Vector v) throws IOException { Writable vectorWritable = new VectorWritable(v); VectorWritable vectorWritable2 = new VectorWritable(); writeAndRead(vectorWritable, vectorWritable2); Vector v2 = vectorWritable2.get(); if (v instanceof NamedVector) { assertTrue(v2 instanceof NamedVector); NamedVector nv = (NamedVector) v; NamedVector nv2 = (NamedVector) v2; assertEquals(nv.getName(), nv2.getName()); assertEquals("Victor", nv.getName()); } assertEquals(v, v2); }
public void map(IntWritable key, VectorWritable value, Context context) throws IOException, InterruptedException { context.write(key, new VectorOrPrefWritable(value.get())); } }
@Override protected void map(Text key, VectorWritable value, Context context) throws IOException, InterruptedException { Vector result = classifier.classifyFull(value.get()); //the key is the expected value context.write(new Text(SLASH.split(key.toString())[1]), new VectorWritable(result)); } }
@Override protected void map(IntWritable key, VectorWritable row, Context context) throws IOException, InterruptedException { // store the sum IntDoublePairWritable store = new IntDoublePairWritable(key.get(), row.get().zSum()); context.write(NullWritable.get(), store); } }
@Override protected void map(IntWritable row, VectorWritable vector, Context context) throws IOException, InterruptedException { context.write(row, new VectorWritable(vector.get().normalize(2))); }
@Override protected void map(IntWritable key, VectorWritable value, Context context) throws IOException, InterruptedException { Vector similarityMatrixRow = value.get(); /* remove self similarity */ similarityMatrixRow.set(key.get(), Double.NaN); index.set(key.get()); vectorOrPref.set(similarityMatrixRow); context.write(index, vectorOrPref); }
public static Vector readVector(DataInput in) throws IOException { VectorWritable v = new VectorWritable(); v.readFields(in); return v.get(); }
@Override public void reduce(WritableComparable<?> key, Iterable<VectorWritable> vectors, Context ctx) throws IOException, InterruptedException { Vector merged = VectorWritable.merge(vectors.iterator()).get(); result.set(new SequentialAccessSparseVector(merged)); ctx.write(key, result); } }
public static Vector.Element[] toArray(VectorWritable vectorWritable) { Vector.Element[] elements = new Vector.Element[vectorWritable.get().getNumNondefaultElements()]; int k = 0; for (Element nonZeroElement : vectorWritable.get().nonZeroes()) { elements[k++] = new TemporaryElement(nonZeroElement.index(), nonZeroElement.get()); } return elements; }
public static Map<String,Vector> readScoresFromCache(Configuration conf) throws IOException { Map<String,Vector> sumVectors = Maps.newHashMap(); for (Pair<Text,VectorWritable> entry : new SequenceFileDirIterable<Text,VectorWritable>(HadoopUtil.getSingleCachedFile(conf), PathType.LIST, PathFilters.partFilter(), conf)) { sumVectors.put(entry.getFirst().toString(), entry.getSecond().get()); } return sumVectors; }
@Override public void map(IntWritable docId, VectorWritable document, Context context) throws IOException, InterruptedException { /* where to get docTopics? */ Vector topicVector = new DenseVector(numTopics).assign(1.0 / numTopics); modelTrainer.train(document.get(), topicVector, true, maxIters); }
@Override public Pair<Writable, Vector> apply(Pair<Writable, VectorWritable> p) { return new Pair(p.getFirst(), p.getSecond().get()); } });
@Override protected void map(Writable key, VectorWritable value, Context context) throws IOException, InterruptedException { omega.computeYRow(value.get(), yRow); if (sb != null) { yRow.assign(sb, Functions.MINUS); } qr.collect(key, yRow); }
private static void writeAllAboveThreshold(List<Cluster> clusterModels, Double clusterClassificationThreshold, SequenceFile.Writer writer, VectorWritable vw, Vector pdfPerCluster) throws IOException { Map<Text, Text> props = Maps.newHashMap(); for (Element pdf : pdfPerCluster.nonZeroes()) { if (pdf.get() >= clusterClassificationThreshold) { WeightedPropertyVectorWritable wvw = new WeightedPropertyVectorWritable(pdf.get(), vw.get(), props); int clusterIndex = pdf.index(); write(clusterModels, writer, wvw, clusterIndex); } } }
@Override protected void map(IntWritable rowIndex, VectorWritable rowVectorWritable, Context ctx) throws IOException, InterruptedException { Vector row = rowVectorWritable.get(); for (Vector.Element elem : row.nonZeroes()) { columnCounts.setQuick(elem.index(), columnCounts.getQuick(elem.index()) + 1); } }
@Override public void map(IntWritable r, VectorWritable v, OutputCollector<IntWritable, VectorWritable> out, Reporter reporter) throws IOException { int row = r.get(); for (Vector.Element e : v.get().nonZeroes()) { RandomAccessSparseVector tmp = new RandomAccessSparseVector(newNumCols, 1); tmp.setQuick(row, e.get()); r.set(e.index()); out.collect(r, new VectorWritable(tmp)); } } }