精华内容
下载资源
问答
  • 主要介绍了Python实现的KMeans聚类算法,结合实例形式较为详细的分析了KMeans聚类算法概念、原理、定义及使用相关操作技巧,需要的朋友可以参考下
  • 该文档详细地讲述了kmeans聚类算法的概念,以及各个参数,各个参数的属性的详细意思及应用,并且通过及例分析讲述了该算法 的应用。
  • matlab kmeans聚类,里面包括代码和例子以及聚类后的图片
  • 上课,老师让做作业,kmeans分类,将iris进行聚类分类,于是就做了这个作业。很简单,我就将其设置为分三类,重点是我在选择初始center的时候,尝试了使用随机选取和使用大招选取两种方式,随机选择初始点的效果不如...

    上课,老师让做作业,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文件中的字符类型转化为数字标签。

    展开全文
  • 特别地,数据集中给定实例对之间的必须链接约束和不能链接约束是当今许多聚类算法中所包​​含的常识。 事实证明,这种方法可以成功地指导许多著名的聚类算法获得更准确的结果。 但是,最近的工作还表明,必须链接...
  • Kmeans聚类算法实例程序源码 K-means 1、kmeans+PSO(matlab代码,以IRIS数据集为输入,用kmeans+PSO对其进行聚类,效果比kmeans好,可以绘制聚类图,并动态显示粒子运动轨迹) 2、kmeans聚类 matlab(多维kmeans...

    Kmeans聚类算法实例程序源码 K-means
    1、kmeans+PSO(matlab代码,以IRIS数据集为输入,用kmeans+PSO对其进行聚类,效果比kmeans好,可以绘制聚类图,并动态显示粒子运动轨迹)
    2、kmeans聚类 matlab(多维kmeans聚类,有数据例程,有轮廓系数评价聚类效果 )
    3、kmeans图像分类 (利用matlab实现的k均值算法,对不同主体的图片进行分类,内含图片资源,分类为人,建筑,车,恐龙,大象和海滩风景)
    4、KMeans+BOF实现图像检索(Matlab)
    5、KMeans和Kmedoid算法的matlab实现
    6、Kmeans算法实例
    7、Kmeans算法python实现(python3.5实现 带数据可以直接运行)
    8、Kmeans算法实例(实现k-mean聚类算法)
    9、kmeans上手实例代码(包括了基于欧式距离的简单点集聚类以及进一步扩展的基于文档向量余弦的文档聚类,代码使用python3编写并有非常详细的注释,包括了数据处理、kmeans计算、轮廓系数计算等多种功能,最终的实现效果能够通过给定k值范围自动寻找最佳k值并给出聚类结果和评价)程序员帮帮

    10、用MapReduce实现KMeans算法
    11、用matlab实现模拟退火kmeans聚类(只要有样本特征库就能运行)
    12、java实现的KMeans聚类算法(可以处理任意维度的向量。并将聚类结果写入文本)
    13、基于kmeans算法的图像颜色量化(运行环境:vs2012+opencv3.0.0)
    14、Scala语言实现Kmeans聚类算法(含有数据)
    15、快速K-均值(kmeans)聚类图像分割算法源代码
    16、Kmeans方法做点的聚类分析,并且画图表示
    17、kmeans聚类算法的python实现程序
    18、Java实现的KMeans均值聚类算法(依据欧式距离把二维坐标平面内的点分类)
    19、用kmeans得到二值分割后,再用svm进行图像分割
    20、基于聚类(Kmeans)算法实现客户价值分析系统(电信运营商)

    展开全文
  • KMeans聚类算法

    2020-03-12 15:34:28
    KMeans聚类算法

    何为聚类?

    俗话说“物以类聚,人以群分”说的是把相同或相似的东西放在一起比较讨论,志同道合的朋友常常能够相聚在一起把酒言欢。朋友间正是因为有相同的志向和趣味,所以能够走到一起,与人一样,数据挖掘里面的聚类是指把具有相同或者相似(退后一步)的对象放在一起讨论,从而挖掘出放在一起的理由和不放在一起的理由以及这样放在一起与不放在一起所带来的额外效用。也许你会问用什么办法来衡量两个对象的相似性呢?这时候就需要把对象的各种属性考虑进来,通过对比分析两个对象的不同属性间的差异来进行判断,比如考察某个班所有学生的聚类情况,已经知道所有学生的期末考试成绩以及平时缺课次数两个属性,可以按照下面规则聚集

    • 学神
      期末考试成绩优异,平时缺课无数

    • 学霸
      期末考试成绩优异,平时不缺课

    • 学渣
      期末考试成绩掉渣,平时缺课无数

    • 学弱
      期末考试成绩掉渣,平时不缺课

    我们看到了按照成绩属性取优异还是掉渣以及缺课属性取缺还是不缺共4种组合可以把班里所有学生划分成4类,这样每一类的学生都有自己的特点,同类别的学生有着非常高的相似度,不同类的学生却是天壤之别。这里,我们又引进了相似度的概念,如果两个对象各属性相似度高,那么这两个对象理应属于同一类别,反之应该属于不同类别,上面我们只是通过描述性的语言来说明分类情况, 那么如何用数学语言来刻画呢? 常见的相似度刻画采用距离公式,主要有以下几种距离公式,为讨论的一般性,我们假设有 n n n个样本,每个样本有 p p p个指标,数据矩阵如下表所示
    在这里插入图片描述
    记第 i i i个样本为 ( i ) = ( x i 1 , ⋯   , x i p ) T (i)=(x_{i1},\cdots,x_{ip})^T (i)=(xi1,,xip)T,第 j j j个样本为 ( j ) = ( x j 1 , ⋯   , x j p ) T (j)=(x_{j1},\cdots,x_{jp})^T (j)=(xj1,,xjp)T,把每个样本看成 p p p维空间里的质点,记 ( i ) (i) i ( j ) (j) j的距离为 D ( i , j ) D(i,j) D(i,j) , 那么

    • 欧式距离(Euclidean Distance)
      D ( i , j ) = [ ∑ l = 1 p ∣ x i l − x j l ∣ 2 ] 1 2 D(i,j)=[ \sum\limits_{l=1}^{p}|x_{il}-x_{jl}|^2 ]^ {\frac{1} {2} } D(i,j)=[l=1pxilxjl2]21

    • 曼哈顿距离(Manhattan Distance)
      D ( i , j ) = ∑ l = 1 p ∣ x i l − x j l ∣ D(i,j)=\sum\limits_{l=1}^{p}|x_{il}-x_{jl}| D(i,j)=l=1pxilxjl

    • 切比雪夫距离 (Chebyshev Distance )
      D ( i , j ) = m a x 1 ≤ l ≤ p ∣ x i l − x j l ∣ D(i,j)=max_ {1\leq l\leq p} |x_{il}-x_{jl}| D(i,j)=max1lpxilxjl

    • 闵可夫斯基距离(Minkowski Distance)
      D ( i , j ) = [ ∑ l = 1 p ∣ x i l − x j l ∣ q ] 1 q D(i,j)=[ \sum\limits_{l=1}^{p}|x_{il}-x_{jl}|^q ]^ {\frac{1} {q} } D(i,j)=[l=1pxilxjlq]q1

    从各种距离公式可以看出,切比雪夫距离和欧式距离是闵科夫斯基距离当 q = 1 q=1 q=1 q = 2 q=2 q=2的特殊情况。

    聚类与分类的区别

    很多初学者会把聚类和分类混肴,那么聚类和分类有何区别呢?主要体现在

    • 学习范畴
      分类属于监督学习范畴,而聚类属于无监督学习范畴

    • 进程不一样
      分类主要用训练数据学习一个模型,里面数据的类别是确定的,然后把测试集中的实例对应到这些确定的类别中,是两步走的过程。而聚类是起初并不知道具体有多少类,可以先行假定类别数,即 k k k 值,然后通过某些判断方法,把所有数据划分到这 k k k个类别中,使得同一类的实例尽可能聚集到一起,不同类实例尽量离间,不需要训练测试,更多像一锤子买卖。

    常见聚类算法及KMeans算法

    常见的聚类算法有基于空间测距的KMeans算法,基于密度划分的DBSCAN算法,基于点距离的 hierarchical clustering算法,基于图距离的Affinity Propagation算法等,这里重点介绍KMeans算法。

    KMeans翻译成中文表示k均值,KMeans算法的关键是找 k k k个均值来当作类别的中心,并以此为参考将其他实例吸收到这 k k k个类别,使得最后距离和最小。假设有 n n n个实例,现在要将其划分到 k k k个不相邻的类别或簇 C = { c 1 , ⋯   , c k } \mathcal{C}=\{c_1,\cdots,c_k\} C={c1,,ck},记第 j j j个簇 c j c_j cj中的样本均值(中心)为 u j u_j uj, KMeans 算法旨在选择合适的 u j u_j uj,使得簇内平方和最小,即
    min ⁡ u j ∈ C ∑ j = 1 k ∑ i = 1 n ∣ ∣ x i − u j ∣ ∣ 2 \min\limits_ {u_j\in C}\sum\limits_{j=1}^k\sum\limits_{i=1}^n||x_i-u_j||^2 ujCminj=1ki=1nxiuj2

    算法实现步骤

    KMeans算法比较简单,只有三步

    1. 初始化 k k k个中心,当成 k k k个初始簇
    2. 将每一个实例划分到离其最近的中心簇
    3. 计算每个簇的均值,得到新的簇中心
      如果前后两次计算得到簇中心不发生变化,或者变化小于给定的阈值,算法结束,否则返回2计算每个样本到新的簇中心的距离

    KMeans的优缺点

    KMeans算法假设簇都是凸的且同性的,而对长条形和不正规的形状表现不好,对于高维数据,KMeans算法会消耗更多计算资源。

    KMeans聚类算法实例

    完整代码

    # -*- coding: utf-8 -*-
    """
    project_name:聚类算法
    @author: 帅帅de三叔
    Created on Wed Nov  6 10:05:42 2019
    """
    import pandas as pd #导入数据分析模块
    from sklearn import  preprocessing #导入数据预处理模块
    from sklearn.cluster import KMeans #导入kmeans聚类算法
    data=pd.read_excel("2018vs2016.xlsx",index_col=u"板块名称",sheet_name="2018") #读取数据
    X=data.iloc[:,0:-1] #聚类用到的特征属性
    X_scaled=preprocessing.StandardScaler(copy=True,with_mean=True,with_std=True).fit_transform(X) #特征属性标准化
    feature=pd.DataFrame(X_scaled)
    k=4 #设置聚类类别数
    maxiteration=500 #设置最大迭代次数
    model=KMeans(n_clusters=k,init='k-means++',n_init=10,max_iter=maxiteration,tol=1e-4,precompute_distances='auto',verbose=0,random_state=None,copy_x=True,n_jobs=2,algorithm='auto') #聚类模型初始化
    model.fit(feature,y=None,sample_weight=None) #训练模型
    lables=pd.DataFrame(model.labels_,index=data.index) #类别标签
    cluster_result=pd.concat([data,lables],axis=1) #沿着水平方向拼接类别标签
    cluster_result.columns=["交通","商业购物","教育","医疗","景观周游","生活娱乐","综合得分","类别标签"] #重命名表头
    print(cluster_result)
    cluster_result.to_excel("板块聚类结果.xlsx")    
    
    

    在这里插入图片描述

    展开全文
  • matlab实现kmeans聚类算法

    千次阅读 2019-09-06 13:26:27
    kmeans聚类算法是一种简单实用的聚类算法,matlab自带函数kmeans可直接对数据进行kmeans聚类。为了方便更好地掌握kmeans聚类算法,今天我们自己来实现一个弱化的版本mykmeans。 mykmeans输入包含三项,分别为聚类所...

    kmeans聚类算法是一种简单实用的聚类算法,matlab自带函数kmeans可直接对数据进行kmeans聚类。为了方便更好地掌握kmeans聚类算法,今天我们自己来实现一个弱化的版本mykmeans。

    mykmeans输入包含三项,分别为聚类所使用的数据data,data每一行代表一个样本,每一列代表一个特征;聚类中心数量numclass;第三项为所使用的距离的定义,默认情况下为欧式距离。

    function [cluster,clusterhistory]=mykmeans(data,numclass,varargin)
    % kmeans聚类。
    % 聚类过程动画显示
    % INPUTS:
    % data:每一行代表一个样本,每一列代表一个特征
    % numclass:聚类中心的数量
    % varargin{1}: 距离定义。支持euclidean(默认)、hamming
    % OUTPUT:
    % cluster: numsample行的列向量,代表每个样本的分类归属
    % clusterhistory{i}.cluster第i次迭代的聚类
    % clusterhistory{i}.core第i次迭代的聚类中心
    %
    % 公众号【数学建模公会】,HCLO4,20190902
    
    if nargin==2
        method='euclidean';
    else
        method=varargin{1};
    end
    % 初始化聚类中心坐标,在数据点中随机选择numclass个点作为初始聚类中心。
    numsample=size(data,1);
    temp=randperm(numsample);
    core=data(temp(1:numclass),:);
    dis=caldis(data,core,method); %存储每个样本到当前聚类中心的距离
    
    
    % 执行迭代过程
    maxIter=20; % 最大迭代次数
    numiter=1;
    clusterhistory=cell(1,maxIter);
    while 1
        
        newcore=zeros(size(core));
        % 迭代聚类中心
        [~,ind]=min(dis,[],2); %计算每个sample归属于哪个聚类中心,如果某个聚类中心没有一个点?
        for i=1:numclass
            newcore(i,:)=mean(dis(ind==i,:));
        end
        clusterhistory{numiter}.cluster=ind;
        clusterhistory{numiter}.core=core;
        
        if all(newcore(:)==core(:))||numiter>=maxIter  % 迭代终止条件,聚类中心不再改变
            cluster=ind;
            break
        end
        
        core=newcore;
        dis=caldis(data,core,method); 
        
        numiter=numiter+1;
        
    end
        
    
    clusterhistory=clusterhistory(1:numiter);
    
    
    end % mykmeans
    
    
    
    function dis=caldis(data,core,method)
    %计算每个样本到当前聚类中心的距离
    numsample=size(data,1);
    numclass=size(core,1);
    dis=zeros(numsample,numclass);
    switch method
        case 'euclidean'
            for i=1:numclass
                dis(:,i)=sqrt(sum((data-repmat(core(i,:),numsample,1)).^2,2));
            end
        case 'hamming'
            for i=1:numclass
                dis(:,i)=mean(data~=repmat(core(i,:),numsample,1),2);
            end
    end
    

    下面一段代码用于测试mykmeans和kmeans的运行结果。生成两组服从二维高斯分布的数据,作为两个数据类别,分别使用mykmeans和matlab自带的kmeans函数进行聚类分析。

    % 测试mykmeans函数
    % 公众号【数学建模公会】,HCLO4,20190902
    
    % 生成模拟数据,平面上的两组点,均服从二维高斯分布
    mu1=[2,8];
    sigma1=[2,2];
    mu2=[8,2];
    sigma2=[3,3];
    
    numsample1=100;
    numsample2=200;
    data1=zeros(numsample1,2);
    data1(:,1)=normrnd(mu1(1),sigma1(1),numsample1,1);
    data1(:,2)=normrnd(mu1(2),sigma1(2),numsample1,1);
    
    data2=zeros(numsample2,2);
    data2(:,1)=normrnd(mu2(1),sigma2(1),numsample2,1);
    data2(:,2)=normrnd(mu2(2),sigma2(2),numsample2,1);
    
    data=[data1;data2];
    
    tic,
    [cluster1,clusterhistory]=mykmeans(data,2);
    toc
    M=getFrame_Kmeans(data,clusterhistory); % 生成聚类动图
    
    tic,
    cluster2=kmeans(data,2);
    toc
    

    下面的函数实现mykmeans聚类过程的可视化,仅针对二维数据和三维数据类型。

    function M=getFrame_Kmeans(data,clusterhistory)
    % kmeans聚类过程可视化程序。只能对二维和三维数据可视化!
    %
    % INPUTS: 
    % data: 聚类用的数据,每行代表一个样本,每列代表一个特征
    % clusterhistory: mykmeans函数输出的聚类过程数据
    %
    % OUTPUT:
    % kmeans聚类过程的动画。
    
    dimension=size(data,2);
    if dimension>3 % 若三维以上,只能通过pca降维处理
        error('无法实现高于三维的数据的聚类可视化')
    end
    
    colorset=cell(1,1000);
    colorset(1:8)={'r','g','b','k','c','m','y','k'};
    for i=9:1000 %如果聚类中心数量大于8,就使用随机的颜色。
        colorset{i}=rand(1,3);
    end
    
    numcore=length(unique(clusterhistory{1}.cluster));
    numiter=length(clusterhistory);
    
    for k=1:numiter
        figure
        hold on
        switch dimension
            case 2
                for i=1:numcore
                    ind=clusterhistory{k}.cluster==i;
                    scatter(data(ind,1),data(ind,2),6,colorset{i})
                    core=clusterhistory{k}.core;
                    plot(core(i,1),core(i,2),[colorset{i},'.'],'MarkerSize',20)
                end
            case 3
                for i=1:numcore
                    ind=clusterhistory{k}.cluster==i;
                    scatter3(data(ind,1),data(ind,2),data(ind,3),6,colorset{i})
                    core=clusterhistory{k}.core;
                    plot3(core(i,1),core(i,2),core(i,3),colorset{i},'MarkerSize',6)
                end
        end
        
        M(k)=getframe(gcf);
        frame = getframe(gcf); 
        im = frame2im(frame);     %将影片动画转换为编址图像,因为图像必须是index索引图像
        imshow(im);
        [I,map] = rgb2ind(im,20); %将真彩色图像转化为索引图像
        if k==1
            imwrite(I,map,'kmeans.gif','gif','Loopcount',inf,'DelayTime',0.3);     %Loopcount只是在i==1的时候才有用
        else
            imwrite(I,map,'kmeans.gif','gif','WriteMode','append','DelayTime',1);%DelayTime:帧与帧之间的时间间隔
        end
        
        
        close(gcf);
        
    end
    
    展开全文
  • java实现的KMeans聚类算法

    热门讨论 2013-01-24 20:00:13
    java实现kmeans算法,可以处理任意维度的向量。并将聚类结果写入文本。
  • Kmeans聚类算法实战

    千次阅读 2020-05-13 12:42:27
    一、需要对所有学生的表进行kmeans聚类1、Excel文件2、代码如下所示(对于Excel文件最后几行无用的数据可以删除。我这里没有删除,我是在读取数据时没有读取最后几行)二、通过第二个表(分流名单)来确定学生类型1...
  • 内容导入:聚类是无监督学习的典型例子,聚类也能为企业运营中也发挥者巨大的作用,比如我们可以利用聚类对目标用户进行群体分类,把目标群体划分成几个具有明显特征区别的细分群体,从而可以在运营活动中为这些细分...
  • Python from sklearn import datasets ...from sklearn.cluster import KMeans # 加载数据集,是一个字典类似Java中的map lris_df = datasets.load_iris() # 挑选出前两个维度作为x...
  • 1、psm价格敏感度分析对应的是不同的用户对于价格的敏感度,分析的角度是从消费者的角度的。体现的是客户和消费者的直接关系,没有考虑到其他的竞争...kmeans的训练和预测部分需要注意的是kmeans的训练和预测对应的...
  • MATLAB实现Kmeans聚类算法

    千次阅读 2018-11-02 16:39:59
    这是我练习的第一个机器学习的算法,写的比较简单,肯定也有一些小错误。也参看了很多其他人的代码。现在贴出来算是我学习的一个历程啦。 clear all;close all;clc; data1=normrnd(0,0.25,100,2); %生成符合 data2=...
  • Kmeans聚类问题实例

    2020-04-19 17:08:48
    kmeans 聚类问题实例,用kmeans聚类算法将数据分成三类,实现三分类问题,并将分类结果进行储存
  • RFM模型多用于已知目标数据集,场景具有一定的局限性,本篇运用一个适用比较广泛的聚类算法——K-Means,它属于无监督机器学习,K-Means算法的思想很简单,对于给定的样本集,按照样本之间的距离大小,将样本集划分...
  • KMeans聚类算法示例

    千次阅读 2017-01-06 22:58:47
    二位点聚类 2.手写字符聚类 3.图像压缩 Clustering: K-Means In-DepthHere we’ll explore K Means Clustering, which is an unsupervised clustering technique.We’ll start with our standard set of initial ...
  • kmeans聚类算法实现

    2020-04-14 13:44:44
    算法原理 模型 已知一组有n个样本的数据集 {xi}i=1n,xi∈Rt \{x_i\}_ {i=1}^n,x_i\in\mathbb R^t {xi​}i=1n​,xi​∈Rt 其中,每个样本xix_ixi​都有ttt个特征,没有标签yiy_iyi​。现在的目的是希望利用样本特征将...
  • from sklearn.cluster import KMeans import matplotlib.pyplot as plt df_features = pd.read_csv(r'C:\预处理后数据.csv',encoding='gbk') # 读入数据 '利用SSE选择k' SSE = [] # 存放每次结果的误差平方和 for ...
  • 先简单了解下Kmeans聚类算法。聚类算法属于无监督学习,其中的KMeans算法是将一组有N个样本的数据划分成K个不相交的 clusters (簇) C。 means (均值)通常被称为 cluster(簇)的 “centroids(质心)”; 注意,...
  • 一、聚类算法——Kmeans Kmeans聚类算法,又叫K均值聚类算法。是一种迭代求解的聚类分析算法。预先将数据分成K组,随机选定K各对象作为初始的聚类中心。然后计算每个对象与各个种子聚类中心之间的距离。把每个对象...
  • KMeans聚类算法应用

    2020-02-22 00:26:00
    KMeans聚类算法应用 1999年31个省份平均每人全年消费支出 import numpy as np from sklearn.cluster import KMeans def loadData(filePath): #利用loadData读取数据 fr = open(filePath,'r+') #r+:读写打开一个...
  • kmeans聚类算法及matlab实现

    万次阅读 多人点赞 2015-11-12 19:25:10
    kmeans聚类算法介绍:kmeans算法是一种经典的无监督机器学习算法,名列数据挖掘十大算法之一。作为一个非常好用的聚类算法,kmeans的思想和实现都比较简单。kmeans的主要思想:把数据划分到各个区域(簇),使得数据与...
  • Kmeans聚类算法

    万次阅读 多人点赞 2017-06-18 23:23:48
    Kmeans聚类算法 动态聚类算法  任务:是将数据集划分成一定数量的子集,例如将一个数据集划分成3、4个子集等。因此要划分成多少个子集往往要预先确定,或大致确定,当然这个子集数目在理想情况能体现数据集比较...
  • 基于RFM模型的K均值聚类算法实现模型介绍K 均值聚类原理聚类步骤导入库读取数据正确的代码...Kmeans聚类算法利用距远近的思想将目标数据聚为指定的k个簇,进而使样本呈现簇内差异小,簇间差异大的特征。 K 均值聚类原
  • 1. Kmeans聚类算法原理 1.1 概述 K-means算法是集简单和经典于一身的基于距离的聚类算法 采用距离作为相似性的评价指标,即认为两个对象的距离越近,其相似度就越大。 该算法认为类簇是由距离靠近的对象组成的,...
  • 09 机器学习 - Kmeans聚类算法案例

    千次阅读 2019-09-27 15:23:06
    对给定的数据集进行聚类 本案例采用二维数据集,共80个样本,有4个类。样例如下(testSet.txt): 1.658985 4.285136 -3.453687 3.424321 4.838138 -1.151539 -5.379713 -3.362104 0.972564 2.924086 -3.567919 1...
  • KMeans聚类算法思想与可视化

    千次阅读 2019-05-03 12:32:24
    KMeans聚类算法思想与可视化

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,156
精华内容 1,662
关键字:

kmeans聚类算法实例