python实现MED分类器

import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn import preprocessing
from sklearn.datasets import make_classification
from sklearn.svm import SVC
import matplotlib.pyplot as plt
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import copy


# 特征白化，返回白化后的矩阵（numpy数组格式）
# 参数为numpy格式的数组，其格式为数学上的矩阵的转置
def whitening(feature_x):
    new_feature_x = np.asmatrix(feature_x).T
    sigma_x = np.cov(new_feature_x)
    eig_x = np.linalg.eig(sigma_x)  # 计算协方差矩阵sigma_x的特征值和特征向量
    diag_x = np.diag(eig_x[0])
    W = np.dot(np.power(np.asmatrix(diag_x).I, 0.5), eig_x[1].T)  # 记得eig_x[1]要转置！因为它是所求特征向量矩阵的转置
    return np.dot(W, new_feature_x).T.A  # 将矩阵转换为numpy的风格


# MED分类器
# 只能分辨训练集中存在的类别
class MedClassifier:
    def __init__(self):
        self.center_dict = {}  # 分类中心点，以类别标签为键   label: center_point(list)
        self.feature_number = 0  # 特征维度
        self.train_state = False  # 训练状态，True为训练完成，False表示还没训练过

    # 根据传入的样本集（特征+标签）来训练MED分类器，
    # 其中每一个特征要求是行向量，标签也是行向量（为了与numpy array的格式对齐）
    # 函数将输入的标签数组转换为字典
    def train(self, feature_set, label_set):
        new_label_set = {key: value for key, value in enumerate(label_set)}  # 将标签集合转换为以下标为键的字典   index: label
        self.feature_number = len(feature_set[0])
        sample_num = len(label_set)  # 样本个数
        count = {}  # 计算每个类别的样本个数  label: count(int)
        # 计算每个类别的分类中心点
        for index in range(sample_num):
            if new_label_set[index] not in count.keys():
                count[new_label_set[index]] = 0
            else:
                count[new_label_set[index]] += 1  # 计算对应标签的样本数
            if new_label_set[index] not in self.center_dict.keys():
                self.center_dict[new_label_set[index]] = feature_set[index]
            else:
                self.center_dict[new_label_set[index]] += feature_set[index]
        for _key_ in self.center_dict.keys():
            for _feature_ in range(self.feature_number):
                self.center_dict[_key_][_feature_] /= count[_key_]
        self.train_state = True

    # 根据输入来进行分类预测，输出以 下标—预测分类 为键值对的字典
    def predict(self, feature_set):
        # 先判断此分类器是否经过训练
        if not self.train_state:
            return {}
        sample_num = len(feature_set)
        distance_to = {}  # 计算某个样本到各分类中心点距离的平方  label: float
        result = {}  # 保存分类结果  index: label
        for _sample_ in range(sample_num):
            for _key_ in self.center_dict.keys():
                delta = feature_set[_sample_] - self.center_dict[_key_]
                distance_to[_key_] = np.dot(delta.T, delta)
            result[_sample_] = min(distance_to, key=distance_to.get)  # 返回最小值的键（即label）
        return result

    # 判断预测准确率
    def accuracy(self, feature_set, label_set):
        if not self.train_state:
            return 0.0
        correct_num = 0
        total_num = len(label_set)
        predict = self.predict(feature_set)
        for _sample_ in range(total_num):
            if predict[_sample_] == label_set[_sample_]:
                correct_num += 1
        return correct_num / total_num

    # 根据指定的阳性类别，计算分类器的性能指标（准确率accuracy，精度precision，召回率recall，特异性specificity，F1_Score）
    def performance(self, feature_set, label_set, positive):
        if not self.train_state:
            return {}
        total_num = len(label_set)
        predict = self.predict(feature_set)
        true_positive, false_positive, true_negative, false_negative = 0, 0, 0, 0
        for _sample_ in range(total_num):
            if predict[_sample_] == label_set[_sample_]:
                if label_set[_sample_] == positive:
                    true_positive += 1
                else:
                    true_negative += 1
            else:
                if label_set[_sample_] == positive:
                    false_negative += 1
                else:
                    false_positive += 1
        accuracy = (true_positive + true_negative) / total_num  # 准确率（预测正确的样本与总样本数之比）
        precision = true_positive / (true_positive + false_positive)  # 精度（所有 预测 为阳性的样本中， 真值 为阳性的比例）
        recall = true_positive / (true_positive + false_negative)  # 召回率（所有 真值 为阳性的样本中， 预测 为阳性的比例）
        specificity = true_negative / (true_negative + false_positive)  # 特异性（所有 真值 为阴性的样本中， 预测 为阴性的比例）
        F1_Score = (2 * precision * recall) / (precision + recall)  # 精度与召回率的加权平均
        return {"accuracy": accuracy, "precision": precision, "recall": recall, "specificity": specificity, "F1_Score": F1_Score}

    # 获取某一类的样本中心点
    def get_center(self, key):
        if key in self.center_dict.keys():
            return self.center_dict[key]
        else:
            return []

    def get_center_dict(self):
        return self.center_dict


# 将字典转换为列表（只保留每个键值对的值）
def dict_values_to_list(_dict_):
    if isinstance(_dict_, dict):
        return list(_dict_.values())
    else:
        return []


