构造性覆盖算法（python实现）

逐风剑客y
已于 2023-12-27 15:49:54 修改
阅读量378
点赞数 6
文章标签：算法 python 开发语言
于 2023-12-26 19:59:24 首次发布
本文链接：https://blog.csdn.net/hbvdf/article/details/135230062
版权
from cmath import sqrt
import numpy as np
from torch.utils.tensorboard  import  SummaryWriter
from numpy import size, dot
from sklearn import datasets as UCI_datasets  # UCI 数据集在sklearn.datasets中有

writer=SummaryWriter("logs")
# **************************
def mycompare_Minimum_radius_method_on_Trdata(index1, index2):
    ans = 0
    for i in range(0, len(feaName)):
        ans = ans + (Tr[index1].data[i] - Tr[index2].data[i]) * (Tr[index1].data[i] - Tr[index2].data[i])
    result = sqrt(ans)
    # return dot(Tr[index1].data, Tr[index2].data)
    return ans


def mycompare_Minimum_radius_method_on_Vardata(index1, index2):
    ans = 0
    for i in range(0, len(feaName)):
        ans = ans + (Var[index1].data[i] - Hidden_Index[index2].data[i]) * (
                Var[index1].data[i] - Hidden_Index[index2].data[i])
    result = sqrt(ans)
    # return dot(Tr[index1].data, Tr[index2].data)
    return ans


def mycompare_Minimum_radius_method_on_Alldata(index1, index2, k):
    ans = 0
    for i in range(0, len(feaName)):
        ans = ans + (Mydata[index1].data[i] - Hidden_Indexs[k][index2].data[i]) * (Mydata[index1].data[i] - Hidden_Indexs[k][index2].data[i])
    result = sqrt(ans)
    # return dot(Tr[index1].data, Tr[index2].data)
    return ans


def remainder_num_Trdata():
    num = 0
    for i in Tr:
        if i.flag == 0:
            num = num + 1
    return num


def remainder_num_Vardata():
    num = 0
    for i in Var:
        if i.flag == 0:
            num = num + 1
    return num


nHidden = 0
# *************************
# ********加载数据集**********
Data = UCI_datasets.load_digits()

feaName = Data.feature_names  # 数据集特征名称
tarName = Data.target_names  # 数据集标签名称

myData = np.array(Data.data)  # 数据集数据
labels = np.array(Data.target)  # 数据集标签
DataSet_wine = {}
DataSet_wine['feature_names'] = feaName
DataSet_wine['class_names'] = tarName
DataSet_wine['data'] = myData
DataSet_wine['label'] = labels
# ********加载数据集完毕**********
print(tarName,labels)

Data_All_num = size(DataSet_wine['data']) / size(DataSet_wine['feature_names'])
# 划分出数据集与测试机
x = np.random.randint(0, Data_All_num, int(Data_All_num))
# y = (x > 0).astype(int)
# 打乱下标顺序
shuffle_indexs = np.random.permutation(len(x))
# 留几成当作测试数据集
test_radio = 0.3
# 求出test的个数
test_size = int(len(x) * test_radio)
test_size_10 = int(len(x) / 10)
# 比如说我现在0-test_size当作test的数据，test_size-最后当成train数据
test_indexs = shuffle_indexs[:test_size]
train_indexs = shuffle_indexs[test_size:]
Tr_data = []
Var_data = []
Tr_label = []
Var_label = []
Tr = []
Var = []
Hidden_Index = []
Hidden_to_label = []


class Hidd_index():
    def __init__(self, hidden, label, radius, datas):
        self.hidden = hidden
        self.label = label
        self.radiu = radius
        self.data = datas


#######数据划分完毕
class CoV():
    def __init__(self, data, label):
        self.data = data
        self.label = label
        self.radiu = 0  # 该点覆盖的半径
        self.flag = 0  # 表示该点未访问过 1代表访问过，2代表根源节点
        self.hidden = -1  # 表示该点所属的隐藏层

    def set_radius(self, radius):
        self.radiu = radius


Mydata = []
for i in range(0, len(x)):
    Mydata.append(CoV(myData[i], labels[i]))

for i in train_indexs:
    Tr_data.append(myData[i])
    Tr_label.append(labels[i])
    Tr.append(CoV(myData[i], labels[i]))
for i in test_indexs:
    Var_data.append(myData[i])
    Var_label.append(labels[i])
    Var.append(CoV(myData[i], labels[i]))
