利用Python实现模糊动态聚类

实验数据集

**本实验选取了实验数据集的前六行。**

算法描述

1.数据规格化

此例采用标准化方法，对特征指标矩阵X的第j列，计算均值和方差，然后作变换

2.构造模糊相似矩阵

此例采用夹角余弦法，公式如下

3.求解模相似阵传递闭包

此例采用平方法求取相似矩阵的传递闭包，从模糊相似矩阵R出发，依次求：R->R2 ->R4->…->Rn。
直到出现新的传递闭包等于上一次传递闭包的结果，算法终止。

4.选取最优lambda分类

此例采用Xie-Beni指标对作为lambda取值的评判标准：

XB指标寻找类内紧凑度和类间分离度之间的某个平衡点，其中
类内紧凑度 = 该公式分子部分/样本数m，越小越好。
类间分离度 = 该公式分母部分*样本数m，越大越好。
XB指标计算结果越小，聚类效果最好。

源代码

# -*- coding: utf-8 -*-
import numpy as np
import pprint
import xlrd
from copy import deepcopy
#矩阵不用科学计数法的显示方式
np.set_printoptions(suppress=True)


def main():
	path = 'D:/煤层块段的特性指标值.xls'
	# 0.读取数据
	matrix = read_excel(path)

	# 1.数据规范化：采用标准化方法
	x_matrix = process_matrix(matrix)

	# 2.构造模糊相似矩阵：采用夹角余弦法
	r_matrix = get_rmatrix(x_matrix)

	#  将模糊相似矩阵取两位小数，否则后面的与lambda值判断大小时会出错
	for i in range(r_matrix.shape[0]) :
		for j in range(r_matrix.shape[1]) :
			r_matrix[i][j] = round(r_matrix[i][j],2)

	print('==================特征指标矩阵================')
	print(matrix)
	print('===============标准化特征指标矩阵=============')
	print(x_matrix)
	print('==================模糊相似矩阵R================')
	print(r_matrix)

	# 3.求传递闭包t(R)
	i = 0
	while True:
		t_r_matrix = get_tR(r_matrix)
		print("==================模糊相似矩阵R^%d================"%(2**i))
		print(t_r_matrix)
		#若get_tR(r_matrix) == t_r_matrix ，退出循环
		if (t_r_matrix == r_matrix).all():
			print("********  R^%d = R^%d ,传递闭包过程结束。******** "%(2**(i-1),2**i))
			break

		#否则，将t_r_matrix作为待求闭包矩阵
		else:
			r_matrix = t_r_matrix
			i += 1


	# 4.按lambda截集进行动态聚类
	result = lambda_clustering(t_r_matrix)
	print("************动态聚类结果为****************")
	for x in result:
		pprint.pprint(x)
	# 5.利用Xie_beni指数寻找最优分类
	best_class = Xie_Beni(result,x_matrix)
	print("***********最优分类结果如下***************")
	print(best_class)


# 1.数据规范化：采用标准化方法
def process_matrix(x_matrix):
	x = deepcopy(x_matrix)
	#获得特征指标矩阵行列数
	x_rows = x.shape[0]
	x_cols = x.shape[1]
	#参数0代表对每一列求均值，参数1代表对每一行求均值，无参数则求所有元素的均值
	mean_matrix = np.mean(x,axis = 0)
	var_matrix = np.var(x,axis = 0)
	for i in range(x_rows):
		for j in range(x_cols):
			x[i][j] = (x[i][j] - mean_matrix[j])/var_matrix[j]

	return x

# 2.构造模糊相似矩阵：采用夹角余弦法
def get_rmatrix(x_matrix):

	x_rows = x_matrix.shape[0]
	x_cols = x_matrix.shape[1]
	# norm_matrix :每一行的2-范式值
	norm_matrix = np.linalg.norm(x_matrix,axis = 1)
	# r_matrix : 模糊相似矩阵
	r_matrix = np.zeros((x_rows,x_rows),dtype = 'float')
	#获得模糊相似接矩阵行列数
	r_rows = r_matrix.shape[0]
	r_cols = r_matrix.shape[1]
	for i in range(r_rows):
		for j in range(r_cols):
			multi_matrix = x_matrix[i] * x_matrix[j]
			r_matrix[i][j] = abs(np.dot(x_matrix[i],x_matrix[j])) / (norm_matrix[i] * norm_matrix[j])

	return r_matrix
	

def get_tR(mat):
	rows = mat.shape[0]
	cols = mat.shape[1]
	min_list = []
	new_mat = np.zeros((rows,cols),dtype = 'float')
	for m in range(rows):
		for n in range(cols):
			min_list = []
			now_row = mat[m]
			now_col = mat[:,n]
			for k in range(len(now_row)):
				min_cell = min(mat[m][k],mat[:,n][k])
				min_list.append(min_cell)
			new_mat[m][n] = max(min_list)
	return new_mat

