Java ClusterWritable.setValue方法代码示例

import org.apache.mahout.clustering.iterator.ClusterWritable; //导入方法依赖的package包/类
@Override
protected void reduce(Text arg0, Iterable<VectorWritable> values,
    Context context) throws IOException, InterruptedException {
  for (VectorWritable value : values) {
    Vector point = value.get();
    canopyClusterer.addPointToCanopies(point, canopies);
  }
  for (Canopy canopy : canopies) {
    ClusterWritable clusterWritable = new ClusterWritable();
    canopy.computeParameters();
    if (canopy.getNumObservations() > clusterFilter) {
  	clusterWritable.setValue(canopy);
      context.write(new Text(canopy.getIdentifier()), clusterWritable);
    }
  }
}
 

import org.apache.mahout.clustering.iterator.ClusterWritable; //导入方法依赖的package包/类
public void writeToSeqFiles(Path path) throws IOException {
  writePolicy(policy, path);
  Configuration config = new Configuration();
  FileSystem fs = FileSystem.get(path.toUri(), config);
  SequenceFile.Writer writer = null;
  ClusterWritable cw = new ClusterWritable();
  for (int i = 0; i < models.size(); i++) {
    try {
      Cluster cluster = models.get(i);
      cw.setValue(cluster);
      writer = new SequenceFile.Writer(fs, config,
          new Path(path, "part-" + String.format(Locale.ENGLISH, "%05d", i)), IntWritable.class,
          ClusterWritable.class);
      Writable key = new IntWritable(i);
      writer.append(key, cw);
    } finally {
      Closeables.closeQuietly(writer);
    }
  }
}
 

import org.apache.mahout.clustering.iterator.ClusterWritable; //导入方法依赖的package包/类
/**
 * Convert vectors to MeanShiftCanopies sequentially
 * 
 * @param input
 *          the Path to the input VectorWritable data
 * @param output
 *          the Path to the initial clusters directory
 * @param measure
 *          the DistanceMeasure
 */
private static void createCanopyFromVectorsSeq(Path input, Path output,
    DistanceMeasure measure) throws IOException {
  Configuration conf = new Configuration();
  FileSystem fs = FileSystem.get(input.toUri(), conf);
  FileStatus[] status = fs.listStatus(input, PathFilters.logsCRCFilter());
  int part = 0;
  int id = 0;
  for (FileStatus s : status) {
    SequenceFile.Writer writer = new SequenceFile.Writer(fs, conf, new Path(
        output, "part-m-" + part++), Text.class, ClusterWritable.class);
    try {
      for (VectorWritable value : new SequenceFileValueIterable<VectorWritable>(
          s.getPath(), conf)) {
        MeanShiftCanopy initialCanopy = MeanShiftCanopy.initialCanopy(value.get(),
		      id++, measure);
        ClusterWritable clusterWritable = new ClusterWritable();
        clusterWritable.setValue(initialCanopy);
  writer.append(new Text(), clusterWritable);
      }
    } finally {
      Closeables.closeQuietly(writer);
    }
  }
}
 

import org.apache.mahout.clustering.iterator.ClusterWritable; //导入方法依赖的package包/类
/**
 * Build a directory of Canopy clusters from the input vectors and other
 * arguments. Run sequential execution
 * 
 * @param input
 *          the Path to the directory containing input vectors
 * @param output
 *          the Path for all output directories
 * @param measure
 *          the DistanceMeasure
 * @param t1
 *          the double T1 distance metric
 * @param t2
 *          the double T2 distance metric
 * @param clusterFilter
 *          the int minimum size of canopies produced
 * @return the canopy output directory Path
 */
private static Path buildClustersSeq(Path input, Path output,
    DistanceMeasure measure, double t1, double t2, int clusterFilter)
    throws IOException {
  CanopyClusterer clusterer = new CanopyClusterer(measure, t1, t2);
  Collection<Canopy> canopies = Lists.newArrayList();
  Configuration conf = new Configuration();
  FileSystem fs = FileSystem.get(input.toUri(), conf);

  for (VectorWritable vw : new SequenceFileDirValueIterable<VectorWritable>(
      input, PathType.LIST, PathFilters.logsCRCFilter(), conf)) {
    clusterer.addPointToCanopies(vw.get(), canopies);
  }

  Path canopyOutputDir = new Path(output, Cluster.CLUSTERS_DIR + '0'+ Cluster.FINAL_ITERATION_SUFFIX);
  Path path = new Path(canopyOutputDir, "part-r-00000");
  SequenceFile.Writer writer = new SequenceFile.Writer(fs, conf, path,
      Text.class, ClusterWritable.class);
  ClusterWritable clusterWritable = new ClusterWritable();
  try {
    for (Canopy canopy : canopies) {
      canopy.computeParameters();
      if (log.isDebugEnabled()) {
        log.debug("Writing Canopy:{} center:{} numPoints:{} radius:{}",
            new Object[] { canopy.getIdentifier(),
                AbstractCluster.formatVector(canopy.getCenter(), null),
                canopy.getNumObservations(),
                AbstractCluster.formatVector(canopy.getRadius(), null) });
      }
      if (canopy.getNumObservations() > clusterFilter) {
      	clusterWritable.setValue(canopy);
      	writer.append(new Text(canopy.getIdentifier()), clusterWritable);
      }
    }
  } finally {
    Closeables.closeQuietly(writer);
  }
  return canopyOutputDir;
}
 

import org.apache.mahout.clustering.iterator.ClusterWritable; //导入方法依赖的package包/类
@Override
protected void map(WritableComparable<?> key, VectorWritable point, Context context)
  throws IOException, InterruptedException {
  MeanShiftCanopy canopy = MeanShiftCanopy.initialCanopy(point.get(), nextCanopyId++, measure);
  ClusterWritable clusterWritable = new ClusterWritable();
  clusterWritable.setValue(canopy);
  context.write(new Text(key.toString()), clusterWritable);
}
 

import org.apache.mahout.clustering.iterator.ClusterWritable; //导入方法依赖的package包/类
@Override
protected void cleanup(Context context) throws IOException, InterruptedException {
  int reducer = 0;
  for (MeanShiftCanopy canopy : canopies) {
    clusterer.shiftToMean(canopy);
    ClusterWritable clusterWritable = new ClusterWritable();
    clusterWritable.setValue(canopy);
    context.write(new Text(String.valueOf(reducer)), clusterWritable);
    reducer++;
    if (reducer >= numReducers) {
      reducer = 0;
    }
  }
  super.cleanup(context);
}