# *********************Train Begin***********************
while remainder_num_Trdata() != 0:
    x = np.random.randint(0, len(Tr))
    if Tr[x].flag == 1 or Tr[x].flag == 2:
        continue
    if Tr[x].flag == 0:
        Tr[x].flag = 2
        dis = float('inf')
        dis1 = float(0)
        for i in range(0, len(Tr)):
            # if (dis<mycompare_Minimum_radius_method_on_Trdata(x, i)) and Tr[x].label != Tr[i].label and Tr[x].hidden ==-1:   #最近异类点 求最大内积即求最近的点
            if (mycompare_Minimum_radius_method_on_Trdata(x, i) < dis) and Tr[x].label != Tr[i].label and Tr[
                x].hidden == -1:
                # if (dis<mycompare_Minimum_radius_method_on_Trdata(x, i) ) and Tr[x].label == Tr[i].label:
                dis = mycompare_Minimum_radius_method_on_Trdata(x, i)
        for i in range(0, len(Tr)):
            temp = mycompare_Minimum_radius_method_on_Trdata(x, i)
            if (temp < dis) and Tr[x].label == Tr[i].label and Tr[x].hidden == -1 and dis1 < temp and Tr[x].label == Tr[
                i].label:  # 最远同类点 求最小内积即求最远点
                dis1 = temp
        Tr[x].hidden = nHidden
        Tr[x].radiu = dis1
        for i in range(0, len(Tr)):
            if (mycompare_Minimum_radius_method_on_Trdata(x, i) < Tr[x].radiu) and Tr[i].flag == 0:
                Tr[i].flag = 1
                Tr[i].hidden = nHidden
        nHidden = nHidden + 1
print("单次nHidden", nHidden)
for i in range(0, len(Tr)):
    if Tr[i].flag == 2:
        Hidden_Index.append(Hidd_index(Tr[i].hidden, Tr[i].label, Tr[i].radiu, Tr[i].data))
        # print(Tr[i].hidden, Tr[i].label)

for i in range(0, nHidden):
    for j in range(0, nHidden):
        if i == Hidden_Index[j].hidden:
            Hidden_to_label.append(Hidden_Index[j].label)
#print(Hidden_to_label)
point = 0
for i in range(0, len(Tr)):
    if Hidden_to_label[Tr[i].hidden] == Tr[i].label:
        point = point + 1
print("单次训练集准确率=", point / len(Tr))

# *********************Test Begin***********************
dis = float('inf')
for i in range(0, len(Var)):
    nHidden1 = -1
    dis = float('inf')
    for j in range(0, len(Hidden_Index)):
        if (mycompare_Minimum_radius_method_on_Vardata(i, j) <= dis) and (
                mycompare_Minimum_radius_method_on_Vardata(i, j) <= Hidden_Index[j].radiu):
            dis = mycompare_Minimum_radius_method_on_Vardata(i, j)
            nHidden1 = Hidden_Index[j].hidden
    Var[i].hidden = nHidden1
for i in range(0, len(Var)):
    if Var[i].hidden == -1:
        dis = float('inf')
        for j in range(0, len(Hidden_Index)):
            if (mycompare_Minimum_radius_method_on_Vardata(i, j) <= dis):
                dis = mycompare_Minimum_radius_method_on_Vardata(i, j)
                nHidden1 = Hidden_Index[j].hidden
        Var[i].hidden = nHidden1
point = 0
for i in range(0, len(Var)):
    if Hidden_to_label[Var[i].hidden] == Var[i].label:
        point = point + 1
