上课，老师让做作业，kmeans分类，将iris进行聚类分类，于是就做了这个作业。很简单，我就将其设置为分三类，重点是我在选择初始center的时候，尝试了使用随机选取和使用大招选取两种方式，随机选择初始点的效果不如放大招。这个大招是这样的：先随机选取一个作为center1，再选取一个距离这个center1最远的点作为center2，再选择一个距离center1和center2最远的点作为center3。
 
在训练过程中更新质心的时候，我不是选择online模式，来一个点更新一次质心，而是选择了mini_batch的模式，先送进来mini_batch个样本，分别将其划归到对应的中心处，然后再进行更新。说这么多屁话，不如把代码放上来，代码如下：
 
import numpy as np
import csv
import random

features = np.loadtxt('iris.csv',delimiter=',',usecols=(1,2,3,4))  #read features
z_min, z_max = features.min(axis=0), features.max(axis=0)          #features normalized
features = (features - z_min)/(z_max - z_min)

csv_file = open('iris.csv')   #transform string to num label
csv_reader_lines = csv.reader(csv_file)
classes_list = []
for i in csv_reader_lines:
    classes_list.append(i[-1])
labels = []
for i in classes_list:
    if i=='setosa':
        labels.append(0)
    elif i=='versicolor':
        labels.append(1)
    else:
        labels.append(2)

labels = np.array(labels)
labels = labels.reshape((150,1))   # transformm list to numpy type

data_index = np.arange(features.shape[0])
np.random.shuffle(data_index)

train_input = features[ data_index[0:120] ]
train_label = labels[ data_index[0:120] ]

test_input = features[ data_index[120:150] ]
test_label = labels[ data_index[120:150] ]

train_length = 120
K = 3
center_1_pos = random.randint(0,train_length)
center1 = train_input[ center_1_pos ]
# center1 = train_input[0]
# center2 = train_input[1]
# center3 = train_input[2]
# print(center1)
# print(center2)
# print(center3)

biggest_distance = 0.0
center_2_pos = 0

for i in range(train_length):#选择center2
    dist = np.sum(pow( (center1 - train_input[i]),2 ))
    if dist > biggest_distance:
        biggest_distance = dist
        center_2_pos = i

center2 = train_input[center_2_pos]


biggest_distance = 0.0
center_3_pos = 0

for i in range(train_length):#选择center3
    dist = np.sum(pow( (center1 - train_input[i]), 2 )) + np.sum(pow( (center2 - train_input[i]) , 2))
    if dist > biggest_distance:
        biggest_distance = dist
        center_3_pos = i

center3 = train_input[center_3_pos]
mini_batch = 20

for epoch in range(10):#在整个数据集上训练10次
    for i in range(6):
        belong1 = []
        belong2 = []
        belong3 = []
        for j in range(mini_batch):#mini_batch
            temp_index = mini_batch * i + j
            belong = 1
            dist_1 = np.sum(pow( ( center1 - train_input[mini_batch*i+j] ),2 ))
            temp_dist = dist_1

            dist_2 = np.sum(pow((center2 - train_input[mini_batch * i + j]), 2))
            dist_3 = np.sum(pow((center3 - train_input[mini_batch * i + j]), 2))

            if(dist_2 < temp_dist):
                temp_dist = dist_2
                belong = 2
            if(dist_3 < temp_dist):
                belong = 3

            if belong==1:
                belong1.append( temp_index )
            elif belong == 2:
                belong2.append(temp_index)
            else:
                belong3.append(temp_index)


        for k in belong1:
            center1 = center1 + train_input[k]
        center1 = center1 / (1 + len(belong1))

        for k in belong2:
            center2 = center2 + train_input[k]
        center2 = center2 / (1 + len(belong2))

        for k in belong3:
            center3 = center3 + train_input[k]
        center3 = center3 / (1 + len(belong3))

    b_1=[]
    b_2=[]
    b_3=[]
    for l in range(test_input.shape[0]):#在测试机上进行测试
        belong = 1
        dist_1 = np.sum(pow((center1 - test_input[l]), 2))
        temp_dist = dist_1

        dist_2 = np.sum(pow((center2 - test_input[ l ]), 2))
        dist_3 = np.sum(pow((center3 - test_input[ l ]), 2))

        if (dist_2 < temp_dist):
            temp_dist = dist_2
            belong = 2
        if (dist_3 < temp_dist):
            belong = 3



        if belong == 1:
            b_1.append(test_label[l][0])
        elif belong == 2:
            b_2.append(test_label[l][0])
        else:
            b_3.append(test_label[l][0])
    print()
    print('epoch : {} / 10' .format(epoch+1))
    print('center1: ',b_1)
    print('center2',b_2)
    print('center3: ',b_3)
 
