Spark MLlib机器学习库-Adult数据集实例上手

最新推荐文章于 2023-06-25 11:30:24 发布

阿福的小书斋

最新推荐文章于 2023-06-25 11:30:24 发布

阅读量1.4k

点赞数 3

分类专栏：大数据开发机器学习文章标签：机器学习 spark-ml pandas spark python

本文链接：https://blog.csdn.net/thuink/article/details/130965273

版权

大数据开发同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

机器学习

1 篇文章 0 订阅

订阅专栏

Spark MLlib机器学习库-Adult数据集实例上手（Python）

数据集Adult介绍

数据集下载：https://archive.ics.uci.edu/ml/machine-learning-databases/adult/
数据集介绍：数据从美国 1994 年人口普查数据库抽取而来，包含有关 48,000 个人及其年收入的信息,可用来预测居民收入是否超过 50K $/ ye a r 。因此可以将问题表述为二元分类。该数据集类变量为年收入是否超过 50 k$ ，属性变量包含年龄、工种、学历、职业、人种等重要信息，值得一提的是，14 个属性变量中有 7 个类别型变量。
数据集要求：增加adult.data后缀，改为adult.data.csv。
数据集表头信息：[age,workclass,fnlwgt,education,education-num,marital-status,occupation,relationship,race,sex,capital-gain,capital-loss,hours-per-week,native-country,income];
(age)年龄（整型）
(workclass)工作分类（字符串）
(fnlwgt)在一个州内，其它渠道观测代表的人数（整型）
(education)教育程度（字符串）
(education-num)受教育时间（整型）
(marital-status)婚姻状态（字符串）
(occupation)职业类型(字符串)
(relationship)关系(字符串)
(race)种族(字符串)
(sex)性别(字符串)
(capital-gain)税收(整型)
(capital-loss)资本损失(整型)
(hours-per-week)每周工作时长(整型)
(native-country)国籍(字符串)
(income)标签(字符串)：[<=50k,>50k]
数据集示例：

在这里插入图片描述

2. 实验内容和要求

使用 Spark MLlib 的二元分类对同一数据集进行分类，这些二元分类包括逻辑回归、KNN、随机森林、朴素贝叶斯、决策树、梯度提升树、多层感知器、线性支持向量机、One-vs-Rest等9个模型，然后评估每个方法的结果并比较这些二元分类法的性能。
以 Logistic Regression 为例，它比线性回归多一步：应用 sigmoid 函数将输出值压缩到 0~1 并与阈值比较，看看它应该属于哪个cluster。线性回归输出连续值，而逻辑回归输出 0 到 1 范围内的概率，然后可以将其映射到两个或多个离散类。你可以在此处了解更多详细信息，例如 Spark 如何执行优化（https://spark.apache.org/docs/latest/mllib-linear-methods.html）。
通过该数据集，调用Spark MLlib机器学习库中的包进行训练预测，学习Spark MLlib库的使用。
分析各个模型的准确性结果，并给予评估，实践机器学习算法

3. 实验平台

系统：Windows 10 x64，Ubuntu 64
系统平台：虚拟机，条件已完成Spark和Hadoop的环境搭建
平台：Spark3.1.2，Hadoop3.1.2
语言：Python
依赖包：pyspark3.1.2，pandas，numpy，sklearn（机器学习算法补充包）

4. 实验步骤

Step 1: 数据加载

通过数据集示例可以发现：数据集中无表头信息需要仔细再创建dataframe的时候添加表头信息

通过Spark自带语言对csv文件进行读取:spark.read.csv()

示例代码：

from pyspark.sql import SparkSession
from pyspark.ml.classification import *
from pyspark.ml.evaluation import *
from pyspark.ml import Pipeline
from pyspark.ml.feature import OneHotEncoder, StringIndexer, VectorAssembler, StandardScaler
from pyspark.sql.types import *
import pandas as pd
import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from pyspark.sql.functions import *

# 创建SparkSession
spark = SparkSession.builder \
    .appName("Data Processing") \
    .getOrCreate()

# 从文件中读取数据并创建DataFrame，将文件路径修改为你的路径
data = spark.read.csv("file:///root/Spark_MLlib_len/Filestorage/adult.data.csv", header=False, inferSchema=True)

# 定义列名列表
column_names = ["age", "workclass", "fnlwgt", "education", "education-num",
                "marital-status", "occupation", "relationship", "race", "sex", "capital-gain",
                "capital-loss", "hours-per-week", "native-country", "income"]
