Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.mahout.clustering; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import org.apache.hadoop.conf.Configuration; import org.apache.mahout.common.parameters.Parameter; import org.apache.mahout.math.RandomAccessSparseVector; import org.apache.mahout.math.SequentialAccessSparseVector; import org.apache.mahout.math.Vector; import org.apache.mahout.math.Vector.Element; import org.apache.mahout.math.VectorWritable; import org.apache.mahout.math.function.Functions; import org.apache.mahout.math.function.SquareRootFunction; import org.codehaus.jackson.map.ObjectMapper; public abstract class AbstractCluster implements Cluster { // cluster persistent state private int id; private long numObservations; private long totalObservations; private Vector center; private Vector radius; // the observation statistics private double s0; private Vector s1; private Vector s2; private static final ObjectMapper jxn = new ObjectMapper(); protected AbstractCluster() { } protected AbstractCluster(Vector point, int id2) { this.numObservations = (long) 0; this.totalObservations = (long) 0; this.center = point.clone(); this.radius = center.like(); this.s0 = (double) 0; this.s1 = center.like(); this.s2 = center.like(); this.id = id2; } protected AbstractCluster(Vector center2, Vector radius2, int id2) { this.numObservations = (long) 0; this.totalObservations = (long) 0; this.center = new RandomAccessSparseVector(center2); this.radius = new RandomAccessSparseVector(radius2); this.s0 = (double) 0; this.s1 = center.like(); this.s2 = center.like(); this.id = id2; } @Override public void write(DataOutput out) throws IOException { out.writeInt(id); out.writeLong(getNumObservations()); out.writeLong(getTotalObservations()); VectorWritable.writeVector(out, getCenter()); VectorWritable.writeVector(out, getRadius()); out.writeDouble(s0); VectorWritable.writeVector(out, s1); VectorWritable.writeVector(out, s2); } @Override public void readFields(DataInput in) throws IOException { this.id = in.readInt(); this.setNumObservations(in.readLong()); this.setTotalObservations(in.readLong()); this.setCenter(VectorWritable.readVector(in)); this.setRadius(VectorWritable.readVector(in)); this.setS0(in.readDouble()); this.setS1(VectorWritable.readVector(in)); this.setS2(VectorWritable.readVector(in)); } @Override public void configure(Configuration job) { // nothing to do } @Override public Collection<Parameter<?>> getParameters() { return Collections.emptyList(); } @Override public void createParameters(String prefix, Configuration jobConf) { // nothing to do } @Override public int getId() { return id; } /** * @param id * the id to set */ protected void setId(int id) { this.id = id; } @Override public long getNumObservations() { return numObservations; } /** * @param l * the numPoints to set */ protected void setNumObservations(long l) { this.numObservations = l; } @Override public long getTotalObservations() { return totalObservations; } protected void setTotalObservations(long totalPoints) { this.totalObservations = totalPoints; } @Override public Vector getCenter() { return center; } /** * @param center * the center to set */ protected void setCenter(Vector center) { this.center = center; } @Override public Vector getRadius() { return radius; } /** * @param radius * the radius to set */ protected void setRadius(Vector radius) { this.radius = radius; } /** * @return the s0 */ protected double getS0() { return s0; } protected void setS0(double s0) { this.s0 = s0; } /** * @return the s1 */ protected Vector getS1() { return s1; } protected void setS1(Vector s1) { this.s1 = s1; } /** * @return the s2 */ protected Vector getS2() { return s2; } protected void setS2(Vector s2) { this.s2 = s2; } @Override public void observe(Model<VectorWritable> x) { AbstractCluster cl = (AbstractCluster) x; setS0(getS0() + cl.getS0()); setS1(getS1().plus(cl.getS1())); setS2(getS2().plus(cl.getS2())); } @Override public void observe(VectorWritable x) { observe(x.get()); } @Override public void observe(VectorWritable x, double weight) { observe(x.get(), weight); } public void observe(Vector x, double weight) { if (weight == 1.0) { observe(x); } else { setS0(getS0() + weight); Vector weightedX = x.times(weight); if (getS1() == null) { setS1(weightedX); } else { getS1().assign(weightedX, Functions.PLUS); } Vector x2 = x.times(x).times(weight); if (getS2() == null) { setS2(x2); } else { getS2().assign(x2, Functions.PLUS); } } } public void observe(Vector x) { setS0(getS0() + 1); if (getS1() == null) { setS1(x.clone()); } else { getS1().assign(x, Functions.PLUS); } Vector x2 = x.times(x); if (getS2() == null) { setS2(x2); } else { getS2().assign(x2, Functions.PLUS); } } @Override public void computeParameters() { if (getS0() == 0) { return; } setNumObservations((long) getS0()); setTotalObservations(getTotalObservations() + getNumObservations()); setCenter(getS1().divide(getS0())); // compute the component stds if (getS0() > 1) { setRadius(getS2().times(getS0()).minus(getS1().times(getS1())).assign(new SquareRootFunction()) .divide(getS0())); } setS0(0); setS1(center.like()); setS2(center.like()); } @Override public String asFormatString(String[] bindings) { String fmtString = ""; try { fmtString = jxn.writeValueAsString(asJson(bindings)); } catch (IOException e) { log.error("Error writing JSON as String.", e); } return fmtString; } public Map<String, Object> asJson(String[] bindings) { Map<String, Object> dict = new HashMap<>(); dict.put("identifier", getIdentifier()); dict.put("n", getNumObservations()); if (getCenter() != null) { try { dict.put("c", formatVectorAsJson(getCenter(), bindings)); } catch (IOException e) { log.error("IOException: ", e); } } if (getRadius() != null) { try { dict.put("r", formatVectorAsJson(getRadius(), bindings)); } catch (IOException e) { log.error("IOException: ", e); } } return dict; } public abstract String getIdentifier(); /** * Compute the centroid by averaging the pointTotals * * @return the new centroid */ public Vector computeCentroid() { return getS0() == 0 ? getCenter() : getS1().divide(getS0()); } /** * Return a human-readable formatted string representation of the vector, not * intended to be complete nor usable as an input/output representation */ public static String formatVector(Vector v, String[] bindings) { String fmtString = ""; try { fmtString = jxn.writeValueAsString(formatVectorAsJson(v, bindings)); } catch (IOException e) { log.error("Error writing JSON as String.", e); } return fmtString; } /** * Create a List of HashMaps containing vector terms and weights * * @return List<Object> */ public static List<Object> formatVectorAsJson(Vector v, String[] bindings) throws IOException { boolean hasBindings = bindings != null; boolean isSparse = v.getNumNonZeroElements() != v.size(); // we assume sequential access in the output Vector provider = v.isSequentialAccess() ? v : new SequentialAccessSparseVector(v); List<Object> terms = new LinkedList<>(); String term = ""; for (Element elem : provider.nonZeroes()) { if (hasBindings && bindings.length >= elem.index() + 1 && bindings[elem.index()] != null) { term = bindings[elem.index()]; } else if (hasBindings || isSparse) { term = String.valueOf(elem.index()); } Map<String, Object> term_entry = new HashMap<>(); double roundedWeight = (double) Math.round(elem.get() * 1000) / 1000; if (hasBindings || isSparse) { term_entry.put(term, roundedWeight); terms.add(term_entry); } else { terms.add(roundedWeight); } } return terms; } @Override public boolean isConverged() { // Convergence has no meaning yet, perhaps in subclasses return false; } }