weightedeuclidean.java

wekaUT是 university texas austin 开发的基于weka的半指导学习(semi supervised learning)的分类器

      }
    }
    Instance diffInstance = new Instance(1.0, diffInstanceValues);
    diffInstance.setDataset(instance1.dataset());
    return diffInstance;
  }

  /**
   * Set the type of  distance to similarity conversion. Values other
   * than CONVERSION_LAPLACIAN, CONVERSION_UNIT, or CONVERSION_EXPONENTIAL will be ignored
   * 
   * @param type type of the similarity to distance conversion to use
   */
  public void setConversionType(SelectedTag conversionType) {
    if (conversionType.getTags() == TAGS_CONVERSION) {
      m_conversionType = conversionType.getSelectedTag().getID();
    }
  }

  /**
   * return the type of distance to similarity conversion
   * @return one of CONVERSION_LAPLACIAN, CONVERSION_UNIT, or CONVERSION_EXPONENTIAL
   */
  public SelectedTag getConversionType() {
    return new SelectedTag(m_conversionType, TAGS_CONVERSION);
  }

    /** The computation of a metric can be either based on distance, or on similarity
   * @returns true because euclidean metrict fundamentally computes distance
   */
  public boolean isDistanceBased() {
    return true;
  }

  /**
   * Given a cluster of instances, return the centroid of that cluster
   * @param instances objects belonging to a cluster
   * @param fastMode whether fast mode should be used for SparseInstances
   * @param normalized normalize centroids for SPKMeans
   * @return a centroid instance for the given cluster
   */
  public Instance getCentroidInstance(Instances instances, boolean fastMode, boolean normalized) {
    double [] values = new double[instances.numAttributes()];
    if (fastMode) {
      values = meanOrMode(instances); // uses fast meanOrMode
    } else {
      for (int j = 0; j < instances.numAttributes(); j++) {
	values[j] = instances.meanOrMode(j); // uses usual meanOrMode
      }
    }
    Instance centroid = new Instance(1.0, values);
    // cluster centroids are dense in SPKMeans
    if (normalized) {
      try {
	normalizeInstanceWeighted(centroid);
      } catch (Exception e) {
	e.printStackTrace();
      }
    }
    return centroid;
  }


  /**
   * Parses a given list of options. Valid options are:<p>
   *
   * -N <br>
   * Normalize the euclidean distance by vectors lengths
   *
   * -E <br>
   * Use exponential conversion from distance to similarity
   * (default laplacian conversion) <p>
   *
   * -U <br>
   * Use unit conversion from similarity to distance (dist=1-sim)
   * (default laplacian conversion) <p>
   *
   * -R <br>
   * The metric is trainable and will be trained using the current MetricLearner
   * (default non-trainable)
   *
   * @param options the list of options as an array of strings
   * @exception Exception if an option is not supported
   */
  public void setOptions(String[] options) throws Exception {
    if (Utils.getFlag('E', options)) {
      setConversionType(new SelectedTag(CONVERSION_EXPONENTIAL, TAGS_CONVERSION));
    } else if (Utils.getFlag('U', options)) {
      setConversionType(new SelectedTag(CONVERSION_UNIT, TAGS_CONVERSION));
    } else {
      setConversionType(new SelectedTag(CONVERSION_LAPLACIAN, TAGS_CONVERSION));
    }

    if (Utils.getFlag('R', options)) {
      setTrainable(Utils.getFlag('R', options));
      setExternal(Utils.getFlag('X', options));
      String metricLearnerString = Utils.getOption('L', options);
      if (metricLearnerString.length() != 0) {
	String [] metricLearnerSpec = Utils.splitOptions(metricLearnerString);
	String metricLearnerName = metricLearnerSpec[0];
	metricLearnerSpec[0] = "";
	System.out.println("Got metric learner " + metricLearnerName + " spec: " + metricLearnerSpec);
	setMetricLearner(MetricLearner.forName(metricLearnerName, metricLearnerSpec));
      } 
    }      
    

    Utils.checkForRemainingOptions(options);
  }

  /**
   * Gets the classifier specification string, which contains the class name of
   * the classifier and any options to the classifier
   *
   * @return the classifier string.
   */
  protected String getMetricLearnerSpec() {
    if (m_metricLearner instanceof OptionHandler) {
      return m_metricLearner.getClass().getName() + " "
	+ Utils.joinOptions(((OptionHandler)m_metricLearner).getOptions());
    }
    return m_metricLearner.getClass().getName();
  }


  /**
   * Returns an enumeration describing the available options.
   *
   * @return an enumeration of all the available options.
   */
  public Enumeration listOptions() {

    Vector newVector = new Vector(4);

    newVector.addElement(new Option("\tNormalize the euclidean distance by vectors lengths\n",
				    "N", 0, "-N"));
    newVector.addElement(new Option("\tUse exponential conversion from similarity to distance\n",
				    "E", 0, "-E"));
    newVector.addElement(new Option("\tUse unit conversion from similarity to distance\n",
				    "U", 0, "-U"));
    newVector.addElement(new Option("\tTrain the metric\n",
				    "R", 0, "-R"));
    newVector.addElement(new Option("\tUse the metric learner for similarity calculations(\"external\")",
				    "X", 0, "-X"));
    newVector.addElement(new Option(
	      "\tFull class name of metric learner to use, followed\n"
	      + "\tby scheme options. (required)\n"
	      + "\teg: \"weka.core.metrics.ClassifierMetricLearner -B weka.classifiers.function.SMO\"",
	      "L", 1, "-L <classifier specification>"));
    
    return newVector.elements();
  }

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

    String [] options = new String [45];
    int current = 0;

    if (m_conversionType == CONVERSION_EXPONENTIAL) {
      options[current++] = "-E";
    } else if (m_conversionType == CONVERSION_UNIT) {
      options[current++] = "-U";
    }
    
    if (m_trainable) {
      options[current++] = "-R";
      if (m_external) {
	options[current++] = "-X";
      }

      options[current++] = "-L";
      options[current++] = Utils.removeSubstring(m_metricLearner.getClass().getName(), "weka.core.metrics.");
      if (m_metricLearner instanceof OptionHandler) {
	String[] metricOptions = ((OptionHandler)m_metricLearner).getOptions();
	for (int i = 0; i < metricOptions.length; i++) {
	  options[current++] = metricOptions[i];
	}
      }
    }
	
    while (current < options.length) {
      options[current++] = "";
    }
    return options;
  }

  /** Create a copy of this metric */
  public Object clone() {
    WeightedEuclidean m = null; 
    m = (WeightedEuclidean) super.clone();
    
    // clone the fields
    // for now clone a metric learner via serialization; TODO:  implement proper cloning in MetricLearners
    try { 
      SerializedObject so = new SerializedObject(m_metricLearner);
      m.m_metricLearner = (MetricLearner) so.getObject();
    } catch (Exception e) {
      System.err.println("Problems cloning m_metricLearner while cloning WeightedEuclidean");
    }
    return m;
  }

    
  public static void main(String[] args) {
    try {
      // Create numeric attributes "length" and "weight"
      Attribute length = new Attribute("length");
      Attribute weight = new Attribute("weight");
      Attribute height = new Attribute("height");
      Attribute width = new Attribute("width");
      
      // Create vector to hold nominal values "first", "second", "third" 
      FastVector my_nominal_values = new FastVector(3); 
      my_nominal_values.addElement("first"); 
      my_nominal_values.addElement("second"); 
      my_nominal_values.addElement("third"); 
      
      // Create nominal attribute "position" 
      Attribute position = new Attribute("position", my_nominal_values);
      
      // Create vector of the above attributes 
      FastVector attributes = new FastVector(4);
      attributes.addElement(length);
      attributes.addElement(weight);
      attributes.addElement(height);
      attributes.addElement(width);
      attributes.addElement(position);
      
      // Create the empty dataset "race" with above attributes
      Instances race = new Instances("race", attributes, 0);
      
      // Make position the class attribute
      race.setClassIndex(position.index());
      
      // Create a sparse instance with three attribute values
      SparseInstance s_inst1 = new SparseInstance(1, new double[0], new int[0], 4);
      s_inst1.setValue(length, 2);
      s_inst1.setValue(weight, 1);
      s_inst1.setValue(position, "third");

      // Create a sparse instance with three attribute values
      SparseInstance s_inst2 = new SparseInstance(1, new double[0], new int[0], 4);
      s_inst2.setValue(length, 1);
      s_inst2.setValue(height, 5);
      s_inst2.setValue(position, "second");

      // Create a non-sparse instance with all attribute values
      Instance inst1 = new Instance(5);
      inst1.setValue(length, 3);
      inst1.setValue(weight, 4);
      inst1.setValue(height, 5);
      inst1.setValue(width, 2);
      inst1.setValue(position, "first");

      // Create a sparse instance with three attribute values
      Instance inst2 = new Instance(5);
      inst2.setValue(length, 2);
      inst2.setValue(weight, 2);
      inst2.setValue(height, 2);
      inst2.setValue(width, 3);
      inst2.setValue(position, "second");
      // Set instances' dataset to be the dataset "race"
      s_inst1.setDataset(race);
      s_inst2.setDataset(race);
      inst1.setDataset(race);
      inst2.setDataset(race);
      
      // Print the instances
      System.out.println("Sparse instance S1: " + s_inst1);
      System.out.println("Sparse instance S2: " + s_inst2);
      System.out.println("Non-sparse instance NS1: " + inst1);
      System.out.println("Non-sparse instance NS2: " + inst2);
      
      // Print the class attribute
      System.out.println("Class attribute: " + s_inst1.classAttribute());
      
      // Print the class index
      System.out.println("Class index: " + s_inst1.classIndex());

      // Create a new metric and print the distances
      WeightedEuclidean metric = new WeightedEuclidean(4);
      metric.setClassIndex(position.index());
      System.out.println("Distance between S1 and S2: " + metric.distance(s_inst1, s_inst2));
      System.out.println("Distance between S1 and NS1: " + metric.distance(s_inst1, inst1));
      System.out.println("Distance between NS1 and S1: " + metric.distance(inst1, s_inst1));
      System.out.println("Distance between NS1 and NS2: " + metric.distance(inst1, inst2));
      System.out.println("\nDistance-similarity conversion type: " +
			 metric.getConversionType().getSelectedTag().getReadable());
      System.out.println("Similarity between S1 and S2: " + metric.similarity(s_inst1, s_inst2));
      System.out.println("Similarity between S1 and NS1: " + metric.similarity(s_inst1, inst1));
      System.out.println("Similarity between NS1 and S1: " + metric.similarity(inst1, s_inst1));
      System.out.println("Similarity between NS1 and NS2: " + metric.similarity(inst1, inst2));
      System.out.println();
      System.out.println("Difference instance S1-S2: " + metric.createDiffInstance(s_inst1, s_inst2));
      System.out.println("Difference instance S1-NS1: " + metric.createDiffInstance(s_inst1, inst1));
      System.out.println("Difference instance NS1-S1: " + metric.createDiffInstance(inst1, s_inst1));
      System.out.println("Difference instance NS1-NS2: " + metric.createDiffInstance(inst1, inst2));
    } catch (Exception e) {
      e.printStackTrace();
    }	
  } 
}