# 使用toDF方法添加列名
data = data.toDF(*column_names)

至此，我们已经读取了数据集并创建了有表头信息的dataframe，接下来是简单的预处理

Step 2: 数据预处理

首先，我们需要观察数据集，理解每个数据集对于预测目标的实际意义是什么来进行判断其价值

通过对数据列值的属性意义以及对income收入的认识，还有对数据集的观察可以发现：

数据集中的确实值都是以” ？“的形式出现
“captital-gain”,”capital-loss”这两列的数据显示有百分之七十以上的记录都是0，可能是因为样本中有很多年龄较小的人，那这两列数据对训练和预测的实际效果是很低效的，考虑到降低计算量，可以选择不处理它们
fnlwgt的意义不明确，好像说是在一个州内类似的人群数量，这个对样本的预测可以说没啥作用
另外education数据列和数值型数据education-num所表达的意义其实是相同的，基本上都是说样本的教育程度如何，因此可以将education数据列去除

在以上的基础上开始数据预处理，由于spark的dataframe和pandas的dataframe对象有区别，spark的dataframe对象中缺少一些我习惯使用的pandas&dataframe的处理方法，所以需要对其进行转换

空值处理（用每列的众数进行填充）：

#数据集预处理
data0 = data.toPandas()
#将数据集中的？，控制替换为None，同时将收入标签改为1，0
# 将'?'替换为None
data0 = data0.replace(" ?",np.nan)
# 将'>50K'替换为1，'<=50K'替换为0
data0['income'] = data0['income'].replace(' <=50K', 0).replace(' >50K', 1)
#将离散数据集中的缺失值替换为相应的众数提高准确率，其中离散数据列已经剔除前面所言的四列
categorical_cols = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'native-country', 'income']
for col_name in categorical_cols:
    mode_value = data0[col_name].mode()[0]  # 计算众数
    data0[col_name] = data0[col_name].fillna(mode_value)  # 替换缺失值为众数
#在实际观察数据集时，发现"capital-gain", "capital-loss"有百分之七十以上的记录都为0，因此为了减少计算量、
#将这两列数据去除，同时fnlwgt的意义不明，对预测的影响不大，也进行去除,education数据列和数值型数据education-num所表达的意义相同也删除
data0 = data0.drop(["capital-gain", "capital-loss","fnlwgt","education"], axis = 1)

Step 3: 数据转化

这一步里面我们要根据不同的模型需求进行数据的转换，这一步我自己做到不太好

有的模型需要进行独热编码，并创建特征向量添加到数据集中，有的模型则不需要这些，只需要进行对分类变量转化为数值变量即可

这里需要将pandas的dataframe重新转换为spark 的dataframe

#数据转化
# 非数值型特征列名
categorical_cols = ['workclass', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'native-country']
#数值型特征列名
numeric_cols = ["age", "education-num", "hours-per-week"]
#转换为spark的dataframe对象
value = data0.values.tolist()
column = list(data0.columns)
data = spark.createDataFrame(value,column)
#可以通过data.info()查看表信息，data.show()查看示例数据
#创建StringIndexer对象将分类变量转换为数值变量
indexers = [StringIndexer(inputCol=col, outputCol=col+"_index", handleInvalid="keep")
            for col in categorical_cols]
#将转化好的数值变量添加到数据集中
pipeline = Pipeline(stages=indexers)
data = pipeline.fit(data).transform(data)
indexers_col = ['workclass_index', 'marital-status_index', 'occupation_index', 'relationship_index', 'race_index', 'sex_index', 'native-country_index']
# 使用OneHotEncoder对分类变量进行独热编码
encoder = [OneHotEncoder(inputCols=[indexer.getOutputCol()], outputCols=[indexer.getOutputCol() + "_encoded"]) for indexer in indexers]
#将转化好的vector变量添加到数据集中，注意，有些模型不需要这样做
pipeline = Pipeline(stages=encoder)
data = pipeline.fit(data).transform(data)
encoder_col = ['workclass_index_encoded', 'marital-status_index_encoded', 'occupation_index_encoded', 'relationship_index_encoded', 'race_index_encoded', 'sex_index_encoded', 'native-country_index_encoded']

# 根据自身需求将有用的特征列组合为一个特征向量
assembler = VectorAssembler(inputCols=[encoder[i].getOutputCols()[0] for i in range(len(encoder))] + numeric_cols,
                            outputCol="features")#这里我用的是独热编码后的数据列和数值型变量，有些模型只需要数值化后的变量和数值型变量就可以了，请根据需求进行调整
