.#semisuppairactivecurvecvresultproducer.java.1.16

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

	    }
 	    		
	    Object [] seResults;
	    if (m_SplitEvaluator instanceof SemiSupClustererSplitEvaluator) {
	      seResults = ((SemiSupClustererSplitEvaluator) m_SplitEvaluator).getResult(labeledTrainPairs, train, unlabeledTrain, test, unlabeledTest, homologHash); 
	    }
	    else {
	      throw new Exception("SplitEvaluator should be SemiSupClustererSplitEvaluator - SemiSupClassifierSplitEvaluator not yet implemented");
	    }

	    Object [] results = new Object [seResults.length + 1];
	    results[0] = getTimestamp();
	    System.arraycopy(seResults, 0, results, 1,
			     seResults.length);
	    if (m_debugOutput) {
	      String resultName = (""+run+"."+(fold+1)+"."+ m_CurrentSize + "." 
				   + Utils.backQuoteChars(runInstances.relationName())
				   +"."
				   +m_SplitEvaluator.toString()).replace(' ','_');
	      resultName = Utils.removeSubstring(resultName, 
						 "weka.clusterers.");
	      resultName = Utils.removeSubstring(resultName, 
						 "weka.filters.");
	      resultName = Utils.removeSubstring(resultName, 
						 "weka.attributeSelection.");
	      m_ZipDest.zipit(m_SplitEvaluator.getRawResultOutput(), resultName);
	    }
	    m_ResultListener.acceptResult(this, key, results);
	  } catch (Exception ex) {
	    // Save the train and test datasets for debugging purposes?
	    throw ex;
	  }
	}

