Apache Spark：Mllib之决策树的操作(java)

最新推荐文章于 2023-09-21 08:34:47 发布
最新推荐文章于 2023-09-21 08:34:47 发布
阅读量469 收藏 1
点赞数 1
分类专栏： Apache Spark 文章标签： spark java apache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45492007/article/details/120251274
版权

当前版本：spark 2.4.6

1. 声明

当前内容主要用于本人学习Spark ML的知识，了解决策树和决策森林，当前内容主要参考Spark高级数据分析的第4章用决策树算法预测森林植被，由于原内容使用scala编写，这里转换为java方式实现

数据准备：数据下载地址

抽掉最后两行数据作为预测数据

2384,170,15,60,5,90,230,245,143,864,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3
2383,165,13,60,4,67,231,244,141,875,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3

2.主要代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.spark.SparkConf;
import org.apache.spark.SparkContext;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.mllib.regression.LabeledPoint;
import org.apache.spark.mllib.linalg.Matrix;
import org.apache.spark.mllib.linalg.Vector;
import org.apache.spark.mllib.linalg.Vectors;
import org.apache.spark.mllib.evaluation.MulticlassMetrics;
import org.apache.spark.mllib.tree.DecisionTree;
import org.apache.spark.mllib.tree.RandomForest;
/*import org.apache.spark.mllib.regression.LabeledPoint;*/
import org.apache.spark.mllib.tree.model.DecisionTreeModel;
import org.apache.spark.mllib.tree.model.RandomForestModel;
import org.apache.spark.rdd.RDD;

import scala.Tuple2;

/**
 * 
 * @author hy
 * @createTime 2021-09-11 08:26:26
 * @description 当前内容主要为使用spark科学数据分析中的决策树类型
 * 1. 决策树
 * 2. 决策森林
 *
 */
public class DecisionTreeTest {
	public static void main(String[] args) {
		SparkConf conf = new SparkConf().setMaster("local").setAppName("test");
		JavaSparkContext jsc = new JavaSparkContext(conf);
		jsc.setLogLevel("WARN");
		// operation
		decisionTreeTest(jsc);
		jsc.close();
	}
	
	/**
	 * 
	 * @author hy
	 * @createTime 2021-09-11 12:53:01
	 * @description 将数据都放入，做出决策
	 * @param rawData
	 * @return
	 *
	 */
	private static JavaRDD<LabeledPoint> createLabeledPointDataUsingBefore(JavaRDD<String> rawData) {
		JavaRDD<LabeledPoint> data = rawData.map(new Function<String, LabeledPoint>() {

			@Override
			public LabeledPoint call(String v1) throws Exception {
				String[] strings = v1.split(",");
				double[] values = new double[strings.length];
				for (int i = 0; i < strings.length; i++) {
					values[i] = Double.valueOf(strings[i]);
				}
				double[] noLastNumValues = Arrays.copyOf(values, values.length - 1);
				Vector featureVector = Vectors.dense(noLastNumValues);
				// 最后一个值就是lable ,但是必须比7小(表示的就是类别)
				double label = values[values.length-1] - 1;
				// 决策树要求当前的label从0开始
				LabeledPoint labeledPoint = new LabeledPoint(label,featureVector);
				return labeledPoint;
			}
		});
		return data;
	}
	
	private static int indexOfArray(double[] array,double findValue) {
		int index = -1;
		for (int i = 0; i < array.length; i++) {
			if(findValue==array[i]) {
				index=i;
				break;
			}
		}
		return index;
	}
	