# feature表示样本特征，label表示对应的标签,m行n列共计m*n个子图
def visualization_2d(feature, label, m, n):
    plt.figure(figsize=(20, 20), dpi=80)
    img = [[] for i in range(m*n)]
    for i in range(m):
        for j in range(n):
            img[i*n+j] = plt.subplot(m, n, i*n+j+1)
            plt.xlabel("x"+str(i))
            plt.ylabel("x"+str(j))
            # plt.xlim(-1, 9)
            # plt.ylim(-1, 9)
            # plt.legend()  # 显示图例
            plt.scatter(feature[:, i], feature[:, j], s=5, c=label, marker='.')
            plt.colorbar()  # 显示颜色条
            plt.grid(True)  # 显示网格线
    plt.show()


# 展示二维平面上，二分类问题的决策线（class_1和class_2）
# feature是样本特征集合，label是对应的标签集合，对每一维特征进行两两比较，n表示特征维数
def show_decision_line(feature, label, med_classifier, class_1=0, class_2=0, n=0):
    plt.figure(figsize=(16, 12), dpi=80)  # 整张画布大小与分辨率
    img = [[] for i in range(n * n)]
    for i in range(n):
        for j in range(n):
            img[i * n + j] = plt.subplot(n, n, i * n + j + 1)
            center_1 = med_classifier.get_center(class_1)
            center_2 = med_classifier.get_center(class_2)
            c_1 = [center_1[i], center_1[j]]  # class_1类中心点的i, j两维的分量
            c_2 = [center_2[i], center_2[j]]  # class_2类中心点的i, j两维的分量
            center_3 = [(c_1[0] + c_2[0]) / 2, (c_1[1] + c_2[1]) / 2]  # 两点连线的中点
            k2, b2 = calculate_vertical_line(c_1, c_2)  # 两点中垂线的斜率和截距
            plt.scatter(feature[:, i], feature[:, j], c=label, s=20, marker='.')  # 整个样本集在特征0和2上的散点图
            plt.scatter(c_1[0], c_1[1], c='b', marker='x')  # 显示med分类器计算的样本中心点
            plt.scatter(c_2[0], c_2[1], c='b', marker='x')
            plt.colorbar()  # 显示散点图的颜色条
            plt.grid(True)  # 显示网格线
            plt.axis('equal')  # 横纵坐标间隔大小相同
            plt.axline(c_1, c_2, color='c', linestyle="--", label="connected line")
            plt.axline(center_3, slope=k2, color='r', label="decision line")
            if i == j:
                plt.legend()  # 对角线上的子图显示出图例
            plt.xlabel("feature " + str(i))
            plt.ylabel("feature " + str(j))
            plt.tight_layout()  # 自动调整子图大小，减少相互遮挡的问题
    plt.show()


# 计算两点连线，返回斜率和纵截距（假设是二维平面上的点，并且用列表表示）
def calculate_connected_line(point_1, point_2):
    if len(point_1) != 2 or len(point_2) != 2:
        return None
    k = (point_1[1] - point_2[1]) / (point_1[0] - point_2[0])
    b = (point_1[0] * point_2[1] - point_2[0] * point_1[1]) / (point_1[0] - point_2[0])
    return k, b


# 计算两点中垂线，返回斜率和纵截距（假设是二维平面上的点，并且用列表表示）
def calculate_vertical_line(point_1, point_2):
    if len(point_1) != 2 or len(point_2) != 2:
        return None
    k = -(point_1[0] - point_2[0]) / (point_1[1] - point_2[1])
    b = (point_1[1] + point_2[1] + (point_1[0] + point_2[0]) * (point_1[0] - point_2[0]) / (point_1[1] - point_2[1]))/2
    return k, b


# 去除某个类别的样本，返回两个numpy数组
def remove_from_sample(feature, label, _class_):
    new_feature = []
    new_label = []
    for index in range(len(label)):
        if label[index] != _class_:
            new_feature.append(feature[index])
            new_label.append(label[index])
    return np.asarray(new_feature), np.asarray(new_label)


if __name__ == '__main__':
    iris = datasets.load_iris()
    iris_x = iris.data
    iris_y = iris.target

    iris_x_whitening = whitening(iris_x)  # 返回的是numpy数组格式，是数学矩阵的转置
    iris_x = iris_x_whitening

    # print(np.cov(iris_x_whitening.T))

    # 显示白化前后的散点图
    # visualization_2d(iris_x, iris_y, 4, 4)
    # visualization_2d(np.asarray(iris_x_whitening).T, iris_y, 4, 4)

    # 去除线性可分的类（0类）
    iris_x_nonlinear, iris_y_nonlinear = remove_from_sample(iris_x, iris_y, 0)

    # 去除线性不可分类（1类）
    iris_x_linear, iris_y_linear = remove_from_sample(iris_x, iris_y, 1)

    # visualization_2d(iris_x_nonlinear, iris_y_nonlinear, 4, 4)  # 显示4个特征两两对比的散点图（包括自己比自己）

    x_train, x_test, y_train, y_test = train_test_split(iris_x_linear, iris_y_linear, test_size=0.3)
    med = MedClassifier()  # 创建MED分类器
    med.train(x_train, y_train)  # 训练
    # print(np.asarray(dict_values_to_list(med.predict(x_test))))  # 用numpy数组格式显示预测结果
    # print(y_test)
    performance = med.performance(x_test, y_test, 0)  # 当以0类为阳性时，计算med分类器的性能指标
    print(performance)

    # 展示每个特征两两对比图，显示决策线
    show_decision_line(x_test, y_test, med, class_1=0, class_2=2, n=4)

• 在鸢尾花数据集上

  • 去除线性可分的类（1类），结果如下：
    
    

  • 去除线性不可分的类（0类），结果如下：