思享工具箱

实验2：基于Weka的数据挖掘程序设计

摘要：
在Eclipse中创建一个新的Java项目，以放置实验程序的源代码。数据预处理：将数值字段规格化为[0,1]范围。调用决策树、随机森林、神经网络、朴素贝叶斯等算法的API，完成预处理数据的分类，并将60%作为训练集。
一、实验目标

在掌握基于Weka工具的数据挖掘（分类、回归、聚类、关联规则分析）应用的基础上，实现基于Weka API的数据挖掘程序设计。

二、实验内容

1.下载安装JDK 7.0 64位版，Weka 3.7版，Eclipse IDE for Java Developers 4.0以上版本。
2.基于Weka API的数据分类。
3.基于Weka API的数据回归。
4.基于Weka API的数据聚类。
5.基于Weka API的关联规则分析。

三、实验步骤

1.下载并安装JDK 7.0 64位版，Weka 3.7版，Eclipse IDE for Java Developers 4.0以上版本

(1)JDK与Weka的安装方法与实验1中相同。
(2)从http://www.eclipse.org/home/index.php 下载并安装Eclipse。
(3)在Eclipse中建立一个新的Java工程，用于放置实验程序的源代码。
(4)编程请遵循Java编程规范。规范中文版参见：
http://www.hawstein.com/posts/google-java-style.html。

2.基于Weka API的数据分类

(1)读取“电费回收数据.csv”。

(2)数据预处理：

(a)将数值型字段规范化至[0,1]区间。
(b)调用特征选择算法（Select attributes），选择关键特征。
实验2：基于Weka的数据挖掘程序设计第1张

(3)分别调用决策树（J48）、随机森林（RandomForest）、神经网络（MultilayerPerceptron）、朴素贝叶斯（NaiveBayes）等算法的API，完成对预处理后数据的分类，取60%作为训练集。输出各算法的查准率（precision）、查全率（recall）、混淆矩阵与运行时间。

运行结果如下：

(a)决策树（J48）

实验2：基于Weka的数据挖掘程序设计第2张

(b)随机森林（RandomForest）

实验2：基于Weka的数据挖掘程序设计第3张

(c)神经网络（MultilayerPerceptron）

实验2：基于Weka的数据挖掘程序设计第4张

(d)朴素贝叶斯（NaiveBayes）

实验2：基于Weka的数据挖掘程序设计第5张

代码如下：

package weka;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Random;
import weka.attributeSelection.AttributeSelection;
import weka.attributeSelection.BestFirst;
import weka.attributeSelection.CfsSubsetEval;
import weka.classifiers.bayes.NaiveBayes;
import weka.classifiers.evaluation.Evaluation;
import weka.classifiers.functions.MultilayerPerceptron;
import weka.classifiers.trees.J48;
import weka.classifiers.trees.RandomForest;
import weka.core.Attribute;
import weka.core.Instances;
import weka.core.Utils;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.Discretize;
import weka.filters.unsupervised.attribute.Normalize;
import weka.filters.unsupervised.attribute.NumericToNominal;
import weka.filters.unsupervised.attribute.Remove;

/**
 * 	二、基于Weka API的数据分类
 * @author 西瓜不甜
 *
 */
public class Test_1 {

	
	