	/**
	 * 
	 * @author hy
	 * @createTime 2021-09-11 13:45:03
	 * @description 使用类型方式
	 * @param rawData
	 * @return
	 *
	 */
	private static JavaRDD<LabeledPoint> createLabeledPointDataUsingType(JavaRDD<String> rawData) {
		JavaRDD<LabeledPoint> data = rawData.map(new Function<String, LabeledPoint>() {

			@Override
			public LabeledPoint call(String v1) throws Exception {
				String[] strings = v1.split(",");
				double[] values = new double[strings.length];
				for (int i = 0; i < strings.length; i++) {
					values[i] = Double.valueOf(strings[i]);
				}
				
				/*
				 * // 得到类型特征：荒地 double[] wildernessValues = Arrays.copyOfRange(values, 10, 14);
				 * double wilderness =indexOfArray(wildernessValues,1.0);
				 * 
				 * // 得到类型特征：土壤 double[] soilValues = Arrays.copyOfRange(values, 14, 54); double
				 * soil =indexOfArray(soilValues,1.0);
				 * 
				 * double[] copyOfRange = Arrays.copyOfRange(values, 0, 10); double[] copyOf =
				 * Arrays.copyOf(copyOfRange, copyOfRange.length+2);
				 * copyOf[copyOf.length-2]=wilderness; copyOf[copyOf.length-1]=soil;
				 */
				
				Vector featureVector = createVectorByLiine(v1);
				// 最后一个值就是lable ,但是必须比7小(表示的就是类别)
				double label = values[values.length-1] - 1;
				// 决策树要求当前的label从0开始
				LabeledPoint labeledPoint = new LabeledPoint(label,featureVector);
				return labeledPoint;
			}
		});
		return data;
	}
	
	
	/**
	 * 
	 * @author hy
	 * @createTime 2021-09-12 08:12:23
	 * @description 将给定的line数据转换为向量数据
	 * @param line
	 * @return
	 *
	 */
	private static Vector createVectorByLiine(String line) {
		String[] strings = line.split(",");
		double[] values = new double[strings.length];
		for (int i = 0; i < strings.length; i++) {
			values[i] = Double.valueOf(strings[i]);
		}
		
		// 得到类型特征：荒地
		double[] wildernessValues = Arrays.copyOfRange(values, 10, 14);
		double wilderness =indexOfArray(wildernessValues,1.0);
		
		// 得到类型特征：土壤
		double[] soilValues = Arrays.copyOfRange(values, 14, 54);
		double soil =indexOfArray(soilValues,1.0);
		
		double[] copyOfRange = Arrays.copyOfRange(values, 0, 10);
		double[] copyOf = Arrays.copyOf(copyOfRange, copyOfRange.length+2);
		copyOf[copyOf.length-2]=wilderness;
		copyOf[copyOf.length-1]=soil;
		
		Vector featureVector = Vectors.dense(copyOf);
		return featureVector;
	}

	private static void decisionTreeTest(JavaSparkContext jsc) {
		JavaRDD<String> rawData = jsc.textFile("C:\\Users\\admin\\Desktop\\mldata\\covtype.data");
		JavaRDD<LabeledPoint> data = createLabeledPointDataUsingType(rawData);

		// map.foreach(x->System.out.println(x));

		// 开始准备训练数(训练数据占80%，交叉检验集和测试集各占10%)
		JavaRDD<LabeledPoint>[] randomSplit = data.randomSplit(new double[] { 0.8, 0.1, 0.1 });

		JavaRDD<LabeledPoint> trainData = randomSplit[0];
		JavaRDD<LabeledPoint> cvData = randomSplit[1];
		JavaRDD<LabeledPoint> testData = randomSplit[2];
		trainData.cache();
		cvData.cache();
		testData.cache();

		// 创建决策树模型(对于具有不同类型的使用trainClassfier,对于使用数值类型使用trainRegressor)
		HashMap<Integer,Integer> hashMap = new HashMap<Integer, Integer>();
		// 4表示最大深度，100表示桶的数量，7 表示集中目标取值的个数，map保存类型特征信息
		// gini代表一种不纯度(不纯度有两种一种是gini另外一种就是熵)
		DecisionTreeModel model = DecisionTree.trainClassifier(trainData, 7, hashMap, "gini", 4, 100);
		// 使用决策森林模型(太慢了)
		//RandomForestModel model = createDecisionRandomForest(trainData);
		
		MulticlassMetrics metrics = getMetrics(model, cvData);
		Matrix confusionMatrix = metrics.confusionMatrix();
		System.out.println(confusionMatrix);
		
		// 下面两个都是准确度，结果是一样的
		System.out.println("准确度："+metrics.accuracy());	
		System.out.println("精确度："+metrics.precision());
		
		// 计算每个类别对其他的精确度
		List<Tuple2<Double,Double>> list=new ArrayList<>();
		for (int i = 0; i < 7; i++) {
			Tuple2<Double, Double> tuple2 = new Tuple2<Double,Double>(metrics.precision(i),metrics.recall(i));
			list.add(tuple2);
		}
		
		System.out.println("输出与其他对比精度：");
		list.forEach(x->{System.out.println(x);});
		
		Double[] trainProbablilities = classProbablilities(testData);
		Double[] cvProbablilities = classProbablilities(cvData);
		
		double sum=0.0;
		for (int i = 0; i < cvProbablilities.length; i++) {
			sum +=cvProbablilities[i]*trainProbablilities[i];
		}
		System.out.println("准确的评估值："+sum);
		
		
		// 计算并获取确定的决策树调优参数(该模型通过设置使用不同的不纯度和桶数量以及决策树的深度方式来实现的，一般是通过循环方式找到最准确度最高的模型进行对testData进行测试)
		DecisionTreeModel newModel = DecisionTree.trainClassifier(trainData.union(cvData), 7, hashMap, "entropy", 20, 300);
		MulticlassMetrics newMetrics = getMetrics(newModel, testData);
		double accuracy = newMetrics.accuracy();
		System.out.println("优化后的决策树对cvData的准确度："+accuracy);
		
		
		// 决策森林的预测
		/* String input="2709,125,28,67,23,3224,253,207,61,4094,0,29"; */
		// 决策树的预测
		String[] lines= {"2384,170,15,60,5,90,230,245,143,864,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3" ,
				"2383,165,13,60,4,67,231,244,141,875,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3"};
		for (int i = 0; i < lines.length; i++) {
			String line = lines[i];
			Vector vector = createVectorByLiine(line);
			double predict = newModel.predict(vector);
			System.out.println("预测结果为："+predict);//预测后的标签为2.0，实际需要+1所以预测结果是正确的
		}
		
	}
	
	
	/**
	 * 
	 * @author hy
	 * @createTime 2021-09-11 13:50:08
	 * @description 创建决策森林
	 *
	 */
	private static RandomForestModel createDecisionRandomForest(JavaRDD<LabeledPoint> trainData) {
		Map<Integer, Integer> hashMap=new HashMap<>();
		hashMap.put(10, 4);
		hashMap.put(11, 40);
		// 20 表示构建20个决策树，20分钟都没有执行完毕
		RandomForestModel randomForestModel = RandomForest.trainClassifier(trainData, 7, hashMap, 20, "auto","entropy",30,300, 10);
		return randomForestModel;
	}