#将特征向量添加到数据集中，有些模型需要有些不需要
data = assembler.transform(data)# #梯度提升树?决策树?多层感知器。这些是需要这么做的模型

#接下来的代码时根据情况删除不相关的列，也是看个人需求。
for col_name in categorical_cols:
    data = data.drop(col_name)#data数据是只删除了分类变量，保留了独热编码的vector和转化的数值型变量
data1 = data.select("*")
data2 = data.select("*")
for col_name in encoder_col:
    data2 = data2.drop(col_name)#去掉独热编码，只有数值变量
for col_name in indexers_col:
    data1 = data1.drop(col_name)#去掉没用的数值型列，只有原始的数值变量和都热编码后的vector变量

# 划分数据集为训练集和测试集，请根据模型的需求修改data2、data、data3
trainData, testData = data2.randomSplit([0.7, 0.3], seed=100)

Step 4: 模型介绍和实例

在本实验中，我们将使用以下模型进行训练：逻辑回归、KNN、随机森林、朴素贝叶斯、决策树、梯度提升树、多层感知器、线性支持向量机、One-vs-Rest。可能强扭的瓜不甜，有些预测结果不尽人意，不过我对预测的准确性没那么高要求，各位可以自己提高数据集的质量！！！

逻辑回归：逻辑回归是一种广泛使用的分类算法，它通过拟合数据集中的数据，学习如何将输入变量映射到一个二进制输出（二元分类）或多个输出（多元分类）。与线性回归不同，逻辑回归的输出是二进制或多元分类值。
KNN：KNN是一种基于实例的学习算法。它根据与新实例相似的训练示例的K个最近邻居来预测新实例的标签。K值通常是用户定义的，可以根据数据集的大小和特征数量进行调整，以找到最佳预测效果。
随机森林：随机森林是一种集成学习算法，它通过同时训练多个决策树来提高预测精度。它创建多个决策树，并使用随机样本和随机特征来训练每个决策树。最后，它使用这些决策树来预测新的输入。
朴素贝叶斯：朴素贝叶斯是一种基于概率统计的学习算法。它利用贝叶斯定理来预测给定输入的标签。它的假设是输入变量独立于彼此，并且每个变量对于给定标签的贡献相同。它被广泛应用于文本分类和垃圾邮件过滤等领域。
决策树：决策树是一种基于树形结构的分类算法，它通过一系列问题将数据集分成许多小的子集，最后将每个子集分类为同一类。每个子集都由一个终止节点表示。决策树易于解释，并且对于具有离散输入变量的数据集非常有效。
梯度提升树：梯度提升树是一种增强学习算法，它通过逐步改进弱分类器的预测结果来构建更强的分类模型。它反复训练一个弱分类器，生成残差，并将残差作为下一个弱分类器的训练集。最终，通过将所有的分类器组合在一起来获得最终的预测结果。
多层感知器：多层感知器是一种基于神经网络的分类算法。它使用多个神经元层来处理数据，并使用反向传播算法来优化网络的权重值。多层感知器通常用于大型数据集上的分类问题。
线性支持向量机：线性支持向量机是一种广泛使用的分类算法，它通过将输入空间的数据点转化为高维空间来寻找输入变量之间的最佳超平面来分离数据。该算法的优点是在处理高维数据集时非常有效，但它通常无法处理非线性问题。
One-vs-Rest：One-vs-Rest是一种用于多类分类的算法，它将多类分类转换为若干个二分类问题，并使用二分类分类器来处理这些问题。它适用于适用于大多数通用分类器，如逻辑回归、支持向量机、随机森林等

Step 5: 不同模型建模训练并预测

逻辑回归模型：（如果无法运行请调整训练集和测试集的数据集，将其改为data，data2，data3）

# 创建逻辑回归逻辑回归模型对象
lr = LogisticRegression(featuresCol="features", labelCol="income")
pipeline = Pipeline(stages=[assembler, lr])
# # 在训练集上训练模型
model = pipeline.fit(trainData)
# 在测试集上进行预测
predictions = model.transform(testData)
# 评估模型
evaluator = BinaryClassificationEvaluator(rawPredictionCol="rawPrediction", labelCol="income")
accuracy = evaluator.evaluate(predictions)
# 打印模型评估结果
print("逻辑回归模型准确性: ", accuracy)
#逻辑回归模型准确性:  0.8813588072801526