下面是我运行程序的结果：
 
epoch : 1 / 10
center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
center3:  [2, 2, 2, 2, 2]

epoch : 2 / 10
center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
center3:  [2, 2, 2, 2, 2]

epoch : 3 / 10
center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
center3:  [2, 2, 2, 2, 2]

epoch : 4 / 10
center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
center3:  [2, 2, 2, 2, 2]

epoch : 5 / 10
center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
center3:  [2, 2, 2, 2, 2]

epoch : 6 / 10
center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
center3:  [2, 2, 2, 2, 2]

epoch : 7 / 10
center1:  [2, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1]
center2 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
center3:  [2, 2, 2, 2, 2]
 
     小数据集上结果还是挺好的。
 
iris数据集的一个下载链接如下：链接: https://pan.baidu.com/s/1PpIwncqbtQbEuGKSxKyBMg  密码: 7ins
 
注意：我在读取iris的数据时候，将第一行的属性名称删除了，要不然处理起来麻烦。
 
哎，做这个小作业也挺有意思的，学习了Nummpy数据的归一化还，csv文件的numpy读取，以及如何将csv文件中的字符类型转化为数字标签。

首先介绍一下（yuan）鸢尾花数据集，该数据集测量了所有150个样本的4个特征单位都是cm，分别是：
 1.sepal length（花萼长度）
 2.sepal width（花萼宽度）
 3.petal length（花瓣长度）
 4.petal width（花瓣宽度）
 对应一个150行4列的矩阵，本文思路是通过PCA压缩数据将其从150行四列变成150行3列，4维变3维（每个特征对应一个维度）
 在网上看了很多，k-means和PCA的结果都是二维的，我想用三维图来展示分类的的效果图就自己将代码改了一下。发个博客记录一下代码，思想大概就是将鸢尾花4维的数据转为三维后再使用k-means分类，因为提前知道了这些数据是来自三类的花，所以提前给出K-means要分类的个数为3，算法会提前随机给3个类似于重心的东西，然后离重心近的会被分到该簇。之后每个簇的重心会随着其簇内样本的增加不断改变。重心大概就是结果图中X所在的位置。
 
#coding=utf-8
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
from mpl_toolkits.mplot3d import Axes3D
from sklearn.cluster import KMeans
import numpy as np





##计算欧式距离
def distEuclid(x, y):
    return np.sqrt(np.sum((x - y) ** 2))


##随机产生n个dim维度的数据 (这里为了展示结果 dim取2或者3)
def genDataset(n, dim):
    data = []
    while len(data) < n:
        p = np.around(np.random.rand(dim) * size, decimals=2)
        data.append(p)
    return data


## 初始化簇中心点 一开始随机从样本中选择k个 当做各类簇的中心
def initCentroid(data, k):
    num, dim = data.shape
    centpoint = np.zeros((k, dim))
    l = [x for x in range(num)]
    np.random.shuffle(l)
    for i in range(k):
        index = int(l[i])
        centpoint[i] = data[index]
    return centpoint


##进行KMeans分类
def KMeans(data, k):
    ##样本个数
    num = np.shape(data)[0]

    ##记录各样本 簇信息 0:属于哪个簇 1:距离该簇中心点距离
    cluster = np.zeros((num, 2))
    cluster[:, 0] = -1

    ##记录是否有样本改变簇分类
    change = True
    ##初始化各簇中心点
    cp = initCentroid(data, k)

    while change:
        change = False

        ##遍历每一个样本
        for i in range(num):
            minDist = 9999.9
            minIndex = -1

            ##计算该样本距离每一个簇中心点的距离 找到距离最近的中心点
            for j in range(k):
                dis = distEuclid(cp[j], data[i])
                if dis < minDist:
                    minDist = dis
                    minIndex = j

            ##如果找到的簇中心点非当前簇 则改变该样本的簇分类
            if cluster[i, 0] != minIndex:
                change = True
                cluster[i, :] = minIndex, minDist

        ## 根据样本重新分类  计算新的簇中心点
        for j in range(k):
            pointincluster = data[[x for x in range(num) if cluster[x, 0] == j]]
            cp[j] = np.mean(pointincluster, axis=0)

    print("finish!")
    return cp, cluster


