基于python的mean-shift算法

一、Mean Shift算法概述

Mean Shift算法又称均值漂移算法,Mean Shift的概念最早是由Fukunage在1975年提出的,在后来又由Yzong Cheng对其进行扩充,主要提出了两点改进:

定义了核函数;

增加了权重系数。

核函数的定义使得偏移向量的贡献随着样本与被偏移点的距离的不同而不同。

权重系数使得不同样本的权重不同。Mean Shift算法在聚类,图像平滑,分割以及视频跟踪等方面有广泛的应用。

二、算法原理

2.1、核函数

 

常用的核函数有高斯核函数。高斯核函数如下所示:

其中,h称为带宽(bandwidth),不同带宽的核函数如下图所示:

2.2、Mean Shift算法的核心思想

 

2.2.1、基本原理

对于Mean Shift算法,是一个迭代的过程,即先算出当前点的偏移均值,将该点移动到此偏移均值,然后以此为新的起始点,继续移动,直到满足最终的条件。

以上是官方的说法,即书上的定义,个人理解就是,在d维空间中,任选一个点,然后以这个点为圆心,h为半径做一个高维球,因为有d维,d可能大于2,所以是高维球。落在这个球内的所有点和圆心都会产生一个向量,向量是以圆心为起点落在球内的点位终点。然后把这些向量都相加。相加的结果就是Meanshift向量。

步骤1:在指定的区域内计算偏移均值(下图中黄色的圈)

步骤2:移动该点到偏移均值点处(如图,其中黄色箭头就是Mh(meanshift向量))

再以meanshift向量的终点为圆心,再做一个高维的球。如下图所以,重复以上步骤,就可得到一个meanshift向量。如此重复下去,meanshift算法可以收敛到概率密度最大得地方。也就是最稠密的地方。

步骤3: 重复上述的过程(计算新的偏移均值,移动)

步骤4: 满足最终的条件,即退出。下图便是最终的结果!

从上述过程可以看出,在Mean Shift算法中,最关键的就是计算每个点的偏移均值然后根据新计算的偏移均值更新点的位置

2.2.2、基本的Mean Shift向量形式

 

2.3、Mean Shift算法流程

 

复制代码
import matplotlib.pyplot as plt

f = open("data")
x = []
y = []
for line in f.readlines():
    lines = line.strip().split("\t")
    if len(lines) == 2:
        x.append(float(lines[0]))
        y.append(float(lines[1]))
f.close()  

plt.plot(x, y, 'b.', label="original data")
plt.title('Mean Shift')
plt.legend(loc="upper right")
plt.show()
复制代码
3.2 实验源码
复制代码
import math
import sys
import numpy as np

MIN_DISTANCE = 0.000001#mini error

def load_data(path, feature_num=2):
    f = open(path)
    data = []
    for line in f.readlines():
        lines = line.strip().split("\t")
        data_tmp = []
        if len(lines) != feature_num:
            continue
        for i in range(feature_num):
            data_tmp.append(float(lines[i]))

        data.append(data_tmp)
    f.close()
    return data

def gaussian_kernel(distance, bandwidth):
    m = np.shape(distance)[0]
    right = np.mat(np.zeros((m, 1)))
    for i in range(m):
        right[i, 0] = (-0.5 * distance[i] * distance[i].T) / (bandwidth * bandwidth)
        right[i, 0] = np.exp(right[i, 0])
    left = 1 / (bandwidth * math.sqrt(2 * math.pi))

    gaussian_val = left * right
    return gaussian_val

def shift_point(point, points, kernel_bandwidth):
    points = np.mat(points)
    m,n = np.shape(points)
    #计算距离
    point_distances = np.mat(np.zeros((m,1)))
    for i in range(m):
        point_distances[i, 0] = np.sqrt((point - points[i]) * (point - points[i]).T)

    #计算高斯核      
    point_weights = gaussian_kernel(point_distances, kernel_bandwidth)

    #计算分母
    all = 0.0
    for i in range(m):
        all += point_weights[i, 0]

    #均值偏移
    point_shifted = point_weights.T * points / all
    return point_shifted

def euclidean_dist(pointA, pointB):
    #计算pointA和pointB之间的欧式距离
    total = (pointA - pointB) * (pointA - pointB).T
    return math.sqrt(total)

def distance_to_group(point, group):
    min_distance = 10000.0
    for pt in group:
        dist = euclidean_dist(point, pt)
        if dist < min_distance:
            min_distance = dist
    return min_distance

