机器学习算法实践——K-Means算法与图像分割

一、理论准备

1.1、图像分割

图像分割是图像处理中的一种方法，图像分割是指将一幅图像分解成若干互不相交区域的集合，其实质可以看成是一种像素的聚类过程。通常使用到的图像分割的方法可以分为：

  • 基于边缘的技术
  • 基于区域的技术

基于聚类算法的图像分割属于基于区域的技术。

1.2、K-Means算法

K-Means算法是基于距离相似性的聚类算法，通过比较样本之间的相似性，将形式的样本划分到同一个类别中，K-Means算法的基本过程为：

  • 初始化常数 ，随机初始化k个聚类中心
  • 重复计算以下过程，直到聚类中心不再改变
    • 计算每个样本与每个聚类中心之间的相似度，将样本划分到最相似的类别中
    • 计算划分到每个类别中的所有样本特征的均值，并将该均值作为每个类新的聚类中心
  • 输出最终的聚类中心以及每个样本所属的类别

在K-Means算法中，需要随机初始化k个聚类中心，而K-Means算法对初始聚类中心的选取较为敏感，若选择的聚类中心不好，则得到的聚类结果会非常差，因此，对K-Means算法提出了很多的改进的方法，如K-Means++算法，在K-Means++算法中，希望初始化的k个聚类中心之间的距离尽可能的大，其具体过程为：

  • 在数据集中随机选择一个样本点作为第一个初始化的聚类中心
  • 选择出其余的聚类中心：
    • 计算样本中的每一个样本点与已经初始化的聚类中心之间的距离，并选择其中最短的距离
    • 以概率选择距离最大的样本作为新的聚类中心，重复上述过程，直到 个聚类中心都被确定
  • 对k个初始化的聚类中心，利用K-Means算法计算最终的聚类中心。

对于K-Means算法的具体过程可以参考博文简单易学的机器学习算法——kMeans，K-Means++算法的具体过程稍后会补充。

二、实践准备

实践中使用Python作为开发语言，使用到的模块包括numpy和Image。numpy模块是python中矩阵计算使用最多的模块。

Image模块是PIL(Python Imaging Library)中的模块，对于Image模块，主要是对图像的一些操作：

  • 模块的头文件

import Image as image

  • 打开图片

fp = open("003.JPG", "rb")

im = image.open(fp)

首先是以二进制文件的形式打开文件，再利用Image模块的open方法导入图片。

对于如下的图片(圣托里尼)：

  • 图片的属性

im.format, im.size, im.mode

得到的结果为：JPEG (1600, 1067) RGB

  • 通道分离：

r,g,b = im.split()

分割成三个通道，此时r,g,b分别为三个图像对象。

  • 取得像素点的值

im.getpixel((4,4))

由于是RGB三通道的，因此此处的值为：(151, 169, 205)

  • 改变单个像素点的值

im.putpixel(xy, color)

  • 图像类型转换：

im=im.convert("L")

由RGB的图像转成灰度的图像，其结果为：

  • 生成新的图像

Image.new(mode, size)

Image.new(mode, size, color)

如：newImg = Image.new(“GBA”,(640,480),(0,255,0))

  • 保存图片

im.save("save.gif","GIF")

三、利用K-Means++算法进行图像分割

3.1、利用K-Means++聚类

在利用K-Means++算法进行图像分割时，将图像中的每一个像素点作为一个样本，对RGB图像来说，每个样本包括三维：(151, 169, 205)，通过归一化，将每个通道的值压缩到[0,1]区间上。数据的导入和处理如下面程序所示：

#coding:UTF-8
import Image as image
import numpy as np
from KMeanspp import run_kmeanspp

def load_data(file_path):
    ‘‘‘导入数据
    input:  file_path(string):文件的存储位置
    output: data(mat):数据
    ‘‘‘
    f = open(file_path, "rb")  # 以二进制的方式打开图像文件
    data = []
    im = image.open(f)  # 导入图片
    m, n = im.size  # 得到图片的大小
    print m, n
    for i in xrange(m):
        for j in xrange(n):
            tmp = []
            x, y, z = im.getpixel((i, j))
            tmp.append(x / 256.0)
            tmp.append(y / 256.0)
            tmp.append(z / 256.0)
            data.append(tmp)
    f.close()
    return np.mat(data)

最终保存成矩阵的形式，矩阵的行为样本的个数，列为每一个通道的数值(RGB)。在利用K-Means++算法对样本进行聚类。主函数如下述代码所示：

