【机器学习】Fuzzy C-Means（模糊C均值聚类）原理概述和python代码实现完整版

作者：凡人多烦事01 | 2024-05-18 13:07:14

踩

fuzzy c-means

准备说明：Python代码运行，需要有数据集，文章最后有csv格式的数据集，请自行下载。

理论知识讲解：

模糊理论

模糊控制是自动化控制领域的一项经典方法。其原理则是模糊数学、模糊逻辑。1965，L. A. Zadeh发表模糊集合“Fuzzy Sets”的论文，首次引入隶属度函数的概念，打破了经典数学“非0即 1”的局限性，用[0,1]之间的实数来描述中间状态。

很多经典的集合（即：论域U内的某个元素是否属于集合A，可以用一个数值来表示。在经典集合中，要么0，要么1）不能描述很多事物的属性，需要用模糊性词语来判断。比如天气冷热程度、人的胖瘦程度等等。模糊数学和模糊逻辑把只取1或0二值（属于/不属于）的普通集合概念推广0~1区间内的多个取值，即隶属度。用“隶属度”来描述元素和集合之间的关系。

如图所示，对于冷热程度，我们采取三个模糊子集：冷、暖、热。对于某一个温度，可能同时属于两个子集。要进一步具体判断，我们就需要提供一个描述“程度”的函数，即隶属度。

例如，身高可以分为“高”、“中等”、“矮”三个子集。取论域U（即人的身高范围）为[1.0,3.0]，单位m。在U上定义三个隶属度函数来确定身高与三个模糊子集的关系：

模糊规则的设定：

(1)专家的经验和知识

– 藉由询问经验丰富的专家，在获得系统的知识后，将知识改为IF....THEN ....的型式。

(2)操作员的操作模式

– 记录熟练的操作员的操作模式，并将其整理为IF....THEN ....的型式。

(3)自学习

– 设定的模糊规则可能存在偏差，模糊控制器能依设定的目标，增加或修改模糊控制规则

 Fuzzy C-Means算法原理

模糊c均值聚类融合了模糊理论的精髓。相较于k-means的硬聚类，模糊c提供了更加灵活的聚类结果。因为大部分情况下，数据集中的对象不能划分成为明显分离的簇，指派一个对象到一个特定的簇有些生硬，也可能会出错。故，对每个对象和每个簇赋予一个权值，指明对象属于该簇的程度。当然，基于概率的方法也可以给出这样的权值，但是有时候我们很难确定一个合适的统计模型，因此使用具有自然地、非概率特性的模糊c均值就是一个比较好的选择。

简单地说，就是要最小化目标函数Jm:（在一些资料中也定义为SSE即误差的平方和）

其中m是聚类的簇数；i，j是类标号； $u_i_j$ 表示样本 $x_i$ 属于j类的隶属度。i表示第i个样本，x是具有d维特征的一个样本。 $c_j$ 是j簇的中心，也具有d维度。||*||可以是任意表示距离的度量。

模糊c是一个不断迭代计算隶属度 $u_i_j$ 和簇中心 $c_j$ 的过程，直到他们达到最优。

，

注：对于单个样本 $x_i$ ，它对于每个簇的隶属度之和为1。

迭代的终止条件为：

其中k是迭代步数， $\varepsilon$ 是误差阈值。上式含义是，继续迭代下去，隶属程度也不会发生较大的变化。即认为隶属度不变了，已经达到比较优（局部最优或全局最优）状态了。该过程收敛于目标Jm的局部最小值或鞍点。

抛开复杂的算式，这个算法的意思就是：给每个样本赋予属于每个簇的隶属度函数。通过隶属度值大小来将样本归类。

算法步骤

1、初始化

通常采用随机初始化。即权值随机地选取。簇数需要人为选定。

2、计算质心

FCM中的质心有别于传统质心的地方在于，它是以隶属度为权重做一个加权平均。

3、更新模糊伪划分

即更新权重（隶属度）。简单地说，如果x越靠近质心c，则隶属度越高，反之越低。

Python代码实现：


