clustermembership.java

代码是一个分类器的实现,其中使用了部分weka的源代码。可以将项目导入eclipse运行

    }
    if (m_NewBatch) {
      resetQueue();
      m_NewBatch = false;
    }
    
    if (outputFormatPeek() != null) {
      convertInstance(instance);
      return true;
    }

    bufferInput(instance);
    return false;
  }

  /**
   * Converts logs back to density values.
   * 
   * @param j the index of the clusterer
   * @param in the instance to convert the logs back
   * @return the densities
   * @throws Exception if something goes wrong
   */
  protected double[] logs2densities(int j, Instance in) throws Exception {

    double[] logs = m_clusterers[j].logJointDensitiesForInstance(in);

    for (int i = 0; i < logs.length; i++) {
      logs[i] += Math.log(m_priors[j]);
    }
    return logs;
  }

  /**
   * Convert a single instance over. The converted instance is added to 
   * the end of the output queue.
   *
   * @param instance the instance to convert
   * @throws Exception if something goes wrong
   */
  protected void convertInstance(Instance instance) throws Exception {
    
    // set up values
    double [] instanceVals = new double[outputFormatPeek().numAttributes()];
    double [] tempvals;
    if (instance.classIndex() >= 0) {
      tempvals = new double[outputFormatPeek().numAttributes() - 1];
    } else {
      tempvals = new double[outputFormatPeek().numAttributes()];
    }
    int pos = 0;
    for (int j = 0; j < m_clusterers.length; j++) {
      if (m_clusterers[j] != null) {
	double [] probs;
	if (m_removeAttributes != null) {
	  m_removeAttributes.input(instance);
	  probs = logs2densities(j, m_removeAttributes.output());
	} else {
	  probs = logs2densities(j, instance);
	}
	System.arraycopy(probs, 0, tempvals, pos, probs.length);
	pos += probs.length;
      }
    }
    tempvals = Utils.logs2probs(tempvals);
    System.arraycopy(tempvals, 0, instanceVals, 0, tempvals.length);
    if (instance.classIndex() >= 0) {
      instanceVals[instanceVals.length - 1] = instance.classValue();
    }
    
    push(new Instance(instance.weight(), instanceVals));
  }

  /**
   * Returns an enumeration describing the available options.
   *
   * @return an enumeration of all the available options.
   */
  public Enumeration listOptions() {
    
    Vector newVector = new Vector(2);
    
    newVector.
      addElement(new Option("\tFull name of clusterer to use. eg:\n"
	                    + "\t\tweka.clusterers.EM\n"
			    + "\tAdditional options after the '--'.\n"
			    + "\t(default: weka.clusterers.EM)",
			    "W", 1, "-W <clusterer name>"));

    newVector.
      addElement(new Option("\tThe range of attributes the clusterer should ignore."
			    +"\n\t(the class attribute is automatically ignored)",
			    "I", 1,"-I <att1,att2-att4,...>"));

    return newVector.elements();
  }

  /**
   * Parses a given list of options. <p/>
   * 
   <!-- options-start -->
   * Valid options are: <p/>
   * 
   * <pre> -W &lt;clusterer name&gt;
   *  Full name of clusterer to use. eg:
   *   weka.clusterers.EM
   *  Additional options after the '--'.
   *  (default: weka.clusterers.EM)</pre>
   * 
   * <pre> -I &lt;att1,att2-att4,...&gt;
   *  The range of attributes the clusterer should ignore.
   *  (the class attribute is automatically ignored)</pre>
   * 
   <!-- options-end -->
   *
   * Options after the -- are passed on to the clusterer.
   *
   * @param options the list of options as an array of strings
   * @throws Exception if an option is not supported
   */
  public void setOptions(String[] options) throws Exception {

    String clustererString = Utils.getOption('W', options);
    if (clustererString.length() == 0)
      clustererString = weka.clusterers.EM.class.getName();
    setDensityBasedClusterer((DensityBasedClusterer)Utils.
			     forName(DensityBasedClusterer.class, clustererString,
				     Utils.partitionOptions(options)));

    setIgnoredAttributeIndices(Utils.getOption('I', options));
    Utils.checkForRemainingOptions(options);
  }

  /**
   * Gets the current settings of the filter.
   *
   * @return an array of strings suitable for passing to setOptions
   */
  public String [] getOptions() {

    String [] clustererOptions = new String [0];
    if ((m_clusterer != null) &&
	(m_clusterer instanceof OptionHandler)) {
      clustererOptions = ((OptionHandler)m_clusterer).getOptions();
    }
    String [] options = new String [clustererOptions.length + 5];
    int current = 0;

    if (!getIgnoredAttributeIndices().equals("")) {
      options[current++] = "-I";
      options[current++] = getIgnoredAttributeIndices();
    }
    
    if (m_clusterer != null) {
      options[current++] = "-W"; 
      options[current++] = getDensityBasedClusterer().getClass().getName();
    }

    options[current++] = "--";
    System.arraycopy(clustererOptions, 0, options, current,
		     clustererOptions.length);
    current += clustererOptions.length;
    
    while (current < options.length) {
      options[current++] = "";
    }
    return options;
  }

  /**
   * Returns a string describing this filter
   *
   * @return a description of the filter suitable for
   * displaying in the explorer/experimenter gui
   */
  public String globalInfo() {

    return "A filter that uses a density-based clusterer to generate cluster "
      + "membership values; filtered instances are composed of these values "
      + "plus the class attribute (if set in the input data). If a (nominal) "
      + "class attribute is set, the clusterer is run separately for each "
      + "class. The class attribute (if set) and any user-specified "
      + "attributes are ignored during the clustering operation";
  }
  
  /**
   * Returns a description of this option suitable for display
   * as a tip text in the gui.
   *
   * @return description of this option
   */
  public String clustererTipText() {
    return "The clusterer that will generate membership values for the instances.";
  }

  /**
   * Set the clusterer for use in filtering
   *
   * @param newClusterer the clusterer to use
   */
  public void setDensityBasedClusterer(DensityBasedClusterer newClusterer) {
    m_clusterer = newClusterer;
  }

  /**
   * Get the clusterer used by this filter
   *
   * @return the clusterer used
   */
  public DensityBasedClusterer getDensityBasedClusterer() {
    return m_clusterer;
  }

  /**
   * Returns the tip text for this property
   *
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String ignoredAttributeIndicesTipText() {

    return "The range of attributes to be ignored by the clusterer. eg: first-3,5,9-last";
  }

  /**
   * Gets ranges of attributes to be ignored.
   *
   * @return a string containing a comma-separated list of ranges
   */
  public String getIgnoredAttributeIndices() {

    if (m_ignoreAttributesRange == null) {
      return "";
    } else {
      return m_ignoreAttributesRange.getRanges();
    }
  }

  /**
   * Sets the ranges of attributes to be ignored. If provided string
   * is null, no attributes will be ignored.
   *
   * @param rangeList a string representing the list of attributes. 
   * eg: first-3,5,6-last
   * @throws IllegalArgumentException if an invalid range list is supplied 
   */
  public void setIgnoredAttributeIndices(String rangeList) {

    if ((rangeList == null) || (rangeList.length() == 0)) {
      m_ignoreAttributesRange = null;
    } else {
      m_ignoreAttributesRange = new Range();
      m_ignoreAttributesRange.setRanges(rangeList);
    }
  }

  /**
   * Main method for testing this class.
   *
   * @param argv should contain arguments to the filter: use -h for help
   */
  public static void main(String [] argv) {
    runFilter(new ClusterMembership(), argv);
  }
}