if __name__ == "__main__":
k = 10#聚类中心的个数
# 1、导入数据
print "---------- 1.load data ------------"
data = load_data("001.jpg")
# 2、利用kMeans++聚类
print "---------- 2.run kmeans++ ------------"
run_kmeanspp(data, k)

k表示的是聚类的个数。K-Means++程序的实现如下面程序所示：

# coding:UTF-8
‘‘‘
Date:20160923
@author: zhaozhiyong
‘‘‘

import numpy as np
from random import random
from KMeans import distance, kmeans, save_result

FLOAT_MAX = 1e100  # 设置一个较大的值作为初始化的最小的距离

def nearest(point, cluster_centers):
    ‘‘‘计算point和cluster_centers之间的最小距离
    input:  point(mat):当前的样本点
        cluster_centers(mat):当前已经初始化的聚类中心
    output: min_dist(float):点point和当前的聚类中心之间的最短距离
    ‘‘‘
    min_dist = FLOAT_MAX
    m = np.shape(cluster_centers)[0]  # 当前已经初始化的聚类中心的个数
    for i in xrange(m):
        # 计算point与每个聚类中心之间的距离
        d = distance(point, cluster_centers[i, ])
        # 选择最短距离
        if min_dist > d:
            min_dist = d
    return min_dist

def get_centroids(points, k):
    ‘‘‘KMeans++的初始化聚类中心的方法
    input:  points(mat):样本
        k(int):聚类中心的个数
    output: cluster_centers(mat):初始化后的聚类中心
    ‘‘‘
    m, n = np.shape(points)
    cluster_centers = np.mat(np.zeros((k , n)))
    # 1、随机选择一个样本点为第一个聚类中心
    index = np.random.randint(0, m)
    cluster_centers[0, ] = np.copy(points[index, ])
    # 2、初始化一个距离的序列
    d = [0.0 for _ in xrange(m)]

    for i in xrange(1, k):
        sum_all = 0
        for j in xrange(m):
            # 3、对每一个样本找到最近的聚类中心点
            d[j] = nearest(points[j, ], cluster_centers[0:i, ])
            # 4、将所有的最短距离相加
            sum_all += d[j]
        # 5、取得sum_all之间的随机值
        sum_all *= random()
        # 6、获得距离最远的样本点作为聚类中心点
        for j, di in enumerate(d):
            sum_all -= di
            if sum_all > 0:
                continue
            cluster_centers[i] = np.copy(points[j, ])
            break
    return cluster_centers

def run_kmeanspp(data, k):
    # 1、KMeans++的聚类中心初始化方法
    print "\t---------- 1.K-Means++ generate centers ------------"
    centroids = get_centroids(data, k)
    # 2、聚类计算
    print "\t---------- 2.kmeans ------------"
    subCenter = kmeans(data, k, centroids)
    # 3、保存所属的类别文件
    print "\t---------- 3.save subCenter ------------"
    save_result("sub_pp", subCenter)
    # 4、保存聚类中心
    print "\t---------- 4.save centroids ------------"
save_result("center_pp", centroids)

在上述代码中主要是初始化k个聚类中心，K-Means算法的核心程序如下所示：

# coding:UTF-8
‘‘‘
Date:20160923
@author: zhaozhiyong
‘‘‘
import numpy as np

def distance(vecA, vecB):
    ‘‘‘计算vecA与vecB之间的欧式距离的平方
    input:  vecA(mat)A点坐标
        vecB(mat)B点坐标
    output: dist[0, 0](float)A点与B点距离的平方
    ‘‘‘
    dist = (vecA - vecB) * (vecA - vecB).T
    return dist[0, 0]

def randCent(data, k):
    ‘‘‘随机初始化聚类中心
    input:  data(mat):训练数据
        k(int):类别个数
    output: centroids(mat):聚类中心
    ‘‘‘
    n = np.shape(data)[1]  # 属性的个数
    centroids = np.mat(np.zeros((k, n)))  # 初始化k个聚类中心
    for j in xrange(n):  # 初始化聚类中心每一维的坐标
        minJ = np.min(data[:, j])
        rangeJ = np.max(data[:, j]) - minJ
        # 在最大值和最小值之间随机初始化
        centroids[:, j] = minJ * np.mat(np.ones((k , 1))) + np.random.rand(k, 1) * rangeJ
    return centroids

