精华内容
下载资源
问答
  • 图聚类
    万次阅读
    2017-07-04 09:49:28

    1.前言

    这篇文章是基于k-means算法进行图片聚类,而不是对单个图片的像素聚类,分别基于RGB、HSV和HOG特征进行聚类分析。

    2.图片特征提取——RGB

    RGB为图片最基本的特征,但很多时候RGB颜色空间并不能很好的作为图片聚类的聚簇依据,通常不符合人们对颜色相似性的主观判断,我尝试了用RGB进行聚类,但是效果并没有其他两种好。
    其实现代码如下:
    def get_rgb_hist_feature(image_name):
        hist_feature = []
        img = cv2.imread(image_name)
        color = ('b', 'g', 'r')
        for index, value in enumerate(color):
            hist = cv2.calcHist([img], [index], None, [256], [0, 256])
            cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)
            hist_feature.append(hist)
        return list(np.array(hist_feature).ravel())
    分别提取RGB颜色空间,最终返回列表。

    3.图片特征提取——HSV

    hsv能够简单的描述一张图片颜色的全局分布,适用于那些难以自动分割、不需要考虑物体空间位置的图像。hsv的三个分量分别为:色彩(Hue)、饱和度(Saturation)、值(Value)。
    其代码实现如下:
    def get_hsv_hist_feature(image_name):
        hist_feature = []
        img = cv2.imread(image_name)
        img = cv2.resize(img, (256, 256))
        hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    
        hist_h = cv2.calcHist([hsv], [0], None, [180], [0, 180])
        hist_h = cv2.normalize(hist_h, hist_h)
        hist_feature[0:180] = hist_h[:,0]
    
        hist_s = cv2.calcHist([hsv], [1], None, [256], [0, 256])
        hist_s = cv2.normalize(hist_s, hist_s)
        hist_feature[180:436] = hist_s[:,0]
    
        hist_v = cv2.calcHist([hsv], [2], None, [256], [0, 256])
        hist_v = cv2.normalize(hist_v,hist_v)
        hist_feature[436:692] = hist_v[:,0]
    
        return list(np.array(hist_feature).ravel())
    在hsv特征中,每个分量都有自己的取值范围,在提取特征时需要注意列表长度。

    4.图片特征提取——HOG特征

    HOG特征检测算法实现的几个步骤:颜色空间归一化、梯度计算、梯度方向直方图、重叠块直方图归一化、HOG特征。
    其实现代码如下:
    def get_hog_feature(image_name):
        img = cv2.imread(image_name)
        img = cv2.resize(img, (256, 256))
        gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        hog_feature = feature.hog(gray_image, orientations=8, pixels_per_cell=(16, 16),
                        cells_per_block=(1, 1))
        return list(hog_feature.ravel())



    更多相关内容
  • 提取图片特征值,方便接下来的降维或者聚类等别的图片处理
  • 模糊C聚类算法的matlab源码,注释非常清晰详细,并有实验图片
  • 利用聚类实现图像的分类,采用C均值算法,种类分为4类、5类和8类,能够画出聚类中心的移动轨迹(利用了RGB信息)。
  • 提取图片边缘特征 图像聚类 通过像素点对图片进行聚类图片二值化,转化为黑白图片
  • 基于图聚类与蚁群算法的社交网络聚类算法.pdf
  • kmeans图像聚类程序

    2017-05-12 10:14:35
    利用kmeans算法对图像聚类的一个小程序,里面包含图片和对应的主函数和调用函数,可以直接运行。
  • k-均值聚类算法实现灰度图像分割,输入图像矩阵和聚类中心个数,返回为最终的聚类中心
  • Python图像聚类

    2019-03-05 10:22:28
    请结合本人该篇博客进行理解: https://blog.csdn.net/weixin_44344462/article/details/88169565
  • 基于相似图片聚类的Web文本特征算法.pdf
  • 图像聚类算法

    千次阅读 2022-05-27 21:14:00
    Means聚类1、定义、优点2、k-means聚类算法的分析流程:3、K-Means优缺点三、 层次聚类1、定义2、凝聚层次聚类的流程3、层次聚类的优缺点4、示例5、树状分类判断四、密度聚类1、算法2、优缺点五、谱聚类1、算法...

    一、 分类与聚类

    1、分类

      分类其实是从特定的数据中挖掘模式,作出判断的过程。

      分类学习主要过程:
      (1)训练数据集存在一个类标记号,判断它是正向数据集(起积极作用,不垃圾邮件),还是负向数据集(起抑制作用,垃圾邮件);
      (2)然后需要对数据集进行学习训练,并构建一个训练的模型;
      (3)通过该模型对预测数据集进预测,并计算其结果的性能。
    在这里插入图片描述

    2、聚类

      从广义上说,聚类就是将数据集中在某些方面相似的数据成员放在一起。

      一个聚类就是一些数据实例的集合,其中处于相同聚类中的数据元素彼此相似,但是处于不同聚类中的元素彼此不同。

      由于在聚类中那些表示数据类别的分类或分组信息是没有的, 即这些数据是没有标签的,所以聚类通常被归为无监督学习(Unsupervised Learning),分类使用的数据大多数是有标签的,称为有监督学习。
    在这里插入图片描述
      聚类的目的也是把数据分类,但是事先是不知道如何去分的,完全是算法自己来判断各条数据之间的相似性,相似的就放在一起。

      在聚类的结论出来之前,完全不知道每一类有什么特点,一定要根据聚类的结果通过人的经验来分析,看看聚成的这一类大概有什么特点。

      总之,聚类主要是"物以类聚",通过相似性把相似元素聚集在一起,它没有标签;而分类通过标签来训练得到一个模型,对新数据集进行预测的过程,其数据存在标签。

    聚类样本间的属性

    1. 有序属性:西瓜的甜度: 0.1,0.5,0.9
    2. 无序属性:性别:男,女

    聚类的常见算法

    聚类算法分为三大类:

    1. 原型聚类:
      • K均值聚类算法
    2. 层次聚类
    3. 密度聚类

    二、K-Means聚类

    1、定义、优点

      K-Means聚类是最常用的聚类算法,最初起源于信号处理,其目标是将数据点划分为K个类簇。

      该算法的最大优点是简单、便于理解,运算速度较快,缺点是要在聚类前指定聚集的类簇数。

      k-means算法是一种原型聚类算法。

    2、k-means聚类算法的分析流程:

    第一步,确定K值,即将数据集聚集成K个类簇或小组。
    第二步,从数据集中随机选择K个数据点作为质心(Centroid)或数据中心。
    第三步,分别计算每个点到每个质心之间的距离,并将每个点划分到离最近质心的小组。
    第四步,当每个质心都聚集了一些点后,重新定义算法选出新的质心。(对于每个簇,计
    算其均值,即得到新的k个质心点)
    第五步,迭代执行第三步到第四步,直到迭代终止条件满足为止(聚类结果不再变化)
    

    在这里插入图片描述
    在这里插入图片描述

    第一步,确定K值,即将数据集聚集成K个类簇或小组。
    ----这里我们选K=2
    第二步,从数据集中随机选择K个数据点作为质心(Centroid)或数
    据中心。
    ----假设我们选择P1和P2作为初始的质心
    第三步,分别计算每个点到每个质心之间的距离,并将每个点划分
    到离最近质心的小组。
    ----计算P3到P1的距离:√10 = 3.16----计算P3到P2的距离:√((3-1)^2+(1-2)^2 =5 = 2.24----所以P3离P2更近,P3就加入P2的簇。同理,P4、P5、P6;
    

    在这里插入图片描述

    P3到P6都跟P2更近,所以第一次分组的结果是:
    • 组A:P1
    • 组B:P2、P3、P4、P5、P6
    
    第四步,当每个质心都聚集了一些点后,重新定义算法选出新的质心。
    (对于每个簇,计算其均值,即得到新的k个质心点)
    ----组A没啥可选的,还是P1自己
    ----组B有五个点,需要选新质心。 这里要注意选择的方法是
    每个组X坐标的平均值和Y坐标的平均值组成的新的点,为
    新质心,也就是说这个质心是“虚拟的”。
    ----因此, B组选出新质心的坐标为: P哥((1+3+8+9+10/5,
    (2+1+8+10+7/5=6.25.6)。
    ----综合两组,新质心为P1(00), P哥(6.25.6) 。
    ----而P2-P6重新成为离散点。
    

    在这里插入图片描述

    再次计算点到质心的距离:
    这时可以看到P2、 P3离P1更近, P4、 P5、 P6离P哥更
    近。
    第二次分组的结果是:
    • 组A: P1、 P2、 P3
    • 组B: P4、 P5、 P6(虚拟质心这时候消失)
    

    在这里插入图片描述

    按照上一次的方法选出两个新的虚拟质心:
    ---P哥11.331), P哥298.33)。
    第三次计算点到质心的距离:
    --- 这时可以看到P1、 P2、 P3离P哥1更近, P4、
    P5、 P6离P哥2更近。
    --- 所以第三次分组的结果是:
    • 组A: P1、 P2、 P3
    • 组B: P4、 P5、 P6
    我们发现,这次分组的结果和上次没有任何变化了,说
    明已经收敛,聚类结束。
    

      在图像处理中,通过K-Means聚类算法可以实现图像分割、图像聚类、图像识别等操作。
      我们通过K-Means可以将这些像素点聚类成K个簇,然后使用每个簇内的质心点来替换簇内所有的像素点,这样就能实现在不改变分辨率的情况下量化压缩图像颜色,实现图像颜色层级分割

    3、K-Means优缺点

    优点:
     1.是解决聚类问题的一种经典算法,简单、快速
     2.对处理大数据集,该算法保持高效率
     3.当结果簇是密集的,它的效果较好

    缺点:
     1.必须事先给出k(要生成的簇的数目)。
     2.对躁声和孤立点数据敏感

    4、代码实现

    # coding=utf-8  
    from sklearn.cluster import KMeans
     
    """
    第一部分:数据集
    X表示二维矩阵数据,篮球运动员比赛数据
    总共20行,每行两列数据
    第一列表示球员每分钟助攻数:assists_per_minute
    第二列表示球员每分钟得分数:points_per_minute
    """
    X = [[0.0888, 0.5885],
         [0.1399, 0.8291],
         [0.0747, 0.4974],
         [0.0983, 0.5772],
         [0.1276, 0.5703],
         [0.1671, 0.5835],
         [0.1306, 0.5276],
         [0.1061, 0.5523],
         [0.2446, 0.4007],
         [0.1670, 0.4770],
         [0.2485, 0.4313],
         [0.1227, 0.4909],
         [0.1240, 0.5668],
         [0.1461, 0.5113],
         [0.2315, 0.3788],
         [0.0494, 0.5590],
         [0.1107, 0.4799],
         [0.1121, 0.5735],
         [0.1007, 0.6318],
         [0.2567, 0.4326],
         [0.1956, 0.4280]   
        ]
     
    #输出数据集
    print (X)
    
    """
    第二部分:KMeans聚类
    clf = KMeans(n_clusters=3) 表示类簇数为3,聚成3类数据,clf即赋值为KMeans
    y_pred = clf.fit_predict(X) 载入数据集X,并且将聚类的结果赋值给y_pred
    """
    
    clf = KMeans(n_clusters=3)
    y_pred = clf.fit_predict(X)
     
    #输出完整Kmeans函数,包括很多省略参数
    print(clf)
    #输出聚类预测结果
    print("y_pred = ",y_pred)
     
    """
    第三部分:可视化绘图
    """
    
    import numpy as np
    import matplotlib.pyplot as plt
    
    #获取数据集的第一列和第二列数据 使用for循环获取 n[0]表示X第一列
    x = [n[0] for n in X]
    print (x)
    y = [n[1] for n in X]
    print (y)
    
    ''' 
    绘制散点图 
    参数:x横轴; y纵轴; c=y_pred聚类预测结果; marker类型:o表示圆点,*表示星型,x表示点;
    '''
    plt.scatter(x, y, c=y_pred, marker='x')
     
    #绘制标题
    plt.title("Kmeans-Basketball Data")
     
    #绘制x轴和y轴坐标
    plt.xlabel("assists_per_minute")
    plt.ylabel("points_per_minute")
     
    #设置右上角图例
    plt.legend(["A","B","C"])
     
    #显示图形
    plt.show()
    
    # coding: utf-8
    
    '''
    在OpenCV中,Kmeans()函数原型如下所示:
    retval, bestLabels, centers = kmeans(data, K, bestLabels, criteria, attempts, flags[, centers])
        data表示聚类数据,最好是np.flloat32类型的N维点集
        K表示聚类类簇数
        bestLabels表示输出的整数数组,用于存储每个样本的聚类标签索引
        criteria表示迭代停止的模式选择,这是一个含有三个元素的元组型数。格式为(type, max_iter, epsilon)
            其中,type有如下模式:
             —–cv2.TERM_CRITERIA_EPS :精确度(误差)满足epsilon停止。
             —-cv2.TERM_CRITERIA_MAX_ITER:迭代次数超过max_iter停止。
             —-cv2.TERM_CRITERIA_EPS+cv2.TERM_CRITERIA_MAX_ITER,两者合体,任意一个满足结束。
        attempts表示重复试验kmeans算法的次数,算法返回产生的最佳结果的标签
        flags表示初始中心的选择,两种方法是cv2.KMEANS_PP_CENTERS ;和cv2.KMEANS_RANDOM_CENTERS
        centers表示集群中心的输出矩阵,每个集群中心为一行数据
    '''
    
    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    #读取原始图像灰度颜色
    img = cv2.imread('lenna.png', 0) 
    print (img.shape)
    
    #获取图像高度、宽度
    rows, cols = img.shape[:]
    
    #图像二维像素转换为一维
    data = img.reshape((rows * cols, 1))
    data = np.float32(data)
    
    #停止条件 (type,max_iter,epsilon)
    criteria = (cv2.TERM_CRITERIA_EPS +
                cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
    
    #设置标签
    flags = cv2.KMEANS_RANDOM_CENTERS
    
    #K-Means聚类 聚集成4类
    compactness, labels, centers = cv2.kmeans(data, 4, None, criteria, 10, flags)
    
    #生成最终图像
    dst = labels.reshape((img.shape[0], img.shape[1]))
    
    #用来正常显示中文标签
    plt.rcParams['font.sans-serif']=['SimHei']
    
    #显示图像
    titles = [u'原始图像', u'聚类图像']  
    images = [img, dst]  
    for i in range(2):  
       plt.subplot(1,2,i+1), plt.imshow(images[i], 'gray'), 
       plt.title(titles[i])  
       plt.xticks([]),plt.yticks([])  
    plt.show()
    

    请添加图片描述

    # coding: utf-8
    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('lenna.png') 
    print (img.shape)
    
    #图像二维像素转换为一维
    data = img.reshape((-1,3))
    data = np.float32(data)
    
    #停止条件 (type,max_iter,epsilon)
    criteria = (cv2.TERM_CRITERIA_EPS +
                cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
    
    #设置标签
    flags = cv2.KMEANS_RANDOM_CENTERS
    
    #K-Means聚类 聚集成2类
    compactness, labels2, centers2 = cv2.kmeans(data, 2, None, criteria, 10, flags)
    
    #K-Means聚类 聚集成4类
    compactness, labels4, centers4 = cv2.kmeans(data, 4, None, criteria, 10, flags)
    
    #K-Means聚类 聚集成8类
    compactness, labels8, centers8 = cv2.kmeans(data, 8, None, criteria, 10, flags)
    
    #K-Means聚类 聚集成16类
    compactness, labels16, centers16 = cv2.kmeans(data, 16, None, criteria, 10, flags)
    
    #K-Means聚类 聚集成64类
    compactness, labels64, centers64 = cv2.kmeans(data, 64, None, criteria, 10, flags)
    
    #图像转换回uint8二维类型
    centers2 = np.uint8(centers2)
    res = centers2[labels2.flatten()]
    dst2 = res.reshape((img.shape))
    
    centers4 = np.uint8(centers4)
    res = centers4[labels4.flatten()]
    dst4 = res.reshape((img.shape))
    
    centers8 = np.uint8(centers8)
    res = centers8[labels8.flatten()]
    dst8 = res.reshape((img.shape))
    
    centers16 = np.uint8(centers16)
    res = centers16[labels16.flatten()]
    dst16 = res.reshape((img.shape))
    
    centers64 = np.uint8(centers64)
    res = centers64[labels64.flatten()]
    dst64 = res.reshape((img.shape))
    
    #图像转换为RGB显示
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    dst2 = cv2.cvtColor(dst2, cv2.COLOR_BGR2RGB)
    dst4 = cv2.cvtColor(dst4, cv2.COLOR_BGR2RGB)
    dst8 = cv2.cvtColor(dst8, cv2.COLOR_BGR2RGB)
    dst16 = cv2.cvtColor(dst16, cv2.COLOR_BGR2RGB)
    dst64 = cv2.cvtColor(dst64, cv2.COLOR_BGR2RGB)
    
    #用来正常显示中文标签
    plt.rcParams['font.sans-serif']=['SimHei']
    
    #显示图像
    titles = [u'原始图像', u'聚类图像 K=2', u'聚类图像 K=4',
              u'聚类图像 K=8', u'聚类图像 K=16',  u'聚类图像 K=64']  
    images = [img, dst2, dst4, dst8, dst16, dst64]  
    for i in range(6):  
       plt.subplot(2,3,i+1), plt.imshow(images[i], 'gray'), 
       plt.title(titles[i])  
       plt.xticks([]),plt.yticks([])  
    plt.show()
    

    请添加图片描述

    三、 层次聚类

    1、定义

      层次聚类是一种很直观的算法。顾名思义就是要一层一层地进行聚类。

      层次法(Hierarchical methods) 先计算样本之间的距离。每次将距离最近的点合并到同一个类。然后,再计算类与类之间的距离,将距离最近的类合并为一个大类。不停的合并,直到合成了一个类。其中类与类的距离的计算方法有:最短距离法,最长距离法,中间距离法,类平均法等。比如最短距离法,将类与类的距离定义为类与类之间样本的最短距离。

      层次聚类算法根据层次分解的顺序分为:自下底向上和自上向下,即凝聚的层次聚类算法和分裂的层次聚类算法(agglomerative和divisive) ,也可以理解为自下而上法(bottom-up)和自上而下法(topdown)。

    2、凝聚层次聚类的流程

      凝聚型层次聚类的策略是先将每个对象作为一个簇,然后合并这些原子簇为越来越大的簇,直到所有对象都在一个簇中,或者某个终结条件被满足绝大多数层次聚类属于凝聚型层次聚类,它们只是在簇间相似度的定义上有所不同。 这里给出采用最小距离的凝聚层次聚类算法流程:

    (1) 将每个对象看作一类,计算两两之间的最小距离;
    (2) 将距离最小的两个类合并成一个新类;
    (3) 重新计算新类与所有类之间的距离;
    (4) 重复(2)(3),直到所有类最后合并成一类。
    

    特点:
    • 凝聚的层次聚类并没有类似K均值的全局目标函数,没有局部极小问题或是很难选择初始点的问题。
    • 合并的操作往往是最终的,一旦合并两个簇之后就不会撤销。
    • 当然其计算存储的代价是昂贵的。

    3、层次聚类的优缺点

    优点:

    1,距离和规则的相似度容易定义,限制少;
    2,不需要预先制定聚类数;
    3,可以发现类的层次关系;
    4,可以聚类成其它形状
    

    缺点:

    1,计算复杂度太高;
    2,奇异值也能产生很大影响;
    3,算法很可能聚类成链状
    

    4、示例

    在这里插入图片描述
      如上图所示给了5个点,横坐标上的乱序数字代表序号并非坐标值。该图描绘了5个点进行层次聚类的过程。
    在这里插入图片描述
    在这里插入图片描述
      Z的第一行: [0, 3]意思是类别0和类别3距离最近,首先聚成一类,并自动定义类别为5(=len(X)-1+1),第三列数字0代表0和3两个点的距离,因为二者是重叠的,同一个坐标,故而距离为0,第四列为该类别的元素数,包含了0和3,故有2个
    在这里插入图片描述
      Z的第二行: [4, 5]意思是类别4和上面聚类的新类别5距离为第二近, 4、 5聚成一类,类别为6(=len(X)-1+2)

    第三行、第四行以此类推,
    因为类别5有两个样本,加上类别4形成类别6,有3个样本;
    类别7是类别12聚类形成,有两个样本;
    类别67聚成一类后,类别85个样本,这样X全部样本参与聚类,聚类完成。
    Z第四列中有样本的个数,当最下面一行中的样本数达到样本总数时,聚类就完成了。
    

    5、树状图分类判断

      想分两类时,就从上往下数有两根竖线时进行切割,那么所对应的竖线下面所连接的为一类
    在这里插入图片描述
      想分三类时,就从上往下数有三根竖线时进行切割,那么所对应的竖线下面所连接的为一类
    在这里插入图片描述
      每一种聚类方法都有其特定的数据结构,对于服从高斯分布的数据用K-Means来进行聚类效果会比较好。而对于类别之间存在层结构的数据,用层次聚类会比较好。

    6、示例代码

    ###cluster.py
    #导入相应的包
    from scipy.cluster.hierarchy import dendrogram, linkage,fcluster
    from matplotlib import pyplot as plt
    
    '''
    linkage(y, method=’single’, metric=’euclidean’) 共包含3个参数: 
    1. y是距离矩阵,可以是1维压缩向量(距离向量),也可以是2维观测向量(坐标矩阵)。
    若y是1维压缩向量,则y必须是n个初始观测值的组合,n是坐标矩阵中成对的观测值。
    2. method是指计算类间距离的方法。
    
    '''
    '''
    fcluster(Z, t, criterion=’inconsistent’, depth=2, R=None, monocrit=None) 
    1.第一个参数Z是linkage得到的矩阵,记录了层次聚类的层次信息; 
    2.t是一个聚类的阈值-“The threshold to apply when forming flat clusters”。
    '''
    
    X = [[1,2],[3,2],[4,4],[1,2],[1,3]]
    Z = linkage(X, 'ward')
    f = fcluster(Z,4,'distance')
    fig = plt.figure(figsize=(5, 3))
    dn = dendrogram(Z)
    print(Z)
    plt.show()
    

    四、密度聚类

    1、算法

    需要两个参数:ε (eps) 和形成高密度区域所需要的最少点数 (minPts)

    • 它由一个任意未被访问的点开始,然后探索这个点的 ε-邻域,如果 ε-邻域里有足够的点(这个点数要确定是指包括自身还是不包括),则建立一个新的聚类,否则这个点被标签为杂音。

    • 注意,这个杂音点之后可能被发现在其它点的 ε-邻域里,而该 ε-邻域可能有足够的点,届时这个点会被加入该聚类中。

    • 当某个点可能既出现在某个点的领域又出现在另一个点的领域,则计算该点到两个目标点的距离确定更适合那个。

    2、优缺点

    优点:

    1. 对噪声不敏感;
    2. 能发现任意形状的聚类。

    缺点:

    1. 但是聚类的结果与参数有很大的关系;
    2. 用固定参数识别聚类,但当聚类的稀疏程度不同时,相同的判定标准可能会破坏聚类的自然结构,即较稀的聚类会被划分为多个类或密度较大且离得较近的类会被合并成一个聚类。

    3、示例代码

    import matplotlib.pyplot as plt  
    import numpy as np  
    from sklearn import datasets 
    from  sklearn.cluster import DBSCAN
     
    iris = datasets.load_iris() 
    X = iris.data[:, :4]  # #表示我们只取特征空间中的4个维度
    print(X.shape)
    # 绘制数据分布图
    '''
    plt.scatter(X[:, 0], X[:, 1], c="red", marker='o', label='see')  
    plt.xlabel('sepal length')  
    plt.ylabel('sepal width')  
    plt.legend(loc=2)  
    plt.show()  
    '''
    
    dbscan = DBSCAN(eps=0.4, min_samples=9)
    dbscan.fit(X) 
    label_pred = dbscan.labels_
     
    # 绘制结果
    x0 = X[label_pred == 0]
    x1 = X[label_pred == 1]
    x2 = X[label_pred == 2]
    plt.scatter(x0[:, 0], x0[:, 1], c="red", marker='o', label='label0')  
    plt.scatter(x1[:, 0], x1[:, 1], c="green", marker='*', label='label1')  
    plt.scatter(x2[:, 0], x2[:, 1], c="blue", marker='+', label='label2')  
    plt.xlabel('sepal length')  
    plt.ylabel('sepal width')  
    plt.legend(loc=2)  
    plt.show()  
    

    五、扩展–谱聚类

    1、算法步骤

    1.根据数据构造一个 图结构(Graph) ,Graph 的每一个节点对应一个数据点,将相
    似的点连接起来,并且边的权重用于表示数据之间的相似度。把这个 Graph 用邻接矩
    阵的形式表示出来,记为 W 。
    
    2. 把 W 的每一列元素加起来得到 N 个数,把它们放在对角线上(其他地方都是零),
    组成一个 N * N的矩阵,记为 D 。并令 L = D-W 。
    
    3.求出 L 的前 k 个特征值,以及对应的特征向量。
    
    4.把这 k 个特征(列)向量排列在一起组成一个 N * k 的矩阵,将其中每一行看作 k
    维空间中的一个向量,并使用 K-means 算法进行聚类。聚类的结果中每一行所属的类
    别就是原来 Graph 中的节点亦即最初的N 个数据点分别所属的类别
    
    
    邻接矩阵:
    逻辑结构分为两部分:V和E集合,其中,V是顶点,E是边。因此,用一个一维数组存放图中
    所有顶点数据;用一个二维数组存放顶点间关系(边或弧)的数据,这个二维数组称为邻接
    矩阵。邻接矩阵又分为有向图邻接矩阵和无向图邻接矩阵
    

    简单抽象谱聚类过程,主要有两步:

    1. 构图,将采样点数据构造成一张网图。
    2. 切图,即将第一步构造出来的按照一定的切边准则,切分成不同的图,而不同的子图,即我们对应的聚类结果。
      在这里插入图片描述
      注:本文章参考了百度百科、他人技术博客、八斗学院课件资料、计算机视觉与模式识别书籍等综合整理而来,如有侵权,联系删除!水平有限,欢迎各位指导交流!
    展开全文
  • 图像聚类程序,界面美观,集成多个聚类算法,其界面编程值得借鉴,聚类算法可直接使用
  • 利用opencv的cvKMeans2进行聚类分析,并给出测试代码,希望对大家有所帮助
  • 基于Delaunay算法的图像分割及像素聚类模型,可自适应估计聚类数,是一种有效的图像分割算法。
  • 实现三维医学图像的聚类,这是子文件,可用于医学图像的K-means聚类
  • 图聚类算法的评价模型.pdf
  • 图聚类是一种重要的聚类算法,可有效应用于蛋白质作用网络和芯片数据聚类等领域。文中针对现有基因芯片数据图聚类方法的不足,提出了一种基于模块性指标和子图平滑度的全局图聚类方法。为防止算法陷入局部最优解,引入...
  • matlab图像聚类

    2018-03-26 15:31:49
    matlab进行图像代码 是个很健康韩国发出VB环境和规范地方
  • 基于相异度度量的图聚类方法.pdf
  • 基于进化规划算法的图像聚类研究.pdf
  • 基于杂草算法优化的轴承时频谱图聚类识别研究.pdf
  • 一种自适应多分辨率图聚类测井相分析方法.pdf
  • 利用Python K-means实现简单图像聚类

    千次阅读 2021-10-19 20:49:58
    因此,我们进行改进,利用ResNet-50进行图像特征的提取(embedding),在特征的基础上聚类而非直接在像素上聚类,代码如下: import os import numpy as np from sklearn.cluster import KMeans import cv2 from ...

    这里直接给出第一个版本的直接实现:

    import os
    import numpy as np
    from sklearn.cluster import KMeans
    import cv2
    from imutils import build_montages
    import matplotlib.image as imgplt
    
    image_path = []
    all_images = []
    images = os.listdir('./images')
    
    for image_name in images:
        image_path.append('./images/' + image_name)
    for path in image_path:
        image = imgplt.imread(path)
        image = image.reshape(-1, )
        all_images.append(image)
    
    clt = KMeans(n_clusters=2)
    clt.fit(all_images)
    labelIDs = np.unique(clt.labels_)
    
    for labelID in labelIDs:
        idxs = np.where(clt.labels_ == labelID)[0]
        idxs = np.random.choice(idxs, size=min(25, len(idxs)),
    		replace=False)
        show_box = []
        for i in idxs:
            image = cv2.imread(image_path[i])
            image = cv2.resize(image, (96, 96))
            show_box.append(image)
        montage = build_montages(show_box, (96, 96), (5, 5))[0]
    
        title = "Type {}".format(labelID)
        cv2.imshow(title, montage)
        cv2.waitKey(0)
    

    主要需要注意的问题是对K-Means原理的理解。K-means做的是对向量的聚类,也就是说,假设要处理的是224×224×3的RGB图像,那么就得先将其转为1维的向量。在上面的做法里,我们是直接对其展平:

    image = image.reshape(-1, )
    

    那么这么做的缺陷也是十分明显的。例如,对于两张一模一样的图像,我们将前者向左平移一个像素。这么做下来后两张图像在感官上几乎没有任何区别,但由于整体平移会导致两者的图像矩阵逐像素比较的结果差异巨大。以橘子汽车聚类为例,实验结果如下:
    在这里插入图片描述
    在这里插入图片描述
    可以看到结果是比较差的。因此,我们进行改进,利用ResNet-50进行图像特征的提取(embedding),在特征的基础上聚类而非直接在像素上聚类,代码如下:

    import os
    import numpy as np
    from sklearn.cluster import KMeans
    import cv2
    from imutils import build_montages
    import torch.nn as nn
    import torchvision.models as models
    from PIL import Image
    from torchvision import transforms
    
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            resnet50 = models.resnet50(pretrained=True)
            self.resnet = nn.Sequential(resnet50.conv1,
                                        resnet50.bn1,
                                        resnet50.relu,
                                        resnet50.maxpool,
                                        resnet50.layer1,
                                        resnet50.layer2,
                                        resnet50.layer3,
                                        resnet50.layer4)
    
        def forward(self, x):
            x = self.resnet(x)
            return x
    
    net = Net().eval()
    
    image_path = []
    all_images = []
    images = os.listdir('./images')
    
    for image_name in images:
        image_path.append('./images/' + image_name)
    for path in image_path:
        image = Image.open(path).convert('RGB')
        image = transforms.Resize([224,244])(image)
        image = transforms.ToTensor()(image)
        image = image.unsqueeze(0)
        image = net(image)
        image = image.reshape(-1, )
        all_images.append(image.detach().numpy())
    
    clt = KMeans(n_clusters=2)
    clt.fit(all_images)
    labelIDs = np.unique(clt.labels_)
    
    for labelID in labelIDs:
    	idxs = np.where(clt.labels_ == labelID)[0]
    	idxs = np.random.choice(idxs, size=min(25, len(idxs)),
    		replace=False)
    	show_box = []
    	for i in idxs:
    		image = cv2.imread(image_path[i])
    		image = cv2.resize(image, (96, 96))
    		show_box.append(image)
    	montage = build_montages(show_box, (96, 96), (5, 5))[0]
    
    	title = "Type {}".format(labelID)
    	cv2.imshow(title, montage)
    	cv2.waitKey(0)
    

    可以发现结果明显改善:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 深度卷积自编码图像聚类算法.pdf
  • 图像的聚类,利用FCM算法进行图像的分类与聚类,得到聚类图像
  • 实现K—Means++聚类,可自己设定K值,并通过散点呈现结果
  • 图聚类

    万次阅读 多人点赞 2019-12-11 20:18:49
    注意这里的指的不是图片,而是顶点+边构成的。 将样例用表示,则通过对图中顶点的划分完成聚类的表示 顶点:样本点 聚类:顶点的划分 边:样本点的相似度 表示无向,为点的集合,E为边集,W为权重...

    图聚类

    基于图的聚类。注意这里的图指的不是图片,而是顶点+边构成的图

    将样例用图表示,则通过对图中顶点的划分完成聚类。

    图的表示

    • 顶点:样本点
    • 聚类:顶点的划分
    • 边:样本点的相似度

     G(V,E)表示无向图,V=\left \{ v_{1},v_{2},..,{v_{m}} \right \}为点的集合,E为边集,W为权重,W_{ij}表示节点v_{i} 、v_{j} 之间相似度

    图的划分

    图的划分是将图完全划分成若干个子图,个子图无交集。

     

    划分要求

    • 同子图内的点相似度高
    • 不同子图间的点相似度低

    损失函数

    由划分要求,我们给出损失函数为 ,所以我们的目标就是最小化这个损失函数。

    图的划分两种常用方法

    • 谱聚类:连续优化方法。通过分析特征向量与特征值,获得聚类结果。
    • 最小割:离散优化方法。将最小割转化为最大网络求解。

    这里着重讲解一下谱聚类算法。

    谱聚类

    是一种基于图论的聚类方法,通过对样本数据的拉普拉斯矩阵的特征向量进行分析来完成聚类。

    算法流程

    1. 计算拉普拉斯矩阵 L 。L=D-W , 其中W为权重矩阵,W为对称矩阵,且主对角线元素都为0;D为度矩阵,Dij,当i!=j时为0,否则Dii为以i为一顶点的所有边权重之和;L为半正定矩阵(即所有特征值非负值),最小特征值为0,且对应的特征向量为单位向量[1,1,...,1]^{T}
    2. 计算L的特征值与特征向量Ve=\left \{ v_{e1},v_{e2},...,v_{en} \right \}   
    3. 取出最小的前k个特征值对应的特征向量构成一个矩阵V=\left \{ v_{1},v_{2},...,v_{k} \right \} ,将矩阵的每一行看做一个样本点并对其进行K-means聚类,得到k个簇

    Example

     已知图G:

    则:

    (1)计算邻接矩阵W与度矩阵D:

    相似度矩阵W
    i/j123456
    10.00.80.60.00.10.0
    20.80.00.80.00.00.0
    30.60.80.00.20.00.0
    40.00.00.20.00.80.7
    50.10.00.00.80.00.8
    60.00.00.00.70.80.0
    度矩阵D
    i/j123456
    10.50.00.00.00.00.0
    20.01.60.00.00.00.0
    30.00.01.60.00.00.0
    40.00.00.01.70.00.0
    50.00.00.00.01.70.0
    60.00.00.00.00.0 

    计算得拉普拉斯矩阵L:

    拉普拉斯矩阵L
    i/j123456
    11.5-0.8-0.60.0-0.10.0
    2-0.81.6-0.80.00.00.0
    3-0.6-0.81.6-0.20.00.0
    40.00.0-0.21.7-0.8-0.7
    5-0.10.00.0-0.81.7-0.8
    60.00.00.0-0.7-0.81.5

    (2)由计算L的次小特征向量:

        ,次小特征向量为

    由聚类按其值的正负分成了两类。

    谱聚类用于图像分割

    对于给定的一组样例,如果要用谱聚类方法,我们首先要构建一个图G(V,E)出来。这样才能算出W。

    对于图像数据,我们定义Wij为像素i与像素j之间的相似度。若图像是a*a的,则W为a^2 * a^2的

     , i,j为 第i和第j节点的像素值

    展开全文
  • 可以实现三维医学图像的聚类,里面包含主函数,可以直接运行
  • 这个应用程序是使用k均值聚类算法分割一个灰度图像。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 212,376
精华内容 84,950
关键字:

图聚类