def group_points(mean_shift_points):
    group_assignment = []
    m,n = np.shape(mean_shift_points)
    index = 0
    index_dict = {}
    for i in range(m):
        item = []
        for j in range(n):
            item.append(str(("%5.2f" % mean_shift_points[i, j])))

        item_1 = "_".join(item)
        print(item_1)
        if item_1 not in index_dict:
            index_dict[item_1] = index
            index += 1

    for i in range(m):
        item = []
        for j in range(n):
            item.append(str(("%5.2f" % mean_shift_points[i, j])))

            item_1 = "_".join(item)
        group_assignment.append(index_dict[item_1])

    return group_assignment

def train_mean_shift(points, kenel_bandwidth=2):
    #shift_points = np.array(points)
    mean_shift_points = np.mat(points)
    max_min_dist = 1
    iter = 0
    m, n = np.shape(mean_shift_points)
    need_shift = [True] * m

    #cal the mean shift vector
    while max_min_dist > MIN_DISTANCE:
        max_min_dist = 0
        iter += 1
        print ("iter : " + str(iter))
        for i in range(0, m):
            #判断每一个样本点是否需要计算偏置均值
            if not need_shift[i]:
                continue
            p_new = mean_shift_points[i]
            p_new_start = p_new
            p_new = shift_point(p_new, points, kenel_bandwidth)
            dist = euclidean_dist(p_new, p_new_start)

            if dist > max_min_dist:#record the max in all points
                max_min_dist = dist
            if dist < MIN_DISTANCE:#no need to move
                need_shift[i] = False

            mean_shift_points[i] = p_new
    #计算最终的group
    group = group_points(mean_shift_points)

    return np.mat(points), mean_shift_points, group

if __name__ == "__main__":
    #导入数据集
    path = "./data"
    data = load_data(path, 2)

    #训练,h=2
    points, shift_points, cluster = train_mean_shift(data, 2)

    for i in range(len(cluster)):
        print( "%5.2f,%5.2f\t%5.2f,%5.2f\t%i" % (points[i,0], points[i, 1], shift_points[i, 0], shift_points[i, 1], cluster[i]))

3,实验结果

经过Mean Shift算法聚类后的数据如下所示:

但在实际工作中的复杂数据用Mean-Shift来聚类因为无法控制k个值,可能会产生过多的类而导致聚类失去意义,但Mean-Shift在图像分割上用处很大 。

mean-shift算法的优缺点:

优点:

不需要设置簇类的个数;

可以处理任意形状的簇类;

算法只需设置带宽这一个参数,带宽影响数据集的核密度估计

算法结果稳定,不需要进行类似K均值的样本初始化

缺点:

聚类结果取决于带宽的设置,带宽设置的太小,收敛太慢,簇类个数过多;带宽设置的太大,一些簇类可能会丢失。

对于较大的特征空间,计算量非常大。

上便是本篇对Mean-Shift简单的介绍,如有错误望指出。

  • 1
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
以下是使用Python实现mean-shift算法中为每个点寻找局部最大值的算法示例代码: ```python import numpy as np # mean-shift算法中的核函数 def gaussian_kernel(distance, bandwidth): return (1 / (bandwidth * np.sqrt(2 * np.pi))) * np.exp(-(distance ** 2) / (2 * bandwidth ** 2)) # mean-shift算法中的均值漂移函数 def mean_shift(data, bandwidth): centroids = data.copy() max_iter = 5 # 最大迭代次数 for i in range(max_iter): for j in range(len(data)): weights = gaussian_kernel(np.linalg.norm(data[j] - centroids, axis=1), bandwidth) centroids[j] = np.sum((data.T * weights).T, axis=0) / np.sum(weights) return centroids # 生成数据 X = np.random.randn(1000, 2) # 使用均值漂移函数求解聚类中心 centroids = mean_shift(X, bandwidth=0.5) # 输出聚类中心 print("Number of estimated clusters : %d" % len(centroids)) print("Cluster centers : \n", centroids) ``` 在上面的代码中,我们首先定义了mean-shift算法中的核函数`gaussian_kernel`和均值漂移函数`mean_shift`。其中,核函数使用高斯分布计算权重,均值漂移函数则使用了一系列迭代操作来寻找局部最大值。接下来,我们使用Numpy生成了1000个二维随机数据点,并将其作为输入传递给均值漂移函数。在函数内部,我们使用了两层循环来迭代求解每个数据点的局部最大值,并使用高斯核函数计算了每个数据点的权重。最后,我们输出了求解得到的聚类中心。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值