def kmeans(data, k, centroids):
    ‘‘‘根据KMeans算法求解聚类中心
    input:  data(mat):训练数据
        k(int):类别个数
        centroids(mat):随机初始化的聚类中心
    output: centroids(mat):训练完成的聚类中心
        subCenter(mat):每一个样本所属的类别
    ‘‘‘
    m, n = np.shape(data)  # m：样本的个数，n：特征的维度
    subCenter = np.mat(np.zeros((m, 2)))  # 初始化每一个样本所属的类别
    change = True  # 判断是否需要重新计算聚类中心
    while change == True:
        change = False  # 重置
        for i in xrange(m):
            minDist = np.inf  # 设置样本与聚类中心之间的最小的距离，初始值为争取穷
            minIndex = 0  # 所属的类别
            for j in xrange(k):
                # 计算i和每个聚类中心之间的距离
                dist = distance(data[i, ], centroids[j, ])
                if dist < minDist:
                    minDist = dist
                    minIndex = j
            # 判断是否需要改变
            if subCenter[i, 0] <> minIndex:  # 需要改变
                change = True
                subCenter[i, ] = np.mat([minIndex, minDist])
        # 重新计算聚类中心
        for j in xrange(k):
            sum_all = np.mat(np.zeros((1, n)))
            r = 0  # 每个类别中的样本的个数
            for i in xrange(m):
                if subCenter[i, 0] == j:  # 计算第j个类别
                sum_all += data[i, ]
                r += 1
            for z in xrange(n):
                try:
                    centroids[j, z] = sum_all[0, z] / r
                    print r
                except:
                    print " r is zero"
    return subCenter

def save_result(file_name, source):
    ‘‘‘保存source中的结果到file_name文件中
    input:  file_name(string):文件名
        source(mat):需要保存的数据
    output:
    ‘‘‘
    m, n = np.shape(source)
    f = open(file_name, "w")
    for i in xrange(m):
        tmp = []
        for j in xrange(n):
            tmp.append(str(source[i, j]))
        f.write("\t".join(tmp) + "\n")
    f.close()

3.2、利用聚类结果生成新的图片

上述的过程中，对每一个像素点进行了聚类，最终利用聚类中心点的RGB值替换原图中每一个像素点的值，便得到了最终的分割后的图片，代码如下所示：

#coding:UTF-8

import Image as image

f_center = open("center_pp")

center = []
for line in f_center.readlines():
    lines = line.strip().split("\t")
    tmp = []
    for x in lines:
        tmp.append(int(float(x) * 256))
    center.append(tuple(tmp))
print center
f_center.close()

fp = open("001.jpg", "rb")
im = image.open(fp)
# 新建一个图片
m, n = im.size
pic_new = image.new("RGB", (m, n)) 

f_sub = open("sub_pp")
i = 0
for line in f_sub.readlines():
    index = float((line.strip().split("\t"))[0])
    index_n = int(index)
    pic_new.putpixel(((i/n),(i % n)),center[index_n])
    i = i + 1
f_sub.close()

pic_new.save("result.jpg", "JPEG")

对于上述的圣托里尼的图片，取不同的k值，得到如下的一些结果：

  • 原图

  • k=3

  • k=5

  • k=7

  • k=10

参考文章

时间： 2024-10-03 20:42:10

机器学习算法实践——K-Means算法与图像分割的相关文章

机器学习随笔01 - k近邻算法

算法名称: k近邻算法 (kNN: k-Nearest Neighbor) 问题提出: 根据已有对象的归类数据,给新对象(事物)归类. 核心思想: 将对象分解为特征,因为对象的特征决定了事对象的分类. 度量每个特征的程度,将其数字化. 所有特征值构成元组,作为该对象的坐标. 计算待检测对象和所有已知对象的距离,选择距离最接近的k个已知对象 (k近邻中的k来源于此). 这k个对象中出现次数最多的分类就是待检测对象的分类. 重要前提: 需要有一批已经正确归类了的对象存在.也就是通常说的训练数据. 重

机器学习实战笔记-K近邻算法1（分类动作片与爱情片）

K近邻算法采用测量不同特征值之间的距离方法进行分类 K近邻算法特点: 优点:精度高.对异常值不敏感.无数据输入假定. 缺点:计算复杂度高.空间复杂度高. 适用数据范围:数值型和标称型. K近邻算法原理: 存在一个样本数据集合,也称作训练样本集,并且样本集中每个数据都存在标签,即我们知道样本集中每一数据与所属分类的对应关系.输人没有标签的新数据后,将新数据的每个特征与样本集中数据对应的 特征进行比较,然后算法提取样本集中特征最相似数据(最近 邻)的分类标签.一般来说,我们只选择样本数据集中前k个最

机器学习实战笔记-K近邻算法2(改进约会网站的配对效果)

