2017-07-12 15:48:48 goodstuddayupyyeah 阅读数 6185

K-means

优缺点

优点:容易实现
缺点:可能收敛到局部最小值,在大规模数据集上收敛较慢

步骤

  1. 选择K个点作为初始聚类中心
  2. 计算其余所有点到聚类中心的距离,并把每个点划分到离它最近的聚类中心所在的聚类中去。计算距离常用欧几里得距离公式,也叫欧氏距离。查看距离的计算方法
  3. 重新计算每个聚类中所有点的平均值,并将其作为新的聚类中心点。
  4. 重复2、3步,直到聚类中心不再发生改变,或者算法达到预定的迭代次数,又或聚类中心的改变小于预先设定的阈值

使用后处理来提高聚类性能

局部最小值指结果还可以但并非最好结果,全局最小值是可能的最好结果
一种用于度量聚类效果的指标是SSE(误差平方和)。SSE值越小表示数据点越接近它们的质心。
后处理方法:将具有最大SSE值的簇划分成为两个簇;合并最近的质心,或者合并两个使得SSE增幅最小的质心。

二分K-Means算法

1. 将所有点作为一个簇,然后将该簇一分为二;
2. 之后选择其中一个簇继续进行划分,选择哪一个簇进行划分取决于对其划分是否可以最大程度降低SSE的值。
3. 不断重复SSE的划分过程,直到得到用户指定的簇数目为止。

Spark实现KMeans

关键步骤

聚类个数K的选择

Spark MLlib 在 KMeansModel 类里提供了 computeCost 方法,该方法通过计算所有数据点到其最近的中心点的平方和来评估聚类的效果。一般来说,同样的迭代次数和算法跑的次数,这个值越小代表聚类的效果越好。但是在实际情况下,我们还要考虑到聚类结果的可解释性,不能一味的选择使 computeCost 结果值最小的那个 K。

初始聚类中心点的选择

Spark MLlib K-means算法的实现在初始聚类点的选择上,借鉴了K-means||的类K-means++实现。K-means++算法在初始点选择上遵循一个基本原则:初始聚类中心点相互之间的距离应该尽可能的远。基本步骤如下:
1. 从数据集中随机选择一个点作为第一个初始点
2. 计算数据集中所有点与最新选择的中心点的距离D(x)
3. 选择下一个中心点,使得

这里写图片描述

最大
4. 重复2、3步,直到K个初始点选择完成

MLlib的K-means实现

  1. 读取训练数据,调用KMeans.train方法对数据集进行聚类训练,方法返回KMeansModel实例
  2. 使用KMeansModel.predict方法对新的数据点进行所属聚类的预测
  3. 均方差(MSE),就是对各个实际存在评分的项,pow(预测评分-实际评分,2)的值进行累加,再除以项数。而均方根差(RMSE)就是MSE开根号。MSE/RMSE值越小说明预测结果越准确

参数

参数 含义
k 所需簇的数量。请注意,可以返回少于k个集群,例如,如果有少于k个不同的集群点
maxIterations 运行的最大迭代次数。
initializationMode 通过k-means ||指定随机初始化或初始化。
initializationSteps 确定k-means ||中的步数算法。
epsilon 确定我们认为k均值收敛的距离阈值。
initialModel 用于初始化的可选集群中心集。如果提供此参数,则仅执行一次运行。

Spark_K-Means_Python

from __future__ import print_function

from numpy import array
from math import  sqrt

from pyspark import SparkContext

from pyspark.mllib.clustering import KMeans, KMeansModel

if __name__ == "__main__":
    sc = SparkContext(appName="KmeansExample")

    # Load and parse the data
    data = sc.textFile("kmeans_data.txt")
    parsedData = data.map(lambda line:array([float(x) for x in line.split(' ')]))

    # Build the Model(cluster the data)
    clusters = KMeans.train(parsedData, 2, maxIterations=10, initializationMode="random")
    print(clusters.clusterCenters)

    print(clusters.predict([0.2, 0.2, 0.2]))

    # Evaluate clustering by computing Within Set Sum of Squared Errors
    def error(point):
        center = clusters.centers[clusters.predict(point)]
        return sqrt(sum([x**2 for x in (point - center)]))

    WSSSE = parsedData.map(lambda point: error(point)).reduce(lambda x, y: x + y)
    print("Within Set Sum of Squared Error = " + str(WSSSE))
2017-04-19 20:59:06 meiguopai1 阅读数 668

 spark平台  mllib K-Means聚类算法 python版本 实现

K-Means 聚类算法可以认为是机器学习比较简单算法,无监督学习。

把自然界的各类人、物属性向量化,来划分k类。

迭代来求k类的中心点。

直接上spark自带源码,spark源码自带