print("单次测试集准确率=", point / len(Var))
Hidden_Indexs = []
Hidden_to_labels = []
for k in range(0, 10):
    nHidden = 0
    test_indexs = shuffle_indexs[k * test_size_10:k * test_size_10 + test_size_10]
    train_indexs = np.concatenate(
        (shuffle_indexs[k * test_size_10 + test_size_10:], shuffle_indexs[0: k * test_size_10]))
    Tr_data = []
    Var_data = []
    Tr_label = []
    Var_label = []
    Tr = []
    Var = []
    Hidden_Index = []
    Hidden_to_label = []

    for i in train_indexs:
        Tr_data.append(myData[i])
        Tr_label.append(labels[i])
        Tr.append(CoV(myData[i], labels[i]))
    for i in test_indexs:
        Var_data.append(myData[i])
        Var_label.append(labels[i])
        Var.append(CoV(myData[i], labels[i]))

    # *********************Train Begin***********************
    while remainder_num_Trdata() != 0:
        x = np.random.randint(0, len(Tr))
        if Tr[x].flag == 1 or Tr[x].flag == 2:
            continue
        if Tr[x].flag == 0:
            Tr[x].flag = 2
            dis = float('inf')
            dis1 = float(0)
            for i in range(0, len(Tr)):
                # if (dis<mycompare_Minimum_radius_method_on_Trdata(x, i)) and Tr[x].label != Tr[i].label and Tr[x].hidden ==-1:   #最近异类点 求最大内积即求最近的点
                if (mycompare_Minimum_radius_method_on_Trdata(x, i) < dis) and Tr[x].label != Tr[i].label and Tr[
                    x].hidden == -1:
                    dis = mycompare_Minimum_radius_method_on_Trdata(x, i)
            for i in range(0, len(Tr)):
                temp = mycompare_Minimum_radius_method_on_Trdata(x, i)
                if (temp < dis) and Tr[x].label == Tr[i].label and Tr[x].hidden == -1 and dis1 < temp and Tr[x].label == \
                        Tr[i].label:  # 最远同类点 求最小内积即求最远点
                    dis1 = temp
            Tr[x].hidden = nHidden
            Tr[x].radiu = dis1
            for i in range(0, len(Tr)):
                if (mycompare_Minimum_radius_method_on_Trdata(x, i) < Tr[x].radiu) and Tr[i].flag == 0:
                    Tr[i].flag = 1
                    Tr[i].hidden = nHidden
            nHidden = nHidden + 1
    print("单次nHidden", nHidden)
    for i in range(0, len(Tr)):
        if Tr[i].flag == 2:
            Hidden_Index.append(Hidd_index(Tr[i].hidden, Tr[i].label, Tr[i].radiu, Tr[i].data))
            # print(Tr[i].hidden, Tr[i].label)

    for i in range(0, nHidden):
        for j in range(0, nHidden):
            if i == Hidden_Index[j].hidden:
                Hidden_to_label.append(Hidden_Index[j].label)
    # print(Hidden_to_label)
    point = 0
    for i in range(0, len(Tr)):
        if Hidden_to_label[Tr[i].hidden] == Tr[i].label:
            point = point + 1
    print("第", k, "轮训练集准确率=", point / len(Tr))
    Hidden_Indexs.append(Hidden_Index)
    Hidden_to_labels.append(Hidden_to_label)
    writer.add_scalar("训练集准确率",point / len(Tr),k)
    # *********************Test Begin***********************
    dis = float('inf')
    for i in range(0, len(Var)):
        nHidden1 = -1
        dis = float('inf')
        for j in range(0, len(Hidden_Index)):
            if (mycompare_Minimum_radius_method_on_Vardata(i, j) <= dis) and (
                    mycompare_Minimum_radius_method_on_Vardata(i, j) <= Hidden_Index[j].radiu):
                dis = mycompare_Minimum_radius_method_on_Vardata(i, j)
                nHidden1 = Hidden_Index[j].hidden
        Var[i].hidden = nHidden1
    for i in range(0, len(Var)):
        if Var[i].hidden == -1:
            dis = float('inf')
            for j in range(0, len(Hidden_Index)):
                if (mycompare_Minimum_radius_method_on_Vardata(i, j) <= dis):
                    dis = mycompare_Minimum_radius_method_on_Vardata(i, j)
                    nHidden1 = Hidden_Index[j].hidden
            Var[i].hidden = nHidden1
    point = 0
    for i in range(0, len(Var)):
        if Hidden_to_label[Var[i].hidden] == Var[i].label:
            point = point + 1
    print("第", k, "轮测试集准确率", point / len(Var))
    writer.add_scalar("测试集准确率", point / len(Var), k)
#**********************在全体数据集上验证**************************
point = 0
for m in range(0, int(Data_All_num)):  # 全体数据
    a = b = c = 0  # 三类
    for k in range(0, 10):  # 10个分类器
        nHidden1 = -1
        dis = float('inf')
        for j in range(0, len(Hidden_Indexs[k])):
            if (mycompare_Minimum_radius_method_on_Alldata(m, j, k) <= dis) and (
                    mycompare_Minimum_radius_method_on_Alldata(m, j, k) <= Hidden_Indexs[k][j].radiu):
                dis = mycompare_Minimum_radius_method_on_Alldata(m, j, k)
                nHidden1 = Hidden_Indexs[k][j].hidden
            Mydata[i].hidden = nHidden1
        for i in range(0, int(Data_All_num)):
            if Mydata[i].hidden == -1:
                dis = float('inf')
                for j in range(0, len(Hidden_Indexs[k])):
                    if (mycompare_Minimum_radius_method_on_Alldata(i, j, k) <= dis):
                        dis = mycompare_Minimum_radius_method_on_Alldata(i, j, k)
                        nHidden1 = Hidden_Indexs[k][j].hidden
                Mydata[i].hidden = nHidden1
        if Hidden_to_labels[k][Mydata[i].hidden] == 0:
            a = a + 1
        if Hidden_to_labels[k][Mydata[i].hidden] == 1:
            b = b + 1
        if Hidden_to_labels[k][Mydata[i].hidden] == 2:
            c = c + 1
    if a >= b and a >= c and Mydata[m].label == 0:
        point = point + 1
    if b >= a and b >= c and Mydata[m].label == 1:
        point = point + 1
    if c >= a and c >= a and Mydata[m].label == 2:
        point = point + 1
print("集成后的准确率", point / float(Data_All_num))
writer.add_scalar("集成后的准确率",point / float(Data_All_num),1)
writer.close()
import cv2
import numpy as np
from matplotlib import pyplot as plt
from scipy.fftpack import fft2, ifft2, fftshift