案例二.:使用K-近邻算法改进约会网站的配对效果 案例分析: 海伦收集的数据集有三类特征,分别是每年获得的飞行常客里程数.玩视频游戏所耗时间百分比. 每周消费的冰淇淋公升数.我们需要将新数据的每个新数据的每个特征与样本集中数据对应的特征进行比较,然后算法提取样本集中特征最相似数据(最近邻)的分类标签.一般来说,我们只选择样本数据集中前k个最相似的数据,这就是k-近邻算法中k的出处,通常k是不大于20的整数.最后,选择k个最相似数据中出现次数最多的分类,作为新数据的分类. 流程:在约会网站上使用K

《机器学习实战》-k近邻算法

目录 K-近邻算法 k-近邻算法概述 解析和导入数据 使用 Python 导入数据 实施 kNN 分类算法 测试分类器 使用 k-近邻算法改进约会网站的配对效果 收集数据 准备数据:使用 Python 解析文本文件 分析数据:使用 Matplotlib 画二维散点图 准备数据:归一化数值 测试算法:验证分类器 使用算法:构建完整可用系统 手写识别系统 准备数据 测试算法 使用算法:构建完整可用系统 总结 K-近邻算法 k-近邻分类算法概述 使用 k-近邻算法改进约会网站的配对效果 手写识别系统

机器学习实战笔记--k近邻算法

1 #encoding:utf-8 2 from numpy import * 3 import operator 4 import matplotlib 5 import matplotlib.pyplot as plt 6 7 from os import listdir 8 9 def makePhoto(returnMat,classLabelVector): #创建散点图 10 fig = plt.figure() 11 ax = fig.add_subplot(111) #例如参数为

图说十大数据挖掘算法(一)K最近邻算法

如果你之前没有学习过K最近邻算法,那今天几张图,让你明白什么是K最近邻算法. 先来一张图,请分辨它是什么水果 很多同学不假思索,直接回答:"菠萝"!!! 仔细看看同学们,这是菠萝么?那再看下边这这张图. 这两个水果又是什么呢? 这就是菠萝与凤梨的故事,下边即将用菠萝和凤梨,给大家讲述怎么用一个算法来知道这是个什么水果的过程,也就是什么是K最近邻算法. (给非吃货同学们补充一个生活小常识,菠萝的叶子有刺,凤梨没有.菠萝的凹槽处是黄色的,而凤梨的凹槽处是绿色的,以后千万不要买错哦!!!)

[迷宫中的算法实践]迷宫生成算法&mdash;&mdash;Prim算法

       普里姆算法(Prim算法),图论中的一种算法,可在加权连通图里搜索最小生成树.意即由此算法搜索到的边子集所构成的树中,不但包括了连通图里的所有顶点(英语:Vertex (graph theory)),且其所有边的权值之和亦为最小.该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克(英语:Vojtěch Jarník)发现:并在1957年由美国计算机科学家罗伯特·普里姆(英语:Robert C. Prim)独立发现:1959年,艾兹格·迪科斯彻再次发现了该算法.因此,在某些场合,普里姆

机器学习实战笔记-K近邻算法3(手写识别系统)

1 准备数据:将图像转换为测试向量 这次数据集还是有两种,训练数据集和测试数据集,分别有2000个,900个. 我们将把一个32*32的二进制图像矩阵转换为1 x 1024的向量,这样前两节使用的分类器就可以处理数字图像信息了. 代码: def img2vector(filename): returnVect = zeros((1,1024)) file = open(filename) for i in range(32): line = file.readline() for j in ra

《机器学习实战》——K近邻算法

原理: (1) 输入点A,输入已知分类的数据集data (2) 求A与数据集中每个点的距离,归一化,并排序,选择距离最近的前K个点 (3) K个点进行投票,票数最多的分类即为所求 优点: 简单,可用于非线性分类 缺点: 当样本不均衡时影响投票结果: 分类结果受K值影响: 时空复杂度高:需要保存全部数据O(N),每次取前k个都要与全部数据进行计算O(N),耗费内存大且计算量大 改进: 样本均衡化 太小的K值容易受噪音影响,大的K值减小噪音但会使分类边界模糊,最合适的方法是用交叉验证确定K值:先确定

算法实践--最小生成树(Kruskal算法)

什么是最小生成树(Minimum Spanning Tree) 每两个端点之间的边都有一个权重值,最小生成树是这些边的一个子集.这些边可以将所有端点连到一起,且总的权重最小 下图所示的例子,最小生成树是{cf, fa, ab} 3条边 Kruskal算法 用到上一篇中介绍的不相交集合(并查集) 首先,定义V是端点的集合,E是边的集合,A为要求的最小生成树集合 初始A为空集合,每个端点都作为单独的不相交集合 将所有边根据其权重进行排序 对每条边(v1, v2),如果其两个端点数据不同的不相交集,则