pyspark使用KMeans聚类

最新推荐文章于 2024-08-01 17:39:08 发布
最新推荐文章于 2024-08-01 17:39:08 发布
阅读量3.5k 收藏 34
点赞数 2
文章标签： 聚类 kmeans 数据挖掘
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46408961/article/details/122402958
版权

01.导入模块，生成对象

from pyspark.sql import SparkSession
from pyspark.ml.feature import VectorAssembler
from pyspark.ml.clustering import KMeans,KMeansSummary
spark = SparkSession.builder.config("spark.driver.host","192.168.1.4")\
    .config("spark.ui.showConsoleProgress","false")\
    .appName("seed").master("local[*]").getOrCreate()

02.导入数据，查看数据内容和结构

data = spark.read.csv("/mnt/e/win_ubuntu/Code/DataSet/MLdataset/seeds_dataset.csv",header=True,inferSchema=True)
data.show(3)
data.printSchema()

输出结果：

         

root
 |-- ID: integer (nullable = true)
 |-- area: double (nullable = true)
 |-- perimeter: double (nullable = true)
 |-- compactness: double (nullable = true)
 |-- lengthOfKernel: double (nullable = true)
 |-- widthOfKernel: double (nullable = true)
 |-- asymmetryCoefficient: double (nullable = true)
 |-- lengthOfKernelGroove: double (nullable = true)
 |-- seedType: integer (nullable = true)

03.查看列名

data.columns

输出结果：

['ID',
 'area',
 'perimeter',
 'compactness',
 'lengthOfKernel',
 'widthOfKernel',
 'asymmetryCoefficient',
 'lengthOfKernelGroove',
 'seedType']

04.分类结果数值化，并查看结果

from pyspark.ml.feature import StringIndexer
stringIndexer = StringIndexer(inputCol="seedType",outputCol="newseedType")
model = stringIndexer.fit(data)
data = model.transform(data)
data.show(3)

输出结果：

         

05.将被数值化的列去掉，并将数值化的列名改为原有列的名称

data = data.select('area','perimeter','compactness','lengthOfKernel','widthOfKernel'\
    ,'asymmetryCoefficient','lengthOfKernelGroove','newseedType')\
    .withColumnRenamed("newseedType","seedType")

06.选取特征标签列，并进行向量化，选取需要的列，再查看前三条数据

vectorAssembler = VectorAssembler(inputCols=['area','perimeter','compactness',\
    'lengthOfKernel','widthOfKernel','asymmetryCoefficient',\
    'lengthOfKernelGroove'],outputCol="features")
tansdata = vectorAssembler.transform(data).select("features","seedType")
tansdata.show(3)

输出结果：

