.#mpckmeans.java.1.110

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

  public void setMetricLearner (MPCKMeansMetricLearner ml) {
    m_metricLearner = ml;
    m_metricLearner.setMetric(m_metric);
    m_metricLearner.setClusterer(this);
  }
  public MPCKMeansMetricLearner getMetricLearner () {
    return m_metricLearner;
  }

  /** Set/get the assigner */
  public MPCKMeansAssigner getAssigner() {
    return m_Assigner;
  }
  public void setAssigner(MPCKMeansAssigner assigner) {
    assigner.setClusterer(this);
    this.m_Assigner = assigner;
  }

  /** Set/get the initializer */
  public MPCKMeansInitializer getInitializer() {
    return m_Initializer;
  }

  public void setInitializer(MPCKMeansInitializer initializer) {
    initializer.setClusterer(this);
    this.m_Initializer = initializer;
  }

  /** Read the seeds from a hastable, where every key is an instance and every value is:
   * the cluster assignment of that instance 
   * seedVector vector containing seeds
   */
  
  public void seedClusterer(HashMap seedHash) {
    System.err.println("Not implemented here");
  }
 
  public void printClusterAssignments() throws Exception {
    if (m_ClusterAssignmentsOutputFile != null) {
      PrintStream p = 
	new PrintStream(new FileOutputStream(m_ClusterAssignmentsOutputFile));
      
      for (int i=0; i<m_Instances.numInstances(); i++) {
	p.println(i + "\t" + m_ClusterAssignments[i]);
      }
      p.close();
    } else {
      System.out.println("\nCluster Assignments:\n");
      for (int i=0; i<m_Instances.numInstances(); i++) {
	System.out.println(i + "\t" + m_ClusterAssignments[i]);
      }
    }
  }


  /** Prints clusters */
  public void printClusters () throws Exception {
    ArrayList clusters = getClusters();
    for (int i=0; i<clusters.size(); i++) {
      Cluster currentCluster = (Cluster) clusters.get(i);
      System.out.println("\nCluster " + i + ": " + currentCluster.size() + " instances");
      if (currentCluster == null) {
	System.out.println("(empty)");
      }
      else {
	for (int j=0; j<currentCluster.size(); j++) {
	  Instance instance = (Instance) currentCluster.get(j);	
	  System.out.println("Instance: " + instance);
	}
      }
    }
  }

  /**
   * Computes the clusters from the cluster assignments, for external access
   * 
   * @exception Exception if clusters could not be computed successfully
   */    

  public ArrayList getClusters() throws Exception {
    m_Clusters = new ArrayList();
    Cluster [] clusterArray = new Cluster[m_NumClusters];

    for (int i=0; i < m_Instances.numInstances(); i++) {
      Instance inst = m_Instances.instance(i);
      if(clusterArray[m_ClusterAssignments[i]] == null)
	clusterArray[m_ClusterAssignments[i]] = new Cluster();
      clusterArray[m_ClusterAssignments[i]].add(inst, 1);
    }

    for (int j =0; j< m_NumClusters; j++) 
      m_Clusters.add(clusterArray[j]);

    return m_Clusters;
  }

  /**
   * Computes the clusters from the cluster assignments, for external access
   * 
   * @exception Exception if clusters could not be computed successfully
   */    

  public HashSet[] getIndexClusters() throws Exception {
    m_IndexClusters = new HashSet[m_NumClusters];
    for (int i=0; i < m_Instances.numInstances(); i++) {
      if (m_verbose) {
	//	System.out.println("In getIndexClusters, " + i + " assigned to cluster " + m_ClusterAssignments[i]);
      }
      if (m_ClusterAssignments[i]!=-1 && m_ClusterAssignments[i] < m_NumClusters) {
	if (m_IndexClusters[m_ClusterAssignments[i]] == null) {
	  m_IndexClusters[m_ClusterAssignments[i]] = new HashSet();
	}
	m_IndexClusters[m_ClusterAssignments[i]].add(new Integer(i));
      }
    }
    return m_IndexClusters;
  }


  public Enumeration listOptions () {
    return null;
  }

  public String [] getOptions () {
    String[] options = new String[150];
    int current = 0;

    if (m_Seedable) {
      options[current++] = "-S";
    }

    if (m_Trainable != TRAINING_NONE) {
      options[current++] = "-T";
      if (m_Trainable == TRAINING_INTERNAL) { 
	options[current++] = "Int";
      } else {
	options[current++] = "Ext";
      }
    }

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

    if (m_Trainable != TRAINING_NONE) {
      options[current++] = "-L";
      options[current++] = Utils.removeSubstring(m_metricLearner.getClass().getName(), "weka.clusterers.metriclearners.");
      String[] metricLearnerOptions = ((OptionHandler)m_metricLearner).getOptions();
      for (int i = 0; i < metricLearnerOptions.length; i++) {
	options[current++] = metricLearnerOptions[i];
      }
    }

    if (m_regularize) {
      options[current++] = "-G";
      options[current++] = Utils.removeSubstring(m_metric.getRegularizer().getClass().getName(), "weka.clusterers.regularizers.");
      if (m_metric.getRegularizer() instanceof OptionHandler) { 
	String[] regularizerOptions = ((OptionHandler)m_metric.getRegularizer()).getOptions();
	for (int i = 0; i < regularizerOptions.length; i++) {
	  options[current++] = regularizerOptions[i];
	}
      }
    } 

    options[current++] = "-A";
    options[current++] = Utils.removeSubstring(m_Assigner.getClass().getName(), "weka.clusterers.assigners.");
    if (m_Assigner instanceof OptionHandler) {
      String[] assignerOptions = ((OptionHandler)m_Assigner).getOptions();
      for (int i = 0; i < assignerOptions.length; i++) {
	options[current++] = assignerOptions[i];
      }
    }

    options[current++] = "-I";
    options[current++] = Utils.removeSubstring(m_Initializer.getClass().getName(), "weka.clusterers.initializers.");
    if (m_Initializer instanceof OptionHandler) {
      String[] initializerOptions = ((OptionHandler)m_Initializer).getOptions();
      for (int i = 0; i < initializerOptions.length; i++) {
	options[current++] = initializerOptions[i];
      }
    }

    if (m_useMultipleMetrics) {
      options[current++] = "-U";
    }

    options[current++] = "-N";
    options[current++] = "" + getNumClusters();
    options[current++] = "-R";
    options[current++] = "" + getRandomSeed();

    options[current++] = "-l";
    options[current++] = "" + m_logTermWeight;
    options[current++] = "-r";
    options[current++] = "" + m_regularizerTermWeight;
    options[current++] = "-m";
    options[current++] = "" + m_MLweight;
    options[current++] = "-c";
    options[current++] = "" + m_CLweight;

    options[current++] = "-I";
    options[current++] = "" + m_maxIterations;
    options[current++] = "-B";
    options[current++] = "" + m_maxBlankIterations;

    options[current++] = "-O";
    options[current++] = "" + m_ClusterAssignmentsOutputFile;
    options[current++] = "-V";
    options[current++] = "" + m_useTransitiveConstraints;

    while (current < options.length) {
      options[current++] = "";
    }

    return  options;
  }

  /**
   * Parses a given list of options.
   * @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('S', options)) {
      System.out.println("Setting seedable to: true");
      setSeedable(true);
    }

    String optionString = Utils.getOption('T', options);
    if (optionString.length() != 0) {
      setTrainable(new SelectedTag(Integer.parseInt(optionString), TAGS_TRAINING));
      System.out.println("Setting trainable to: true");
    }

    optionString = Utils.getOption('M', options);
    if (optionString.length() != 0) {
      String[] metricSpec = Utils.splitOptions(optionString);
      String metricName = metricSpec[0]; 
      metricSpec[0] = "";
      setMetric((LearnableMetric) Utils.forName(LearnableMetric.class, 
						metricName, metricSpec));
      System.out.println("Setting metric to: " + metricName);
    }

    optionString = Utils.getOption('L', options);
    if (optionString.length() != 0) {
      String[] learnerSpec = Utils.splitOptions(optionString);
      String learnerName = learnerSpec[0]; 
      learnerSpec[0] = "";
      setMetricLearner((MPCKMeansMetricLearner) Utils.forName(MPCKMeansMetricLearner.class,
							      learnerName, learnerSpec));
      System.out.println("Setting metricLearner to: " + m_metricLearner);
    }

    optionString = Utils.getOption('G', options);
    if (optionString.length() != 0) {
      String[] regularizerSpec = Utils.splitOptions(optionString);
      String regularizerName = regularizerSpec[0]; 
      regularizerSpec[0] = "";
      m_metric.setRegularizer((Regularizer) Utils.forName(Regularizer.class,
							  regularizerName, regularizerSpec));
      System.out.println("Setting regularizer to: " + regularizerName);
    }

    optionString = Utils.getOption('A', options);
    if (optionString.length() != 0) {
      String[] assignerSpec = Utils.splitOptions(optionString);
      String assignerName = assignerSpec[0]; 
      assignerSpec[0] = "";
      setAssigner((MPCKMeansAssigner) Utils.forName(MPCKMeansAssigner.class,
						    assignerName, assignerSpec));
      System.out.println("Setting assigner to: " + assignerName);
    }
    
    optionString = Utils.getOption('I', options);
    if (optionString.length() != 0) {
      String[] initializerSpec = Utils.splitOptions(optionString);
      String initializerName = initializerSpec[0]; 
      initializerSpec[0] = "";
      setInitializer((MPCKMeansInitializer) Utils.forName(MPCKMeansInitializer.class,
							  initializerName, initializerSpec));
      System.out.println("Setting initializer to: " + initializerName);
    }

    if (Utils.getFlag('U', options)) {
      setUseMultipleMetrics(true);
      System.out.println("Setting multiple metrics to: true");
    }

    optionString = Utils.getOption('N', options);
    if (optionString.length() != 0) {
      setNumClusters(Integer.parseInt(optionString));
      System.out.println("Setting numClusters to: " + m_NumClusters);
    } 

    optionString = Utils.getOption('R', options);
    if (optionString.length() != 0) {
      setRandomSeed(Integer.parseInt(optionString));
      System.out.println("Setting randomSeed to: " + m_RandomSeed);
    }

    optionString = Utils.getOption('l', options);
    if (optionString.length() != 0) {
      setLogTermWeight(Double.parseDouble(optionString));
      System.out.println("Setting logTermWeight to: " + m_logTermWeight);
    }

    optionString = Utils.getOption('r', options);
    if (optionString.length() != 0) {
      setRegularizerTermWeight(Double.parseDouble(optionString));
      System.out.println("Setting regularizerTermWeight to: " 
			 + m_regularizerTermWeight);
    }

    optionString = Utils.getOption('m', options);
    if (optionString.length() != 0) {
      setMustLinkWeight(Double.parseDouble(optionString));
      System.out.println("Setting mustLinkWeight to: " + m_MLweight);
    }

    optionString = Utils.getOption('c', options);
    if (optionString.length() != 0) {
      setCannotLinkWeight(Double.parseDouble(optionString));
      System.out.println("Setting cannotLinkWeight to: " + m_CLweight);
    }

    optionString = Utils.getOption('I', options);
    if (optionString.length() != 0) {
      setMaxIterations(Integer.parseInt(optionString));
      System.out.println("Setting maxIterations to: " + m_maxIterations);
    }

    optionString = Utils.getOption('B', options);
    if (optionString.length() != 0) {
      setMaxBlankIterations(Integer.parseInt(optionString));
      System.out.println("Setting maxBlankIterations to: " + m_maxBlankIterations);
    }

    optionString = Utils.getOption('O', options);
    if (optionString.length() != 0) {
      setClusterAssignmentsOutputFile(optionString);
      System.out.println("Setting clusterAssignmentsOutputFile to: " 
			 + m_ClusterAssignmentsOutputFile);
    }

    if (Utils.getFlag('V', options)) {
      setUseTransitiveConstraints(true);
      System.out.println("Setting useTransitiveConstraints to: true");
    }
  }
  
  /**   
   * return a string describing this clusterer
   *
   * @return a description of the clusterer as a string
   */
  public String toString() {
    StringBuffer temp = new StringBuffer();
    return temp.toString();
  }


  /**
   * set the verbosity level of the clusterer
   * @param verbose messages on(true) or off (false)
   */
  public void setVerbose (boolean verbose) {
    m_verbose = verbose;
  }

  /**
   * get the verbosity level of the clusterer
   * @return messages on(true) or off (false)
   */
  public boolean getVerbose () {
    return m_verbose;
  }

  /** Set/get the use of transitive closure */
  public void setUseTransitiveConstraints(boolean useTransitiveConstraints) {
    m_useTransitiveConstraints = useTransitiveConstraints;
  }

  public boolean getUseTransitiveConstraints() {
    return m_useTransitiveConstraints;
  } 

  /**
   * Turn on/off the use of per-cluster metrics
   * @param useMultipleMetrics if true, individual metrics will be used for each cluster
   */
  public void setUseMultipleMetrics (boolean useMul