##展示结果  各类簇使用不同的颜色  中心点使用X表示
def Show(data, k, cp, cluster):
    num, dim = data.shape
    color = ['b', 'r', 'g', 'c', 'y', 'm', 'k']
    ##二维图
    if dim == 2:
        for i in range(num):
            mark = int(cluster[i, 0])
            plt.plot(data[i, 0], data[i, 1], color[mark] + 'o')

        for i in range(k):
            plt.plot(cp[i, 0], cp[i, 1], color[i] + 'x')
    ##三维图
    elif dim == 3:
        ax = plt.subplot(122, projection='3d')
        for i in range(num):
            mark = int(cluster[i, 0])
            ax.scatter(data[i, 0], data[i, 1], data[i, 2], c=color[mark])
            ax.set_title('k-means result')
        for i in range(k):
            ax.scatter(cp[i, 0], cp[i, 1], cp[i, 2], c=color[i], marker='x')

    plt.show()
if __name__ == "__main__":
        data = load_iris()#以字典形式加载鸢尾花数据集
        y = data.target #使用y表示数据集中的标签
        x = data.data #使用x表示数据集中的属性数据
        #使用PCA 算法，设置降维后主成分数目为 2
        #print(x,'\n', y)
        #print(x)
        #print(type(x))
        size = 20  ##取值范围
        pca = PCA(n_components=3)
        #对原始数据进行降维，保存在 reduced_X 中
        reduced_X = pca.fit_transform(x)
        print('降维后的数据为:\n',reduced_X)#降维后的数据
        print('各主成分方差解释度为：',pca.explained_variance_ratio_)#方差解释度
        print('主成分对应的载荷矩阵为',pca.components_)
        red_x, red_y , red_z = [], [],[]
        blue_x, blue_y , blue_z= [], [],[]
        green_x, green_y, green_z=[],[],[]

        for i in range(len(reduced_X)):
            #标签为0时，3维标签数据保存到列表red_x,red_y,redz中
            if y[i] == 0:
                red_x.append(reduced_X[i][0])
                red_y.append(reduced_X[i][1])
                red_z.append(reduced_X[i][2])#
            elif y[i] == 1:
                blue_x.append(reduced_X[i][0])
                blue_y.append(reduced_X[i][1])
                blue_z.append(reduced_X[i][2])#
            else:
                green_x.append(reduced_X[i][0])
                green_y.append(reduced_X[i][1])
                green_z.append(reduced_X[i][2])#
        X = reduced_X[:, :3]  # #表示我们取特征空间中的3个维度
       #print(X.shape)
       #print(X)
       #print(type(X))
        num = 50 ##点个数
        k=3 ##分类个数
        data = X
        cp,cluster = KMeans(data,k)
        ax=plt.figure().add_subplot(121,projection='3d')
        ax.scatter(red_x, red_y,red_z,c='r', marker='o')
        ax.scatter(blue_x, blue_y,blue_z,c='b', marker='o')
        ax.scatter(green_x, green_y,green_z,c='g', marker='o')#散点图中用s，其余图用markersize可调节散点的大小
        ax.set_title('PCA result')
        Show(data,k,cp,cluster)









 

 一，鸢尾花Iris数据集解析
 
 
 
 
 
 
 
 
二，绘制Iris数据集散点图，数据集已经给出具体类别
 
from sklearn import datasets
import matplotlib.pyplot as plt

#加载数据集，是一个字典类似Java中的map
lris_df = datasets.load_iris()


#挑选出前两个维度作为x轴和y轴，你也可以选择其他维度
x_axis = lris_df.data[:,0]
y_axis = lris_df.data[:,2]

#c指定点的颜色，当c赋值为数值时，会根据值的不同自动着色
plt.scatter(x_axis, y_axis, c=lris_df.target)
plt.show()
 
 
 
 三，Python使用kmeans聚类，并绘制新的聚类散点图。
 
from sklearn import datasets
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

#加载数据集，是一个字典类似Java中的map
lris_df = datasets.load_iris()

#挑选出前两个维度作为x轴和y轴，你也可以选择其他维度
x_axis = lris_df.data[:,0]
y_axis = lris_df.data[:,2]


#这里已经知道了分3类，其他分类这里的参数需要调试
model = KMeans(n_clusters=3)

#训练模型
model.fit(lris_df.data)

#选取行标为100的那条数据，进行预测
prddicted_label= model.predict([[6.3, 3.3, 6, 2.5]])

#预测全部150条数据
all_predictions = model.predict(lris_df.data)

#打印出来对150条数据的聚类散点图
plt.scatter(x_axis, y_axis, c=all_predictions)
plt.show()
 
 
 
 
 
四，也可以聚成两类：
 