	// 计算该类型在所占的比例
	private static Double[] classProbablilities(JavaRDD<LabeledPoint> data) {
		Map<Double, Long> countByValue = data.map(x->x.label()).countByValue();
		List<Tuple2<Double,Long>> counts=new ArrayList<>();
		Long sum = 0L;
		for (Entry<Double, Long> entry : countByValue.entrySet()) {
			counts.add(new Tuple2<Double, Long>(entry.getKey(), entry.getValue()));
			sum+=entry.getValue();
		}
		//System.out.println("sum==>"+sum);
		//System.out.println(counts);
		counts.sort(new Comparator<Tuple2<Double, Long>>() {

			@Override
			public int compare(Tuple2<Double, Long> o1, Tuple2<Double, Long> o2) {
				// TODO Auto-generated method stub
				return (int)(o1._1-o2._1);
			}
		});
		Double[] returnValues=new Double[counts.size()];
		for (int i = 0; i < returnValues.length; i++) {
			returnValues[i]=counts.get(i)._2/(sum*1.0);
		}
		//System.out.println(Arrays.toString(returnValues));
		return returnValues;
		
	}
	
	private static MulticlassMetrics getMetrics(DecisionTreeModel model, JavaRDD<LabeledPoint> data) {
		RDD<Tuple2<Object, Object>> rdd = data.map(new Function<LabeledPoint, Tuple2<Object, Object>>() {

			@Override
			public Tuple2<Object, Object> call(LabeledPoint example) throws Exception {
				double predict = model.predict((org.apache.spark.mllib.linalg.Vector) example.features());
				return new Tuple2<Object, Object>(predict, example.label());
			}
		}).rdd();

		return new MulticlassMetrics(rdd);

	}
	
	private static MulticlassMetrics getMetrics(RandomForestModel model, JavaRDD<LabeledPoint> data) {
		RDD<Tuple2<Object, Object>> rdd = data.map(new Function<LabeledPoint, Tuple2<Object, Object>>() {
			@Override
			public Tuple2<Object, Object> call(LabeledPoint example) throws Exception {
				double predict = model.predict( example.features());
				return new Tuple2<Object, Object>(predict, example.label());
			}
		}).rdd();

		return new MulticlassMetrics(rdd);

	}
}

3. 测试结果

13611.0  7091.0   14.0    0.0  0.0   0.0  326.0   
5215.0   22528.0  532.0   0.0  8.0   0.0  39.0    
0.0      372.0    3255.0  0.0  0.0   0.0  0.0     
0.0      0.0      293.0   0.0  0.0   0.0  0.0     
0.0      913.0    33.0    0.0  12.0  0.0  0.0     
0.0      464.0    1265.0  0.0  0.0   0.0  0.0     
1064.0   25.0     0.0     0.0  0.0   0.0  1051.0  
准确度：0.6962020959887113
精确度：0.6962020959887113
输出与其他对比精度：
(0.6843137254901961,0.6468491588252068)
(0.7176122065428598,0.7954240519737307)
(0.6036721068249258,0.8974358974358975)
(0.0,0.0)
(0.6,0.012526096033402923)
(0.0,0.0)
(0.742231638418079,0.4911214953271028)
准确的评估值：0.37602803637168397
优化后的决策树对cvData的准确度：0.9208749848932166
预测结果为：2.0
预测结果为：2.0

