本文已参与「新人创作礼」活动,一起开启掘金创作之路。
构建全连接神经网络(上),并实现分类任务:
1.我们首先构建网络结构,这里构建五层神经网络:
import torch.nn as nn
from torchvision import transforms as T ##导入模块
class Net(nn.Module):
# 搭建5层网络
def __init__(self, input, hidden_1, hidden_2, hidden_3, hidden_4, output): ##在用到Net时,可以自己手动根据不同的数据集进行改动各层的大小。
# nn.Module子类的函数必须在构造函数中执行父类的构造函数
super(Net, self).__init__()
##充分利用Sequential函数,将线性层Linear、BatchNormalization和激活函数层Tanh()连接起来,从而构造一层全连接。
self.hidden_layer1 = nn.Sequential(
nn.Linear(input, hidden_1), nn.BatchNorm1d(hidden_1),
nn.Tanh()
)
self.hidden_layer2 = nn.Sequential(
nn.Linear(hidden_1, hidden_2), nn.BatchNorm1d(hidden_2),
nn.Tanh()
)
self.hidden_layer3 = nn.Sequential(
nn.Linear(hidden_2, hidden_3), nn.BatchNorm1d(hidden_3),
nn.Tanh()
)
self.hidden_layer4 = nn.Sequential(
nn.Linear(hidden_3, hidden_4), nn.BatchNorm1d(hidden_4),
nn.Tanh()
)
self.output_layer = nn.Sequential(
nn.Linear(hidden_4, output),
nn.Sigmoid()
)
##固定式的前向传播
def forward(self, x):
x = self.hidden_layer1(x)
x = self.hidden_layer2(x)
x = self.hidden_layer3(x)
x = self.hidden_layer4(x)
x = self.output_layer(x)
return x
-
除此之外,我们也可以看看比较经典且详细的几种网络的构建方式,如简单的全连接层、激活层、BN层:
from torchvision import transforms as T transform = T.Compose([ T.Resize(128), # 缩放图像,保持长宽比不变,最短边长度为128 T.CenterCrop(128), # 从图片中间切出128*128的图片 T.ToTensor(), T.Normalize(mean=[.8, .8, .8], std=[.8, .8, .8]) ]) from torchvision import models from torch import nn from torchvision import datasets class simpleNet(nn.Module): # 定义一个最简单的三层全连接神经网络,每一层都是线性的 def __init__(self, in_dim, n_hidden_1, n_hiddle_2, out_dim): super(simpleNet, self).__init__() self.layer1 = nn.Linear(in_dim, n_hidden_1) self.layer2 = nn.Linear(n_hidden_1, n_hiddle_2) self.layer3 = nn.Linear(n_hiddle_2, out_dim) def forward(self, x): x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) return x """ 改进一下simpleNet网络,添加激励函数,增强网络的非线性,将新网络命名为Activation_Net。激励函数的选择有很多,这里选择RELU()函数 """ class Activation_Net(nn.Module): # 在上面的simpleNet网络的基础上,在每层的输出部分添加激励函数 def __init__(self, in_dim, n_hiddle_1, n_hiddle_2, out_dim): super(Activation_Net, self).__init__() # 下部分代码(除了输出层)的输出部分都添加了激励函数,最后还用了nn.Sequential()函数,这个函数将 # nn.Linear()函数和nn.ReLU()函数组合到一起作为self。layer。注意输出层不能有激励函数,因为输出结果表示实际的预测值 self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hiddle_1), nn.ReLU(True)) self.layer2 = nn.Sequential(nn.Linear(n_hiddle_1, n_hiddle_2), nn.ReLU(True)) self.layer3 = nn.Sequential(nn.Linear(n_hiddle_2, out_dim)) def forward(self, x): x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) return x """ 最后我们还需要增加一个加快收敛速度的函数——即为批标准化函数,将新网络命名为Batch_Net, 对于批处理同样使用nn.Sequential()函数,将nn.BatchNormld()函数组合进了网络中, 注意,批标准化函数一般放在激励函数的前面 """ class Batch_Net(nn.Module): def __init__(self, in_dim, n_hiddle_1, n_hiddle_2, out_dim): super(Batch_Net, self).__init__() self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hiddle_1), nn.BatchNorm1d(n_hiddle_1), nn.ReLU(True)) self.layer2 = nn.Sequential(nn.Linear(n_hiddle_1, n_hiddle_2), nn.BatchNorm1d(n_hiddle_2), nn.ReLU(True)) self.layer3 = nn.Sequential(nn.Linear(n_hiddle_2, out_dim)) def forward(self, x): x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) return x
2.数据集的装备、网络进行初始化、定义网络训练、测试及交叉验证等过程:
utils.py
"""
整个实验运行时涉及的一些自定义方法
包括数据获取、网络初始化、网络训练、网络测试以及交叉验证
"""
import pandas as pd
import numpy as np
import Visualization as v
import time
import torch as t
import torch.nn as nn
def get_datas(file):
"""
读取数据
:param file: 数据存储路径
:return: 数据集和标签集
"""
# 读取数据
origin_datas = pd.read_excel(file)
# 将数据转为ndarray
datas_array = origin_datas.to_numpy()
# 固定随机种子,确保每次运行结果一致
np.random.seed(5)
# 打乱数据顺序
np.random.shuffle(datas_array)
# 提取特征和标签
ds = datas_array[:, :-1] ##抽取除了倒数最后一列的数据
ls = datas_array[:, -1] ##抽取倒数最后一列的数据
# 判断标签是否符合标准,即是否从0开始标注
if 0 not in ls:
# 标签从1开始,就将每个标签值-1
ls = ls - 1
# 将数据转为float32的张量, 将标签转为long类型(int64)的张量
ds = t.from_numpy(ds).float()
ls = t.from_numpy(ls).long()
return ds, ls
def init(model):
"""
训练前对模型权重进行初始化
:param model: 训练模型
"""
for m in model.modules():
if isinstance(m, nn.Linear):
nn.init.xavier_uniform_(m.weight)
def train(train_ds, train_ls, model, criterion, optimizer, epochs=20):
"""
训练模型
:param train_ds: 训练数据
:param train_ls: 训练标签
:param model: 训练模型
:param criterion: 损失函数
:param optimizer: 优化算法
:param epochs: 迭代次数
:return: 训练损失值
"""
train_correct = 0
# 将训练集迁移到GPU上
train_ds = train_ds.cuda()
train_ls = train_ls.cuda()
model = model.cuda()
init(model)
for epoch in range(epochs):
model.train()
# 每次训练前梯度置零
optimizer.zero_grad()
# 正向传播
output = model(train_ds)
# 计算损失值
train_loss = criterion(output, train_ls)
# 反向传播
train_loss.backward()
# 更新参数
optimizer.step()
# 获取预测值
predict = output.max(1, keepdim=True)[1]
# 统计预测正确个数
train_correct += predict.eq(train_ls.view_as(predict)).sum().item()
# 计算准确率
train_accuracy = train_correct / train_ds.shape[0]
print("Train loss: {:.3f}".format(train_loss.item()))
print("Train Accuracy:{:.2f}%".format(train_accuracy*100))
return train_loss.item(), train_accuracy
def for_test(test_ds, test_ls, model, criterion):
"""
测试模型
:param test_ds: 测试数据
:param test_ls: 测试标签
:param model: 测试模型
:param criterion: 损失函数
:return: 测试损失值,测试准确度
"""
# 将测试数据迁移到GPU上
test_ds = test_ds.cuda()
test_ls = test_ls.cuda()
model = model.eval()
correct = 0
with t.no_grad():
# 使用训练好的模型测试
output = model(test_ds)
# 计算测试集损失函数
test_loss = criterion(output, test_ls)
# 获取预测值
predict = output.max(1, keepdim=True)[1]
# 统计预测正确个数
correct += predict.eq(test_ls.view_as(predict)).sum().item()
# 计算准确率
accuracy = correct / test_ds.shape[0]
print("Test loss: {:.3f}".format(test_loss.item()))
print("Test Accuracy:{:.2f}%".format(accuracy*100))
return test_loss.item(), accuracy
def cross_validation(k, c_datas, c_labels, c_model, c_epochs, c_criterion, c_opt, result_name):
"""
对模型进行交叉验证
:param k: 划分子集个数
:param c_datas: 数据集
:param c_labels: 标签集
:param c_model: 用于分类的模型
:param c_epochs: 迭代次数
:param c_criterion: 损失函数
:param c_opt: 优化算法
:param result_name: 实验结果文件名字符串
"""
# 获取样本总数
examples = c_datas.shape[0]
# 每一份有几个样本
batch_examples = examples // k
# 存储每次验证结果
performs = []
# 存储训练损失值、准确率,测试损失值、准确率,用于可视化和计算最终结果
t_loss_list = []
t_acc_list = []
v_loss_list = []
v_acc_list = []
# 记录整个训练起始时间
start_time = time.perf_counter()
# 根据k值划分训练集和测试集
for i in range(k):
print("第{}次训练和测试结果:".format(i + 1))
if i == k-1:
# 如果是最后一个子集,索引直接取到最后,避免数据集不能整除的情况
test_datas = c_datas[i * batch_examples:, :]
test_labels = c_labels[i * batch_examples:]
else:
# 非最后一个子集,根据每一份的样本数进行划分,每次取走一份作为测试集
test_datas = c_datas[i*batch_examples:(i+1)*batch_examples, :]
test_labels = c_labels[i*batch_examples:(i+1)*batch_examples]
# 剩下的没有用于测试的数据集和标签集,通过tensor拼接形成训练集
train_datas = t.cat((c_datas[0:i*batch_examples, :], c_datas[(i+1)*batch_examples:, :]), dim=0)
train_labels = t.cat((c_labels[0:i*batch_examples], c_labels[(i+1)*batch_examples:]), dim=0)
# 训练
t_loss, t_acc = train(train_datas, train_labels, c_model, c_criterion, c_opt, epochs=c_epochs)
# 测试
v_loss, v_acc = for_test(test_datas, test_labels, c_model, c_criterion)
# 清空cuda缓存
t.cuda.empty_cache()
# 将该次训练损失值和测试准确度存放到列表中
performs.append((v_acc, v_loss))
t_loss_list.append(t_loss)
t_acc_list.append(t_acc)
v_loss_list.append(v_loss)
v_acc_list.append(v_acc)
# 记录整个训练结束时间
end_time = time.perf_counter()
# 根据准确度从小到大排序
performs = sorted(performs)
# 打印最高准确度
print("{}次中最佳性能 --> loss: {:.3f}, accuracy: {:.2f}%".format(k, performs[-1][1], performs[-1][0] * 100))
print("{}次中最差性能 --> loss: {:.3f}, accuracy: {:.2f}%".format(k, performs[0][1], performs[0][0] * 100))
# 计算交叉验证平均值
t_loss_avg = np.mean(np.array(t_loss_list))
t_acc_avg = np.mean(np.array(t_acc_list))
v_loss_avg = np.mean(np.array(v_loss_list))
v_acc_avg = np.mean(np.array(v_acc_list))
print("{}次平均性能:"
"\n\t--> Train loss: {:.3f}, Train accuracy: {:.2f}%"
"\n\t--> Test loss: {:.3f}, Test accuracy: {:.2f}%"
.format(k, t_loss_avg, t_acc_avg*100, v_loss_avg, v_acc_avg * 100))
# 计算交叉验证方差值
t_loss_var = np.var(np.array(t_loss_list))
t_acc_var = np.var(np.array(t_acc_list))
v_loss_var = np.var(np.array(v_loss_list))
v_acc_var = np.var(np.array(v_acc_list))
print("{}次结果方差:"
"\n\t--> Train loss: {:.8f}, Train accuracy: {:.8f}"
"\n\t--> Test loss: {:.8f}, Test accuracy: {:.8f}"
.format(k, t_loss_var, t_acc_var, v_loss_var, v_acc_var))
# 打印耗时
print("共耗时:{:.3f} s".format(end_time - start_time))
# 可视化模型性能
v.visualization(t_loss_list, t_acc_list, v_loss_list, v_acc_list, result_name, is_save=True)
2.1导入模块:
import pandas as pd
import numpy as np
import Visualization as v
import time
import torch as t
import torch.nn as nn
2.2定义获取数据集函数:
def get_datas(file):
"""
读取数据
:param file: 数据存储路径
:return: 数据集和标签集
"""
# 读取数据
origin_datas = pd.read_excel(file)
# 将数据转为ndarray
datas_array = origin_datas.to_numpy()
# 固定随机种子,确保每次运行结果一致
np.random.seed(5)
# 打乱数据顺序
np.random.shuffle(datas_array)
# 提取特征和标签
ds = datas_array[:, :-1] ##抽取除了倒数最后一列的数据
ls = datas_array[:, -1] ##抽取倒数最后一列的数据
# 判断标签是否符合标准,即是否从0开始标注
if 0 not in ls:
# 标签从1开始,就将每个标签值-1
ls = ls - 1
# 将数据转为float32的张量, 将标签转为long类型(int64)的张量
ds = t.from_numpy(ds).float()
ls = t.from_numpy(ls).long()
return ds, ls
2.3 初始化网络:
"""
训练前对模型权重进行初始化
:param model: 训练模型
"""
for m in model.modules():
if isinstance(m, nn.Linear):
nn.init.xavier_uniform_(m.weight) ##这里调用xavier_uniform初始化函数
2.4 定义训练网络函数:
def train(train_ds, train_ls, model, criterion, optimizer, epochs=20):
"""
训练模型
:param train_ds: 训练数据
:param train_ls: 训练标签
:param model: 训练模型
:param criterion: 损失函数
:param optimizer: 优化算法
:param epochs: 迭代次数
:return: 训练损失值
"""
train_correct = 0
# 将训练集迁移到GPU上
train_ds = train_ds.cuda()
train_ls = train_ls.cuda()
model = model.cuda()
init(model)
for epoch in range(epochs):
model.train()
# 每次训练前梯度置零
optimizer.zero_grad()
# 正向传播
output = model(train_ds)
# 计算损失值
train_loss = criterion(output, train_ls)
# 反向传播,计算梯度
train_loss.backward()
# 更新参数
optimizer.step()
# 获取预测值
predict = output.max(1, keepdim=True)[1]
# 统计预测正确个数
train_correct += predict.eq(train_ls.view_as(predict)).sum().item()
# 计算准确率
train_accuracy = train_correct / train_ds.shape[0]
print("Train loss: {:.3f}".format(train_loss.item()))
print("Train Accuracy:{:.2f}%".format(train_accuracy*100))
return train_loss.item(), train_accuracy
2.5 定义测试函数:
def for_test(test_ds, test_ls, model, criterion):
"""
测试模型
:param test_ds: 测试数据
:param test_ls: 测试标签
:param model: 测试模型
:param criterion: 损失函数
:return: 测试损失值,测试准确度
"""
# 将测试数据迁移到GPU上
test_ds = test_ds.cuda()
test_ls = test_ls.cuda()
model = model.eval()
correct = 0
with t.no_grad():
# 使用训练好的模型测试
output = model(test_ds)
# 计算测试集损失函数
test_loss = criterion(output, test_ls)
# 获取预测值
predict = output.max(1, keepdim=True)[1]
# 统计预测正确个数
correct += predict.eq(test_ls.view_as(predict)).sum().item()
# 计算准确率
accuracy = correct / test_ds.shape[0]
print("Test loss: {:.3f}".format(test_loss.item()))
print("Test Accuracy:{:.2f}%".format(accuracy*100))
return test_loss.item(), accuracy
2.6 定于交叉熵验证函数(这里使用交叉熵验证的方式划分训练和测试数据集):
def cross_validation(k, c_datas, c_labels, c_model, c_epochs, c_criterion, c_opt, result_name):
"""
对模型进行交叉验证
:param k: 划分子集个数
:param c_datas: 数据集
:param c_labels: 标签集
:param c_model: 用于分类的模型
:param c_epochs: 迭代次数
:param c_criterion: 损失函数
:param c_opt: 优化算法
:param result_name: 实验结果文件名字符串
"""
# 获取样本总数
examples = c_datas.shape[0]
# 每一份有几个样本
batch_examples = examples // k ##取整
# 存储每次验证结果
performs = []
# 存储训练损失值、准确率,测试损失值、准确率,用于可视化和计算最终结果
t_loss_list = []
t_acc_list = []
v_loss_list = []
v_acc_list = []
# 记录整个训练起始时间
start_time = time.perf_counter()
# 根据k值划分训练集和测试集
for i in range(k):
print("第{}次训练和测试结果:".format(i + 1))
if i == k-1:
# 如果是最后一个子集,索引直接取到最后,避免数据集不能整除的情况
test_datas = c_datas[i * batch_examples:, :]
test_labels = c_labels[i * batch_examples:]
else:
# 非最后一个子集,根据每一份的样本数进行划分,每次取走一份作为测试集
test_datas = c_datas[i*batch_examples:(i+1)*batch_examples, :]
test_labels = c_labels[i*batch_examples:(i+1)*batch_examples]
# 剩下的没有用于测试的数据集和标签集,通过tensor拼接形成训练集
train_datas = t.cat((c_datas[0:i*batch_examples, :], c_datas[(i+1)*batch_examples:, :]), dim=0)
train_labels = t.cat((c_labels[0:i*batch_examples], c_labels[(i+1)*batch_examples:]), dim=0)
# 训练
t_loss, t_acc = train(train_datas, train_labels, c_model, c_criterion, c_opt, epochs=c_epochs)
# 测试
v_loss, v_acc = for_test(test_datas, test_labels, c_model, c_criterion)
# 清空cuda缓存
t.cuda.empty_cache()
# 将该次训练损失值和测试准确度存放到列表中
performs.append((v_acc, v_loss))
t_loss_list.append(t_loss)
t_acc_list.append(t_acc)
v_loss_list.append(v_loss)
v_acc_list.append(v_acc)
# 记录整个训练结束时间
end_time = time.perf_counter()
# 根据准确度从小到大排序
performs = sorted(performs)
# 打印最高准确度
print("{}次中最佳性能 --> loss: {:.3f}, accuracy: {:.2f}%".format(k, performs[-1][1], performs[-1][0] * 100))
print("{}次中最差性能 --> loss: {:.3f}, accuracy: {:.2f}%".format(k, performs[0][1], performs[0][0] * 100))
# 计算交叉验证平均值
t_loss_avg = np.mean(np.array(t_loss_list))
t_acc_avg = np.mean(np.array(t_acc_list))
v_loss_avg = np.mean(np.array(v_loss_list))
v_acc_avg = np.mean(np.array(v_acc_list))
print("{}次平均性能:"
"\n\t--> Train loss: {:.3f}, Train accuracy: {:.2f}%"
"\n\t--> Test loss: {:.3f}, Test accuracy: {:.2f}%"
.format(k, t_loss_avg, t_acc_avg*100, v_loss_avg, v_acc_avg * 100))
# 计算交叉验证方差值
t_loss_var = np.var(np.array(t_loss_list))
t_acc_var = np.var(np.array(t_acc_list))
v_loss_var = np.var(np.array(v_loss_list))
v_acc_var = np.var(np.array(v_acc_list))
print("{}次结果方差:"
"\n\t--> Train loss: {:.8f}, Train accuracy: {:.8f}"
"\n\t--> Test loss: {:.8f}, Test accuracy: {:.8f}"
.format(k, t_loss_var, t_acc_var, v_loss_var, v_acc_var))
# 打印耗时
print("共耗时:{:.3f} s".format(end_time - start_time))
# 可视化模型性能
v.visualization(t_loss_list, t_acc_list, v_loss_list, v_acc_list, result_name, is_save=True)
3.可视化结果
"""
实验结果可视化
"""
import matplotlib.pyplot as plt
def visualization(t_loss_list, t_acc_list, v_loss_list, v_acc_list, result_name, is_save=False):
plt.ion()
f, axes = plt.subplots(2, 2)
ax0 = axes[0, 0]
ax1 = axes[0, 1]
ax2 = axes[1, 0]
ax3 = axes[1, 1]
ax0.clear()
ax0.plot([x for x in range(1, 11)], t_loss_list)
ax0.set_xlabel("the epoch of cross validation")
ax0.set_ylabel("Loss")
ax0.set_title("Loss of Training")
ax0.set_ylim((1, max(t_loss_list)))
ax0.set_xlim((1, 10))
ax1.clear()
ax1.plot([x for x in range(1, 11)], t_acc_list)
ax1.set_xlabel("the epoch of cross validation")
ax1.set_ylabel("Accuracy")
ax1.set_title("Accuracy of Training")
ax1.set_ylim((0.5, 1))
ax1.set_xlim((1, 10))
ax2.clear()
ax2.plot([x for x in range(1, 11)], v_loss_list)
ax2.set_xlabel("the epoch of cross validation")
ax2.set_ylabel("Loss")
ax2.set_title("Loss of Testing")
ax2.set_ylim((1, max(v_loss_list)))
ax2.set_xlim((1, 10))
ax3.clear()
ax3.plot([x for x in range(1, 11)], v_acc_list)
ax3.set_xlabel("the epoch of cross validation")
ax3.set_ylabel("Accuracy")
ax3.set_title("Accuracy of Testing")
ax3.set_ylim((0.5, 1))
ax3.set_xlim((1, 10))
plt.tight_layout() # 自动布局子图
if is_save:
plt.savefig(result_name + ".png")
plt.show()
4.main函数
import utils as f
import net as classifier
import torch.nn as nn
import torch.optim as opt
DATAFILE1 = "datas\AD.xlsx" # 各个数据集的路径
DATAFILE2 = "datas\heart.xlsx"
DATAFILE3 = "datas\maxLittle.xlsx"
DATAFILE4 = "datas\PD.xlsx"
DATAFILE5 = "datas\pima-indians-diabetes.xlsx"
DATAFILE6 = "datas\vehicle.xlsx"
DATAFILE7 = "datas\WDBC.xlsx"
DATAFILE8 = "datas\Wisconsin.xlsx"
EPOCHS = 500 # 迭代次数
def run(datafile, model, lr):
print("Starting")
print("Loading datas...")
# 获取数据集和标签集
datas, labels = f.get_datas(datafile)
print("Datas Loaded!")
# 定义损失函数,使用交叉熵损失函数
criterion = nn.CrossEntropyLoss()
# 定义优化算法,使用Adam算法,学习率lr为0.005,β1=0.9,β2=0.99
optimizer = opt.Adam(model.parameters(), lr=lr, betas=(0.9, 0.99))
print("Training and Validating...")
# 根据数据集路径生成结果图的文件名
picture_name = datafile.split("\")[-1].split(".")[0] + "_result"
f.cross_validation(10, datas, labels, model, EPOCHS, criterion, optimizer, picture_name)
if __name__ == '__main__':
# 创建分类器
classifer1 = classifier.Net(32, 256, 128, 64, 16, 3) ##对应于AD数据集的模型
classifer2 = classifier.Net(13, 104, 52, 26, 13, 2) ##对应于heart数据集的模型
classifer3 = classifier.Net(22, 176, 88, 44, 11, 2) ##对应于maxLittle数据集的模型
classifer4 = classifier.Net(26, 104, 52, 26, 13, 2) ##对应于PD数据集的模型
classifer5 = classifier.Net(8, 64, 32, 16, 8, 2) ##对应于pima-inidians-diabetes数据集的模型
classifer6 = classifier.Net(18, 144, 72, 36, 18, 4) ##对应于vehicle数据集的模型
classifer7 = classifier.Net(30, 240, 120, 60, 30, 2) ##对应于WDBC数据集的模型
classifer8 = classifier.Net(9, 72, 36, 18, 9, 4) ##对应于Wisconsin数据集的模型
mode = input('请输入数据集名称:')
if mode == "AD":
print("------ 对AD数据集进行交叉验证 -----")
run(DATAFILE1, classifer1, 0.005)
elif mode == "heart":
print("\n------ 对heart数据集进行交叉验证 -----")
run(DATAFILE2, classifer2, 0.0005)
elif mode == "maxLittle":
print("\n------ 对maxLittle数据集进行交叉验证 -----")
run(DATAFILE3, classifer3, 0.0005)
elif mode == "PD":
print("\n------ 对PD数据集进行交叉验证 -----")
run(DATAFILE4, classifer4, 0.0005)
elif mode == "pima-indians-diabetes":
print("\n------ 对pima-inidians-diabetes数据集进行交叉验证 -----")
run(DATAFILE5, classifer5, 0.0005)
elif mode == "vehicle":
print("\n------ 对vehicle数据集进行交叉验证 -----")
run(DATAFILE6, classifer6, 0.0005)
elif mode == "WDBC":
print("\n------ 对WDBC数据集进行交叉验证 -----")
run(DATAFILE7, classifer7, 0.0005)
elif mode == "Wisconsin":
print("\n------ 对Wisconsin数据集进行交叉验证 -----")
run(DATAFILE8, classifer8, 0.0005)
\