#将类别参数改成2
model = KMeans(n_clusters=2)
 
 
 
 五，kmeans算法流程
 
      1）随机选取k个点作为种子点(这k个点不一定属于数据集，k个点就代表有k类)
 
      2）分别计算每个数据点到k个种子点的距离，离哪个种子点最近，就属于哪类
 
      3）重新计算k个种子点的坐标(简单常用的方法是求坐标值的平均值作为新的坐标值)
 
      4）重复2、3步，直到种子点坐标不变或者循环次数完成
 
 
 六，kmeans的不足
 
 
 
    1）初始分类数目k值很难估计，不确定应该分成多少类才最合适(ISODATA算法通过类的自动合并和分裂，得到较为合理的类型数目k)（meanshift也可以不用提前知道分多少类别，参考博文：https://blog.csdn.net/u010916338/article/details/86495308）
 
    2）不同的随机种子会得到完全不同的结果(K-Means++算法可以用来解决这个问题，其可以有效地选择初始点)

 
 
 
  
 
   
Python
 
  
 
  
 
   
 
    

    

     
    
    

     
    
 
    
from sklearn import datasets
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

# 加载数据集，是一个字典类似Java中的map
lris_df = datasets.load_iris()

# 挑选出前两个维度作为x轴和y轴，你也可以选择其他维度
x_axis = lris_df.data[:, 0]
y_axis = lris_df.data[:, 2]

# 这里已经知道了分3类，其他分类这里的参数需要调试
model = KMeans(n_clusters=3)

# 训练模型
model.fit(lris_df.data)

# 选取行标为100的那条数据，进行预测
# prddicted_label = model.predict([[6.3, 3.3, 6, 2.5]])

# 预测全部150条数据
all_predictions = model.predict(lris_df.data)

# 打印出来对150条数据的聚类散点图
plt.scatter(x_axis, y_axis, c=all_predictions)
plt.show()
 
   
 
  
 
 
 
 
 
  
 
   
Spark-Mlib
 
  
 
  
 
   
 
    
package com.kami.demo01

import org.apache.spark.SparkContext
import org.apache.spark.ml.clustering.{KMeans, KMeansModel}
import org.apache.spark.ml.feature.{MinMaxScaler, MinMaxScalerModel}
import org.apache.spark.sql.{DataFrame, SparkSession}


object rua01 {

  /**
   * 安德森鸢尾花卉数据集
   * https://download.csdn.net/download/qq_33887096/12573555
   * 其数据集包含了150个样本，都属于鸢尾属下的三个亚属，分别是山鸢尾、变色鸢尾和维吉尼亚鸢尾。四个特征被用作样本的定量分析，它们分别是花萼和花瓣的长度和宽度。基于这四个特征的集合，费雪发展了一个线性判别分析以确定其属种。
   * IRIS数据集由Fisher在1936年整理的一个经典数据集，在统计学习和机器学习领域都经常被用作示例。
   * 数据集内包含 3 类共 150 条记录，每类各 50 个数据，每条数据包含4个特征，都是浮点数，单位为厘米。
   * Sepal.Length(花萼长度)
   * Sepal.Width(花萼宽度)
   * Petal.Length(花瓣长度)
   * Petal.Width(花瓣宽度))
   *
   * 目标值为鸢尾花的分类:
   * Iris Setosa(山鸢尾)
   * Iris Versicolour(杂色鸢尾)
   * Iris Virginica(维吉尼亚鸢尾)
   *
   *
   * K-Means 使用的数据格式libSVM
   * libsvm数据格式
   * libsvm使用的训练数据和检验数据文件格式如下：
   * 1. [label] [index1]:[value1] [index2]:[value2] …
   * 2. [label] [index1]:[value1] [index2]:[value2] …
   * label  目标值，就是class(属于哪一类)， 要分类的种类，通常是一些整数。
   * index 是有顺序的索引，通常是连续的整数。就是指特征编号，必须按照升序排列
   * value 就是特征值，用来train的数据，通常是一堆实数组成。
   * 样例数据
   * 1 1:5.1 2:3.5 3:1.4 4:0.2
   * 1 1:4.9 2:3.0 3:1.4 4:0.2
   * 1 1:4.7 2:3.2 3:1.3 4:0.2
   * 1 1:4.6 2:3.1 3:1.5 4:0.2
   *
   * @param args
   */