KNN近邻算法：这是调用外部包的，因为MLlib里面没用，除非你自己写一个

#KNN算法
# 将 Spark DataFrame 转换为 Pandas DataFrame
pandas_df = data2.toPandas()
pandas_df.info()
# 将特征和标签分离
X = pandas_df.drop("income", axis=1)
y = pandas_df["income"]
# 划分数据集为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=100)
# 创建KNNClassifier模型对象
knn = KNeighborsClassifier(n_neighbors=5)
# 在训练集上训练模型
knn.fit(X_train, y_train)
# 在测试集上进行预测
y_pred = knn.predict(X_test)
# 计算准确性
accuracy = accuracy_score(y_test, y_pred)
print("KNN近邻算法准确性: ", accuracy)
# KNN近邻算法准确性:  0.8053024874603337

随机森林：

#随机森林
# 创建随机森林分类器对象
rf = RandomForestClassifier(featuresCol="features", labelCol="income")
# 创建 Pipeline，将特征处理和模型训练连接在一起
pipeline = Pipeline(stages=[assembler, rf])
# 拟合模型
model = pipeline.fit(trainData)
# 预测
predictions = model.transform(testData)
# 评估
evaluator = BinaryClassificationEvaluator(labelCol="income", rawPredictionCol="rawPrediction", metricName="areaUnderROC")
accuracy = evaluator.evaluate(predictions)
print("随机森林准确性:", accuracy)
# 随机森林准确性: 0.8696915445142397

朴素贝叶斯：

from pyspark.sql import SparkSession
from pyspark.ml.classification import *
from pyspark.ml.evaluation import *
from pyspark.ml import Pipeline
from pyspark.ml.feature import OneHotEncoder, StringIndexer, VectorAssembler, StandardScaler
from pyspark.sql.types import *
import pandas as pd
import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from pyspark.sql.functions import *
# 创建SparkSession
spark = SparkSession.builder \
    .appName("Data Processing") \
    .getOrCreate()

# 从文件中读取数据并创建DataFrame
data = spark.read.csv("file:///root/Spark_MLlib_len/Filestorage/adult.data.csv", header=False, inferSchema=True)

# 定义列名列表
column_names = ["age", "workclass", "fnlwgt", "education", "education-num",
                "marital-status", "occupation", "relationship", "race", "sex", "capital-gain",
                "capital-loss", "hours-per-week", "native-country", "income"]

# 使用toDF方法添加列名
data = data.toDF(*column_names)
#数据集预处理
data0 = data.toPandas()
#将数据集中的？，控制替换为None，同时将收入标签改为1，0

# 将'?'替换为None
data0 = data0.replace(" ?",np.nan)
# 将'>50K'替换为1，'<=50K'替换为0
data0['income'] = data0['income'].replace(' <=50K', 0).replace(' >50K', 1)
#将离散数据集中的缺失值替换为相应的众数提高准确率
# trans = {'workclass' : data['workclass'].mode()[0], 'occupation' : data['occupation'].mode()[0], 'native-country' : data['native-country'].mode()[0]}
categorical_cols = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'native-country', 'income']

for col_name in categorical_cols:
    mode_value = data0[col_name].mode()[0]  # 计算众数
    data0[col_name] = data0[col_name].fillna(mode_value)  # 替换缺失值为众数

#在实际观察数据集时，发现"capital-gain", "capital-loss"有百分之七十以上的记录都为0，因此为了减少计算量、
#将这两列数据去除，同时fnlwgt的意义不明，对预测的影响不大，也进行去除,education数据列和数值型数据education-num所表达的意义相同也删除
data0 = data0.drop(["capital-gain", "capital-loss","fnlwgt","education"], axis = 1)
# 非数值型特征列名
categorical_cols = ['workclass', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'native-country']
#数值型特征列名
numeric_cols = ["age", "education-num", "hours-per-week"]
value = data0.values.tolist()
column = list(data0.columns)
data = spark.createDataFrame(value,column)
# 将分类变量转换为数值变量
indexers = [StringIndexer(inputCol=col, outputCol=col+"_index", handleInvalid="keep")
            for col in categorical_cols]
pipeline = Pipeline(stages=indexers)
data = pipeline.fit(data).transform(data)
# 创建特征向量Assembler
assembler = VectorAssembler(inputCols=[col+"_index" for col in categorical_cols] + numeric_cols,
                            outputCol="features")