kmeans_data.txt
0.0 0.0 0.0
0.1 0.1 0.1
0.2 0.2 0.2
9.0 9.0 9.0
9.1 9.1 9.1
9.2 9.2 9.2


#kmeans.py

from __future__ import print_function

import sys

import numpy as np
from pyspark import SparkContext
from pyspark.mllib.clustering import KMeans


def parseVector(line):
    return np.array([float(x) for x in line.split(' ')])


if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: kmeans <file> <k>", file=sys.stderr)
        exit(-1)
    sc = SparkContext(appName="KMeans")
    lines = sc.textFile(sys.argv[1])
    data = lines.map(parseVector)
    k = int(sys.argv[2])
    model = KMeans.train(data, k)
    print("Final centers: " + str(model.clusterCenters))
    print("Total Cost: " + str(model.computeCost(data)))
    sc.stop()

k为2

spark-submit kmeans.py '/root/lxs/machine/mllib/kmeans_data.txt' 2

Final centers: [array([ 9.1,  9.1,  9.1]), array([ 0.1,  0.1,  0.1])]

Total Cost: 0.11999999999994547

k为3

Final centers: [array([ 0.1,  0.1,  0.1]), array([ 9.05,  9.05,  9.05]), array([ 9.2,  9.2,  9.2])]

Total Cost: 0.07500000000004324

k为4

Final centers: [array([ 0.05,  0.05,  0.05]), array([ 9.05,  9.05,  9.05]), array([ 0.2,  0.2,  0.2]), array([ 9.2,  9.2,  9.2])]

Total Cost: 0.03000000000004321

k为5

Final centers: [array([ 0.05,  0.05,  0.05]), array([ 9.,  9.,  9.]), array([ 9.2,  9.2,  9.2]), array([ 9.1,  9.1,  9.1]), array([ 0.2,  0.2,  0.2])]

Total Cost: 0.01500000000000001

简单列子后续详细分析。

2019-11-22 09:42:12 leemusk 阅读数 8

聚类

官方文档

K-means

k均值是最常用的聚类算法之一,它将数据点聚集成预定数量的聚类。 MLlib实现包括称为kmeans ||的k-means ++方法的并行变体。
Means被实现为一个估计器,并生成一个KMeansModel作为基础模型。
在这里插入图片描述

from pyspark.ml.clustering import KMeans
from pyspark.ml.evaluation import ClusteringEvaluator

# Loads data.
dataset = spark.read.format("libsvm").load("data/mllib/sample_kmeans_data.txt")

# Trains a k-means model.
kmeans = KMeans().setK(2).setSeed(1)
model = kmeans.fit(dataset)

# Make predictions
predictions = model.transform(dataset)

# Evaluate clustering by computing Silhouette score
evaluator = ClusteringEvaluator()

silhouette = evaluator.evaluate(predictions)
print("Silhouette with squared euclidean distance = " + str(silhouette))

# Shows the result.
centers = model.clusterCenters()
print("Cluster Centers: ")
for center in centers:
    print(center)

Latent Dirichlet allocation (LDA)``

LDA被实现为支持EMLDAOptimizer和OnlineLDAOptimizer的Estimator,并生成LDAModel作为基础模型。如果需要,专家用户可以将EMLDAOptimizer生成的LDAModel强制转换为DistributedLDAModel。

from pyspark.ml.clustering import LDA

# Loads data.
dataset = spark.read.format("libsvm").load("data/mllib/sample_lda_libsvm_data.txt")

# Trains a LDA model.
lda = LDA(k=10, maxIter=10)
model = lda.fit(dataset)

ll = model.logLikelihood(dataset)
lp = model.logPerplexity(dataset)
print("The lower bound on the log likelihood of the entire corpus: " + str(ll))
print("The upper bound on perplexity: " + str(lp))

# Describe topics.
topics = model.describeTopics(3)
print("The topics described by their top-weighted terms:")
topics.show(truncate=False)

# Shows the result
transformed = model.transform(dataset)
transformed.show(truncate=False)

Bisecting k-means

将k均值平分是一种使用除法(或“自上而下”)方法的层次聚类:所有观测值都在一个聚类中开始,并且随着一个人向下移动,递归执行拆分。
平分K均值通常会比常规K均值快得多,但通常会产生不同的聚类。
BisectingKMeans被实现为一个估计器,并生成一个BisectingKMeansModel作为基础模型。

from pyspark.ml.clustering import BisectingKMeans

# Loads data.
dataset = spark.read.format("libsvm").load("data/mllib/sample_kmeans_data.txt")

# Trains a bisecting k-means model.
bkm = BisectingKMeans().setK(2).setSeed(1)
model = bkm.fit(dataset)