//  	PCKMeans pckmeans = (PCKMeans) ((SemiSupClustererSplitEvaluator)m_SplitEvaluator).getClusterer(); // KLUGE, will have to remove later!!
//  	HashSet[] indexClusters = pckmeans.getIndexClusters();
//  	for (int i = 0; i < indexClusters.length; i++) {
//  	  HashSet cluster = indexClusters[i];
//  	  if (cluster == null) {
//  	    System.out.println("Cluster " + i + " is null");
//  	  }
//  	  else {
//  	    System.out.println ("Cluster " + i + " consists of " + cluster.size() + " elements");
//  	    Iterator iter = cluster.iterator();
//  	    while (iter.hasNext()) {
//  	      int idx = ((Integer) iter.next()).intValue();
//  	      if (idx < train.numInstances()) {
//  		System.out.println("\t\t" + train.instance(idx).classValue());
//  	      }
//  	      else {
//  		System.out.println("\t\t" + test.instance(idx-train.numInstances()).classValue());
//  	      }
//  	    }
//  	  }
//  	}
      
	if (m_PlotPoints != null) {
	  pointNum++;
	  int oldCurrentSize = m_CurrentSize;
	  m_CurrentSize = plotPoint(pointNum);
	  if (m_DoActive && m_CurrentSize<maxTrainSize()) {
	    ActiveLearningClusterer clusterer = (ActiveLearningClusterer) ((SemiSupClustererSplitEvaluator)m_SplitEvaluator).getClusterer();
	    labeledTrainPairs = InstancePair.getPairs(train, m_CurrentSize, m_useMustLinkPairsOnly); // Active learning done totally in clustering code now, only size of labeledTrainPairs is important
	  }
	  else if (m_CurrentSize < maxTrainSize()) {
	    labeledTrainPairs = InstancePair.getPairs(train, m_CurrentSize, m_useMustLinkPairsOnly);
	  }
	}
	else {
	  int oldCurrentSize = m_CurrentSize;
	  m_CurrentSize += m_StepSize;
	  ActiveLearningClusterer clusterer = (ActiveLearningClusterer) ((SemiSupClustererSplitEvaluator)m_SplitEvaluator).getClusterer();
	  if (m_DoActive && m_CurrentSize<maxTrainSize()) {
	    labeledTrainPairs = InstancePair.getPairs(train, m_CurrentSize, m_useMustLinkPairsOnly); // Active learning done totally in clustering code now, only size of labeledTrainPairs is important
	  }
	  else if (m_CurrentSize < maxTrainSize()) {
	    labeledTrainPairs = InstancePair.getPairs(train, m_CurrentSize, m_useMustLinkPairsOnly);
	  }
	}
      }
    }
  }

  public static HashMap readHomologs(Instances data) throws Exception {
    HashMap homologHash = new HashMap();
    String dataName = data.relationName();
    String homologFileName = null;
    if ((dataName.indexOf("expr") != -1) ||
	(dataName.indexOf("phylo") != -1)) {
      StringTokenizer tok = new StringTokenizer(dataName,"-");
      String name = tok.nextToken();
      homologFileName = "/u/ml/data/bio/arffFromPhylo/" + name + ".homologs";
      System.out.println("Read homologFile: " + homologFileName);
    }
    
    BufferedReader homologFile  = new BufferedReader(new FileReader(homologFileName));
      
    String line = homologFile.readLine();
    while (line != null) {
      StringTokenizer tok = new StringTokenizer(line, "\t");
      String gene1 = tok.nextToken(); // first token
      //      System.out.println("Gene1: " + gene1);
      String gene2 = tok.nextToken(); // second token
      //      System.out.println("Gene2: " + gene2);
      Object homologList1 = homologHash.get(gene1);
      if (homologList1 == null) {
	HashSet homologList = new HashSet();
	homologList.add(gene2);
	homologHash.put(gene1, homologList);
      } else {
	((HashSet)homologList1).add(gene2);
      }
      Object homologList2 = homologHash.get(gene2);
      if (homologList2 == null) {
	HashSet homologList = new HashSet();
	homologList.add(gene1);
	homologHash.put(gene2, homologList);
      } else {
	((HashSet)homologList2).add(gene1);
      }
      line = homologFile.readLine();
    }
    return homologHash;
  }


  public ArrayList reorganizeTrainForActiveLearning(ArrayList trainPairs, int currentSize, InstancePair[] pairsForActiveLearning, Instances trainWithLabels) throws Exception{
    for (int i=0; i<pairsForActiveLearning.length; i++) {
      // Check that pairs for active learning have been correctly picked, not from test
      if (pairsForActiveLearning[i].first >= trainWithLabels.numInstances() ||
	  pairsForActiveLearning[i].second >= trainWithLabels.numInstances()) {
	throw new Exception ("Something wrong ... asking for active learning on test!!");
      }
      else if (pairsForActiveLearning[i].first >= pairsForActiveLearning[i].second) {// first should be < second at this point
	throw new Exception("Something wrong ... first >= second!!");
      }
      System.out.println("Now adding active learned: " + pairsForActiveLearning[i]);
      trainPairs.add(pairsForActiveLearning[i]);
    }
    if (trainPairs.size() != currentSize) {
      throw new Exception("Pair numbers do not match, something wrong!!");
    }
    return trainPairs;
  }

  /** Determines if the points specified are fractions of the total number of examples */
  protected boolean setIsFraction(){
    if (m_PlotPoints != null){
      if(!isInteger(m_PlotPoints[0]))//if the first point is not an integer
	m_IsFraction = true;
      else
	m_IsFraction = false;
    }
    return m_IsFraction;
  }
  
  /** Return the number of training examples for the ith point on the
   * curve for plotPoints as specified.
   */
  protected int plotPoint(int i) {
    // If i beyond number of given plot points return a value greater than maximum training size
    if (i >= m_PlotPoints.length)
      return maxTrainSize() + 1;
    double point = m_PlotPoints[i];
    // If plot point is an integer (other than a non-initial 1)
    // treat it as a specific number of examples
    if (isInteger(point) && !(Utils.eq(point, 1.0) && i!=0))
      return (int)point;
    else
      // Otherwise, treat it as a percentage of the full set
      return (int)Math.round(point * maxTrainSize());
  }
  
  /** Return true if the given double represents an integer value */
  protected static boolean isInteger(double val) {
    return Utils.eq(Math.floor(val), Math.ceil(val));
  }
  
  /**
   * Gets the names of each of the columns produced for a single run.
   * This method should really be static.
   *
   * @return an array containing the name of each column
   */
  public String [] getKeyNames() {

    String [] keyNames = m_SplitEvaluator.getKeyNames();
    // Add in the names of our extra key fields
    int numExtraKeys;
    if(m_IsFraction)
      numExtraKeys = 5;
    else 
      numExtraKeys = 4;
    String [] newKeyNames = new String [keyNames.length + numExtraKeys];
    newKeyNames[0] = DATASET_FIELD_NAME;
    newKeyNames[1] = RUN_FIELD_NAME;
    newKeyNames[2] = FOLD_FIELD_NAME;
    newKeyNames[3] = STEP_FIELD_NAME;
    if(m_IsFraction) newKeyNames[4] = FRACTION_FIELD_NAME;
    System.arraycopy(keyNames, 0, newKeyNames, numExtraKeys, keyNames.length);
    return newKeyNames;
  }

  /**
   * Gets the data types of each of the columns produced for a single run.
   * This method should really be static.
   *
   * @return an array containing objects of the type of each column. The 
   * objects should be Strings, or Doubles.
   */
  public Object [] getKeyTypes() {
    Object [] keyTypes = m_SplitEvaluator.getKeyTypes();
    int numExtraKeys;
    if(m_IsFraction)
      numExtraKeys = 5;
    else 
      numExtraKeys = 4;
    // Add in the types of our extra fields
    Object [] newKeyTypes = new String [keyTypes.length + numExtraKeys];
    newKeyTypes[0] = new String();
    newKeyTypes[1] = new String();
    newKeyTypes[2] = new String();
    newKeyTypes[3] = new String();
    if(m_IsFraction) newKeyTypes[4] = new String();
    System.arraycopy(keyTypes, 0, newKeyTypes, numExtraKeys, keyTypes.length);
    return newKeyTypes;
  }

  /**
   * Gets the names of each of the columns produced for a single run.
   * This method should really be static.
   *
   * @return an array containing the name of each column
   */
  public String [] getResultNames() {

    String [] resultNames = m_SplitEvaluator.getResultNames();
    // Add in the names of our extra Result fields
    String [] newResultNames = new String [resultNames.length + 1];
    newResultNames[0] = TIMESTAMP_FIELD_NAME;
    System.arraycopy(resultNames, 0, newResultNames, 1, resultNames.length);
    return newResultNames;
  }

  /**
   * Gets the data types of each of the columns produced for a single run.
   * This method should really be static.
   *
   * @return an array containing objects of the type of each column. The 
   * objects should be Strings, or Doubles.
   */
  public Object [] getResultTypes() {

    Object [] resultTypes = m_SplitEvaluator.getResultTypes();
    // Add in the types of our extra Result fields
    Object [] newResultTypes = new Object [resultTypes.length + 1];
    newResultTypes[0] = new Double(0);
    System.arraycopy(resultTypes, 0, newResultTypes, 1, resultTypes.length);
    return newResultTypes;
  }

  /**
   * Gets a description of the internal settings of the result
   * producer, sufficient for distinguishing a ResultProducer
   * instance from another with different settings (ignoring
   * those settings set through this interface). For example,
   * a cross-validation ResultProducer may have a setting for the
   * number of folds. For a given state, the results produced should
   * be compatible. Typically if a ResultProducer is an OptionHandler,
   * this string will represent the command line arguments required
   * to set the ResultProducer to that state.
   *
   * @return the description of the ResultProducer state, or null
   * if no state is defined
   */
  public String getCompatibilityState() {

    String result = "-X " + m_NumFolds + " -S " + getStepSize() + 
	" -L " + getLowerSize() + " -U " + getUpperSize() + " ";
    if (m_SplitEvaluator == null) {
      result += "<null SplitEvaluator>";
    } else {
      result += "-W " + m_SplitEvaluator.getClass().getName();
    }
    return result + " --";
  }

  /**
   * Returns the tip text for this property
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String outputFileTipText() {
    return "Set the destination for saving raw output. If the rawOutput "
      +"option is selected, then output from the splitEvaluator for "
      +"individual folds is saved. If the destination is a directory, "
      +"then each output is saved to an individual gzip file; if the "
      +"destination is a file, then each output is saved as an entry "
      +"in a zip file.";
  }

  /**
   * Get the value of OutputFile.
   *
   * @return Value of OutputFile.
   */
  public File getOutputFile() {
    
    return m_OutputFile;
  }
  
  /**
   * Set the value of OutputFile.
   *
   * @param newOutputFile Value to assign to OutputFile.
   */
  public void setOutputFile(File newOutputFile) {
    
    m_OutputFile = newOutputFile;
  }  

  /**
   * Returns the tip text for this property
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String numFoldsTipText() {
    return "Number of folds to use in cross validation.";
  }

  /**
   * Get the value of NumFolds.
   *
   * @return Value of NumFolds.
   */
  public int getNumFolds() {
    
    return m_NumFolds;
  }

  
  /**
   * Set the value of NumFolds.
   *
   * @param newNumFolds Value to assign to NumFolds.
   */
  public void setNumFolds(int newNumFolds) {
    
    m_NumFolds = newNumFolds;
  }

