构建全连接神经网络(上),并实现分类任务:

877 阅读11分钟

本文已参与「新人创作礼」活动,一起开启掘金创作之路。

构建全连接神经网络(上),并实现分类任务:

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)

\