# Evaluate clustering.
cost = model.computeCost(dataset)
print("Within Set Sum of Squared Errors = " + str(cost))

# Shows the result.
print("Cluster Centers: ")
centers = model.clusterCenters()
for center in centers:
    print(center)

4. Gaussian Mixture Model (GMM)

高斯混合模型表示一种复合分布,其中从k个高斯子分布之一中抽取点,每个子分布都有自己的概率。 spark.ml实现使用期望最大化算法在给定一组样本的情况下得出最大似然模型。 GaussianMixture被实现为Estimator,并生成GaussianMixtureModel作为基础模型。
在这里插入图片描述

from pyspark.ml.clustering import GaussianMixture

# loads data
dataset = spark.read.format("libsvm").load("data/mllib/sample_kmeans_data.txt")

gmm = GaussianMixture().setK(2).setSeed(538009335)
model = gmm.fit(dataset)

print("Gaussians shown as a DataFrame: ")
model.gaussiansDF.show(truncate=False)
2017-10-18 11:09:15 wc781708249 阅读数 1718

参考地址:

1、http://spark.apache.org/docs/latest/ml-guide.html

2、https://github.com/apache/spark/tree/v2.2.0

3、http://spark.apache.org/docs/latest/ml-clustering.html



K-means

from pyspark.ml.clustering import KMeans

# Loads data.
dataset = spark.read.format("libsvm").load("data/mllib/sample_kmeans_data.txt")

# Trains a k-means model.
kmeans = KMeans().setK(2).setSeed(1)
model = kmeans.fit(dataset)

# Evaluate clustering by computing Within Set Sum of Squared Errors.
wssse = model.computeCost(dataset)
print("Within Set Sum of Squared Errors = " + str(wssse))

# Shows the result.
centers = model.clusterCenters()
print("Cluster Centers: ")
for center in centers:
    print(center)

Latent Dirichlet allocation (LDA)

from pyspark.ml.clustering import LDA

# Loads data.
dataset = spark.read.format("libsvm").load("data/mllib/sample_lda_libsvm_data.txt")

# Trains a LDA model.
lda = LDA(k=10, maxIter=10)
model = lda.fit(dataset)

ll = model.logLikelihood(dataset)
lp = model.logPerplexity(dataset)
print("The lower bound on the log likelihood of the entire corpus: " + str(ll))
print("The upper bound on perplexity: " + str(lp))

# Describe topics.
topics = model.describeTopics(3)
print("The topics described by their top-weighted terms:")
topics.show(truncate=False)

# Shows the result
transformed = model.transform(dataset)
transformed.show(truncate=False)

Bisecting k-means

from pyspark.ml.clustering import BisectingKMeans

# Loads data.
dataset = spark.read.format("libsvm").load("data/mllib/sample_kmeans_data.txt")

# Trains a bisecting k-means model.
bkm = BisectingKMeans().setK(2).setSeed(1)
model = bkm.fit(dataset)

# Evaluate clustering.
cost = model.computeCost(dataset)
print("Within Set Sum of Squared Errors = " + str(cost))

# Shows the result.
print("Cluster Centers: ")
centers = model.clusterCenters()
for center in centers:
    print(center)

Gaussian Mixture Model (GMM)

from pyspark.ml.clustering import GaussianMixture

# loads data
dataset = spark.read.format("libsvm").load("data/mllib/sample_kmeans_data.txt")

gmm = GaussianMixture().setK(2).setSeed(538009335)
model = gmm.fit(dataset)

print("Gaussians shown as a DataFrame: ")
model.gaussiansDF.show(truncate=False)


2019-06-04 14:48:24 qq_23860475 阅读数 132
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__":
    appname = "KMeans"
    master ="local[4]" 
    conf = SparkConf().setAppName(appname).setMaster(master)  #spark配置                
    spark=SparkSession.builder.config(conf=conf).getOrCreate()#spark实例化
#读取数据
    data = [(Vectors.dense([0.0, 0.0]),), (Vectors.dense([1.0, 1.0]),),\
           (Vectors.dense([9.0, 8.0]),), (Vectors.dense([8.0, 9.0]),)]    
    df = spark.createDataFrame(data, ["features"])

#用k均值进行聚类    
    kmeans = KMeans(k=2, seed=1)
    model = kmeans.fit(df)
    centers = model.clusterCenters()
    model.computeCost(df)#每个点到其中心距离平方和
    result = model.transform(df).select("features", "prediction")#输出聚类结果

#将聚类结果转为python中的dataframe
    columns=result.columns#提取强表字段
    result=result.collect()#
    result=pd.DataFrame(result,columns=columns)#转为python中的dataframe
    print(result)
    spark.stop()

运行结果:

 

 

没有更多推荐了,返回首页