import weka.clusterers.Clusterer; //导入依赖的package包/类
public Clusterer getFinalizedClusterer() throws DistributedWekaException {
  if (m_canopy == null) {
    throw new DistributedWekaException(
      "CanopyMapTask has not been initialized yet!");
  }

  if (!m_finalized) {
    throw new DistributedWekaException(
      "This map task has note been finalized yet!");
  }

  if (m_finalFullPreprocess == null) {
    return m_canopy;
  }

  PreconstructedFilteredClusterer fc = new PreconstructedFilteredClusterer();
  fc.setFilter((Filter) m_finalFullPreprocess);
  fc.setClusterer(m_canopy);

  return fc;
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
 * Make the final PreconstructedKMeans clusterer to wrap the centroids and
 * stats found during map-reduce.
 * 
 * @param best the best result from the runs of k-means that were performed in
 *          parallel
 * @param preprocess any pre-processing filters applied
 * @param initialStartingPoints the initial starting centroids
 * @param finalNumIterations the final number of iterations performed
 * @return a final clusterer object
 * @throws DistributedWekaException if a problem occurs
 */
protected Clusterer makeFinalClusterer(KMeansReduceTask best,
  Filter preprocess, Instances initialStartingPoints, int finalNumIterations)
  throws DistributedWekaException {

  Clusterer finalClusterer = null;
  PreconstructedKMeans finalKMeans = new PreconstructedKMeans();
  // global priming data for the distance function (this will be in
  // the transformed space if we're using preprocessing filters)
  Instances globalPrimingData = best.getGlobalDistanceFunctionPrimingData();
  NormalizableDistance dist = new EuclideanDistance();
  dist.setInstances(globalPrimingData);
  finalKMeans.setClusterCentroids(best.getCentroidsForRun());
  finalKMeans.setFinalNumberOfIterations(finalNumIterations + 1);
  if (initialStartingPoints != null) {
    finalKMeans.setInitialStartingPoints(initialStartingPoints);
  }
  try {
    finalKMeans.setDistanceFunction(dist);
    finalKMeans.setClusterStats(best.getAggregatedCentroidSummaries());
  } catch (Exception e) {
    throw new DistributedWekaException(e);
  }

  if (!getInitWithRandomCentroids()) {
    finalKMeans.setInitializationMethod(new SelectedTag(
      SimpleKMeans.KMEANS_PLUS_PLUS, SimpleKMeans.TAGS_SELECTION));
  }

  finalKMeans.setDisplayStdDevs(getDisplayCentroidStdDevs());

  finalClusterer = finalKMeans;

  if (preprocess != null) {
    PreconstructedFilteredClusterer fc =
      new PreconstructedFilteredClusterer();
    fc.setFilter(preprocess);
    fc.setClusterer(finalKMeans);
    finalClusterer = fc;
  }

  return finalClusterer;
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
 * Static factory method to create an appropriate concrete ScoringModel
 * given a particular base model
 *
 * @param model the model to wrap in a ScoringModel
 * @return a concrete subclass of ScoringModel
 * @throws Exception if a problem occurs
 */
public static ScoringModel createScorer(Object model) throws Exception {
  if (model instanceof Classifier) {
    return new ClassifierScoringModel(model);
  } else if (model instanceof Clusterer) {
    return new ClustererScoringModel(model);
  }
  return null;
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
 * Creates a new <code>BatchClustererEvent</code> instance.
 *
 * @param source the source object
 * @param scheme a Clusterer
 * @param tstI the training/test instances
 * @param setNum the set number of the training/testinstances
 * @param maxSetNum the last set number in the series
 * @param testOrTrain 0 if the set is a test set, >0 if it is a training set
 */
public BatchClustererEvent(Object source, Clusterer scheme, DataSetEvent tstI, int setNum, int maxSetNum, int testOrTrain) {
  super(source);
  //    m_trainingSet = trnI;
  m_clusterer = scheme;
  m_testSet = tstI;
  m_setNumber = setNum;
  m_maxSetNumber = maxSetNum;
  if(testOrTrain == 0)
      m_testOrTrain = TEST;
  else
      m_testOrTrain = TRAINING;
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
 * Gets the clusterer specification string, which contains the class name of
 * the clusterer and any options to the clusterer.
 * 
 * @return the clusterer string.
 */
protected String getClustererSpec() {
  Clusterer c = getClusterer();
  if (c instanceof OptionHandler) {
    return c.getClass().getName() + " "
      + Utils.joinOptions(((OptionHandler) c).getOptions());
  }
  return c.getClass().getName();
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
  * Gets the clusterer specification string, which contains the class name of
  * the clusterer and any options to the clusterer.
  *
  * @return the clusterer string.
  */
 protected String getClustererSpec() {
   Clusterer c = getClusterer();
   if (c instanceof OptionHandler) {
     return c.getClass().getName() + " "
+ Utils.joinOptions(((OptionHandler)c).getOptions());
   }
   return c.getClass().getName();
 }
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
 * returns a configured cluster algorithm
 */
protected Clusterer getClusterer() {
  EM c = new EM();
  try {
    c.setOptions(new String[0]);
  }
  catch (Exception e) {
    e.printStackTrace();
  }
  return c;
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
  * Gets the clusterer specification string, which contains the class name of
  * the clusterer and any options to the clusterer.
  *
  * @return the clusterer string.
  */
 protected String getClustererSpec() {
   
   Clusterer c = getClusterer();
   if (c instanceof OptionHandler) {
     return c.getClass().getName() + " "
+ Utils.joinOptions(((OptionHandler)c).getOptions());
   }
   return c.getClass().getName();
 }
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
 * Static factory method to create an instance of an appropriate subclass of
 * WekaScoringModel given a Weka model.
 * 
 * @param model a Weka model
 * @return an appropriate WekaScoringModel for this type of Weka model
 * @exception Exception if an error occurs
 */
public static WekaScoringModel createScorer(Object model) throws Exception {
  if (model instanceof Classifier) {
    return new WekaScoringClassifier(model);
  } else if (model instanceof Clusterer) {
    return new WekaScoringClusterer(model);
  }
  return null;
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
public ClassifierWrapper(Clusterer clusterer) {
    this.clusterer = clusterer;
    this.wrapperType = WRAPPERTYPE_CLUSTERER;
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
public Clusterer getClusterer() {
    return clusterer;
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
public void setClusterer(Clusterer clusterer) {
    this.clusterer = clusterer;
    this.wrapperType = WRAPPERTYPE_CLUSTERER;
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
@Override
public Clusterer getClusterer() {
  return m_finalClusterer;
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
@Override
public void setModel(Object model) {
  m_model = (Clusterer) model;

}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
 * Saves the currently selected clusterer
 */
protected void saveClusterer(String name, Clusterer clusterer,
  Instances trainHeader, int[] ignoredAtts) {

  File sFile = null;
  boolean saveOK = true;

  int returnVal = m_FileChooser.showSaveDialog(this);
  if (returnVal == JFileChooser.APPROVE_OPTION) {
    sFile = m_FileChooser.getSelectedFile();
    if (!sFile.getName().toLowerCase().endsWith(MODEL_FILE_EXTENSION)) {
      sFile = new File(sFile.getParent(), sFile.getName()
        + MODEL_FILE_EXTENSION);
    }
    m_Log.statusMessage("Saving model to file...");

    try {
      OutputStream os = new FileOutputStream(sFile);
      if (sFile.getName().endsWith(".gz")) {
        os = new GZIPOutputStream(os);
      }
      ObjectOutputStream objectOutputStream = new ObjectOutputStream(os);
      objectOutputStream.writeObject(clusterer);
      if (trainHeader != null) {
        objectOutputStream.writeObject(trainHeader);
      }
      if (ignoredAtts != null) {
        objectOutputStream.writeObject(ignoredAtts);
      }
      objectOutputStream.flush();
      objectOutputStream.close();
    } catch (Exception e) {

      JOptionPane.showMessageDialog(null, e, "Save Failed",
        JOptionPane.ERROR_MESSAGE);
      saveOK = false;
    }
    if (saveOK) {
      m_Log.logMessage("Saved model (" + name + ") to file '"
        + sFile.getName() + "'");
    }
    m_Log.statusMessage("OK");
  }
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
 * Signify that this batch of input to the filter is finished.
 * 
 * @return true if there are instances pending output
 * @throws IllegalStateException if no input structure has been defined
 */
@Override
public boolean batchFinished() throws Exception {
  if (getInputFormat() == null) {
    throw new IllegalStateException("No input instance format defined");
  }

  Instances toFilter = getInputFormat();

  if (!isFirstBatchDone()) {
    // filter out attributes if necessary
    Instances toFilterIgnoringAttributes = removeIgnored(toFilter);

    // serialized model or build clusterer from scratch?
    File file = getSerializedClustererFile();
    if (!file.isDirectory()) {
      ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
      m_ActualClusterer = (Clusterer) ois.readObject();
      Instances header = null;
      // let's see whether there's an Instances header stored as well
      try {
        header = (Instances) ois.readObject();
      } catch (Exception e) {
        // ignored
      }
      ois.close();
      // same dataset format?
      if ((header != null)
        && (!header.equalHeaders(toFilterIgnoringAttributes))) {
        throw new WekaException(
          "Training header of clusterer and filter dataset don't match:\n"
            + header.equalHeadersMsg(toFilterIgnoringAttributes));
      }
    } else {
      m_ActualClusterer = AbstractClusterer.makeCopy(m_Clusterer);
      m_ActualClusterer.buildClusterer(toFilterIgnoringAttributes);
    }

    // create output dataset with new attribute
    Instances filtered = new Instances(toFilter, 0);
    ArrayList<String> nominal_values = new ArrayList<String>(
      m_ActualClusterer.numberOfClusters());
    for (int i = 0; i < m_ActualClusterer.numberOfClusters(); i++) {
      nominal_values.add("cluster" + (i + 1));
    }
    filtered.insertAttributeAt(new Attribute("cluster", nominal_values),
      filtered.numAttributes());

    setOutputFormat(filtered);
  }

  // build new dataset
  for (int i = 0; i < toFilter.numInstances(); i++) {
    convertInstance(toFilter.instance(i));
  }

  flushInput();
  m_NewBatch = true;
  m_FirstBatchDone = true;

  return (numPendingOutput() != 0);
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
 * Saves the currently selected clusterer
 */
protected void saveClusterer(String name, Clusterer clusterer,
    Instances trainHeader, int[] ignoredAtts) {

  File sFile = null;
  boolean saveOK = true;

  int returnVal = m_FileChooser.showSaveDialog(this);
  if (returnVal == JFileChooser.APPROVE_OPTION) {
    sFile = m_FileChooser.getSelectedFile();
    if (!sFile.getName().toLowerCase().endsWith(MODEL_FILE_EXTENSION)) {
      sFile = new File(sFile.getParent(), sFile.getName()
          + MODEL_FILE_EXTENSION);
    }
    m_Log.statusMessage("Saving model to file...");

    try {
      OutputStream os = new FileOutputStream(sFile);
      if (sFile.getName().endsWith(".gz")) {
        os = new GZIPOutputStream(os);
      }
      ObjectOutputStream objectOutputStream = new ObjectOutputStream(os);
      objectOutputStream.writeObject(clusterer);
      if (trainHeader != null)
        objectOutputStream.writeObject(trainHeader);
      if (ignoredAtts != null)
        objectOutputStream.writeObject(ignoredAtts);
      objectOutputStream.flush();
      objectOutputStream.close();
    } catch (Exception e) {

      JOptionPane.showMessageDialog(null, e, "Save Failed",
          JOptionPane.ERROR_MESSAGE);
      saveOK = false;
    }
    if (saveOK)
      m_Log.logMessage("Saved model (" + name + ") to file '"
          + sFile.getName() + "'");
    m_Log.statusMessage("OK");
  }
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
 * updates the capabilities filter of the GOE
 * 
 * @param filter the new filter to use
 */
protected void updateCapabilitiesFilter(Capabilities filter) {
  Instances tempInst;
  Capabilities filterClass;

  if (filter == null) {
    m_ClustererEditor.setCapabilitiesFilter(new Capabilities(null));
    return;
  }

  if (!ExplorerDefaults.getInitGenericObjectEditorFilter())
    tempInst = new Instances(m_Instances, 0);
  else
    tempInst = new Instances(m_Instances);
  tempInst.setClassIndex(-1);

  if (!m_ignoreKeyList.isSelectionEmpty()) {
    tempInst = removeIgnoreCols(tempInst);
  }

  try {
    filterClass = Capabilities.forInstances(tempInst);
  } catch (Exception e) {
    filterClass = new Capabilities(null);
  }

  m_ClustererEditor.setCapabilitiesFilter(filterClass);

  // check capabilities
  m_StartBut.setEnabled(true);
  Capabilities currentFilter = m_ClustererEditor.getCapabilitiesFilter();
  Clusterer clusterer = (Clusterer) m_ClustererEditor.getValue();
  Capabilities currentSchemeCapabilities = null;
  if (clusterer != null && currentFilter != null
      && (clusterer instanceof CapabilitiesHandler)) {
    currentSchemeCapabilities = ((CapabilitiesHandler) clusterer)
        .getCapabilities();

    if (!currentSchemeCapabilities.supportsMaybe(currentFilter)
        && !currentSchemeCapabilities.supports(currentFilter)) {
      m_StartBut.setEnabled(false);
    }
  }
}
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/**
  * Signify that this batch of input to the filter is finished.
  *
  * @return true if there are instances pending output
  * @throws IllegalStateException if no input structure has been defined 
  */  
 public boolean batchFinished() throws Exception {
   if (getInputFormat() == null)
     throw new IllegalStateException("No input instance format defined");

   Instances toFilter = getInputFormat();
   
   if (!isFirstBatchDone()) {
     // filter out attributes if necessary
     Instances toFilterIgnoringAttributes = removeIgnored(toFilter);

     // serialized model or build clusterer from scratch?
     File file = getSerializedClustererFile();
     if (!file.isDirectory()) {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
m_ActualClusterer = (Clusterer) ois.readObject();
Instances header = null;
// let's see whether there's an Instances header stored as well
try {
  header = (Instances) ois.readObject();
}
catch (Exception e) {
  // ignored
}
ois.close();
// same dataset format?
if ((header != null) && (!header.equalHeaders(toFilterIgnoringAttributes)))
  throw new WekaException(
      "Training header of clusterer and filter dataset don't match:\n"
      + header.equalHeadersMsg(toFilterIgnoringAttributes));
     }
     else {
m_ActualClusterer = AbstractClusterer.makeCopy(m_Clusterer);
m_ActualClusterer.buildClusterer(toFilterIgnoringAttributes);
     }

     // create output dataset with new attribute
     Instances filtered = new Instances(toFilter, 0); 
     FastVector nominal_values = new FastVector(m_ActualClusterer.numberOfClusters());
     for (int i = 0; i < m_ActualClusterer.numberOfClusters(); i++) {
nominal_values.addElement("cluster" + (i+1)); 
     }
     filtered.insertAttributeAt(new Attribute("cluster", nominal_values),
  filtered.numAttributes());

     setOutputFormat(filtered);
   }

   // build new dataset
   for (int i=0; i<toFilter.numInstances(); i++) {
     convertInstance(toFilter.instance(i));
   }
   
   flushInput();
   m_NewBatch = true;
   m_FirstBatchDone = true;

   return (numPendingOutput() != 0);
 }
 

import weka.clusterers.Clusterer; //导入依赖的package包/类
/** Creates a default MakeDensityBasedClusterer */
public Clusterer getClusterer() {
  return new MakeDensityBasedClusterer();
}