import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
/***
	 * <p>To get 10-fold cross validation in one single arff in <b>path</b></p>
	 * <p>Use C4.5 and <b>Resampling</b> to classify the dataset.</p>
	 * @param path dataset path
	 * @throws Exception
	 */
	public static void getEvalResultbyResampling(String path, int index) throws Exception{
		
		Instances ins = DataSource.read(path);
		int numAttr = ins.numAttributes();
		ins.setClassIndex(numAttr - 1);
		
		Resample resample = new Resample();
		resample.setInputFormat(ins);
		
		/** classifiers setting*/
		J48 j48 = new J48();
//		j48.setConfidenceFactor(0.4f);
		j48.buildClassifier(ins);

		FilteredClassifier fc = new FilteredClassifier();
		fc.setClassifier(j48);
		fc.setFilter(resample);
			
		Evaluation eval = new Evaluation(ins);	
		eval.crossValidateModel(fc, ins, 10, new Random(1));
		
//		System.out.printf(" %4.3f %4.3f %4.3f", eval.precision(0), eval.recall(0), eval.fMeasure(0));
//		System.out.printf(" %4.3f %4.3f %4.3f", eval.precision(1), eval.recall(1), eval.fMeasure(1));
//		System.out.printf(" %4.3f \n\n", (1-eval.errorRate()));
		results[index][0] = eval.precision(0);
		results[index][1] = eval.recall(0);
		results[index][2] = eval.fMeasure(0);
		results[index][3] = eval.precision(1);
		results[index][4] = eval.recall(1);
		results[index][5] = eval.fMeasure(1);
		results[index][6] = 1-eval.errorRate();
			
	}
 

import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
public Instances _getTrainingFromParams(String params)
{
    Resample filter = newFilter();
    filter.setInvertSelection(false);
    setFilterParams(filter, params);
    return getInstances(getTraining(), filter);
}
 

import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
public Instances _getTestingFromParams(String params)
{
    //Get the instances filtered (Not we use the training data here)
    Resample filter = newFilter();
    filter.setInvertSelection(true);
    setFilterParams(filter, params);

    return getInstances(getTraining(), filter);
}
 

import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
protected final Resample newFilter(){
    Resample filter = new Resample();
    try{
        filter.setInputFormat(getTraining());
    }catch(Exception e){
        filter = new RegressionResample();
    }
    return filter;
}
 

import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
private void setFilterParams(Resample filter, String paramStr)
{
    Properties params = Util.parsePropertyString(paramStr);
    filter.setNoReplacement(true);
    filter.setRandomSeed(Integer.parseInt(params.getProperty("seed", "0")));
    filter.setSampleSizePercent(Double.parseDouble(params.getProperty("percent", "70")));
    filter.setBiasToUniformClass(Double.parseDouble(params.getProperty("base", "0")));
}
 

import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
private Instances getInstancesFromParamsForSubClass(String params, boolean invert)
{
    Resample filter = newFilter();
    filter.setInvertSelection(false);
    int level = setFilterParams(filter, params);

    Instances instances = getTraining();
    for(int i = 0; i <= level-1; i++)
        instances = getInstances(instances, filter);

    filter.setInvertSelection(invert);
    return getInstances(instances, filter);
}
 

import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
private int setFilterParams(Resample filter, String paramStr)
{
    Properties params = Util.parsePropertyString(paramStr);
    filter.setNoReplacement(true);
    if(!"{SEED}".equals(params.getProperty("levelSeed"))) 
        filter.setRandomSeed(Integer.parseInt(params.getProperty("levelSeed", "0")));
    filter.setSampleSizePercent(Double.parseDouble(params.getProperty("levelPercent", "70")));
    filter.setBiasToUniformClass(Double.parseDouble(params.getProperty("levelBias", "0")));
    int level = Integer.parseInt(params.getProperty("level", "-1"));
    if(level < 0)
        throw new RuntimeException("Invalid level '" + level+ "'");
    return level;
}
 

import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
private Instances getInstancesFromParamsForSubClass(String params, boolean invert)
{
    Resample filter = newFilter();
    filter.setInvertSelection(invert);
    setFilterParams(filter, params);

    return getInstances(getTraining(), filter);
}
 

import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
private void setFilterParams(Resample filter, String paramStr)
{
    Properties params = Util.parsePropertyString(paramStr);
    filter.setNoReplacement(true);

    if(!"{SEED}".equals(params.getProperty("terminationSeed"))) 
        filter.setRandomSeed(Integer.parseInt(params.getProperty("terminationSeed", "0")));
    filter.setSampleSizePercent(Double.parseDouble(params.getProperty("terminationPercent", "30")));
    filter.setBiasToUniformClass(Double.parseDouble(params.getProperty("terminationBias", "0")));
}
 

import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
private Instances downsample(Instances stringsReplacedData, double percent) throws Exception {
  Instances reduced;
  Resample sampler = new Resample();
  sampler.setRandomSeed(1);
  //do not change distribution
  sampler.setBiasToUniformClass(0);
  sampler.setSampleSizePercent(percent);
  sampler.setInputFormat(stringsReplacedData);
  reduced = Filter.useFilter(stringsReplacedData, sampler);
  return reduced;
}
 

import weka.filters.supervised.instance.Resample; //导入依赖的package包/类
private Instances dumbResample(Instances reduced) throws Exception {
  Resample resampleFilter = new Resample();
  resampleFilter.setRandomSeed(1);
  resampleFilter.setBiasToUniformClass(1);
  resampleFilter.setInputFormat(reduced);
  return Filter.useFilter(reduced, resampleFilter);
}