这里本来有决策森林，但是由于决策森林很耗时间(对于单台电脑)，所以没有执行操作

预测结果为2.0，这个结果就是label，实际上要+1，所以和上面的是对应的

4. 总结

1. SparkML在进行计算的时候需要Vector向量数据(特征向量)和label数据

2. 通过创建不同的参数模型，来对测试数据进行测试，得到最终的准确度，通过准确度来展现模型的正确性

3. 模型的准确性和输入的参数有关

4. 不明白当前数据向量的获取和定义方式

编程写手
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Apache Spark MLlib
禅与计算机程序设计艺术
06-05 996
Apache Spark MLlib 1.背景介绍 在当今的数据时代,机器学习(Machine Learning)已经成为各行各业不可或缺的核心技术。Apache Spark作为一款开源的大数据处理引擎,其机器学习库MLlib为数据科学家和机器学习工程师提供了强大的工具集,用于构建可扩展
java mllib 算法_決策樹算法原理及Spark MLlib調用實例（Scala/Java/python）
weixin_42613360的博客
02-24 111
決策樹算法介紹：決策樹以及其集成算法是機器學習分類和回歸問題中非常流行的算法。因其易解釋性、可處理類別特征、易擴展到多分類問題、不需特征縮放等性質被廣泛使用。樹集成算法如隨機森林以及boosting算法幾乎是解決分類和回歸問題中表現最優的算法。決策樹是一個貪心算法遞歸地將特征空間划分為兩個部分，在同一個葉子節點的數據最后會擁有同樣的標簽。每次划分通過貪心的以獲得最大信息增益為目的，從可選擇的分裂方...
SparkMLlib Java 决策树分类算法(DecisionTree)
Spider_Black的博客
07-07 1510
我们在实际应用开发时，需整合各个模块的代码，使其粘合在一起，而Java就是最好的粘合工具，此篇文章中，介绍了SparkMLlib的决策树，使用java开发做分类。
Java应用|使用Apache Spark MLlib构建机器学习模型【下】
小易
09-21 652
如果您觉得本博客的内容对您有所帮助或启发，请关注我的博客，以便第一时间获取最新技术文章和教程。同时，也欢迎您在评论区留言，分享想法和建议。
Apache Spark 3.0 机器学习库（MLlib）指南
纸上得来终觉浅，绝知此事要躬行
09-06 1841
学习地址：https://spark.apache.org/docs/latest/ml-guide.html 学习目录 MLlib：主要指南 基本统计 数据源 流水线 提取，转换和选择特征 分类与回归 聚类 协同过滤 频繁模式挖掘 模型选择和调整 进阶主题 MLlib：基于RDD的API指南 资料类型 基本统计 分类与回归 协同过滤 聚类 降维 特征提取和转换 频繁模式挖掘 评估指标 PMML模型导出 优化（开发人员） 机器学习库（MLlib）指南 ..
spark mlib java_如何在Java应用里集成Spark MLlib训练好的模型做预测
weixin_29536515的博客
02-13 425
前言昨天媛媛说，你是不是很久没写博客了。我说上一篇1.26号，昨天3.26号，刚好两个月，心中也略微有些愧疚。今天正好有个好朋友问，怎么在Java应用里集成Spark MLlib训练好的模型。在StreamingPro里其实都有实际的使用例子，但是如果有一篇文章讲述下，我觉得应该能让更多人获得帮助追本溯源记得我之前吐槽过Spark MLlib的设计，也是因为一个朋友使用了spark MLlib的p...
java mllib 算法_决策树回归算法介绍及Spark MLlib调用实例（Scala/Java/python）
weixin_39952190的博客
02-24 254
决策树回归算法介绍：决策树以及其集成算法是机器学习分类和回归问题中非常流行的算法。因其易解释性、可处理类别特征、易扩展到多分类问题、不需特征缩放等性质被广泛使用。树集成算法如随机森林以及boosting算法几乎是解决分类和回归问题中表现最优的算法。决策树是一个贪心算法递归地将特征空间划分为两个部分，在同一个叶子节点的数据最后会拥有同样的标签。每次划分通过贪心的以获得最大信息增益为目的，从可选择的分...
决策树（java）variance 回归.zip_c4.5_mllib_决策树
09-20
在Java编程环境下，我们可以利用各种库来实现决策树模型，如Apache Spark的MLlib库。本篇将详细介绍如何使用MLlib库中的C4.5决策树算法进行回归分析。 C4.5是决策树算法的一种改进版本，由Ross Quinlan提出，相比ID...
毕业设计：基于sparkMLlib的森林植被类型预测分类系统.zip
最新发布
09-26
标题中的“毕业设计：基于sparkMLlib的森林植被类型预测分类系统”表明这是一个关于机器学习的项目，使用了Apache Spark的MLlib库进行森林植被类型的预测分类。在本项目中，开发者可能利用了数据挖掘技术，对森林...
spark-java-text-classifier:Apache Spark文本分类示例
05-22
3. 选择模型：Spark MLlib 提供了多种机器学习模型，如朴素贝叶斯（Naive Bayes）、支持向量机（SVM）、决策树（Decision Tree）和随机森林（Random Forest）等，它们都可以用于文本分类。开发者需要根据数据特性和...
bigbench-ml:使用Spark MLlib实现BigBench机器学习逻辑
05-20
例如，使用MLlib的预处理功能进行数据清洗和标准化，使用分类算法如逻辑回归或决策树进行预测，使用聚类算法如K-means进行数据分组，以及使用协同过滤进行推荐系统建模。 三、Spark MLlib的关键算法 1. **分类**：...
spark-mllib_2.10-1.0.0.zip
10-11
在Spark MLlib中，分类算法包括逻辑回归、决策树、随机森林和梯度提升机等，这些算法广泛应用于预测分析中。回归算法如线性回归和岭回归则用于预测连续数值。聚类算法如K-Means和Gaussian混合模型用于无监督学习，...
【算法】顺时针旋转矩阵
LeonJin的博客
10-15 1062
有一个NxN整数矩阵，请编写一个算法，将矩阵顺时针旋转90度。 给定一个NxN的矩阵，和矩阵的阶数N,请返回旋转后的NxN矩阵,保证N小于等于300。 测试样例： [[1,2,3],[4,5,6],[7,8,9]],3 返回：[[7,4,1],[8,5,2],[9,6,3]] 这是一道发现规律的题目，规律很简单 import java.util.*; public class Rotate { public int[][] rotateMatrix(int[][] A, ..
关于spark的mllib学习总结（Java版）
hellozhxy的博客
08-20 1898
本篇博客主要讲述如何利用spark的mliib构建机器学习模型并预测新的数据，具体的流程如下图所示：  加载数据 对于数据的加载或保存，mllib提供了MLUtils包，其作用是Helper methods to load,save and pre-process data used in MLLib.博客中的数据是采用spark中提供的数据sample_libsvm_data.txt，其有一...
SparkMLlib Java 朴素贝叶斯分类算法(NaiveBayes)
Spider_Black的博客
07-07 2533
本文章主要介绍SparkMLlib，使用Java开发，Java语言可以更好的粘合各个板块。在做大数据软件之类的开发中，会经常使用Java开发Spark。
基于Spark Mllib, 使用java api操作的电影推荐系统(spark1.5.2 jdk1.7)
Carson的专栏
02-10 700
最近在学习Spark Mllib，看了一些它的算法，但不知道算法怎么去应用，网上的实例大部分都是使用Scala语言写的，没有java的代码，从网上找到了一篇基于Spark Mllib，SparkSQL的电影推荐系统 也是使用Scala语言（对其不是很了解，暂时也没有多少时间去学），还好他讲得特别细，关于测试数据他都有下载地址，在这就不多说了。直接把由其改写的java代码附上： maven依赖如下...
mllib java怎么调用_如何准备mllib中的训练数据
weixin_42505792的博客
02-26 128
ML LogisticRegression 尚不支持多项分类，但MLLib NaiveBayes 和 LogisticRegressionWithLBFGS 都支持它 . 在第一种情况下，它应该默认工作：import org.apache.spark.mllib.classification.NaiveBayesval nbModel = new NaiveBayes().setModelTy...
SparkMLlib入门：机器学习与SparkMLlib详解
SparkMLlib是Apache Spark中的一个强大模块，专注于机器学习和数据挖掘，它是构建在Spark分布式计算框架之上的工具集。本资源主要针对Spark MLlib的入门和深入理解，包括机器学习的基本概念、SparkMLlib的架构解析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值