# data = assembler.transform(data)
# 将数据拆分为训练集和测试集
trainData, testData = data.randomSplit([0.7, 0.3], seed=100)
# 朴素贝叶斯
# 创建朴素贝叶斯分类器对象
nb = NaiveBayes(featuresCol="features", labelCol="income")
# 创建 Pipeline，将特征处理和模型训练连接在一起
pipeline = Pipeline(stages=[assembler, nb])
# 拟合模型
model = pipeline.fit(trainData)
# 预测
predictions = model.transform(testData)
# 评估
evaluator = BinaryClassificationEvaluator(labelCol="income", rawPredictionCol="rawPrediction",metricName="areaUnderROC")
accuracy = evaluator.evaluate(predictions)
print("朴素贝叶斯准确性:", accuracy)
# # 朴素贝叶斯准确性: 0.4645749248604551

决策树：

#决策树
# 创建决策树分类器对象
dt = DecisionTreeClassifier(featuresCol="features", labelCol="income")
# 训练和预测决策树模型
dt_model = dt.fit(trainData)
dt_predictions = dt_model.transform(testData)
# 创建二分类评估器
evaluator = BinaryClassificationEvaluator(labelCol="income", metricName="areaUnderROC")
accuracy = evaluator.evaluate(dt_predictions)
print("决策树准确性:", accuracy)
# 决策树准确性: 0.6851748679189733 这是我没想到，没有试过不用都热编码的数据集，感兴趣可以去试试

梯度提升树：

#梯度提升树
# 创建梯度提升树分类器对象
gbt = GBTClassifier(featuresCol="features", labelCol="income")
# 训练和预测梯度提升树模型
gbt_model = gbt.fit(trainData)
gbt_predictions = gbt_model.transform(testData)
# 创建二分类评估器
evaluator = BinaryClassificationEvaluator(labelCol="income", metricName="areaUnderROC")
# 模型的准确性
gbt_accuracy = evaluator.evaluate(gbt_predictions)
print("梯度提升树准确性:", gbt_accuracy)
# 梯度提升树准确性: 0.8879586322454801

多层感知器：比较特殊不能进行独热编码，这里我是单独重写的

from pyspark.sql import SparkSession
from pyspark.ml.classification import *
from pyspark.ml.evaluation import *
from pyspark.ml import Pipeline
from pyspark.ml.feature import OneHotEncoder, StringIndexer, VectorAssembler, StandardScaler
from pyspark.sql.types import *
import pandas as pd
import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from pyspark.sql.functions import *
# 创建SparkSession
spark = SparkSession.builder \
    .appName("Data Processing") \
    .getOrCreate()

# 从文件中读取数据并创建DataFrame
data = spark.read.csv("file:///root/Spark_MLlib_len/Filestorage/adult.data.csv", header=False, inferSchema=True)

# 定义列名列表
column_names = ["age", "workclass", "fnlwgt", "education", "education-num",
                "marital-status", "occupation", "relationship", "race", "sex", "capital-gain",
                "capital-loss", "hours-per-week", "native-country", "income"]

# 使用toDF方法添加列名
data = data.toDF(*column_names)
#数据集预处理
data0 = data.toPandas()
#将数据集中的？，控制替换为None，同时将收入标签改为1，0

# 将'?'替换为None
data0 = data0.replace(" ?",np.nan)
# 将'>50K'替换为1，'<=50K'替换为0
data0['income'] = data0['income'].replace(' <=50K', 0).replace(' >50K', 1)
#将离散数据集中的缺失值替换为相应的众数提高准确率
categorical_cols = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'native-country', 'income']
for col_name in categorical_cols:
    mode_value = data0[col_name].mode()[0]  # 计算众数
    data0[col_name] = data0[col_name].fillna(mode_value)  # 替换缺失值为众数

#在实际观察数据集时，发现"capital-gain", "capital-loss"有百分之七十以上的记录都为0，因此为了减少计算量、
#将这两列数据去除，同时fnlwgt的意义不明，对预测的影响不大，也进行去除,education数据列和数值型数据education-num所表达的意义相同也删除
data0 = data0.drop(["capital-gain", "capital-loss","fnlwgt","education"], axis = 1)

#数据转化
# 非数值型特征列名
categorical_cols = ['workclass', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'native-country']
#数值型特征列名
numeric_cols = ["age", "education-num", "hours-per-week"]
value = data0.values.tolist()
column = list(data0.columns)
data = spark.createDataFrame(value,column)
# 将分类变量转换为数值变量
indexers = [StringIndexer(inputCol=col, outputCol=col+"_index", handleInvalid="keep")
            for col in categorical_cols]