  def main(args: Array[String]): Unit = {
    // 屏蔽日志
    //    Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
    //    Logger.getLogger("org.apache.jetty.server").setLevel(Level.OFF)

    // 设置运行环境
    val sparkSession: SparkSession = SparkSession.builder().master("local[*]").appName("K-Means").getOrCreate()
    val sparkContext: SparkContext = sparkSession.sparkContext
    sparkContext.setLogLevel("warn")

    val irisLibSvmDF = sparkSession.read.format("libsvm").load("data\\iris_kmeans.txt")
    //    irisLibSvmDF.show(false)

    /**
     * 数据归一化(将数据归一到0-1之间，计算速度快)
     * 把数据映射到0～1范围之内处理，更加便捷快速
     * MinMaxScaler  把有量纲表达式变成无量纲表达式，便于不同单位或量级的指标能够进行比较和加权。
     * x = (x - X_min) / (X_max - X_min)
     */

    val scalerDatas: MinMaxScalerModel = new MinMaxScaler()
      .setInputCol("features") //设置需要归一化的列
      .setOutputCol("featuresOut") //归一化后的数据的列名字
      .fit(irisLibSvmDF) //设置数据

    val scalerDF: DataFrame = scalerDatas.transform(irisLibSvmDF)
    //    scalerDF.show(false)

    //使用kmeans进行计算
    val prediction: KMeansModel = new KMeans()
      .setK(3) //设置需要划分类别的数量/个数
      .setMaxIter(10) //设置最大计算次数
      .setFeaturesCol("featuresOut") //设置特征的列    归一化后的列
      .setPredictionCol("predictionValue") //设置最终预测后的结果列名
      .setSeed(20) //设置随机种子    在运行多次时结果相同
      .fit(scalerDF)


    val predictionDF: DataFrame = prediction.transform(scalerDF)
    //    predictionDF.show(false)

    predictionDF.groupBy("label", "predictionValue").count().show()

    sparkContext.stop()
    sparkSession.stop()
  }
}
 
   
 
  
 
 
 
 
 
  
 
   
Spark-ML
 
  
 
  
 
   
 
    
package com.kami.demo01

import org.apache.spark.SparkContext
import org.apache.spark.ml.feature.StringIndexerModel
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.{DataFrame, Row, SparkSession}

/**
 * http://spark.apache.org/docs/latest/mllib-clustering.html#k-means
 * 聚类分析是一个无监督学习 (Unsupervised Learning) 过程, 一般是用来对数据对象按照其特征属性进行分组，经常被应用在客户分群，欺诈检测，图像分析等领域。K-means 应该是最有名并且最经常使用的聚类算法了，其原理比较容易理解，并且聚类效果良好，有着广泛的使用。
 * K-means是聚类算法重较为简单的一种，其属于无监督学习，所以训练样本中没有没有类别标签，只有特征。
 */

/**
 * 安德森鸢尾花卉数据集(英文：Anderson's Iris data set)，也称鸢尾花卉数据集(英文：Iris flower data set)或费雪鸢尾花卉数据集(英文：Fisher's Iris data set)，是一类多重变量分析的数据集。它最初是埃德加·安德森从加拿大加斯帕半岛上的鸢尾属花朵中提取的形态学变异数据[1]，后由罗纳德·费雪作为判别分析的一个例子[2]，运用到统计学中。
 * http://archive.ics.uci.edu/ml/datasets/Iris
 * 费雪鸢尾花卉数据集
 * 花萼长度	花萼宽度	花瓣长度	花瓣宽度	属种
 */

object rua02 {
  def main(args: Array[String]): Unit = {
    val sparkSession: SparkSession = SparkSession.builder().master("local[*]").appName("wula").getOrCreate()
    val sparkContext: SparkContext = sparkSession.sparkContext
    sparkContext.setLogLevel("warn")
    val structType: StructType = new StructType().add("Sepal.Length", "double").add("Sepal.Width", "double").add("Petal.Length", "double").add("Petal.Width", "double").add("Species", "string")
    val fileRdd: RDD[String] = sparkContext.textFile("file:///C:\\tool\\dev\\JAVA\\2020.06\\day0624_work01\\data\\iris.data")
    //    fileRdd.foreach(x=>println(x))
    val fileRddC: RDD[Row] = fileRdd.filter(x => !x.equals("")).map(_.split(",")).map(x => Row(x(0).toDouble, x(1).toDouble, x(2).toDouble, x(3).toDouble, x(4)))
    val df: DataFrame = sparkSession.createDataFrame(fileRddC, structType)
    //    df.show(false)

    //特征索引转化
    import org.apache.spark.ml.feature.StringIndexer
    val indexer: StringIndexer = new StringIndexer().setInputCol("Species").setOutputCol("categoryIndex")
    val model: StringIndexerModel = indexer.fit(df)
    val indexed: DataFrame = model.transform(df)
    indexed.show()

    sparkContext.stop()
    sparkSession.stop()
  }
}