kmeans处理大数据_python中kmeans算法数据处理 - CSDN
  • K-Means算法是常用的聚类算法,但其算法本身存在一定的问题,例如在大数据量下的计算时间过长就是一个重要问题。为此,Mini Batch K-Means,这个基于K-Means的变种聚类算法应运而生。 大数据量是什么量级?...

    K-Means算法是常用的聚类算法,但其算法本身存在一定的问题,例如在大数据量下的计算时间过长就是一个重要问题。为此,Mini Batch K-Means,这个基于K-Means的变种聚类算法应运而生。

    大数据量是什么量级?通过当样本量大于1万做聚类时,就需要考虑选用Mini Batch K-Means算法。但是,在选择算法时,除了算法效率(运行时间)外,算法运行的准确度也是选择算法的重要因素。Mini Batch K-Means算法的准确度如何?

    minibatchkmeans11

    上图是我们队3万的样本点分别使用K-Means和Mini Batch KMeans进行聚类的结果,由结果可知,在3万样本点的基础上,二者的运行时间相差2倍多,但聚类结果差异却很小(右侧粉红色的错误点)。

    因此,Mini Batch KMeans是一种能尽量保持聚类准确性下但能大幅度降低计算时间的聚类模型。

    K-Means的计算时间到底跟样本量之间是怎样的关系(用脚想也知道是样本量越大,计算时间越长),我们用一个实例来实验下。在下面的例子中,利用Python生成一个具有三个分类类别的样本类,其中的样本点(二维空间)的数量从100开始增长到1000000(步长为1000),我们用图例来看看计算时间与样本量的关系。(为了得到下面这幅图,我等了2个小时)结果如下:

    time_minibatchkmeans11

    从图中可以发现,在样本点为二维空间前提下,当数据量在2之下时,计算时间都可以接受(2秒以内);但是计算时间跟数据量基本成线性关系,计算1000000个样本聚类耗时近16秒。由此可以试想,如果你的观测点有更多维度(更多维度意味着需要更多的计算量),那么耗时将比上述场景大很多。

    回到本文的主体算法Mini Batch KMeans上来,应用Mini Batch KMeans能尽量在保持数据准确性的前提下降低运算时间,它是怎么做到的?

    Mini Batch KMeans使用了一个种叫做Mini Batch(分批处理)的方法对数据点之间的距离进行计算。Mini Batch的好处是计算过程中不必使用所有的数据样本,而是从不同类别的样本中抽取一部分样本来代表各自类型进行计算。由于计算样本量少,所以会相应的减少运行时间,但另一方面抽样也必然会带来准确度的下降。

    实际上,这种思路不仅应用于K-Means聚类,还广泛应用于梯度下降、深度网络等机器学习和深度学习算法。

    Mini Batch KMeans的使用方法非常简单,跟K-Means一样,在Python的机器学习库SKlearn中,通过fit方法训练数据,然后通过labels_ 属性获得每个样本点的聚类结果值。演示代码如下:

    1. #coding:utf-8
    2. import numpy as np
    3. from sklearn.cluster import MiniBatchKMeans
    4. from sklearn import datasets
    5. np.random.seed(5)
    6. iris = datasets.load_iris()
    7. X = iris.data
    8. clf = MiniBatchKMeans(n_clusters = 3)
    9. clf.fit(X)
    10. pre_clu = clf.labels_
    11. #将原始数据集X和聚类结果标签组合成新数据集并输出前10条
    12. new_X = np.column_stack((X, pre_clu))
    13. print new_X[:10]

    运行结果如下:

    1. array([[ 5.1,  3.5,  1.4,  0.2,  1. ],
    2.        [ 4.9,  3. ,  1.4,  0.2,  1. ],
    3.        [ 4.7,  3.2,  1.3,  0.2,  1. ],
    4.        [ 4.6,  3.1,  1.5,  0.2,  1. ],
    5.        [ 5. ,  3.6,  1.4,  0.2,  1. ],
    6.        [ 5.4,  3.9,  1.7,  0.4,  1. ],
    7.        [ 4.6,  3.4,  1.4,  0.3,  1. ],
    8.        [ 5. ,  3.4,  1.5,  0.2,  1. ],
    9.        [ 4.4,  2.9,  1.4,  0.2,  1. ],
    10.        [ 4.9,  3.1,  1.5,  0.1,  1. ]])

     

    应用场景,由于Mini Batch KMeans跟K-Means是极其相似的两种聚类算法,因此应用场景基本一致,具体请参考K均值(K-Means)

    其中,Mini Batch KMeans可配置的参数如下:

    1. class sklearn.cluster.MiniBatchKMeans(n_clusters=8, init='k-means++', max_iter=100, batch_size=100, verbose=0, compute_labels=True, random_state=None, tol=0.0, max_no_improvement=10, init_size=None, n_init=3, reassignment_ratio=0.01)

     


     

    尾巴

    默认情况下,无论是K-Means还是MiniBatchKMeans都是需要指定聚类数量,即算法里面的n_clusters参数值,但实际应用时发现不指定也是可以的。这并不意味着Python会“自动”帮你选择最佳类别数,而是已经预置了一个默认的类别8。如果你不去设置,它会默认分为8个类别。既然是通过Mini Batch进行抽样,那到底Mini Batch是什么?Mini Batch是原始数据集中的子集,这个子集是在每次训练迭代时抽取抽取的样本。这个值默认是100个,可以通过batch_size进行设置。

    展开全文
  • K-Means算法是无监督的聚类算法,它实现起来比较简单,聚类效果也不错,因此...包括初始化优化K-Means++, 距离计算优化elkan K-Means算法和大数据情况下的优化Mini Batch K-Means算法。 1. K-Means原理初探  K-Me...

     K-Means算法是无监督的聚类算法,它实现起来比较简单,聚类效果也不错,因此应用很广泛。K-Means算法有大量的变体,本文就从最传统的K-Means算法讲起,在其基础上讲述K-Means的优化变体方法。包括初始化优化K-Means++, 距离计算优化elkan K-Means算法和大数据情况下的优化Mini Batch K-Means算法。

    1. K-Means原理初探

        K-Means算法的思想很简单,对于给定的样本集,按照样本之间的距离大小,将样本集划分为K个簇。让簇内的点尽量紧密的连在一起,而让簇间的距离尽量的大。

        如果用数据表达式表示,假设簇划分为(C1,C2,...Ck)(C1,C2,...Ck),则我们的目标是最小化平方误差E:

    E=∑i=1k∑x∈Ci||x−μi||22E=∑i=1k∑x∈Ci||x−μi||22

        其中μiμi是簇CiCi的均值向量,有时也称为质心,表达式为:

    μi=1|Ci|∑x∈Cixμi=1|Ci|∑x∈Cix

        如果我们想直接求上式的最小值并不容易,这是一个NP难的问题,因此只能采用启发式的迭代方法。

        K-Means采用的启发式方式很简单,用下面一组图就可以形象的描述。

      上图a表达了初始的数据集,假设k=2。在图b中,我们随机选择了两个k类所对应的类别质心,即图中的红色质心和蓝色质心,然后分别求样本中所有点到这两个质心的距离,并标记每个样本的类别为和该样本距离最小的质心的类别,如图c所示,经过计算样本和红色质心和蓝色质心的距离,我们得到了所有样本点的第一轮迭代后的类别。此时我们对我们当前标记为红色和蓝色的点分别求其新的质心,如图4所示,新的红色质心和蓝色质心的位置已经发生了变动。图e和图f重复了我们在图c和图d的过程,即将所有点的类别标记为距离最近的质心的类别并求新的质心。最终我们得到的两个类别如图f。

            当然在实际K-Mean算法中,我们一般会多次运行图c和图d,才能达到最终的比较优的类别。

     

    2. 传统K-Means算法流程

    算法步骤:

    1.(随机)选择K个聚类的初始中心;

    2.对任意一个样本点,求其到K个聚类中心的距离,将样本点归类到距离最小的中心的聚类,如此迭代n次;

    3.每次迭代过程中,利用均值等方法更新各个聚类的中心点(质心);

    4.对K个聚类中心,利用2,3步迭代更新后,如果位置点变化很小(可以设置阈值),则认为达到稳定状态,迭代结束,对不同的聚类块和聚类中心可选择不同的颜色标注。

    优点 
    1)原理比较简单,实现也是很容易,收敛速度快。 
    2)聚类效果较优。 
    3)算法的可解释度比较强。 
    4)主要需要调参的参数仅仅是簇数k。

    缺点 
    1)K值的选取不好把握 
    2)对于不是凸的数据集比较难收敛 
    3)如果各隐含类别的数据不平衡,比如各隐含类别的数据量严重失衡,或者各隐含类别的方差不同,则聚类效果不佳。 
    4) 最终结果和初始点的选择有关,容易陷入局部最优。
    5) 对噪音和异常点比较的敏感。

    3. K-Means初始化优化K-Means++

           k个初始化的质心的位置选择对最后的聚类结果和运行时间都有很大的影响,因此需要选择合适的k个质心。如果仅仅是完全随机的选择,有可能导致算法收敛很慢。K-Means++算法就是对K-Means随机初始化质心的方法的优化。

        K-Means++的对于初始化质心的优化策略也很简单,如下:

        a)  从输入的数据点集合中随机选择一个点作为第一个聚类中心μ1
          b) 对于数据集中的每一个点xi,计算它与已选择的聚类中心中最近聚类中心的距离D(xi)=argmin||xi−μr||^2……r=1,2,...kselected

        c) 选择下一个新的数据点作为新的聚类中心,选择的原则是:D(x)较大的点,被选取作为聚类中心的概率较大
        d) 重复b和c直到选择出k个聚类质心
        e) 利用这k个质心来作为初始化质心去运行标准的K-Means算法

    K-Means++对初始聚类中心点的选取做了优化,简要来说就是使初始聚类中心点尽可能的分散开来,这样可以有效的减少迭代次数,加快运算速度。

    4. K-Means距离计算优化elkan K-Means

      在传统的K-Means算法中,我们在每轮迭代时,要计算所有的样本点到所有的质心的距离,这样会比较的耗时。那么,对于距离的计算有没有能够简化的地方呢?elkan K-Means算法就是从这块入手加以改进。它的目标是减少不必要的距离的计算。那么哪些距离不需要计算呢?

      elkan K-Means利用了两边之和大于等于第三边,以及两边之差小于第三边的三角形性质,来减少距离的计算。

      第一种规律是对于一个样本点xx和两个质心μj1,μj2。如果我们预先计算出了这两个质心之间的距离D(j1,j2),则如果计算发现2D(x,j1)≤D(j1,j2),我们立即就可以知道D(x,j1)≤D(x,j2)。此时我们不需要再计算D(x,j2),也就是说省了一步距离计算。

       第二种规律是对于一个样本点x和两个质心μj1,μj2。我们可以得到D(x,j2)≥max{0,D(x,j1)−D(j1,j2)}。这个从三角形的性质也很容易得到。

      利用上边的两个规律,elkan K-Means比起传统的K-Means迭代速度有很大的提高。但是如果我们的样本的特征是稀疏的,有缺失值的话,这个方法就不使用了,此时某些距离无法计算,则不能使用该算法。

          个人理解,第一个规律简单有效,很容易理解,但是第二个规律对简化运算量的意义不是很大。

    5. 大样本优化Mini Batch K-Means

      在统的K-Means算法中,要计算所有的样本点到所有的质心的距离。如果样本量非常大,比如达到10万以上,特征有100以上,此时用传统的K-Means算法非常的耗时,就算加上elkan K-Means优化也依旧。在大数据时代,这样的场景越来越多。此时Mini Batch K-Means应运而生。

      顾名思义,Mini Batch,也就是用样本集中的一部分的样本来做传统的K-Means,这样可以避免样本量太大时的计算难题,算法收敛速度大大加快。当然此时的代价就是我们的聚类的精确度也会有一些降低。一般来说这个降低的幅度在可以接受的范围之内。

      在Mini Batch K-Means中,我们会选择一个合适的批样本大小batch size,我们仅仅用batch size个样本来做K-Means聚类。那么这batch size个样本怎么来的?一般是通过无放回的随机采样得到的。

      为了增加算法的准确性,我们一般会多跑几次Mini Batch K-Means算法,用得到不同的随机采样集来得到聚类簇,选择其中最优的聚类簇。

    该算法的迭代步骤有两步:

    1:从数据集中随机抽取一些数据形成小批量,把他们分配给最近的质心

    2:更新质心

    与K均值算法相比,数据的更新是在每一个小的样本集上。对于每一个小批量,通过计算平均值得到更新质心,并把小批量里的数据分配给该质心,随着迭代次数的增加,这些质心的变化是逐渐减小的,直到质心稳定或者达到指定的迭代次数,停止计算

    Mini Batch K-Means比K-Means有更快的 收敛速度,但同时也降低了聚类的效果,但是在实际项目中却表现得不明显。个人理解,Mini Batch K-Means通过小样本的实验,可以初步预测聚类中心的位置,对n次Mini Batch K-Means的聚类结果取均值作为大样本实验初始聚类中心的位置,也能够减少运算量,加快聚类速度。

    下边给出显示上边这副图的代码,也是对K-Means和Mini Batch K-Means算法的一个比较:

    import time
     
    import numpy as np
    import matplotlib.pyplot as plt
     
    from sklearn.cluster import MiniBatchKMeans, KMeans
    from sklearn.metrics.pairwise import pairwise_distances_argmin
    from sklearn.datasets.samples_generator import make_blobs
     
    ##############################################################################
    # Generate sample data
    np.random.seed(0)
     
    batch_size = 45
    centers = [[1, 1], [-1, -1], [1, -1]] #初始化三个中心
    n_clusters = len(centers)       #聚类的数目为3
    #产生3000组两维的数据,以上边三个点为中心,以(-10,10)为边界,数据集的标准差是0.7
    X, labels_true = make_blobs(n_samples=3000, centers=centers, cluster_std=0.7)
     
    ##############################################################################
    # Compute clustering with Means
     
    k_means = KMeans(init='k-means++', n_clusters=3, n_init=10)
    t0 = time.time() #当前时间
    k_means.fit(X)
    #使用K-Means 对 3000数据集训练算法的时间消耗
    t_batch = time.time() - t0
     
    ##############################################################################
    # Compute clustering with MiniBatchKMeans
     
    mbk = MiniBatchKMeans(init='k-means++', n_clusters=3, batch_size=batch_size,
                          n_init=10, max_no_improvement=10, verbose=0)
    t0 = time.time()
    mbk.fit(X)
    #使用MiniBatchKMeans 对 3000数据集训练算法的时间消耗
    t_mini_batch = time.time() - t0
     
    ##############################################################################
    # Plot result
     
    #创建一个绘图对象, 并设置对象的宽度和高度, 如果不创建直接调用plot, Matplotlib会直接创建一个绘图对象
    '''
    当绘图对象中有多个轴的时候,可以通过工具栏中的Configure Subplots按钮,
    交互式地调节轴之间的间距和轴与边框之间的距离。
    如果希望在程序中调节的话,可以调用subplots_adjust函数,
    它有left, right, bottom, top, wspace, hspace等几个关键字参数,
    这些参数的值都是0到1之间的小数,它们是以绘图区域的宽高为1进行正规化之后的坐标或者长度。
    '''
    fig = plt.figure(figsize=(8, 3))
    fig.subplots_adjust(left=0.02, right=0.98, bottom=0.05, top=0.9)
    colors = ['#4EACC5', '#FF9C34', '#4E9A06']
     
    # We want to have the same colors for the same cluster from the
    # MiniBatchKMeans and the KMeans algorithm. Let's pair the cluster centers per
    # closest one.
    k_means_cluster_centers = np.sort(k_means.cluster_centers_, axis=0)
    mbk_means_cluster_centers = np.sort(mbk.cluster_centers_, axis=0)
    k_means_labels = pairwise_distances_argmin(X, k_means_cluster_centers)
    mbk_means_labels = pairwise_distances_argmin(X, mbk_means_cluster_centers)
    order = pairwise_distances_argmin(k_means_cluster_centers,
                                      mbk_means_cluster_centers)
     
    # KMeans
    ax = fig.add_subplot(1, 3, 1) #add_subplot  图像分给为 一行三列,第一块
    for k, col in zip(range(n_clusters), colors):
        my_members = k_means_labels == k
        cluster_center = k_means_cluster_centers[k]
        ax.plot(X[my_members, 0], X[my_members, 1], 'w',
                markerfacecolor=col, marker='.')
        ax.plot(cluster_center[0], cluster_center[1], 'o', markerfacecolor=col,
                markeredgecolor='k', markersize=6)
    ax.set_title('KMeans')
    ax.set_xticks(())
    ax.set_yticks(())
    plt.text(-3.5, 1.8,  'train time: %.2fs\ninertia: %f' % (
        t_batch, k_means.inertia_))
     
    # MiniBatchKMeans
    ax = fig.add_subplot(1, 3, 2)#add_subplot  图像分给为 一行三列,第二块
    for k, col in zip(range(n_clusters), colors):
        my_members = mbk_means_labels == order[k]
        cluster_center = mbk_means_cluster_centers[order[k]]
        ax.plot(X[my_members, 0], X[my_members, 1], 'w',
                markerfacecolor=col, marker='.')
        ax.plot(cluster_center[0], cluster_center[1], 'o', markerfacecolor=col,
                markeredgecolor='k', markersize=6)
    ax.set_title('MiniBatchKMeans')
    ax.set_xticks(())
    ax.set_yticks(())
    plt.text(-3.5, 1.8, 'train time: %.2fs\ninertia: %f' %
             (t_mini_batch, mbk.inertia_))
     
    # Initialise the different array to all False
    different = (mbk_means_labels == 4)
    ax = fig.add_subplot(1, 3, 3)#add_subplot  图像分给为 一行三列,第三块
     
    for k in range(n_clusters):
        different += ((k_means_labels == k) != (mbk_means_labels == order[k]))
     
    identic = np.logical_not(different)
    ax.plot(X[identic, 0], X[identic, 1], 'w',
            markerfacecolor='#bbbbbb', marker='.')
    ax.plot(X[different, 0], X[different, 1], 'w',
            markerfacecolor='m', marker='.')
    ax.set_title('Difference')
    ax.set_xticks(())
    ax.set_yticks(())
     
    plt.show()

    运行结果如下:

     

    6. K-Means与KNN

        初学者很容易把K-Means和KNN搞混,两者其实差别还是很大的。

        K-Means是无监督学习的聚类算法,没有样本输出;而KNN是监督学习的分类算法,有对应的类别输出。KNN基本不需要训练,对测试集里面的点,只需要找到在训练集中最近的k个点,用这最近的k个点的类别来决定测试点的类别。而K-Means则有明显的训练过程,找到k个类别的最佳质心,从而决定样本的簇类别。

        当然,两者也有一些相似点,两个算法都包含一个过程,即找出和某一个点最近的点。两者都利用了最近邻(nearest neighbors)的思想。

    列个表格对比一下特点:

    KNN

    K-Means

    1.KNN是分类算法 

     

    2.监督学习 

    3.喂给它的数据集是带label的数据,已经是完全正确的数据

    1.K-Means是聚类算法 

     

    2.非监督学习 

    3.喂给它的数据集是无label的数据,是杂乱无章的,经过聚类后才变得有点顺序,先无序,后有序

    没有明显的前期训练过程,属于memory-based learning 有明显的前期训练过程
    K的含义:来了一个样本x,要给它分类,即求出它的y,就从数据集中,在x附近找离它最近的K个数据点,这K个数据点,类别c占的个数最多,就把x的label设为c K的含义:K是人工固定好的数字,假设数据集合可以分为K个簇,由于是依靠人工定好,需要一点先验知识
       
    相似点:都包含这样的过程,给定一个点,在数据集中找离它最近的点。即二者都用到了NN(Nears Neighbor)算法,一般用KD树来实现NN。

     

    7.应用实例

    这是官网的一个例子,详细参见:http://scikit-learn.org/stable/auto_examples/cluster/plot_color_quantization.html#sphx-glr-auto-examples-cluster-plot-color-quantization-py

    执行夏宫(中国)图像的逐像素矢量量化(VQ),将显示图像所需的颜色数量从96,615种独特颜色减少到64,同时保持整体外观质量。

    在该示例中,像素在3D空间中表示,并且K均值用于找到64个颜色簇。在图像处理文献中,从K-means(聚类中心)获得的码本被称为调色板。使用单个字节,可以寻址多达256种颜色,而RGB编码每个像素需要3个字节。例如,GIF文件格式使用这样的调色板。

    为了比较,还示出了使用随机码本(随机拾取的颜色)的量化图像。

     

    print(__doc__)
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.cluster import KMeans
    from sklearn.metrics import pairwise_distances_argmin
    from sklearn.datasets import load_sample_image
    from sklearn.utils import shuffle
    from time import time

    n_colors = 64

    # Load the Summer Palace photo
    china = load_sample_image("china.jpg")

    # Convert to floats instead of the default 8 bits integer coding. Dividing by
    # 255 is important so that plt.imshow behaves works well on float data (need to
    # be in the range [0-1])
    china = np.array(china, dtype=np.float64) / 255

    # Load Image and transform to a 2D numpy array.
    w, h, d = original_shape = tuple(china.shape)
    assert d == 3
    image_array = np.reshape(china, (w * h, d))

    print("Fitting model on a small sub-sample of the data")
    t0 = time()
    image_array_sample = shuffle(image_array, random_state=0)[:1000]
    kmeans = KMeans(n_clusters=n_colors, random_state=0).fit(image_array_sample)
    print("done in %0.3fs." % (time() - t0))

    # Get labels for all points
    print("Predicting color indices on the full image (k-means)")
    t0 = time()
    labels = kmeans.predict(image_array)
    print("done in %0.3fs." % (time() - t0))


    codebook_random = shuffle(image_array, random_state=0)[:n_colors + 1]
    print("Predicting color indices on the full image (random)")
    t0 = time()
    labels_random = pairwise_distances_argmin(codebook_random,
                                              image_array,
                                              axis=0)
    print("done in %0.3fs." % (time() - t0))


    def recreate_image(codebook, labels, w, h):
        """Recreate the (compressed) image from the code book & labels"""
        d = codebook.shape[1]
        image = np.zeros((w, h, d))
        label_idx = 0
        for i in range(w):
            for j in range(h):
                image[i][j] = codebook[labels[label_idx]]
                label_idx += 1
        return image

    # Display all results, alongside original image
    plt.figure(1)
    plt.clf()
    ax = plt.axes([0, 0, 1, 1])
    plt.axis('off')
    plt.title('Original image (96,615 colors)')
    plt.imshow(china)

    plt.figure(2)
    plt.clf()
    ax = plt.axes([0, 0, 1, 1])
    plt.axis('off')
    plt.title('Quantized image (64 colors, K-Means)')
    plt.imshow(recreate_image(kmeans.cluster_centers_, labels, w, h))

    plt.figure(3)
    plt.clf()
    ax = plt.axes([0, 0, 1, 1])
    plt.axis('off')
    plt.title('Quantized image (64 colors, Random)')
    plt.imshow(recreate_image(codebook_random, labels_random, w, h))
    plt.show()

    第二个例子:

    实例说明:利用sklearn.datasets.make_blobs产生1500条两维的数据集进行不同情况下的聚类示例,参见网址:https://blog.csdn.net/gamer_gyt/article/details/51244850

    代码如下

    import numpy as np      #科学计算包
    import matplotlib.pyplot as plt      #python画图包
     
    from sklearn.cluster import KMeans       #导入K-means算法包
    from sklearn.datasets import make_blobs
     
    plt.figure(figsize=(12, 12))
     
    """
    make_blobs函数是为聚类产生数据集
    产生一个数据集和相应的标签
    n_samples:表示数据样本点个数,默认值100
    n_features:表示数据的维度,默认值是2
    centers:产生数据的中心点,默认值3
    cluster_std:数据集的标准差,浮点数或者浮点数序列,默认值1.0
    center_box:中心确定之后的数据边界,默认值(-10.0, 10.0)
    shuffle :洗乱,默认值是True
    random_state:官网解释是随机生成器的种子
    更多参数即使请参考:http://scikit-learn.org/dev/modules/generated/sklearn.datasets.make_blobs.html#sklearn.datasets.make_blobs
    """
    n_samples = 1500
    random_state = 170
    X, y = make_blobs(n_samples=n_samples, random_state=random_state)
     
     
    # Incorrect number of clusters
    y_pred = KMeans(n_clusters=2, random_state=random_state).fit_predict(X)
     
    plt.subplot(221)  #在2图里添加子图1
    plt.scatter(X[:, 0], X[:, 1], c=y_pred) #scatter绘制散点
    plt.title("Incorrect Number of Blobs")   #加标题
     
    # Anisotropicly distributed data
    transformation = [[ 0.60834549, -0.63667341], [-0.40887718, 0.85253229]]
    X_aniso = np.dot(X, transformation)    #返回的是乘积的形式
    y_pred = KMeans(n_clusters=3, random_state=random_state).fit_predict(X_aniso)
     
    plt.subplot(222)#在2图里添加子图2
    plt.scatter(X_aniso[:, 0], X_aniso[:, 1], c=y_pred)
    plt.title("Anisotropicly Distributed Blobs")
     
    # Different variance
    X_varied, y_varied = make_blobs(n_samples=n_samples,
                                    cluster_std=[1.0, 2.5, 0.5],
                                    random_state=random_state)
    y_pred = KMeans(n_clusters=3, random_state=random_state).fit_predict(X_varied)
     
    plt.subplot(223)#在2图里添加子图3
    plt.scatter(X_varied[:, 0], X_varied[:, 1], c=y_pred)
    plt.title("Unequal Variance")
     
    # Unevenly sized blobs
    X_filtered = np.vstack((X[y == 0][:500], X[y == 1][:100], X[y == 2][:10]))
    y_pred = KMeans(n_clusters=3, random_state=random_state).fit_predict(X_filtered)
     
    plt.subplot(224)#在2图里添加子图4
    plt.scatter(X_filtered[:, 0], X_filtered[:, 1], c=y_pred)
    plt.title("Unevenly Sized Blobs")
     
    plt.show() #显示图</span>

     

    参考网址:

    https://www.cnblogs.com/pinard/p/6164214.html

    https://blog.csdn.net/sinat_35512245/article/details/55051306

    https://en.wikipedia.org/wiki/K-means_clustering

    http://scikit-learn.org/stable/auto_examples/cluster/plot_color_quantization.html#sphx-glr-auto-examples-cluster-plot-color-quantization-py

     

    展开全文
  • k-means 聚类算法

    2014-12-20 14:47:10
    聚类算法 一、聚类算法简介: 1、什么是聚类? 将物理或抽象对象的集合分组成为有类似的对象组成的多个簇的过程被称为聚类。由聚类所生成的簇是一组数据对象的集合,这些对象与同一个簇中的对象彼此相似,与其它...

    聚类算法

    一、聚类算法简介:

    1、什么是聚类?

    将物理或抽象对象的集合分组成为有类似的对象组成的多个簇的过程被称为聚类。由聚类所生成的簇是一组数据对象的集合,这些对象与同一个簇中的对象彼此相似,与其它簇中的对象相异。在许多应用中,可以将一个簇中的数据对象作为一个整体来对待。

    2.分类:

    大体上,主要的聚类技术可以划分为如下几类:

    A.划分方法

      给定一个个对象或元组的数据库,一个划分方法构建数据的k个划分,每个划分表示一个聚簇,并且k<=n。也就是说,它将数据划分为k个组,同时满足如下要求:

      (i)每个组至少包含一个对象;

      (ii)每个对象必须属于且只属于一个组。

      给定要构建的划分数目k,划分方法首先创建一个初始划分。然后采用一种迭代的重定位技术,尝试通过对象在划分间移动来改进划分。一个好的划分的一般准则是:在同一类中的对象之间尽可能“接近”或相关,而不同类中的对象之间尽可能“远离”或不同。还有许多其它划分质量评判准则。

      为了达到全局最优,基于划分的聚类会要求穷举三所有可能的划分。实际上,绝大多数应用采用了以下两个比较流行的启发式方法:

      (1)聚于质心的技术: k-平均方法

      k-平均算法以k为参数,把n个对象分为k个簇,以使簇内具有较高的相似度,而簇间的相似度较低。相似度的计算根据一个簇中对象的平均值(被看作簇的重心)来进行。

      k-平均算法的处理流程如下。首先,随机地选择k个对象,每个对象初始地代表一个簇的平均值或中心。对剩余的每个对象,根据其与各个簇中心的距离,将它赋给最近的簇。然后重新计算每个簇的平均值。这个过程不断重复,直到准则函数收敛。通常采用平方误差准则,其定义如下:

      (2-1)

      这里的E是数据库中所有对象的平方误差的总和,p是空间的点,表示给定的数据对象,mi是簇Ci的平均值(p 和mi都是多维的)。这个准则是使图生成的结果簇尽可能的紧凑和独立。

      例1 假设有一个分布在空间中的对象集合,如图2-1所示。给定k=3,即要求将这些对象聚类为三个簇。根据k-平均算法,我们任意选择三个对象作为初始簇的中心,簇中心在图中用“+”来标示。根据与簇中心的距离,每个对象分配给离其最近的一个簇。这样分布形成如图a中所绘的图形。

      这样的分组会改变聚类的中心,也就是说,每个聚类的平均值会根据类中的对象重新计算。依据这些新的聚类中心,对象被重新分配到各个类中。这样重新分配形成了图b中描绘的轮廓。

    以上的过程重复产生了图c的情况。最后,当没有对象重新分配发生时,处理过程结束,聚类的结果被返回。

    图2-1 基于K-means方法的一组对象的聚类

      这个算法尝试找出是平方误差函数值最小的K个划分,当结果簇是密集的,而簇与簇之间区别明显时,它的效果较好。对处理大数据集,该算法是相对可伸缩的和高效率的,因为它的复杂程度是 O(nkt)。其中,n是所有对象的数目,k是簇的数目,t是迭代的数目。通常的,k<

      但是,k-平均方法只有在簇的平均值被定义的情况下使用。这可能不适应某些应用。例如涉及有分类属性的数据。要求用户必须事先给出k(要生成的簇的数目)可能算是该方法的一个缺点。K-平均方法不适合于发现非凸面形状的簇,或者大小差别很大的簇,并且,它对于“噪声”和孤立点数据很敏感,少量的该类数据能够对平均值产生很大影响。

      (2)基于有代表性的对象的技术 k-中心点方法

      采用簇中位置最中心的对象,作为参照点即中心点,这样划分依然是基于最小化所有对象与参照点之间的相异度之和的原则来执行的。这是k-中心点的基础。它的基本策略是:首先为每个簇随意选择一个代表对象;剩余对象根据与代表对象的距离分配给最近的一个簇。然后反复用非代表对象代替代表对象,以改进聚类的质量。聚类结果的质量用一个代价函数来估算,该函数度量对象与参照对象之间的平均相异度。为了判定一个非代表对象是否是当前一个代表对象的好的替代,对于每一个非中心点对象p,下面的四种情况被考虑:

      ·第一种情况:p当前隶属于中心点Oj。如果Oj被Orandom所代替作为中心点,且p离一个Oi最近,i≠j,那么p被重新分配给Oi.

      ·第二种情况:p当前隶属于中心点Oj.如果Oj被Orandom代替作为中心点,且p离Orandom最近,那么p被重新分配给Orandom。

      ·第三种情况:p当前隶属于中心点Oi,i≠j。如果Oj 被Orandom代替作为一个中心点,而p依然离Oi最近,那么对象的隶属不发生变化。

      ·第四种情况: p当前隶属于中心点Oi,i≠j。如果Oj 被Orandom代替作为一个中心点,且p离Orandom最近,那么p被重新分配给Orandom。

      “那个方法更健壮:k-平均或者k-中心点?”当存在“噪声”和孤立点数据时,k-中心点比k-平均更健壮,这是因为中心点不像平均值那样容易受到极端数据影响。但是,k-中心点的执行代价比k-平均方法高.

      这些启发式方法对中小规模的数据库中发现球状簇很实用。为了对大规模的数据集进行聚类,以及处理复杂形状的聚类,基于划分的方法需要进一步的扩展。

    B.层次的方法

      一个层次的聚类方法将数据对象组成一棵聚类的树。根据层次分解是自底向上的还是自顶向下形成的,层次的聚类方法可以进一步分为凝聚的(agglomerative)和分裂的(divisive)层次聚类。

      (1)凝聚的层次聚类:这种自底向上的策略首先将每个对象作为单独的一个簇,然后和并这些原子簇为越来越大的簇,直到所有的对像都在一个簇中,或者达到某个终止条件。

     

      (2)分裂的层次聚类:这种自顶向下的策略与凝聚的层次聚类相反,它首先将所有的对象置于一个簇中。然后逐渐细分为越来越小的簇,直到每个对象在单独的一个簇中,或者达到一个终止条件,例如打到了某个希望的簇数目后者两个簇之间的距离超过了某个阀值。

      例2 图2-3描述了一个凝聚的层次聚类方法AGNES(Agglomerative NESting)和一个分裂的层次聚类方法DIANA(Divisive Analysis)在一个包含五个对象的数据集合{a,b,c,d,e}上的处理过程。最初,AGNES将每个对象作为一个簇,然后这些簇根据某些准则一步步合并。例如,如果簇C1中的一个对象和簇 C2中的一个对象之间的距离使所有属于不同簇的对象间欧式距离最小的,C1和C2可能被合并。其每个簇可以被簇中所有对象代表,两个簇间的相似度由两个不同簇中距离最近的数据点对的相似度来确定。聚类的合并过程反复进行直到所有对象最终合并为一个簇。

      在DIANA方法处理过程中,所有的对象都放在一个簇中。根据一些原则(如簇中最邻近的对象的最大欧氏距离),将该簇分裂。簇的分裂过程反复进行,直到最终每个新的簇只包含一个对象。

      层次聚类方法尽管简单,但经常会遇到合并或分裂点选择的困难。这样的选择是非常关键的,因为一旦一组对象(合并或分裂)完成,它就不能被撤销,下一步的处理将在新完成的簇上进行。这个严格规定是有用的,由于不用担心组合数目的不同选择,计算代价会比较小。但是,已做的处理不能被撤消,聚类之间也不能交换对象。如果在某一步没有很好的选择合并或分裂的决定,可能会导致低质量的聚类结果。而且,这种聚类不具有很好的可伸缩性。因为合并或分裂的决定需要检查和估算大量的对象或结果。

      改进层次方法的聚类质量的一个有希望的方向是将层次聚类和其他聚类技术集成。有两种方法可以改进层次聚类的结果:

      (i) 在每层划分中,仔细分析对象间的“联接”,例如CURE和Chameleon中的做法。

    (ii)综合层次凝聚和迭代的重定位方法。首先用自底向上的层次算法,然后用迭代的重定位来改进结果。例如BIRCH中的方法。

    C.基于密度的方法

      绝大多数划分方法给予对象之间的距离进行聚类。这样的方法只能发现球状的簇,而在发现任意形状的簇上遇到了困难。随之提出了基于密度的聚类方法,它是将簇看作是数据空间中被低密度区域分割开的高密度区域。其主要思想是:只要邻近区域的密度(对象或数据点的数目)超出了某个阀值,就继续聚类。也就是说,对给定类中的每个数据点,在一个给定范围的区域中必须至少某个数目的点。这样的方法可以用来过滤“噪声”孤立点数据,发现任意形状的簇。

      DBSCAN是一个有代表性的基于密度的方法,它根据一个密度阀值来控制簇的增长。

      OPTICS是另一个基于密度的方法,它为自动的和交互的聚类分析计算一个聚类顺序。

    D、基于网格的方法

      基于网格的方法把对象空间量化为有限数目的单元,形成一个网格结构。所有的聚类操作都在这个网格结构(即量化的空间)上进行。这种方法的主要优点是处理速度快,其处理时间独立与数据对象的数目,只与量化空间中的每一维的单元数目有关。

      基于网格方法的有代表性的例子:STING,它利用存储在网格单元中的统计信息;WaveCluster,它利用一种小波变换方法来聚类对象;CLIQUE,它是在高维数据空间中基于网格和密度的聚类方法。

    E、基于模型的方法

      基于模型的方法为每一个簇假定一个模型,寻找数据对给定模型的最佳拟合。一个基于模型的算法可能通过构建反映数据点空间分布密度函数来定位聚类。它也基于标准的统计数字自动决定聚类的数目,考虑“噪声”数据或孤立点,从而产生健壮的聚类方法。这样的方法经常基于这样的假设:数据是根据潜在的概率分布生成的。

      基于模型的方法主要有两类:统计学方法和神经网络方法。

      一些聚类算法集成了多种聚类方法的思想,所以有时将某个给定的算法划分为属于某些聚类方法是困难的。此外,某些应用可能有特定的聚类标准,要求综合多个聚类技术。

    3、对比:

    算法

    算法效率

    适合的数据类型

    发现的聚类类型

    对脏数据或异常数据的敏感性

    对数据输入顺序的敏感性

    BIRCH

    数值

    凸形或球形 

    不敏感

    不太敏感

    DBSCAN

    一般

    数值

    任意形状

    敏感

    敏感

    CURE

    较高

    数值

    任意形状

    不敏感 

    不太敏感

    K-poto

    一般

    数值和符号

    凸形或球形

    敏感 

    一般

    CLARANS

    较低

    数值

    凸形或球形

    不敏感

    非常敏感

    CUQUE

    较低

    数值

    凸形或球形

    一般

    不敏感

      

    二、k-means算法:

    1、简介:

    此算法以K为参数,把N个对象分为K个簇,以使簇内具有较高的相似度,而且簇间的相似度较低。相似度的计算根据一个簇中对象的平均值来进行。

    此算法的工作过程为:首先从N个数据对象任意选择K个对象作为初始聚类中心;而对于所剩下其它对象,则根据它们与这些聚类中心的相似度(距离),分别将它们分配给与其最相似的(聚类中心所代表的)聚类;然后再计算每个所获新聚类的聚类中心(该聚类中所有对象的均值);不断重复这一过程直到标准测度函数开始收敛为止。

    一般都采用均方差作为标准测度函数.K个聚类具有以下特点:各聚类本身尽可能的紧凑,而各聚类之间尽可能的分开。

    K-MEANS算法的具体流程如下:
    1)从N个数据对象任意选择K个对象作为初始聚类中心;
    2
    )根据每个聚类对象的均值(中心对象),计算每个对象与这些中心对象的距离;并根据最小距离重新对相应对象进行划分;
    3
    )重新计算每个(有变化)聚类的均值(中心对象)
    4
    )重复2/3步直到满足既定的条件,算法结束。

     

    k-means算法流程图

    2、伪码算法:

     

    展开全文
  • 基于LRFMC+KMeans航空大数据客户价值分析 ** (客户是公司存在的意义根本,如何找出价值客户, 针对性提供更个性化的服务? 公司资源是有限的,如何把有限的资源用在高价值的客户上?怎么才算有价值?产品面要大...

    **

    基于LRFMC+KMeans航空大数据客户价值分析

    **
    (客户是公司存在的意义根本,如何找出价值客户, 针对性提供更个性化的服务?
    公司资源是有限的,如何把有限的资源用在高价值的客户上?怎么才算有价值?产品面要大,客户人群才广,同时分类营销,分类服务)所以客户分类是企业数据分析的核心任务。。
    吸引一般客户–培养一般客户–价值客户–vip客户
    LRFMC模型:航空领域做价值分析的模型
    KMeans方法:实现聚类的机器学习方法
    背景:
    通过某航空公司多年的客户信息历史数据(6万余条),将客户进行分类。
    分为:价值客户(优质服务)、保持客户(服务+价格)、发展客户(价格)、挽留客户
    根据分类制定不同的销售策略。

    目标:
    1. 完成历史样本数据的预处理,便于适合后续算法模型使用
    2. 算法模型的选型、训练、智能分类的实现
    3. 根据分类的客户群,制定不同的销售策略

    工作流程:
    一、行业背景知识
    1. 了解行业背景知识—基础
    2. 掌握行业专业术语
    3. 对历史数据文件进行初步探索分析

    二、领域标准分析模型
    4. 了解行业客户价值分析通用模型 RFM
    5. 了解航空领域专业客户价值分析模型 LRFMC

    三、科学计算与数据分析(本阶段项目任务)
    6. 抽取数据
    7. 数据探索分析
    8. 数据预处理
    8.1 数据清洗
    8.2 属性规约
    8.3 数据变换

    四、人工智能算法模型训练(下阶段人工智能项目任务,非本阶段项目任务)
    9. 构建算法模型K-Means
    10. 算法模型训练
    11. 实现历史客户分类

    五、根据结论得出最终结果
    12. 客户群数据特征分析可视化
    13. 客户群特征描述

    需要了解行业,没有行业知识无从下手

    专业航空领域的数据模型
    kmeans是实现手段
    1.1 需求背景
    信息时代的来临是的企业营销焦点从产品中心转变为客户中心,客户关系管理成为企业的核心问题。客户关系管理的关键问题是客户分类,通过客户分类,区分无价值客户、高价值客户,企业针对不同价值的客户指定优化的个性化服务,采取不同营销策略,将优先营销资源集中与高价值客户,实现企业利润最大化目标。准确的客户分类结果是企业精准营销的最重要参考依据。有限的资源需要花在刀刃上。

    面对市场竞争,各个航空该公司都推出了更优惠的营销方式来吸引更多的客户,国内能够航空公司面临着旅客流失、竞争力下降和航空资源未充分利用等经营危机。通过建立合理的客户价值评估模型、对客户进行分群,分析比较不同客户群的客户价值,并制定相应的营销策略,对不同的客户群提供个性化的客户服务是必须和有效的。目前该航空公司已积累了大量的会员档案信息和其乘坐航班的记录。经过加工后得到表1所示的部分数据信息。
    优质客户优质服务,要做精准营销,高价值客户是利润增长点。有限的
    FIRST_FLIGHT_DATE 62988 non-null object
    GENDER 62985 non-null object
    FFP_TIER 62988 non-null int64
    WORK_CITY 60719 non-null object
    WORK_PROVINCE 59740 non-null object
    WORK_COUNTRY 62962 non-null object
    AGE 62568 non-null float64
    LOAD_TIME 62988 non-nul
    其中很多不满62988条数据的字段,不重要不需要管他。我们根据我们的模型就处理我们关注的字段即可。

    data_clean.py 数据清洗

    目标:清洗不满足条件的原始数据,并将最终结果保存成excel文件

    步骤1:导入pandas模块

    import pandas as pd,import os

    步骤2:设置原始数据文件的地址

    csvFile = os.getcwd() + ‘\data’ + os.sep + ‘air_data.csv’

    csvFile = ‘./data/air_data.csv’

    步骤3:使用pd.read_csv()函数读取数据

    data = pd.read_csv(csvFile, encoding=’utf-8’)

    步骤4:输出前5条测试片段数据

    print(data.head())

    步骤5:输出数据的统计信息

    print(data.info()) #62988条记录 全部记录

    步骤6:设置初步筛选的条件

    condition = data[‘SUM_YR_1’].notnull() & data[‘SUM_YR_2’].notnull()

    步骤7:初步删选原始数据,将第1年飞行累计和第2年飞行累计进行筛选过滤

    data = data[condition]

    print(data) #运行后62299 比上一次62988少

    步骤8:设置数据过滤的条件

    condition1 = data[‘SUM_YR_1’] != 0 #第一年总票价不等于0 :SUM_YR_1
    condition2 = data[‘SUM_YR_2’] != 0 #第二年总票价不等于0:SUM_YR_2
    condition3 = (data[‘SEG_KM_SUM’] != 0) & (data[‘avg_discount’] != 0)#总飞行公里数 SEG_KM_SUM 平均折扣率 avg_discount

    步骤9:根据过滤条件筛选数据

    data = data[condition1 | condition2 | condition3]

    print(‘\n 筛选之后的数据’)

    print(data) #运行后62292比上一次少7行

    步骤10:设置excel文件的保存存储路径

    excelPath = os.getcwd() + ‘\out’ + os.sep + ‘cleaned.xls’
    print(excelPath)

    步骤11:将最终的数据探索结果保存到一个excel的中间文件中cleaned.xls

    data.to_excel(excelPath)
    print(‘>>数据清洗结束,并保存结果数据文件.’) #运行后,cleaned.xls文件出现

    累计62292条数据 第一行是目录

    data_explore.py数据探索

    目标:通过对历史数据aire_data.csv的分析,得到所有44个数据属性的空值个数、最小值以及最大值三个数据指标

    步骤1:导入pandas模块

    import pandas as pd,import os

    步骤2:设置原始数据文件的地址

    csvFile = os.getcwd() + ‘\data’ + os.sep + ‘air_data.csv’

    步骤3:使用pd.read_csv()函数读取数据

    data = pd.read_csv(csvFile, encoding=’utf-8’)

    步骤4:输出前5条测试片段数据

    print(data.head())

    步骤5:输出数据的统计信息

    print(data.info())

    步骤6:获取数据中的空值项———–

    Pandas模块库中 describe( ) 函数获取数据并转置。percentiles参数是指计算多少的分位数表—–(如1/4分位数、中位数等);

    自动计算非空值数据,???–就是把空值补为nan标志。T 是转置,转之后的数据方便我们后续查阅及使用。

    explore = data.describe(percentiles=[], include=’all’).T #主要目的:填空值为nan,且转置

    print(‘设置数据中的空值项统计:’)

    print(explore)

    步骤7:计算每个属性的空值个数

    explore[‘null’] = len(data) - explore[‘count’]

    print(‘每个属性的空值个数:’)

    print(explore[‘null’]) #SUM_YR_1 551 SUM_YR_2 138

    步骤8:抽取数据中的空值个数null、最大值max、最小值min三个数据属性(数据选项) ?????????

    explore = explore[[‘null’, ‘max’, ‘min’]]

    步骤9:重置列索引名称

    explore.columns = [‘空值数’, ‘最大值’, ‘最小值’]
    print(‘\n数据探索整理之后的数据结果:’)
    print(explore)

    步骤10:设置excel文件的保存存储路径

    excelPath = os.getcwd() + ‘\out’ + os.sep + ‘explore.xls’

    步骤11:将最终的数据探索结果保存到一个excel的中间文件中explore.xls

    explore.to_excel(excelPath)
    print(‘>>数据探索结束,并保存结果数据文件.’) #生成文件explore.py 10kb


    data_reduction.py数据规约(挑选需要的数据属性)与转换
    目标:根据LRFMC模型从原始数据中选取指定的属性数据项

    步骤1:导入pandas模块

    import pandas as pd;import os

    步骤2:设置原始清洗后的数据文件的地址

    excelFile = os.getcwd() + ‘\out’ + os.sep + ‘cleaned.xls’

    步骤3:使用pd.ExcelFile()函数读取excel文件 之前read csv能读几种文件??

    ef = pd.ExcelFile(excelFile, encoding=’utf-8’)

    步骤4:读取到有效Sheet页数据并转换成DataFrame对象

    data = ef.parse(‘Sheet1’)
    print(data.head())# 步骤4:输出前5条测试片段数据
    print(data.info())# 步骤5:输出数据的统计信息

    步骤6:筛选出核心的6个数据属性

    data = data[[‘FFP_DATE’, ‘LOAD_TIME’, ‘FLIGHT_COUNT’, ‘avg_discount’, ‘SEG_KM_SUM’, ‘LAST_TO_END’]]

    print(data.info()) # 运行以后[62292 rows x 6 columns] # print(data)

    # 步骤7:获取L属性的数据 同时给上索引 L R F M C 对吧——–???

    data[‘L’] = (pd.to_datetime(data[‘LOAD_TIME’]) - pd.to_datetime(data[‘FFP_DATE’]))/30

    to_datetime 得到的是天数

    data[‘R’] = data[‘LAST_TO_END’]/30
    data[‘F’] = data[‘FLIGHT_COUNT’]
    data[‘M’] = data[‘SEG_KM_SUM’]
    data[‘C’] = data[‘avg_discount’]

    print(data[[‘L’, ‘R’, ‘F’, ‘M’, ‘C’]]) #运行以后 [62292 rows x 5 columns]

    步骤8:设置excel文件的保存存储路径

    excelPath = os.getcwd() + ‘\out’ + os.sep + ‘reduction.xls’

    步骤11:将最终的数据探索结果保存到一个excel的中间文件中explore.xls

    data.to_excel(excelPath)
    print(‘>>数据规约、变换,并保存结果数据文件.’)
    个指标的数据提取后,对每个指标数据分布情况进行分析,其数据的取值范围见表7。

    表7:LRFMC指标取值范围
    属性名称 L R F M C
    最小值 12.23 0.03 2 368 0.14
    最大值 114.63 24.37 213 580 717 1.5
    从表7中数据可以发现,5个指标的取值范围数据差异较大,为了消除数量级数据带来的影响,需要对数据进行标准化处理。
    标准差标准化处理的Python代码清单如下所示,datafile 为输入数据文件,zscoredata为标准差标准化后的数据集。
    data_std.py数据标准化计算

    目标:获取到最终的标准数据样本

    步骤1:导入pandas模块

    import pandas as pd;import os

    步骤2:设置原始清洗后的数据文件的地址

    excelFile = os.getcwd() + ‘\data’ + os.sep + ‘zscoredata.xls’

    步骤3:使用pd.ExcelFile()函数读取数据

    ef = pd.ExcelFile(excelFile, encoding=’utf-8’)

    步骤4:读取到有效Sheet页数据并转换成DataFrame对象

    data = ef.parse(‘Sheet1’)

    步骤4:输出前5条测试片段数据

    print(data.head())

    步骤5:输出数据的统计信息

    print(data.info())

    步骤6:对数据进行标准化计算 每项数据减去数据(axis=0)平均值

    后除以数据(axis=0)的标准差值(—-???)std(axis=0)。

    标准pian差:标准差(Standard Deviation)又称均方差,是离均差平方的算术平均数的平方根,用σ表示。

    标准差是方差的算术平方根。标准差能反映一个数据集的离散程度。一个较大的标准差,代表大部分数值和

    其平均值之间差异较大;一个较小的标准差,代表这些数值较接近平均值。

    data = (data - data.mean(axis=0))/(data.std(axis=0))
    print(‘\n标准化计算后的数据:’)
    print(data)

    步骤8:设置excel文件的保存存储路径

    excelPath = os.getcwd() + ‘\out’ + os.sep + ‘zscoredata.xls’

    步骤9:重新设置数据列索引名称

    data.columns = [‘Z’+i for i in data.columns]

    步骤10:将最终的数据探索结果保存到一个excel的中间文件中zscoredata.xls

    data.to_excel(excelPath, index=False)
    print(‘>>数据标准化完毕,并保存结果数据文件.’)
    zscoredata.xls 6.7m文件形成 ,看下图 项目就结束了

    这里写图片描述

    展开全文
  • import numpy as np from sklearn.datasets import make_blobs ...from sklearn.cluster import KMeans from sklearn.metrics import pairwise_distances import matplotlib.pyplot as plt import matplo...
    import numpy as np
    
    from sklearn.datasets import make_blobs
    from sklearn.cluster import KMeans
    from sklearn.metrics import pairwise_distances
    import matplotlib.pyplot as plt
    import matplotlib as mpl
    from cycler import cycler
    
    from .tools import discrete_scatter
    from .plot_2d_separator import plot_2d_classification
    from .plot_helpers import cm3
    
    
    def plot_kmeans_algorithm():
    
        X, y = make_blobs(random_state=1)
        # we don't want cyan in there
        with mpl.rc_context(rc={'axes.prop_cycle': cycler('color', ['#0000aa',
                                                                    '#ff2020',
                                                                    '#50ff50'])}):
            fig, axes = plt.subplots(3, 3, figsize=(10, 8), subplot_kw={'xticks': (), 'yticks': ()})
            axes = axes.ravel()
            axes[0].set_title("Input data")
            discrete_scatter(X[:, 0], X[:, 1], ax=axes[0], markers=['o'], c='w')
    
            axes[1].set_title("Initialization")
            init = X[:3, :]
            discrete_scatter(X[:, 0], X[:, 1], ax=axes[1], markers=['o'], c='w')
            discrete_scatter(init[:, 0], init[:, 1], [0, 1, 2], ax=axes[1],
                             markers=['^'], markeredgewidth=2)
    
            axes[2].set_title("Assign Points (1)")
            km = KMeans(n_clusters=3, init=init, max_iter=1, n_init=1).fit(X)
            centers = km.cluster_centers_
            # need to compute labels by hand. scikit-learn does two e-steps for max_iter=1
            # (and it's totally my fault)
            labels = np.argmin(pairwise_distances(init, X), axis=0)
            discrete_scatter(X[:, 0], X[:, 1], labels, markers=['o'],
                             ax=axes[2])
            discrete_scatter(init[:, 0], init[:, 1], [0, 1, 2],
                             ax=axes[2], markers=['^'], markeredgewidth=2)
    
            axes[3].set_title("Recompute Centers (1)")
            discrete_scatter(X[:, 0], X[:, 1], labels, markers=['o'],
                             ax=axes[3])
            discrete_scatter(centers[:, 0], centers[:, 1], [0, 1, 2],
                             ax=axes[3], markers=['^'], markeredgewidth=2)
    
            axes[4].set_title("Reassign Points (2)")
            km = KMeans(n_clusters=3, init=init, max_iter=1, n_init=1).fit(X)
            labels = km.labels_
            discrete_scatter(X[:, 0], X[:, 1], labels, markers=['o'],
                             ax=axes[4])
            discrete_scatter(centers[:, 0], centers[:, 1], [0, 1, 2],
                             ax=axes[4], markers=['^'], markeredgewidth=2)
    
            km = KMeans(n_clusters=3, init=init, max_iter=2, n_init=1).fit(X)
            axes[5].set_title("Recompute Centers (2)")
            centers = km.cluster_centers_
            discrete_scatter(X[:, 0], X[:, 1], labels, markers=['o'],
                             ax=axes[5])
            discrete_scatter(centers[:, 0], centers[:, 1], [0, 1, 2],
                             ax=axes[5], markers=['^'], markeredgewidth=2)
    
            axes[6].set_title("Reassign Points (3)")
            labels = km.labels_
            discrete_scatter(X[:, 0], X[:, 1], labels, markers=['o'],
                             ax=axes[6])
            markers = discrete_scatter(centers[:, 0], centers[:, 1], [0, 1, 2],
                                       ax=axes[6], markers=['^'],
                                       markeredgewidth=2)
    
            axes[7].set_title("Recompute Centers (3)")
            km = KMeans(n_clusters=3, init=init, max_iter=3, n_init=1).fit(X)
            centers = km.cluster_centers_
            discrete_scatter(X[:, 0], X[:, 1], labels, markers=['o'],
                             ax=axes[7])
            discrete_scatter(centers[:, 0], centers[:, 1], [0, 1, 2],
                             ax=axes[7], markers=['^'], markeredgewidth=2)
            axes[8].set_axis_off()
            axes[8].legend(markers, ["Cluster 0", "Cluster 1", "Cluster 2"], loc='best')
    
    
    def plot_kmeans_boundaries():
        X, y = make_blobs(random_state=1)
        init = X[:3, :]
        km = KMeans(n_clusters=3, init=init, max_iter=2, n_init=1).fit(X)
        discrete_scatter(X[:, 0], X[:, 1], km.labels_, markers=['o'])
        discrete_scatter(km.cluster_centers_[:, 0], km.cluster_centers_[:, 1],
                         [0, 1, 2], markers=['^'], markeredgewidth=2)
        plot_2d_classification(km, X, cm=cm3, alpha=.4)
    
    
    def plot_kmeans_faces(km, pca, X_pca, X_people, y_people, target_names):
        n_clusters = 10
        image_shape = (87, 65)
        fig, axes = plt.subplots(n_clusters, 11, subplot_kw={'xticks': (), 'yticks': ()},
                                 figsize=(10, 15), gridspec_kw={"hspace": .3})
    
        for cluster in range(n_clusters):
            center = km.cluster_centers_[cluster]
            mask = km.labels_ == cluster
            dists = np.sum((X_pca - center) ** 2, axis=1)
            dists[~mask] = np.inf
            inds = np.argsort(dists)[:5]
            dists[~mask] = -np.inf
            inds = np.r_[inds, np.argsort(dists)[-5:]]
            axes[cluster, 0].imshow(pca.inverse_transform(center).reshape(image_shape), vmin=0, vmax=1)
            for image, label, asdf, ax in zip(X_people[inds], y_people[inds],
                                              km.labels_[inds], axes[cluster, 1:]):
                ax.imshow(image.reshape(image_shape), vmin=0, vmax=1)
                ax.set_title("%s" % (target_names[label].split()[-1]), fontdict={'fontsize': 9})
    
        # add some boxes to illustrate which are similar and which dissimilar
        rec = plt.Rectangle([-5, -30], 73, 1295, fill=False, lw=2)
        rec = axes[0, 0].add_patch(rec)
        rec.set_clip_on(False)
        axes[0, 0].text(0, -40, "Center")
    
        rec = plt.Rectangle([-5, -30], 385, 1295, fill=False, lw=2)
        rec = axes[0, 1].add_patch(rec)
        rec.set_clip_on(False)
        axes[0, 1].text(0, -40, "Close to center")
    
        rec = plt.Rectangle([-5, -30], 385, 1295, fill=False, lw=2)
        rec = axes[0, 6].add_patch(rec)
        rec.set_clip_on(False)
        axes[0, 6].text(0, -40, "Far from center")

    过程解析:

    在大数据集的情况下还可以使用scikit-learn 提供了MiniBatchKMeans算法,大致思想就是对数据进行抽样,每次不使用所有的数据来计算,这就会导致准确率的损失。

    MiniBatchKmeans 继承自Kmeans 因为MiniBathcKmeans 本质上还利用了Kmeans 的思想.从构造方法和文档大致能看到这些参数的含义,了解了这些参数会对使用的时候有很大的帮助。batch_size 是每次选取的用于计算的数据的样本量,默认为100.Mini Batch K-Means算法是K-Means算法的变种,采用小批量的数据子集减小计算时间,同时仍试图优化目标函数,这里所谓的小批量是指每次训练算法时所随机抽取的数据子集,采用这些随机产生的子集进行训练算法,大大减小了计算时间,与其他算法相比,减少了k-均值的收敛时间,小批量k-均值产生的结果,一般只略差于标准算法。

    代码只需要修改一行:

    clf = MiniBatchKMeans(n_clusters = 3)

     

    展开全文
  • 本文转载自:k-means|endymecy 前言 k-means、k-means++以及k-means||算法分析 本文会介绍一般的k-means算法、k-means++算法以及基于k-means++算法的k-means||算法。在spark ml,已经实现了k-means算法以及k-...
  • python Kmeans算法解析

    2018-11-05 21:52:00
    一. 概述 首先需要先介绍一下无监督学习,所谓无监督学习,...聚类算法可以对数据进行数据归约,即在尽可能保证数据完整的前提下,减少数据的量级,以便后续处理。也可以对聚类数据结果直接应用或分析。 而Kmeans...
  • 大数据的采集是指利用多个数据库来接收发自客户端(Web、App或者传感器形式等)的 数据,并且用户可以通过这些数据库来进行简单的查询和处理工作。比如,电商会使用传统的关系型数据库MySQL和Oracle等来存储每一笔事务...
  • K-MEANS

    2018-07-17 11:04:08
    K-means   聚类就是对大量未知标注的数据集,按照数据内部存在的数据特征将数据集划分为不同的类别,使类别内的数据比较相似,类别间的数据相似度比较小,是一种无监督学习算法。 聚类算法的重点是计算样本项...
  • 这是一份迟来的年终报告,本来昨天就要发出来的,实在是没忙开,今天我就把它当作新年礼物送给各位看官,以下文章都是我结合日常工作、学习,每当“夜深人静"的时候写出来的一些小总结,希望...
  • 一、大数据是指无法在一定时间内用常规软件工具对其内容进行抓取、管理和处理的数据集合。大数据技术,是指从各种各样类型的数据中,快速获得有价值信息的能力。适用于大数据的技术,包括大规模并行处理(MPP)...
  • 1.导入相关的包 import numpy as np import pandas as pd import matplotlib.pyplot as plt 2.导入数据 # 导入航空公司会员客户数据 df = pd.read_csv(r"C:\Python\基于数据挖掘技术的航空公司会员客户价值研究报告...
  • 转自:https://www.cnblogs.com/itdyb/p/5691958.html准确的客户分类的结果是企业优化营销资源的重要依据,本文利用了航空公司的部分数据,利用Kmeans聚类方法,对航空公司的客户进行了分类,来识别出不同的客户群体...
  • Spark MLlib 机器学习—Kmeans 聚类算法分析足球比赛 一、实验介绍 1.1 内容介绍 K-means 算法采用距离作为相似性的评价指标,即认为两个对象的距离越近,其相似度就越大。该算法认为类簇是由距离靠近的对象组成的,...
  • kmeans优缺点 及改进

    2016-04-29 10:49:53
    Kmeans: 优点: 简单易实现 缺点: 可能收敛于局部最小值(对初始k个聚类中心的选择敏感),在大规模数据集上收敛较慢 适用数据类型:数值型数据 度量聚类效果的指标: SSE(sum of squared error, 误差平方...
  • 大数据时代处理数据理念的三大转变:要全体不要抽样,要效率不要绝对精确,要相关不要因果。 大数据时代处理数据理念的三大转变:要全体不要抽样,要效率不要绝对精确,要相关不要因果。 大数据处理的流程  ...
  • Kmeans是一种非监督的聚类方法,是最常用的聚类技术之一。kmeans尝试找到数据的自然类别,通过用户设定的类别个数K,它可以快速的找到“好的”类别中心,“好的”意味着聚类中心位于数据的自然中心。 (一)算法步骤...
  • 写在前面: 博主是一名软件工程系大数据应用开发专业大二的学生,昵称来源于《爱丽丝梦游仙境》中的Alice和自己的昵称。作为一名互联网小白,写博客一方面是为了记录自己的学习历程,一方面是希望能够帮助到很多和...
  • 这次课程主要讲述一个关于Kmeans聚类的数据分析案例,通过这个案例让同学们简单了解大数据分析的基本流程,以及使用Python实现相关的聚类分析。 主要内容包括: 1.Anaconda软件的安装过程及简单配置 2.聚类及...
  • 一,题记要说当下IT行业什么最火?...二,大数据里面的角色角色一:大数据工程大数据工程需要解决数据的定义、收集、计算与保存的工作,因此大数据工程师们在设计和部署这样的系统时首要考虑的是...
1 2 3 4 5 ... 20
收藏数 2,587
精华内容 1,034
关键字:

kmeans处理大数据