	public static void main(String[] args) throws Exception {
		
		/**
		 * 1.读取"电费回收数据.csv"
		 */
		
		Instances data = new Instances(new BufferedReader(new FileReader("C:\Users\西瓜不甜\Desktop\workspace\weka\电费回收数据.arff")));
		
        
        
        /**
         * 2.数据预处理
         * (1)删除无用属性
         */
        String[] options = new String[2];
        options[0] = "-R";                                    // remove
        options[1] = "1-2,7,10,12";                           // "CONS_NO", "YMD", "RCVED_DATE", "CUISHOU_COUNT", "YM"
        Remove remove = new Remove();                         
        remove.setOptions(options);                          
        remove.setInputFormat(data);                     	
        data = Filter.useFilter(data, remove);   	  		// apply filter
        
        data.setClassIndex(data.numAttributes() - 1);  		// set class
 
        /**
         * 2.数据预处理
         * (2)归一化
         */
        Normalize norm = new Normalize();  
        norm.setInputFormat(data);  
        data = Filter.useFilter(data, norm);  

        
        /**
         * 2.数据预处理
         * (3)特征选择
         */
        AttributeSelection attSelect = new AttributeSelection();
        CfsSubsetEval eval = new CfsSubsetEval();
        BestFirst search = new BestFirst();
        attSelect.setEvaluator(eval);
        attSelect.setSearch(search);
        attSelect.SelectAttributes(data);
        
        int[] indices = attSelect.selectedAttributes();
        System.out.print("
 Select Attributes : starting with (0): " + Utils.arrayToString(indices) + '	');
        
        for (int i = 0; i <indices.length; i++) {
        	int index = indices[i];
        	Attribute attribute = data.attribute(index); 
        	System.out.print(attribute.name() + " ");
        }
        System.out.println();  
        
        
        /**
         * 2.数据预处理
         * (4) 离散化
         */
        Discretize disc = new Discretize();
        disc.setInputFormat(data);
        data = Filter.useFilter(data, disc);
        
        
        /**
         * 2.数据预处理
         * (5) 类型转换
         */
        NumericToNominal nutono = new NumericToNominal();
        nutono.setInputFormat(data);
        data = Filter.useFilter(data, nutono);
        
        
        /**
         * 3.数据分类
         * (0) 取60%为训练集，40%为测试集
         */
        data.randomize(new Random(0));
		int trainSize = (int) Math.round(data.numInstances() * 0.60);
		int testSize = data.numInstances() - trainSize;
		Instances train = new Instances(data, 0, trainSize);
		Instances test = new Instances(data, trainSize, testSize);

		
		long startTime, endTime;
		Evaluation evaluation;
        /**
         * 3.数据分类
         * (1)决策树(J48)
         */
		
		startTime = System.currentTimeMillis();
		
        J48 j48 = new J48();							// train classifier
        j48.buildClassifier(train);
        evaluation = new Evaluation(train);				// evaluate classifier and print some statistics
        evaluation.evaluateModel(j48, test);
        
        endTime = System.currentTimeMillis();
        
        System.out.println(evaluation.toSummaryString("
======J48 : Results======
" + "Runtime : " + (endTime - startTime) + "ms
", false));
        System.out.println(evaluation.toClassDetailsString());
        System.out.println(evaluation.toMatrixString());
        
        
        /**
         * 3.数据分类
         * (2)随机森林(RandomForest)
         */
        startTime = System.currentTimeMillis();
        
        RandomForest rf = new RandomForest();			// train classifier
        rf.buildClassifier(train);
        evaluation = new Evaluation(train);				// evaluate classifier and print some statistics
        evaluation.evaluateModel(rf, test);
        
        endTime = System.currentTimeMillis();
        
        System.out.println(evaluation.toSummaryString("
======RandomForest : Results======
" + "Runtime : " + (endTime - startTime) + "ms
", false));
        System.out.println(evaluation.toClassDetailsString());
        System.out.println(evaluation.toMatrixString());
        
        
        /**
         * 3.数据分类
         * (3)神经网络(MultilayerPerceptron)
         * ps:运行时间约4h,谨慎运行。
         */
        
        startTime = System.currentTimeMillis();
        
        MultilayerPerceptron mp = new MultilayerPerceptron();			// train classifier
        mp.buildClassifier(train);
        evaluation = new Evaluation(train);				// evaluate classifier and print some statistics
        evaluation.evaluateModel(mp, test);
        
        endTime = System.currentTimeMillis();
        
        System.out.println(evaluation.toSummaryString("
======MultilayerPerceptron : Results======
" + "Runtime : " + (endTime - startTime) + "ms
", false));
        System.out.println(evaluation.toClassDetailsString());
        System.out.println(evaluation.toMatrixString());
        
        /**
         * 3.数据分类
         * (4)朴素贝叶斯(NaiveBayes)
         */
        
        startTime = System.currentTimeMillis();
        
        NaiveBayes nb = new NaiveBayes();			// train classifier
        nb.buildClassifier(train);
        evaluation = new Evaluation(train);				// evaluate classifier and print some statistics
        evaluation.evaluateModel(nb, test);
        
        endTime = System.currentTimeMillis();
        
        System.out.println(evaluation.toSummaryString("
======NaiveBayes : Results======
" + "Runtime : " + (endTime - startTime) + "ms
", false));
        System.out.println(evaluation.toClassDetailsString());
        System.out.println(evaluation.toMatrixString());
	}

}

3.基于Weka API的回归分析

(1)读取“配网抢修数据.csv”。

(2)数据预处理：

(a)将数值型字段规范化至[0,1]区间。
(b)调用特征选择算法（Select attributes），选择关键特征。

(3)分别调用随机森林（RandomForest）、神经网络（MultilayerPerceptron）、线性回归（LinearRegression）等算法的API对数据进行回归分析，取60%作为训练集。输出各算法的均方根误差（RMSE，Root Mean Squared Error）、相对误差（relative absolute error）与运行时间。

运行结果如下：

(a)随机森林（RandomForest）

实验2：基于Weka的数据挖掘程序设计第6张

(b)神经网络（MultilayerPerceptron）

实验2：基于Weka的数据挖掘程序设计第7张

(c)线性回归（LinearRegression）

实验2：基于Weka的数据挖掘程序设计第8张

代码如下：

package weka;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Random;
import weka.attributeSelection.AttributeSelection;
import weka.attributeSelection.BestFirst;
import weka.attributeSelection.CfsSubsetEval;
import weka.classifiers.evaluation.Evaluation;
import weka.classifiers.functions.LinearRegression;
import weka.classifiers.functions.MultilayerPerceptron;
import weka.classifiers.trees.RandomForest;
import weka.core.Attribute;
import weka.core.Instances;
import weka.core.Utils;
import weka.core.converters.ConverterUtils.DataSource;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.Discretize;
import weka.filters.unsupervised.attribute.Normalize;
import weka.filters.unsupervised.attribute.Remove;

/**
 * 	三、基于Weka API的回归分析
 * @author 西瓜不甜
 *
 */
public class Test_2 {
	
	
	public static void main(String[] args) throws Exception {


		/**
		 * 1.读取"配网抢修数据.csv"
		 */
		// load file
		Instances data = new Instances(new BufferedReader(new FileReader("C:\Users\西瓜不甜\Desktop\workspace\weka\配网抢修数据.arff")));
		
        /**
         * 2.数据预处理
         * (1)删除无用属性
         */
        String[] options = new String[2];
        options[0] = "-R";                                  // remove
        options[1] = "1-2";                           		// YMD（年月日）、REGION_ID（地区编号）
        Remove remove = new Remove();                         
        remove.setOptions(options);                          
        remove.setInputFormat(data);                     	
        data = Filter.useFilter(data, remove);   	  		// apply filter
        
      
        data.setClassIndex(data.numAttributes() - 1);  		// set class
        
        /**
         * 2.数据预处理
         * (2)归一化
         */
        Normalize norm = new Normalize();  
        norm.setInputFormat(data);  
        data = Filter.useFilter(data, norm);  
        
        /**
         * 2.数据预处理
         * (3)特征选择
         */
        AttributeSelection attSelect = new AttributeSelection();
        CfsSubsetEval eval = new CfsSubsetEval();
        BestFirst search = new BestFirst();
        attSelect.setEvaluator(eval);
        attSelect.setSearch(search);
        attSelect.SelectAttributes(data);
        
        int[] indices = attSelect.selectedAttributes();
        
        System.out.print("
 Select Attributes : starting with (0): " + Utils.arrayToString(indices) + '	');
        for (int i = 0; i <indices.length; i++) {
        	int index = indices[i];
        	Attribute attribute = data.attribute(index); 
        	System.out.print(attribute.name() + "	");
        }
        System.out.println();  
        
        /**
         * 2.数据预处理
         * (4) 离散化
         */
        Discretize disc = new Discretize();
        disc.setInputFormat(data);
        data = Filter.useFilter(data, disc);
        
        /**
         * 3.数据回归
         * (0) 取60%为训练集，40%为测试集
         */
        data.randomize(new Random(0));
		int trainSize = (int) Math.round(data.numInstances() * 0.60);
		int testSize = data.numInstances() - trainSize;
		Instances train = new Instances(data, 0, trainSize);
		Instances test = new Instances(data, trainSize, testSize);
        
		 /**
         * 3.数据回归
         * (1)随机森林(RandomForest)
         */
		 RandomForest rf = new RandomForest();				// train classifier
	     rf.buildClassifier(train);
	     Evaluation evaluation;
	     evaluation = new Evaluation(train);				// evaluate classifier and print some statistics
	     evaluation.evaluateModel(rf, test);
	     System.out.println(evaluation.toSummaryString("
======RandomForest : Results======
", false));
	     
	     /**
	      * 3.数据回归
	      * (2)神经网络(MultilayerPerceptron)
	      */
         MultilayerPerceptron mp = new MultilayerPerceptron();	// train classifier
         mp.buildClassifier(train);
       
         evaluation = new Evaluation(test);						// evaluate classifier and print some statistics
         evaluation.evaluateModel(mp, test);
         System.out.println(evaluation.toSummaryString("
======MultilayerPerceptron : Results======
", false));
         
         /**
	      * 3.数据回归
	      * (3)线性回归(LinearRegression)
	      */
         LinearRegression lr = new LinearRegression();		// train classifier
         lr.buildClassifier(train);
         
         evaluation = new Evaluation(train);				// evaluate classifier and print some statistics
         evaluation.evaluateModel(lr, test);
         System.out.println(evaluation.toSummaryString("
======LinearRegression : Results======
", false));
	}

}

3.基于Weka API的回归分析

(1)读取“配网抢修数据.csv”。

(2)数据预处理：

(a)将数值型字段规范化至[0,1]区间。
(b)调用特征选择算法（Select attributes），选择关键特征。
实验2：基于Weka的数据挖掘程序设计第9张

(3)分别调用随机森林（RandomForest）、神经网络（MultilayerPerceptron）、线性回归（LinearRegression）等算法的API对数据进行回归分析，取60%作为训练集。输出各算法的均方根误差（RMSE，Root Mean Squared Error）、相对误差（relative absolute error）与运行时间。

(a)随机森林（RandomForest）

实验2：基于Weka的数据挖掘程序设计第10张

(b)神经网络（MultilayerPerceptron）

实验2：基于Weka的数据挖掘程序设计第11张

(c)线性回归（LinearRegression）

实验2：基于Weka的数据挖掘程序设计第12张

4.基于Weka API的数据聚类

(1)读取“移动客户数据.tsv”（TAB符分隔列）。

(2)数据预处理：

(a)将数值型字段规范化至[0,1]区间。
(b)调用特征选择算法（Select attributes），选择关键特征。
实验2：基于Weka的数据挖掘程序设计第13张

(3)分别调用K均值（SimpleKMeans）、期望值最大化（EM）、层次聚类（HierarchicalClusterer）等算法的API对数据进行聚类，输出各算法的聚类质量与运行时间。聚类质量根据以下2个指标计算：

a)Silhouette指标

实验2：基于Weka的数据挖掘程序设计第14张

b)S_Dbw指标

运行结果如下：

(a)K均值（SimpleKMeans）

实验2：基于Weka的数据挖掘程序设计第15张
实验2：基于Weka的数据挖掘程序设计第16张

(b)期望值最大化（EM）

实验2：基于Weka的数据挖掘程序设计第17张
实验2：基于Weka的数据挖掘程序设计第18张

(c)层次聚类（HierarchicalClusterer）

java.lang.OutOfMemoryError: Java heap space

代码如下：

package weka;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Random;
import weka.attributeSelection.AttributeSelection;
import weka.attributeSelection.BestFirst;
import weka.attributeSelection.CfsSubsetEval;
import weka.classifiers.evaluation.Evaluation;
import weka.classifiers.functions.LinearRegression;
import weka.classifiers.functions.MultilayerPerceptron;
import weka.classifiers.trees.RandomForest;
import weka.clusterers.ClusterEvaluation;
import weka.clusterers.EM;
import weka.clusterers.HierarchicalClusterer;
import weka.clusterers.SimpleKMeans;
import weka.core.Attribute;
import weka.core.Instances;
import weka.core.Utils;
import weka.core.converters.ConverterUtils.DataSource;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.Discretize;
import weka.filters.unsupervised.attribute.Normalize;
import weka.filters.unsupervised.attribute.Remove;

/**
 * 	四、	基于Weka API的数据聚类
 * @author 西瓜不甜
 *
 */
public class Test_3 {

	
	
	public static void main(String[] args) throws Exception {
		/**
		 * 1.读取"移动客户数据表.tsv"
		 */
		// load file
	    Instances data = new Instances(new BufferedReader(new FileReader("C:\Users\西瓜不甜\Desktop\workspace\weka\移动客户数据表.arff")));
	    
	    
	    /**
	     * 2.数据预处理
	     * (1)删除无用属性
	     */
	    String[] options = new String[2];
	    options[0] = "-R";                                  // remove
	    options[1] = "1-4,72-73";                           		// SUM_MONTH、USER_ID、MSISDN、CUS_ID、MODEL_ID、LMODEL_ID
	    Remove remove = new Remove();                         
	    remove.setOptions(options);                          
	    remove.setInputFormat(data);                     	
	    data = Filter.useFilter(data, remove);   	  		// apply filter
	  
	    data.setClassIndex(data.numAttributes() - 1);  		// set class
	    
	    /**
         * 2.数据预处理
         * (2)归一化
         */
        Normalize norm = new Normalize();  
        norm.setInputFormat(data);  
        data = Filter.useFilter(data, norm);  
        
        /**
         * 2.数据预处理
         * (3)特征选择
         */
        AttributeSelection attSelect = new AttributeSelection();
        CfsSubsetEval eval = new CfsSubsetEval();
        BestFirst search = new BestFirst();
        attSelect.setEvaluator(eval);
        attSelect.setSearch(search);
        attSelect.SelectAttributes(data);
        
        int[] indices = attSelect.selectedAttributes();
        
        System.out.print("
 Select Attributes : starting with (0): " + Utils.arrayToString(indices) + '	');
        for (int i = 0; i <indices.length; i++) {
        	int index = indices[i];
        	Attribute attribute = data.attribute(index); 
        	System.out.print(attribute.name() + "	");
        }
        System.out.println();  
        
        
        /**
         * 3.数据聚类
         * (0)generate the class-less data to train the clusterer with(生成无类数据以训练聚类器)
         */
        Remove filter = new Remove();
        filter.setAttributeIndices("" + (data.classIndex() + 1));
        filter.setInputFormat(data);
        data = Filter.useFilter(data, filter);
        
        /**
         * 3.数据聚类
         * (1)K均值(SimpleKMeans)
         */
        long startTime, endTime;
        ClusterEvaluation evaluation;
        
        startTime = System.currentTimeMillis();
        
        SimpleKMeans kmeans = new SimpleKMeans();
        kmeans.buildClusterer(data);
        evaluation = new ClusterEvaluation();
        evaluation.setClusterer(kmeans);
        evaluation.evaluateClusterer(data);
        
        endTime = System.currentTimeMillis();
        
        System.out.println(" Runtime : " + (endTime - startTime) + "ms
");
        System.out.println(evaluation.clusterResultsToString());
        
        /**
         * 3.数据聚类
         * (2)期望值最大化(EM)
         * ps:运行时间约2h,谨慎运行。
         */
        
        startTime = System.currentTimeMillis();
        
        EM em = new EM();
        em.buildClusterer(data);
        evaluation = new ClusterEvaluation();
        evaluation.setClusterer(em);
        evaluation.evaluateClusterer(data);
        
        endTime = System.currentTimeMillis();
        
        System.out.println(" Runtime : " + (endTime - startTime) + "ms
");
        System.out.println(evaluation.clusterResultsToString());
        
        /**
         * 3.数据聚类
         * (3)层次聚类（HierarchicalClusterer）
         * ps:设到 8g 也还是不行
         */
        
        startTime = System.currentTimeMillis();
        
        HierarchicalClusterer hc = new HierarchicalClusterer();
        hc.buildClusterer(data);
        evaluation = new ClusterEvaluation();
        evaluation.setClusterer(hc);
        evaluation.evaluateClusterer(data);
        
        endTime = System.currentTimeMillis();
        
        System.out.println(" Runtime : " + (endTime - startTime) + "ms
");
        System.out.println(evaluation.clusterResultsToString());

	}
	
    
}

5.基于Weka API的关联规则分析

(1)读取“配网抢修数据.csv”。

(2)数据预处理：

(a)将数值型字段规范化至[0,1]区间。
(b)调用特征选择算法（Select attributes），选择关键特征。

(3)调用Apriori算法对数值型字段进行关联规则分析，输出不同置信度（confidence）下算法生成的规则集。

运行结果如下：

(a)置信度：0.9

实验2：基于Weka的数据挖掘程序设计第19张

(b)置信度：0.6

实验2：基于Weka的数据挖掘程序设计第20张

(c)置信度：0.4

实验2：基于Weka的数据挖掘程序设计第21张

代码如下：

package weka;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Random;
import weka.associations.Apriori;
import weka.attributeSelection.AttributeSelection;
import weka.attributeSelection.BestFirst;
import weka.attributeSelection.CfsSubsetEval;
import weka.classifiers.evaluation.Evaluation;
import weka.classifiers.functions.LinearRegression;
import weka.classifiers.functions.MultilayerPerceptron;
import weka.classifiers.trees.RandomForest;
import weka.core.Attribute;
import weka.core.Instances;
import weka.core.Utils;
import weka.core.converters.ConverterUtils.DataSource;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.Discretize;
import weka.filters.unsupervised.attribute.Normalize;
import weka.filters.unsupervised.attribute.NumericToNominal;
import weka.filters.unsupervised.attribute.Remove;

/**
 * 	五、基于Weka API的关联规则分析
 * @author 西瓜不甜
 *
 */
public class Test_4 {
	
	public static void useApriori(double confidence , Instances data) throws Exception {
		long startTime, endTime;
		
		startTime = System.currentTimeMillis();
		
		Apriori apriori = new Apriori();
		String[] options = new String[2];
        options[0] = "-C";
        options[1] = Double.toString(confidence);
        apriori.setOptions(options);
        apriori.buildAssociations(data);
        
        endTime = System.currentTimeMillis();
        System.out.println(" 
Runtime : " + (endTime - startTime) + "ms
");
        System.out.println(apriori);
	}
	
	public static void main(String[] args) throws Exception {


		/**
		 * 1.读取"配网抢修数据.csv"
		 */
		// load file
        Instances data = new Instances(new BufferedReader(new FileReader("C:\Users\西瓜不甜\Desktop\workspace\weka\配网抢修数据.arff")));
        
        
        /**
         * 2.数据预处理
         * (1)删除无用属性
         */
        String[] options = new String[2];
        options[0] = "-R";                                  // remove
        options[1] = "1-2";                           		// YMD（年月日）、REGION_ID（地区编号）
        Remove remove = new Remove();                         
        remove.setOptions(options);                          
        remove.setInputFormat(data);                     	
        data = Filter.useFilter(data, remove);   	  		// apply filter
        
      
        data.setClassIndex(data.numAttributes() - 1);  		// set class
        
        /**
         * 2.数据预处理
         * (2)归一化
         */
        Normalize norm = new Normalize();  
        norm.setInputFormat(data);  
        data = Filter.useFilter(data, norm);  
        
        /**
         * 2.数据预处理
         * (3)特征选择
         */
        AttributeSelection attSelect = new AttributeSelection();
        CfsSubsetEval eval = new CfsSubsetEval();
        BestFirst search = new BestFirst();
        attSelect.setEvaluator(eval);
        attSelect.setSearch(search);
        attSelect.SelectAttributes(data);
        
        int[] indices = attSelect.selectedAttributes();
        
        System.out.print("
 Select Attributes : starting with (0): " + Utils.arrayToString(indices) + '	');
        for (int i = 0; i <indices.length; i++) {
        	int index = indices[i];
        	Attribute attribute = data.attribute(index); 
        	System.out.print(attribute.name() + "	");
        }
        System.out.println();  
        

        /**
         * 2.数据预处理
         * (4) 类型转换
         */
        NumericToNominal nutono = new NumericToNominal();
        nutono.setInputFormat(data);
        data = Filter.useFilter(data, nutono);
        
        
        /**
         * 3.关联规则分析
         * 	置信度 0.9、0.6、0.4
         */
        useApriori(0.9 , data);
        useApriori(0.6 , data);
        useApriori(0.4 , data);
        
	}

}

标签：#大数据#数据挖掘算法#聚类分析#weka#数据挖掘#分类数据 | 浏览：625 | 发布日期：

免责声明：文章转载自《实验2：基于Weka的数据挖掘程序设计》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇VS2019 技巧SQLAlchemy技术文档（中文版）-上下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

大数据测试总结

前言        随着各个国家使用大数据应用程序或应用大数据技术场景的数量呈指数增长，相应的，对于测试大数据应用时所需的知识与大数据测试工程师的需求也在同步增加。医疗、能源、通信、零售业、金融、体育等各行业都可以从其数据的采集、传输、存储、分析等各个环节产生巨大的经济价值，马爸爸认为，未来的时代将不是IT时代，而是DT的时代，即Data Technolo...

cmd黑窗口查询数据库中数据时中文乱码

1.打开cmd窗口，输入show variables like 'character_set_%'; 2.因为操作系统是中文操作系统，默认使用的字符集是GB2312，所以需要把输出窗口使用的字符编码改成gb2312才能够正常显示中文。 使用如下的命令设置输出窗口使用的字符编码：set character_set_results=gb2312;...

如何用R来处理数据表的长宽转换（图文详解）

不多说，直接上干货！ 很多地方都需用到这个知识点，比如Tableau里。 通常可以采取如python 和 r来作为数据处理的前期。 Tableau学习系列之Tableau如何通过数据透视表方式读取数据文件（图文详解）如何用Python来处理数据表的长宽转换（图文详解） 数据长宽转换是很常用的需求，特别是当是从Excel中导入的汇总表时，常常需要转换成一维表...

Pandas日期数据处理：如何按日期筛选、显示及统计数据

对于我们宽客相对重要一些，在本地实现回测和交易的宽客，需要自己清洗数据。 而证券行情数据是时间序列数据，和时间索引又分不开，下面这篇文章，帮助我们更好的使用pandas处理和日期时间相关的数据。 该文引自：http://www.mamicode.com/info-detail-1822406.html ---------------------------...

根据查询条件批量修改表数据

--表：table  --字段：columsA、columsB、columsC、columsD void Main(){ string sql="select columsA from table"; DataTable dt=SqlHelper.executeQuery(sql); dt.rows[0]["columsA"]="111"; sdaUpda...

tp5 高效率随机抽取数据(不重复)

public function getRandTable(){ $num = 5; //需要抽取的默认条数 $table = 't_marclog'; //需要抽取的数据表 $countcus = Db::name($table)->count(); //获取总记录数 $min = Db::name(...

最新文章

随机推荐

思享工具箱导航