+--------------------+--------+
|            features|seedType|
+--------------------+--------+
|[15.26,14.84,0.87...|     2.0|
|[14.88,14.57,0.88...|     2.0|
|[14.29,14.09,0.90...|     2.0|
+--------------------+--------+
only showing top 3 rows

07.详细查看上面三条数据内容

tansdata.head(3)

输出结果：

[Row(features=DenseVector([15.26, 14.84, 0.871, 5.763, 3.312, 2.221, 5.22]), seedType=2.0),
 Row(features=DenseVector([14.88, 14.57, 0.8811, 5.554, 3.333, 1.018, 4.956]), seedType=2.0),
 Row(features=DenseVector([14.29, 14.09, 0.905, 5.291, 3.337, 2.699, 4.825]), seedType=2.0)]

08.进行数据归一化(标准化)，并查看前3条数据结果

from pyspark.ml.feature import StandardScaler
standardScaler = StandardScaler(inputCol="features",outputCol="scaledFeatures")
model_one = standardScaler.fit(tansdata)
stddata = model_one.transform(tansdata)
stddata.show(3)
stddata.head(3)

输出结果：

+--------------------+--------+--------------------+
|            features|seedType|      scaledFeatures|
+--------------------+--------+--------------------+
|[15.26,14.84,0.87...|     2.0|[5.24452795332028...|
|[14.88,14.57,0.88...|     2.0|[5.11393027165175...|
|[14.29,14.09,0.90...|     2.0|[4.91116018695588...|
+--------------------+--------+--------------------+
only showing top 3 rows
​
[Row(features=DenseVector([15.26, 14.84, 0.871, 5.763, 3.312, 2.221, 5.22]), seedType=2.0, scaledFeatures=DenseVector([5.2445, 11.3633, 36.8608, 13.0072, 8.7685, 1.4772, 10.621])),
​
 Row(features=DenseVector([14.88, 14.57, 0.8811, 5.554, 3.333, 1.018, 4.956]), seedType=2.0, scaledFeatures=DenseVector([5.1139, 11.1566, 37.2883, 12.5354, 8.8241, 0.6771, 10.0838])),
 
 Row(features=DenseVector([14.29, 14.09, 0.905, 5.291, 3.337, 2.699, 4.825]), seedType=2.0, scaledFeatures=DenseVector([4.9112, 10.789, 38.2997, 11.9419, 8.8347, 1.7951, 9.8173]))]

09.拆分训练数据集和预测数据集，并查看各自的条数

traindata,testdata = stddata.randomSplit([0.7,0.3])
print(traindata.count(),testdata.count())

输出结果：144 66

10.查看原始数据有多少类(决定聚类时的参数)，且不同类的数据条数

data.groupBy("seedType").count().show()

输出结果：

+--------+-----+
|seedType|count|
+--------+-----+
|     0.0|   70|
|     1.0|   70|
|     2.0|   70|
+--------+-----+

11.使用KMeans进行聚类，获取聚类模型

kmeans = KMeans(featuresCol="scaledFeatures",k=3)
model_two = kmeans.fit(traindata)

12.查看集合内误差平方和，用于度量聚类的有效性

通过 WSSSE 的计算构建出 K-WSSSE 间的相关关系，从而确定K的值，一般来说，最优的K值即是 K-WSSSE 曲 线的 拐点（Elbow） 位置（当然，对于某些情况来说，我们还需要考虑K值的语义可解释性，而不仅仅是教条地 参考WSSSE曲线）

model_two.computeCost(traindata)

输出结果：278.93528584662363

13.查看每个类别的聚类中心

model_two.clusterCenters()

输出结果：

[array([ 4.81493032, 10.80927774, 37.32735111, 12.22557524,  8.52734653,
         1.77975592, 10.19931557]),
 array([ 6.27124632, 12.33416237, 37.34515336, 13.89858067,  9.68210196,
         2.37627184, 12.26465184]),
 array([ 4.04007365, 10.12681315, 35.71260412, 11.82304628,  7.46653997,
         3.24431969, 10.43654837])]

14.通过测试数据，查看模型预测情况

这里的类别和我们原有的类别seedType是一一对应的，值不一定相等

model_two.transform(testdata).show()

输出结果：

+--------------------+--------+--------------------+----------+
|            features|seedType|      scaledFeatures|prediction|
+--------------------+--------+--------------------+----------+
|[10.82,12.83,0.82...|     1.0|[3.71859714645645...|         2|
|[10.91,12.8,0.837...|     1.0|[3.74952817632531...|         2|
|[11.35,13.12,0.82...|     1.0|[3.90074654457308...|         2|
|[11.42,12.86,0.86...|     2.0|[3.92480401224886...|         0|
|[11.65,13.07,0.85...|     1.0|[4.00384997746928...|         2|
|[11.82,13.4,0.827...|     1.0|[4.06227525611046...|         2|
|[11.87,13.02,0.87...|     1.0|[4.07945916159316...|         0|
|[12.01,13.52,0.82...|     1.0|[4.12757409694473...|         2|
................................................................

15.通过训练数据，验证上面"这里的类别和我们原有的类别seedType是一一对应的，值不一定相等"

model_two.transform(traindata).show()

输出结果：

+--------------------+--------+--------------------+----------+
|            features|seedType|      scaledFeatures|prediction|
+--------------------+--------+--------------------+----------+
|[10.59,12.41,0.86...|     1.0|[3.63955118123602...|         2|
|[10.74,12.73,0.83...|     1.0|[3.69110289768413...|         2|
|[10.79,12.93,0.81...|     1.0|[3.70828680316683...|         2|
|[10.8,12.57,0.859...|     1.0|[3.71172358426337...|         2|
|[10.83,12.96,0.80...|     1.0|[3.72203392755299...|         2|
|[10.93,12.8,0.839...|     1.0|[3.75640173851839...|         2|
..................................................................

16.通过观察发现原有类别，与预测出来的类别的对应关系为：

原有类别：seedType预测结果：prediction
0.01
1.02
2.00

17.根据上方关系表，编写注册UDF函数进行转换

from pyspark.sql.functions import udf
from pyspark.sql.types import DoubleType
def func(x):
    if x==1:
        return 0.0
    elif x==2:
        return 1.0
    else :
        return 2.0
fudf = udf(func,DoubleType())

18.将上面训练数据和测试数据的结果进行赋值

trainres = model_two.transform(traindata)
testres = model_two.transform(testdata)

19.训练结果通过UDF进行转换，并查看结果

trainres = trainres.withColumn("res",fudf("prediction"))
trainres.show()

输出结果：

+--------------------+--------+--------------------+----------+---+
|            features|seedType|      scaledFeatures|prediction|res|
+--------------------+--------+--------------------+----------+---+
|[10.59,12.41,0.86...|     1.0|[3.63955118123602...|         2|1.0|
|[10.74,12.73,0.83...|     1.0|[3.69110289768413...|         2|1.0|
|[10.79,12.93,0.81...|     1.0|[3.70828680316683...|         2|1.0|
|[10.8,12.57,0.859...|     1.0|[3.71172358426337...|         2|1.0|
|[10.83,12.96,0.80...|     1.0|[3.72203392755299...|         2|1.0|
|[10.93,12.8,0.839...|     1.0|[3.75640173851839...|         2|1.0|
|[11.02,13.0,0.818...|     1.0|[3.78733276838725...|         2|1.0|
|[11.14,12.79,0.85...|     1.0|[3.82857414154573...|         2|1.0|
......................................................................

20.查看训练数据的预测结果的结构，以便下面筛选时进行判断

trainres.printSchema()

输出结果：同为double，可以直接取==判断

root
 |-- features: vector (nullable = true)
 |-- seedType: double (nullable = false)
 |-- scaledFeatures: vector (nullable = true)
 |-- prediction: integer (nullable = false)
 |-- res: double (nullable = true)

21.计算训练数据的预测结果中，与真实相符的数据条数

trainres.filter(trainres.res == trainres.seedType).count()

输出结果：133

前面统计过训练数据的总条数共-------------144条

22.同理测试数据的预测结果中，与真实相符的数据条数

testres = testres.withColumn("res",fudf("prediction"))
testres.filter(testres.res == testres.seedType).count()
testres.count()

输出结果：66

前面统计过测试数据的总条数共---------------66条

Gadaite
关注
pyspark入门---通过kmeans分析出租车数据并调用百度API进行可视化
05-11 3541
通过kmeans分析出租车数据并进行可视化（1）数据准备（2）创建dataframe（3）kmeans聚类分析（4）调用百度API进行数据可视化 （1）数据准备 采用数据为出租车载客时的GPS记录数据集，数据格式为CSV，CSV格式是数据分析中常见的一种数据格式。CSV（Comma-Separated Values） 即逗号分隔值，文件以文本的方式存储表格数据（包含数字和文本）。其中每一行代表一条记录，每条记录被逗号分隔为字段，并且每条记录都有同样的字段序列。本实验一共181230条记录，具体文件格式见下表
kmeans-pyspark:Spark中分布式K-means聚类的Python实现
05-09
本地开发和运营 依存关系 确保您已将Python 2.7和pip一起安装。 然后运行： pip install -r requirements.txt 正在运行的工作 使用中央作业运行程序模块src/index.py运行所有作业。 您完全不需要编辑此文件。 python src/index.py <job> <k> <file1> <file2> 参数： <job> src/spark_jobs.py定义的作业功能名称 <k>生成的簇数 <file1>数据文件的文件路径（可以是项目中的绝对路径或本地路径） 这些作业可以占用多个文件。 这些应仅附加到命令中。 例如： python src/index.py user__reputation__to__upvotes_cast 3 tests/fixtures/users.xml 新增工作 所有作业均从src/s
PySpark关联规则及聚类模型简明教程
最新发布
chendengyi2的博客
08-01 958
数据集：简单关联规则分析.txt，为5张购物小票，每张购物小票上面是购买的商品名称，如下图所示。数据集的样本数很少，这里仅为演示PySpark关联规则的简单教程，方便读者理解。在PySpark中，有LDA（Latent Dirichlet Allocation，潜在狄利克雷分配）、BisectingKMeans和KMeans三种不同的聚类或主题模型算法。（1）LDALDA：是一种文档主题生成模型，也是一种无监督学习算法。它主要用于发现文档集合中的潜在主题，并将每个文档表示为这些主题的混合体。
Pyspark聚类--KMeans
weixin_46408961的博客
03-12 1976
KMeans class pyspark.ml.clustering.KMeans(featuresCol=‘features’, predictionCol=‘prediction’, k=2, initMode=‘k-means||’, initSteps=2, tol=0.0001, maxIter=20, seed=None, distanceMeasure=‘euclidean’) 使用类似 k-means++ 的初始化模式进行 K-means 聚类（Bahmani 等人的 k-means|| 算
pySpark与Kmeans算法实现
wonderboyLU的博客
07-16 1764
一、实践Spark的共享变量 不使用广播变量时： Spark的执行过程中，Spark的一个或者多个函数操作会作为一个Task分发到某个节点上的Executor中去执行，当函数用到程序中定义的变量，那么那么Spark会将这些变量创建一个副本，并与这些函数一起打包到相应的task中。那么当有很多个task都应用到同一个变量时，spark会多次复制并打包传输这些变量，但变量本身有可能是一个很大的字典或者集合，这就会引起大量的网络传输，也有可能会造成一个Executor的内存溢出。 广播变量的意义： 就
【机器学习】在大数据上使用PySpark进行K-Means
fengdu78的博客
04-25 3321
作者 | Angel Das编译 | VK来源 | Towards Data Science如果你不熟悉K Means聚类，我建议你阅读下面的文章。本文主要研究数据并行和聚类，大数据上的K...
pyspark_聚类分析
Andy_shenzl的博客
07-15 1938
数据集 本次使用得到数据集为莺尾花数据集-iris数据集，共有150条记录，5列[花萼长度、花萼宽度、花瓣长度、花瓣宽度、花朵类别]，共有三种类别，每种类别50条记录。 先导入数据 df=spark.read.csv('iris_dataset.csv',inferSchema=True,header=True) print((df.count(),len(df.columns))) df.printSchema() root |-- sepal_length: double (nullable = t
pyspark kmeans聚类
05-25
在 PySpark 中使用 KMeans 聚类算法可以通过以下步骤实现： 1. 导入必要的库和模块 ```python from pyspark.ml.clustering import KMeans from pyspark.ml.evaluation import ClusteringEvaluator from ...
PySpark-ClusterClassify:使用AWS Sagemaker在MNIST数据集上进行分布式KMeans聚类和XGBoost分类作业
03-27
在本项目"PySpark-ClusterClassify"中，我们将探讨如何使用Apache Spark的Python接口PySpark，结合Amazon Web Services (AWS) 的SageMaker服务，对著名的MNIST手写数字数据集进行分布式KMeans聚类和XGBoost分类任务...
sparkmllib实现kmeans聚类
06-01
好的，下面是 sparkmllib 实现 kmeans 聚类的步骤： ...以上就是 sparkmllib 实现 kmeans 聚类的基本步骤，需要注意的是，我们需要设置 k 值，即聚类的数量，还需要评估模型的好坏，这里使用的是 Silhouette 系数。
KMeans聚类算法的并行化：利用多核计算加速数据聚类
KMeans聚类算法是一种无监督机器学习算法，用于将数据点分组到称为簇的相似组中。它通过迭代地分配数据点到最近的簇中心并更新簇中心来工作。KMeans算法的目的是最小化簇内数据点的平方误差，从而形成紧凑且分离的簇...
PySpark对电影和用户进行聚类分析
12-21
之前的博文使用pyspark.mllib.recommendation做推荐案例，代码实现了如何为用户做电影推荐和为电影找到潜在的感兴趣用户。本篇博文介绍如何利用因子分解出的用户特征、电影特征做用户和电影的聚类分析，以看能否找到不同于已知的、有趣的新信息。 第一步：获取用户评分数据显式因式分解后的movieFactors、userFactors。 from pyspark.mllib.recommendation import ALS,Rating #用户评分数据 rawData = sc.textFile("/Users/gao/data/ml-100k/u.data") rawRatin
Pyspark聚类--LDA
weixin_46408961的博客
03-12 1228
LDA class pyspark.ml.clustering.LDA(featuresCol=‘features’, maxIter=20, seed=None, checkpointInterval=10, k=10, optimizer=‘online’, learningOffset=1024.0, learningDecay=0.51, subsamplingRate=0.05, optimizeDocConcentration=True, docConcentration=None, topic
k-means聚类算法(pyspark实现)
weixin_42455006的博客
05-10 669
import sys #The sys module contains functions related to the Python interpreter and its environment. from typing import List #The typing library is a library that helps us implement type annotations import numpy as np #This code requires NumPy f
pyspark：k均值
06-04 858
from pyspark import SparkConf from pyspark.sql import SparkSession from pyspark.ml.linalg import Vectors from pyspark.ml.clustering import KMeans import pandas as pd if __name__ == "__main__": a...
Pyspark聚类--BisectingKMeans
weixin_46408961的博客
03-12 640
BisectingKMeans class pyspark.ml.clustering.BisectingKMeans(featuresCol=‘features’, predictionCol=‘prediction’, maxIter=20, seed=None, k=4, minDivisibleClusterSize=1.0, distanceMeasure=‘euclidean’) 一种基于 Steinbach、Karypis 和 Kumar 的论文“文档聚类技术比较”的二等分 k-means 算
pyspark 分裂聚类BisectingKMeans
luoganttcc的博客
06-09 951
from pyspark.ml.clustering import BisectingKMeans from pyspark.sql import SparkSession spark= SparkSession\ .builder \ .appName("dataFrame") \ .getOrCr...
使用 pyspark 进行 Clustering 的简单例子 -- KMeans
shiter编写程序的艺术
11-01 1289
K-means算法适合于简单的聚类问题，但可能不适用于复杂的聚类问题。此外，在使用K-means算法之前，需要对数据进行预处理和缩放，以避免偏差。K-means是一种聚类算法，它将数据点分为不同的簇或组。原理简介：K-Means算法通过迭代寻找数据集中的k个簇，每个簇内的数据点尽可能相似（即，簇内距离最小），不同簇之间的数据点尽可能不同（即，簇间距离最大）。算法首先随机选择k个数据点作为初始的聚类中心（也称为质心），然后对数据集中的每个数据点，根据其与聚类中心的距离将其分配到最近的簇中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值