#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@author: panggezhenbucuo
"""
import copy
import math
import random
import time
 
global MAX  # 用于初始化隶属度矩阵U
MAX = 10000.0
 
global Epsilon  # 结束条件
Epsilon = 0.0000001
 
 
def import_data_format_iris(file):
    """
    file这里是输入文件的路径，如iris.txt.
    格式化数据，前四列为data，最后一列为类标号（有0，1，2三类）
    如果是你自己的data，就不需要执行此段函数了。
    """
    data = []
    cluster_location = []
    with open(str(file), 'r') as f:
        for line in f:
            current = line.strip().split(",")  # 对每一行以逗号为分割，返回一个list
            print(current)
            current_dummy = []
            for j in range(0, len(current) - 1):
                #print(current[j])
                current_dummy.append(float(current[j]))  # current_dummy存放data
 
            # 下面注这段话提供了一个范例：若类标号不是0，1，2之类数字时该怎么给数据集
            j += 1
            if current[j] == "Iris-setosa\n":
                cluster_location.append(0)
            elif current[j] == "Iris-versicolor\n":
                cluster_location.append(1)
            else:
                cluster_location.append(2)
            data.append(current_dummy)
    print("加载数据完毕")
    return data
 
 
#	return data , cluster_location
 
def randomize_data(data):
    """
    该功能将数据随机化，并保持随机化顺序的记录
    """
    order = list(range(0, len(data)))
    random.shuffle(order)
    new_data = [[] for i in range(0, len(data))]
    for index in range(0, len(order)):
        new_data[index] = data[order[index]]
    return new_data, order
 
 
def de_randomise_data(data, order):
    """
    此函数将返回数据的原始顺序，将randomise_data()返回的order列表作为参数
    """
    new_data = [[] for i in range(0, len(data))]
    for index in range(len(order)):
        new_data[order[index]] = data[index]
    return new_data
 
 
def print_matrix(list):
    """
    以可重复的方式打印矩阵
    """
    for i in range(0, len(list)):
        print(list[i])
 
 
def initialize_U(data, cluster_number):
    """
    这个函数是隶属度矩阵U的每行加起来都为1. 此处需要一个全局变量MAX.
    """
    global MAX
    U = []
    for i in range(0, len(data)):
        current = []
        rand_sum = 0.0
        for j in range(0, cluster_number):
            dummy = random.randint(1, int(MAX))
            current.append(dummy)
            rand_sum += dummy
        for j in range(0, cluster_number):
            current[j] = current[j] / rand_sum
        U.append(current)
    return U
 
 
def distance(point, center):
    """
    该函数计算2点之间的距离（作为列表）。我们指欧几里德距离。闵可夫斯基距离
    """
    if len(point) != len(center):
        return -1
    dummy = 0.0
    for i in range(0, len(point)):
        dummy += abs(point[i] - center[i]) ** 2
    return math.sqrt(dummy)
 
 
def end_conditon(U, U_old):
    """
	结束条件。当U矩阵随着连续迭代停止变化时，触发结束
	"""
    global Epsilon
    for i in range(0, len(U)):
        for j in range(0, len(U[0])):
            if abs(U[i][j] - U_old[i][j]) > Epsilon:
                return False
    return True
 
 
def normalise_U(U):
    """
    在聚类结束时使U模糊化。每个样本的隶属度最大的为1，其余为0
    """
    for i in range(0, len(U)):
        maximum = max(U[i])
        for j in range(0, len(U[0])):
            if U[i][j] != maximum:
                U[i][j] = 0
            else:
                U[i][j] = 1
    return U
 
 
# m的最佳取值范围为[1.5，2.5]
def fuzzy(data, cluster_number, m):
    """
    这是主函数，它将计算所需的聚类中心，并返回最终的归一化隶属矩阵U.
    参数是：簇数(cluster_number)和隶属度的因子(m)
    """
    # 初始化隶属度矩阵U
    U = initialize_U(data, cluster_number)
    # print_matrix(U)
    # 循环更新U
    while (True):
        # 创建它的副本，以检查结束条件
        U_old = copy.deepcopy(U)
        # 计算聚类中心
        C = []
        for j in range(0, cluster_number):
            current_cluster_center = []
            for i in range(0, len(data[0])):
                dummy_sum_num = 0.0
                dummy_sum_dum = 0.0
                for k in range(0, len(data)):
                    # 分子
                    dummy_sum_num += (U[k][j] ** m) * data[k][i]
                    # 分母
                    dummy_sum_dum += (U[k][j] ** m)
                # 第i列的聚类中心
                current_cluster_center.append(dummy_sum_num / dummy_sum_dum)
            # 第j簇的所有聚类中心
            C.append(current_cluster_center)
 
        # 创建一个距离向量, 用于计算U矩阵。
        distance_matrix = []
        for i in range(0, len(data)):
            current = []
            for j in range(0, cluster_number):
                current.append(distance(data[i], C[j]))
            distance_matrix.append(current)
 
        # 更新U
        for j in range(0, cluster_number):
            for i in range(0, len(data)):
                dummy = 0.0
                for k in range(0, cluster_number):
                    # 分母
                    dummy += (distance_matrix[i][j] / distance_matrix[i][k]) ** (2 / (m - 1))
                U[i][j] = 1 / dummy
 
        if end_conditon(U, U_old):
            print("结束聚类")
            break
    print("标准化 U")
    U = normalise_U(U)
    return U
 
 
def checker_iris(final_location):
    """
    和真实的聚类结果进行校验比对
    """
    right = 0.0
    for k in range(0, 3):
        checker = [0, 0, 0]
        for i in range(0, 50):
            for j in range(0, len(final_location[0])):
                if final_location[i + (50 * k)][j] == 1:  # i+(50*k)表示 j表示第j类
                    checker[j] += 1  # checker分别统计每一类分类正确的个数
        right += max(checker)  # 累加分类正确的个数
    print('分类正确的个数是:', right)
    answer = right / 150 * 100
    return "准确率：" + str(answer) + "%"
 
 
if __name__ == '__main__':
    # 加载数据
    data = import_data_format_iris("Iris.csv")
    # print_matrix(data)
 
    # 随机化数据
    data, order = randomize_data(data)
    # print_matrix(data)
 
    start = time.time()
    # 现在我们有一个名为data的列表，它只是数字
    # 我们还有另一个名为cluster_location的列表，它给出了正确的聚类结果位置
    # 调用模糊C均值函数
    final_location = fuzzy(data, 3, 2)
 
    # 还原数据
    final_location = de_randomise_data(final_location, order)
    #	print_matrix(final_location)
 
    # 准确度分析
    print(checker_iris(final_location))
    print("用时：{0}".format(time.time() - start))

运行结果展示：

最后，需要数据集和代码的朋友们，请关注如下微信公众号，回复"模糊聚类"，即可获取完整内容：

微信公众号：胖哥真不错。

祝您学习愉快。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/588383