pipeline = Pipeline(stages=indexers)
data = pipeline.fit(data).transform(data)
# 创建特征向量Assembler
assembler = VectorAssembler(inputCols=[col+"_index" for col in categorical_cols] + numeric_cols,
                            outputCol="features")
data = assembler.transform(data)
# 将数据拆分为训练集和测试集
trainData, testData = data.randomSplit([0.7, 0.3], seed=100)
# 创建多层感知器分类器对象
layers = [len(assembler.getInputCols()), 5,4,2]
mlp = MultilayerPerceptronClassifier( maxIter=100,layers=layers,labelCol="income",featuresCol="features", blockSize=128,seed=1234)
# 训练多层感知器模型
mlp_model = mlp.fit(trainData)
# 预测测试集
mlp_predictions = mlp_model.transform(testData)
mlp_predictions.show()
predictionAndLabels = mlp_predictions.select("prediction","income")
predictionAndLabels.show()
# 创建二分类评估器
evaluator = BinaryClassificationEvaluator(labelCol="income", metricName="areaUnderROC")
# 计算模型准确性
mlp_accuracy = evaluator.evaluate(mlp_predictions)
print("多层感知器准确性:", mlp_accuracy)
# 多层感知器准确性: 0.8193229027653665

线性支持向量机：

#线性支持向量机
# 创建线性支持向量机分类器对象
lsvc = LinearSVC(featuresCol="features", labelCol="income")
# 训练和预测线性支持向量机模型
lsvc_model = lsvc.fit(trainData)
lsvc_predictions = lsvc_model.transform(testData)
# 创建二分类评估器
evaluator = BinaryClassificationEvaluator(labelCol="income", metricName="areaUnderROC")
lsvc_accuracy = evaluator.evaluate(lsvc_predictions)
print("线性支持向量机准确性:", lsvc_accuracy)
# 线性支持向量机准确性: 0.8710679300137312

One-vs-Rest：

#One-vs-Rest
# 创建一个多类逻辑回归分类器
lsvc = LogisticRegression(maxIter=100, tol=1E-6, fitIntercept=True)
# 创建One-vs-Rest分类器对象
ovr = OneVsRest(classifier=lsvc, featuresCol="features", labelCol="income")
# 训练和预测One-vs-Rest模型
ovr_model = ovr.fit(trainData)
ovr_predictions = ovr_model.transform(testData)
# 创建二分类评估器
evaluator = BinaryClassificationEvaluator(labelCol="income", metricName="areaUnderROC")
ovr_accuracy = evaluator.evaluate(ovr_predictions)
print("One-vs-Rest准确性:", ovr_accuracy)
# One-vs-Rest准确性: 0.8813588072801526

Step 7: 结论

逻辑回归模型准确性: 0.8813588072801526

KNN近邻算法准确性: 0.8053024874603337

随机森林准确性: 0.8696915445142397

朴素贝叶斯准确性: 0.4645749248604551

决策树准确性: 0.6851748679189733

梯度提升树准确性: 0.8879586322454801

多层感知器准确性: 0.8193229027653665

线性支持向量机准确性: 0.8710679300137312

One-vs-Rest准确性: 0.8813588072801526

这是所有结果的展示，可以看到朴素贝叶斯的准确性最低，可能是我的训练集和测试集的问题，
在进行独热编码后的准确性甚至连30%都不到（也许它也不需要特征向量化），决策树也比较低（或许是在数据集里不该处理独热编码？？因为它对离散型数据的分类很有效，又或者是不需要特征向量）。最高准确度是梯度提升树。以上准确性较低的模型就留个客官们细细体味吧，小菜鸡就搞到这里了。有点费神；

如果对你有帮助，请一键三连！你们的支持是我继续的动力。。。之一，嘿嘿嘿。

阿福的小书斋

关注

3
点赞
踩
37

收藏

觉得还不错? 一键收藏
1
评论
Spark MLlib机器学习库-Adult数据集实例上手

在本实验中，我们将使用以下模型进行训练：逻辑回归、KNN、随机森林、朴素贝叶斯、决策树、梯度提升树、多层感知器、线性支持向量机、One-vs-Rest。可能强扭的瓜不甜，有些预测结果不尽人意
复制链接

扫一扫