//    /**
//     * Get the active learning algorithm type. 
//     *
//     * @returns the active learning method 
//     */
//    public SelectedTag getActiveType ()
//    {
//        return new SelectedTag(m_ActiveType, TAGS_ACTIVE);
//    }

//    /**
//     * Set the active learning algorithm type.
//     *
//     * @param activeMethod the active learning method to use
//     */
//    public void setActiveType (SelectedTag activeMethod)
//    {
//      if (activeMethod.getTags() == TAGS_ACTIVE) {
//        System.out.println("Active learning method: " + activeMethod.getSelectedTag().getReadable());
//        m_ActiveType = activeMethod.getSelectedTag().getID();
//      }
//    }

  /**
   * Returns the tip text for this property
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String isTransductiveTipText() {
    return "Whether evaluation is transductive or not.";
  }

  /**
   * Get the value of IsTransductive.
   *
   * @return Value of IsTransductive.
   */
  public boolean getIsTransductive() {
    
    return m_IsTransductive;
  }

  
  /**
   * Set the value of IsTransductive.
   *
   * @param flag Value to assign to IsTransductive.
   */
  public void setIsTransductive(boolean flag) {
    
    m_IsTransductive = flag;
  }

  /**
   * Get the value of useMustLinkPairsOnly.
   * @return value of useMustLinkPairsOnly.
   */
  public boolean getUseMustLinkPairsOnly() {
    return m_useMustLinkPairsOnly;
  }
  
  /**
   * Set the value of useMustLinkPairsOnly.
   * @param v  Value to assign to useMustLinkPairsOnly.
   */
  public void setUseMustLinkPairsOnly(boolean  v) {
    this.m_useMustLinkPairsOnly = v;
  }
  
  

  /**
   * Returns the tip text for this property
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String DoActiveTipText() {
    return "Whether active learning is performed or not.";
  }

  /**
   * Get the value of m_DoActive.
   *
   * @return Value of m_DoActive.
   */
  public boolean getDoActive() {
    
    return m_DoActive;
  }

  
  /**
   * Set the value of m_DoActive.