# 4.按lambda截集进行动态聚类
def lambda_clustering(final_matrix):
	rows = final_matrix.shape[0]
	cols = final_matrix.shape[1]
	result = [] #返回的结果
	lambda_list = []  #所有的lambda值
	temp_matrix = np.zeros((rows,cols),dtype = 'float')

	for i in final_matrix :
		for j in i :
			if j not in lambda_list :
				lambda_list.append(j)

	lambda_list.sort()

	for i in range(len(lambda_list)):
		class_list = []  #分类情况
		mark_list = [] #存储当前lambda值，已经被分组的样本
		temp_infor = {'matrix':np.zeros((rows,cols),dtype = 'float'),'lambda':lambda_list[i],'class':[]} #每个lambda值的分类情况

		for m in range(rows):
			for n in range(cols):
				if final_matrix[m][n] >= lambda_list[i]:
					temp_infor['matrix'][m][n] = 1
				else:
					temp_infor['matrix'][m][n] = 0

		for m in range(rows):
			if (m+1) in mark_list:
				continue
			now_class = []
			now_class.append(m+1)
			mark_list.append(m+1)
			for n in range(m+1,rows):
				if (temp_infor['matrix'][m] == temp_infor['matrix'][n]).all() :
					now_class.append(n+1)
					mark_list.append(n+1)
			class_list.append(now_class)
			
		temp_infor['class'] = class_list
		result.append(temp_infor)
	return result


#print("===============t(R)%f==========="%lambda_list[i])
		#print(temp_matrix)
def Xie_Beni(infor_list,x_matrix):
	class_num = 0    #当前总类数
	class_list = []  #当前分类情况
	result = []      #返回结果
	rate = 0 #Xie_Beni指数
	flag = 0 #标记Xie_Beni指数最大的分类情况

	for temp in infor_list:
		this_in_measure = 0	#当前分类的类内紧密度，类中各点与类中心的距离平方和
		this_out_measure = 100000	#当前分类的类间分离度，最小的类与类中心的平方
		result_infor = {'class':[],'in':0,'out':0} #每一种分类生成一个 class-in-out字典，最后append到result中用作函数返回值
		class_list = temp['class']
		class_num = len(class_list)
		means_list = [np.zeros((1,x_matrix.shape[1]),dtype = 'float')]*class_num #该分类下，每一类的均值
		#遍历每一类
		for i in range(class_num):
			#求每一类的类中心
			this_class_num = len(class_list[i])
			this_sum = np.zeros((1,x_matrix.shape[1]),dtype = 'float')
			this_means = np.zeros((1,x_matrix.shape[1]),dtype = 'float')
			for j in range(this_class_num):
				this_sum += x_matrix[class_list[i][j]-1]
			this_means = this_sum/this_class_num
			means_list[i] = this_means

		#计算当前分类类间分离度
		for m in range(len(means_list)):

			#当所有样本分为一类的时候，类间分离度为无穷大，但这样的分类没有任何意义，所以置0，不予以比较。
			if len(means_list) == 1:
				this_out_measure = 0
				break
			for n in range(m+1,len(means_list)):
				temp = fun(means_list[m],means_list[n])
				if temp < this_out_measure:
					this_out_measure = temp

		#计算当前分类类内紧密度
		for m in range(class_num):
			this_class_num = len(class_list[i])
			for n in range(this_class_num):
				add = fun(means_list[m],np.array([x_matrix[n-1]]))
				this_in_measure += add
		#print(this_in_measure)
		#print(this_out_measure)
		this_rate = this_out_measure/this_in_measure
		print("当前分类情况为")
		print(class_list)
		print("Xie_Beni指数为%f"%this_rate)
		print("==============================")
		if this_rate > rate:
			rate = this_rate
			flag = class_list
	return flag


#计算向量间距离，本题采用二范式
def fun(x1,x2):
	distance = 0
	if len(x1) != len(x2):
		print("输入的矩阵有误")
		return False
	temp_x = x1 - x2
	for i in range(len(x1)):
		increase = temp_x[0,i]**2
		distance += increase
	return distance
#传入excel目录
def read_excel(path):
	#打开exel
	workbook = xlrd.open_workbook(path,'r') 
	#获得sheet1名字
	sheet1 = workbook.sheets()[0] 
	rows = sheet1.nrows
	cols = sheet1.ncols
	#建立特征指标矩阵
	x_matrix = np.zeros((rows-1,cols-1),dtype = 'float')
	#第一行是列名，从第二行开始
	for i in range(0,rows-1):
		#第一列是序号，从第二列开始
		for j in range(0,cols-1):
			x_matrix[i][j]= sheet1.cell(i+1,j+1).value
	return x_matrix

if __name__ == '__main__':
	main()

实验结果

1.特征指标矩阵

2.标准化后的特征指标矩阵

3.求模糊相似矩阵传递闭包

4.动态聚类结果

5.模糊动态图

6.Xie_Beni指标求解最佳lambda