模糊聚类python可执行完整代码

该资源包括两部分代码，都是python实现，使用两种方式实现了模糊聚类，使用的数据集也在压缩包内，配置好环境可直接运行。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# author:1111
# datetime:2019/2/22 11:17
# software: PyCharm

from pylab import *
from numpy import *
import copy
import random
import  time
import math
import matplotlib.pyplot as plt

import matplotlib.animation as animation
import decimal
#



#初始化隶属度矩阵U
global MAX
MAX = 10000.0
#用于结束条件
global Epsilon
Epsilon = 0.00000001

def import_data（file）:
    “““
    格式化数据，前四列为data最后一列为cluster_location
    “““
    data = []
    cluster_location = []
    with open（str（file）‘r‘） as f :
        for line in f:
            current = line.strip（）.split（““）
            current_dummy = []
            #只读取数据库中除去最后一列之外的其他数据
            for j in range（0len（current）-1）:
                current_dummy.append（float（current[j]））
            j += 1#将指针位移到表示类别的列 j=4
            #对原始数据每一行的数据进行分类，分为三类，用012表示
            if  current[j] == “Iris-setosa“:
                 cluster_location.append（0）

            elif current[j] == “Iris-versicolor“:
                 cluster_location.append（1）

            elif current[j] == “Iris-virginica“:
                 cluster_location.append（2）
            #创建只剩属性的新数据集
            data.append（current_dummy）
    print（“data lode over“）
    return data  cluster_location

def randomise_data（data）:
    “““
    将数据随机化并保持随机化顺序的记录
    :param data:
    :return:
    “““
    order = list（range（0len（data）））#数据的条目数

    random.shuffle（order）#随机排序列表

    new_data = [[] for i in range（0len（data））]
    for index in range（0len（order））:
        new_data[index] = data[order[index]] #随机化数据顺序之后所对应的数据进行重新赋值，相当于随机化原始数据
    return  new_dataorder

def de_randomise_data（dataorder）:
    “““
    将返回数据的原始顺序，将randomise_data（）返回的order列表作为参数
    :param data:
    :param order:
    :return:
    “““
    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 initialise_U（data cluster_number）:
    “““
    隶属度矩阵U的每行加起来为1
    :param data:
    :param cluster_number:
    :return:
    “““
    global MAX
    U = []
    for i in range（0len（data））:
        current = []
        rand_sum = 0.0
        for j in range（0cluster_number）:
            dummy = random.randint（1int（MAX））
            current.append（dummy）
            rand_sum += dummy

        for j in range（0cluster_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矩阵随着连续迭代停止变化时

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----

     文件       4700  2019-03-09 22:13  模糊聚类\iris.txt

     文件       8560  2019-03-14 15:35  模糊聚类\KCM.py

     文件       3716  2019-03-13 22:40  模糊聚类\result.csv

     文件       4431  2019-03-14 15:20  模糊聚类\tst.py

     目录          0  2019-03-15 20:51  模糊聚类

----------- ---------  ---------- -----  ----

                21407                    5