devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

深度学习模型：Pytorch搭建ResNet、DenseNet网络，完成一维数据分类任务_class resnet(torch.nn.module): def __init__(self,i

作者：IT小白 | 2024-02-09 22:28:25

赞

踩

class resnet(torch.nn.module): def __init__(self,in_channels=1, classes=2):

2023.7.17

DenseNet和ResNet都是深度学习中常用的网络结构，它们各有优缺点。

DenseNet的优点是可以充分利用网络中的信息，因为每个层都可以接收来自前面所有层的信息。这种密集连接的结构可以提高网络的准确性，减少过拟合的风险。此外，DenseNet的参数量比ResNet少，训练速度更快。

ResNet的优点是可以解决深度网络中的梯度消失问题，使得网络可以更深更复杂。ResNet的残差结构可以让信息直接从前面的层传递到后面的层，避免了信息的丢失，提高了网络的准确性。此外，ResNet的结构简单，易于理解和实现。

DenseNet和ResNet的缺点也有所不同。DenseNet的缺点是需要更多的内存和计算资源，因为每个层都需要接收来自前面所有层的信息。此外，DenseNet的结构较为复杂，不易于理解和实现。

ResNet的缺点是在某些情况下可能会出现过拟合的问题，因为残差结构可以让信息直接从前面的层传递到后面的层，可能会导致网络过于复杂，难以泛化。

一、数据集的处理：

训练集、验证集、测试集的划分：

数据会被整理为.txt:（例如形成的trian.txt）

                最后会分割为trian_data.txt和train_labels.txt两个文件 

  1. import os
  2. import numpy as np
  3. import random
  4. import math
  5.  
  6.  
  7.  
  8. def normalization(data):  # 归一化:均值0,方差1
  9.     data = (data - data.mean()) / data.std()
  10.     return data
  11.  
  12.  
  13. def random_rowl(data):  # 把行的顺序随机排列
  14.     idx = np.arange(data.shape[0])
  15.     np.random.shuffle(idx)
  16.     data = data[idx[0:]]
  17.     return data
  18.  
  19.  
  20. def getfilelist(path):  # 读取文件夹下所有txt文件
  21.     filelist = []
  22.     for filename in os.listdir(path):
  23.         if os.path.splitext(filename)[1] == '.txt':
  24.             filelist.append(filename)
  25.     random.shuffle(filelist)  # 随机打乱文件列表里的顺序
  26.     return filelist
  27.  
  28.  
  29. path = '第一类数据的文件夹子路径','第二类数据的文件夹子路径','第三类数据的文件夹子路径'
  30.  
  31. sort_num = 3  # 一共多少类？
  32.  
  33. for i in range(sort_num):  # 个数修改为路径的数目，与文件夹个数相同
  34.     fileName = "{}/".format(path[i])
  35.     files = getfilelist(fileName)
  36.     # files=getfilelist(path[i]+'/')
  37.     a = len(files)
  38.     print(path[i], a)
  39.     data = np.loadtxt(fileName + files[0])[:, 1]
  40.     data = normalization(data)
  41.     for j in range(1, a):
  42.         data1 = np.loadtxt(fileName + '/' + files[j])[:, 1]
  43.         data1 = normalization(data1)
  44.         data = np.c_[data, data1]
  45.     data = data.T
  46.  
  47.     # 加标签
  48.     label = np.zeros((len(data), sort_num))  # 标签也改为分类的数目，与文件夹个数相同
  49.  
  50.     for m in range(len(label)):
  51.         label[m, i] = 1
  52.     data = np.c_[data, label]
  53.     data = random_rowl(data)
  54.  
  55.     t = math.floor(len(data) * 0.7)
  56.  
  57.     v = math.floor(len(data) * 0.2)
  58.     train = data[:t, :]
  59.     val = data[t:(t + v), :]
  60.     test = data[(t + v):, :]
  61.  
  62.     np.savetxt(path[i] + '_train.txt', train, fmt='%.6f')
  63.     np.savetxt(path[i] + '_val.txt', val, fmt='%.6f')
  64.     np.savetxt(path[i] + '_test.txt', test, fmt='%.6f')
  65.  
  66. train = np.loadtxt(path[0] + '_train.txt')
  67. val = np.loadtxt(path[0] + '_val.txt')
  68. test = np.loadtxt(path[0] + '_test.txt')
  69.  
  70. for i in range(1, sort_num):  # 需要修改为与分类个数相同，最后一个数与文件夹
  71.     train1 = np.loadtxt(path[i] + '_train.txt')
  72.     val1 = np.loadtxt(path[i] + '_val.txt')
  73.     test1 = np.loadtxt(path[i] + '_test.txt')
  74.  
  75.     train = random_rowl(np.r_[train, train1])
  76.     val = random_rowl(np.r_[val, val1])
  77.     test = random_rowl(np.r_[test, test1])
  78.  
  79. np.savetxt('train.txt', train, fmt='%.6f') # 划分训练集
  80. np.savetxt('val.txt', val, fmt='%.6f')  # 划分验证集
  81. np.savetxt('test.txt', test, fmt='%.6f')  # 划分测试集
  82.  
  83.  
  84. # 从train.txt、val.txt、test.txt中分别获取数据和标签
  85.  
  86. class_num = sort_num  # 分类的类数 
  87.  
  88. train_labels = np.loadtxt('./train.txt')[:, -class_num:]
  89. test_labels = np.loadtxt('./test.txt')[:, -class_num:]
  90. val_labels = np.loadtxt('./val.txt')[:, -class_num:]
  91.  
  92. train_data = np.loadtxt('./train.txt')[:, :-class_num]
  93. test_data = np.loadtxt('./test.txt')[:, :-class_num]
  94. val_data = np.loadtxt('./val.txt')[:, :-class_num]
  95.  
  96. np.savetxt('train_data.txt', train_data, fmt='%.6f')
  97. np.savetxt('val_data.txt', val_data, fmt='%.6f')
  98. np.savetxt('test_data.txt', test_data, fmt='%.6f')
  99.  
  100. np.savetxt('train_labels.txt', train_labels, fmt='%d')
  101. np.savetxt('val_labels.txt', val_labels, fmt='%d')
  102. np.savetxt('test_labels.txt', test_labels, fmt='%d')

二、数据的训练：

ResNet：

  1. import numpy as np
  2. import torch.optim as optim
  3. import torch.nn as nn
  4.  
  5. import torch
  6. from torch.utils.data import DataLoader, Dataset
  7.  
  8.  
  9. class Bottlrneck(torch.nn.Module):
  10.     def __init__(self, In_channel, Med_channel, Out_channel, downsample=False):
  11.         super(Bottlrneck, self).__init__()
  12.         self.stride = 1
  13.         if downsample == True:
  14.             self.stride = 2
  15.  
  16.         self.layer = torch.nn.Sequential(
  17.             torch.nn.Conv1d(In_channel, Med_channel, 1, self.stride),
  18.             torch.nn.BatchNorm1d(Med_channel),
  19.             torch.nn.ReLU(),
  20.             torch.nn.Conv1d(Med_channel, Med_channel, 3, padding=1),
  21.             torch.nn.BatchNorm1d(Med_channel),
  22.             torch.nn.ReLU(),
  23.             torch.nn.Conv1d(Med_channel, Out_channel, 1),
  24.             torch.nn.BatchNorm1d(Out_channel),
  25.             torch.nn.ReLU(),
  26.         )
  27.  
  28.         if In_channel != Out_channel:
  29.             self.res_layer = torch.nn.Conv1d(In_channel, Out_channel, 1, self.stride)
  30.         else:
  31.             self.res_layer = None
  32.  
  33.     def forward(self, x):
  34.         if self.res_layer is not None:
  35.             residual = self.res_layer(x)
  36.         else:
  37.             residual = x
  38.         return self.layer(x) + residual
  39.  
  40.  
  41. class ResNet(torch.nn.Module):
  42.     def __init__(self, in_channels=2, classes=6):
  43.         super(ResNet, self).__init__()
  44.         self.features = torch.nn.Sequential(
  45.             torch.nn.Conv1d(in_channels, 64, kernel_size=7, stride=2, padding=3),
  46.             torch.nn.MaxPool1d(3, 2, 1),
  47.  
  48.             Bottlrneck(64, 64, 256, False),
  49.             Bottlrneck(256, 64, 256, False),
  50.             Bottlrneck(256, 64, 256, False),
  51.             #
  52.             Bottlrneck(256, 128, 512, True),
  53.             Bottlrneck(512, 128, 512, False),
  54.             Bottlrneck(512, 128, 512, False),
  55.             Bottlrneck(512, 128, 512, False),
  56.             #
  57.             Bottlrneck(512, 256, 1024, True),
  58.             Bottlrneck(1024, 256, 1024, False),
  59.             Bottlrneck(1024, 256, 1024, False),
  60.             Bottlrneck(1024, 256, 1024, False),
  61.             Bottlrneck(1024, 256, 1024, False),
  62.             Bottlrneck(1024, 256, 1024, False),
  63.             #
  64.             Bottlrneck(1024, 512, 2048, True),
  65.             Bottlrneck(2048, 512, 2048, False),
  66.             Bottlrneck(2048, 512, 2048, False),
  67.  
  68.             torch.nn.AdaptiveAvgPool1d(1)
  69.         )
  70.         self.classifer = torch.nn.Sequential(
  71.             torch.nn.Linear(2048, classes)
  72.         )
  73.  
  74.     def forward(self, x):
  75.         x = torch.Tensor.view(x, (-1, 2, 511))
  76.         x = self.features(x)
  77.         x = x.view(-1, 2048)
  78.         x = self.classifer(x)
  79.         return x
  80.  
  81.  
  82. class MyDataset(Dataset):
  83.     def __init__(self, raman_dir, label_file):
  84.         self.raman_dir = np.loadtxt(raman_dir)
  85.         self.label_file = np.loadtxt(label_file)
  86.         self.raman_data = []
  87.         self.label_list = []
  88.         for index in self.raman_dir:
  89.             self.raman_data.append(index)
  90.  
  91.         for index in self.label_file:
  92.             self.label_list.append(index)
  93.  
  94.     def __getitem__(self, idx):
  95.         raman = torch.Tensor(self.raman_data[idx])
  96.         label = torch.Tensor(self.label_list[idx])
  97.         label = np.argmax(label)
  98.  
  99.         return raman, label
  100.  
  101.     def __len__(self):
  102.         # 获取数据集的长度
  103.         return len(self.label_list)
  104.  
  105.  
  106. if __name__ == '__main__':
  107.     # 准备数据集
  108.     train_data = './train_data.txt'
  109.     val_data = './val_data.txt'
  110.     
  111.     # 标签
  112.     train_label = './train_labels.txt'
  113.     val_label = './val_labels.txt'
  114.  
  115.     # 创建数据加载器
  116.     batch_size = 128
  117.     # 训练集输入
  118.     train_dataset = MyDataset(train_data, train_label)
  119.     train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
  120.     # 测试集输入
  121.     test_dataset = MyDataset(test_data, test_label)
  122.     test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True)
  123.     # 验证集输入
  124.     val_dataset = MyDataset(val_data, val_label)
  125.     val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True)
  126.  
  127.     train_data_size = len(train_dataset)
  128.     val_data_size = len(val_dataset)
  129.  
  130.     # 创建网络模型
  131.     class_num = 6
  132.     test_data_length = 600
  133.     ResNetOutput = ResNet(in_channels=2, classes=class_num).cuda()
  134.  
  135.     # 定义损失函数
  136.     loss_fn = nn.CrossEntropyLoss().cuda()
  137.  
  138.     # 定义优化器
  139.     learning_rate = 0.00001
  140.     optimizer = optim.Adam(ResNetOutput.parameters(), lr=learning_rate)
  141.  
  142.     # 记录验证的次数
  143.     total_train_step = 0
  144.     total_val_step = 0
  145.  
  146.     # 训练
  147.     epoch = 100
  148.     acc_list = np.zeros(epoch)
  149.     print("{0:-^27}".format('Train_Model'))
  150.     for i in range(epoch):
  151.         print("----------epoch={}----------".format(i + 1))
  152.         ResNetOutput.train()
  153.         for data in train_dataloader:  # data 是batch大小
  154.             raman_train_data, t_labels = data
  155.             raman_train_data = raman_train_data.cuda()
  156.             t_labels = t_labels.cuda()
  157.             output = ResNetOutput(raman_train_data)
  158.             loss = loss_fn(output, t_labels)
  159.  
  160.             # 优化器优化模型
  161.             optimizer.zero_grad()  # 梯度清零
  162.             loss.backward()  # 反向传播
  163.             optimizer.step()  # 优化更新参数
  164.  
  165.             total_train_step = total_train_step + 1
  166.             print("train_times:{},Loss:{}".format(total_train_step, loss.item()))
  167.  
  168.         # 测试步骤开始
  169.         ResNetOutput.eval()
  170.         total_val_loss = 0
  171.         total_accuracy = 0
  172.         with torch.no_grad():  # 测试的时候不需要对梯度进行调整，所以梯度设置不调整
  173.             for data in val_dataloader:
  174.                 raman_val_data, v_labels = data
  175.                 raman_val_data = raman_val_data.cuda()
  176.                 v_labels = v_labels.cuda()
  177.                 outputs = ResNetOutput(raman_val_data)
  178.                 loss = loss_fn(outputs, v_labels)
  179.                 total_val_loss = total_val_loss + loss.item()  # 计算损失值的和
  180.                 accuracy = 0
  181.  
  182.                 for j in v_labels:
  183.  
  184.                     if outputs.argmax(1)[j] == v_labels[j]:
  185.                         accuracy = accuracy + 1
  186.  
  187.                 # accuracy = (outputs.argmax(1) == v_labels).sum()  # 计算一个数据的精确度
  188.                 total_accuracy = total_accuracy + accuracy
  189.  
  190.         val_acc = float(total_accuracy / 1440) * 100
  191.         acc_list[i] = val_acc
  192.         print('the_classification_is_correct :', total_accuracy)  # 正确分类的个数
  193.         print("val_Loss:{}".format(total_val_loss))
  194.         print("val_acc:{}".format(float(total_accuracy / 1440) * 100), '%')
  195.  
  196.         total_val_step += 1
  197.         torch.save(ResNetOutput, "ResNet_{}.pth".format(i))
  198.         # torch.save(ResNetOutput.state_dict(), "ResNet_{}.pth".format(i))
  199.         print("{0:-^24}".format('Model_Save'), '\n')
  200.         print('val_max=', max(acc_list), '%')

注意！在代码的75行：

x = torch.Tensor.view(x, (-1, 2, 511))  # 511的位置要根据自己的数据集形状调整

DenseNet：

  1. import numpy as np
  2. import torch.optim as optim
  3. import torch.nn as nn
  4.  
  5. import torch
  6. from torch.utils.data import DataLoader, Dataset
  7.  
  8.  
  9. class DenseLayer(torch.nn.Module):
  10.     def __init__(self, in_channels, middle_channels=128, out_channels=32):
  11.         super(DenseLayer, self).__init__()
  12.         self.layer = torch.nn.Sequential(
  13.             torch.nn.BatchNorm1d(in_channels),
  14.             torch.nn.ReLU(inplace=True),
  15.             torch.nn.Conv1d(in_channels, middle_channels, 1),
  16.             torch.nn.BatchNorm1d(middle_channels),
  17.             torch.nn.ReLU(inplace=True),
  18.             torch.nn.Conv1d(middle_channels, out_channels, 3, padding=1)
  19.         )
  20.  
  21.     def forward(self, x):
  22.         return torch.cat([x, self.layer(x)], dim=1)
  23.  
  24.  
  25. class DenseBlock(torch.nn.Sequential):
  26.     def __init__(self, layer_num, growth_rate, in_channels, middele_channels=128):
  27.         super(DenseBlock, self).__init__()
  28.         for i in range(layer_num):
  29.             layer = DenseLayer(in_channels + i * growth_rate, middele_channels, growth_rate)
  30.             self.add_module('denselayer%d' % (i), layer)
  31.  
  32.  
  33. class Transition(torch.nn.Sequential):
  34.     def __init__(self, channels):
  35.         super(Transition, self).__init__()
  36.         self.add_module('norm', torch.nn.BatchNorm1d(channels))
  37.         self.add_module('relu', torch.nn.ReLU(inplace=True))
  38.         self.add_module('conv', torch.nn.Conv1d(channels, channels // 2, 3, padding=1))
  39.         self.add_module('Avgpool', torch.nn.AvgPool1d(2))
  40.  
  41.  
  42. class DenseNet(torch.nn.Module):
  43.     def __init__(self, layer_num=(6, 12, 24, 16), growth_rate=32, init_features=64, in_channels=1, middele_channels=128,
  44.                  classes=6):
  45.         super(DenseNet, self).__init__()
  46.         self.feature_channel_num = init_features
  47.         self.conv = torch.nn.Conv1d(in_channels, self.feature_channel_num, 7, 2, 3)
  48.         self.norm = torch.nn.BatchNorm1d(self.feature_channel_num)
  49.         self.relu = torch.nn.ReLU()
  50.         self.maxpool = torch.nn.MaxPool1d(3, 2, 1)
  51.         # self.attention = SpatialAttention(64)  # 空间注意力机制
  52.  
  53.         self.DenseBlock1 = DenseBlock(layer_num[0], growth_rate, self.feature_channel_num, middele_channels)
  54.         self.feature_channel_num = self.feature_channel_num + layer_num[0] * growth_rate
  55.         self.Transition1 = Transition(self.feature_channel_num)
  56.  
  57.         self.DenseBlock2 = DenseBlock(layer_num[1], growth_rate, self.feature_channel_num // 2, middele_channels)
  58.         self.feature_channel_num = self.feature_channel_num // 2 + layer_num[1] * growth_rate
  59.         self.Transition2 = Transition(self.feature_channel_num)
  60.  
  61.         self.DenseBlock3 = DenseBlock(layer_num[2], growth_rate, self.feature_channel_num // 2, middele_channels)
  62.         self.feature_channel_num = self.feature_channel_num // 2 + layer_num[2] * growth_rate
  63.         self.Transition3 = Transition(self.feature_channel_num)
  64.  
  65.         self.DenseBlock4 = DenseBlock(layer_num[3], growth_rate, self.feature_channel_num // 2, middele_channels)
  66.         self.feature_channel_num = self.feature_channel_num // 2 + layer_num[3] * growth_rate
  67.  
  68.         self.avgpool = torch.nn.AdaptiveAvgPool1d(1)
  69.  
  70.         self.classifer = torch.nn.Sequential(
  71.             torch.nn.Linear(self.feature_channel_num, self.feature_channel_num // 2),
  72.             torch.nn.ReLU(),
  73.             torch.nn.Dropout(0.5),
  74.             torch.nn.Linear(self.feature_channel_num // 2, classes),
  75.  
  76.         )
  77.  
  78.     def forward(self, x):
  79.         x = torch.Tensor.view(x, (-1, 1, 1022))  # 第一个参数是batch_size
  80.         x = x.resize_as_(x.to(torch.float32))
  81.         x = self.conv(x)
  82.         x = self.norm(x)  # 正则化
  83.         x = self.relu(x)
  84.         x = self.maxpool(x)
  85.         x = self.DenseBlock1(x)
  86.         x = self.Transition1(x)
  87.         x = self.DenseBlock2(x)
  88.         x = self.Transition2(x)
  89.         x = self.DenseBlock3(x)
  90.         x = self.Transition3(x)
  91.         x = self.DenseBlock4(x)
  92.         x = self.avgpool(x)
  93.         x = x.view(-1, self.feature_channel_num)
  94.         x = self.classifer(x)
  95.  
  96.         return x
  97.  
  98.  
  99. class MyDataset(Dataset):  # 利用Pytorch的内置函数加载数据
  100.     def __init__(self, raman_dir, label_file):
  101.         self.raman_dir = np.loadtxt(raman_dir)
  102.         self.label_file = np.loadtxt(label_file)
  103.         self.raman_data = []
  104.         self.label_list = []
  105.         for index in self.raman_dir:
  106.             self.raman_data.append(index)
  107.  
  108.         for index in self.label_file:
  109.             self.label_list.append(index)
  110.  
  111.     def __getitem__(self, idx):
  112.         raman = torch.Tensor(self.raman_data[idx])
  113.         label = torch.Tensor(self.label_list[idx])
  114.         label = np.argmax(label)
  115.  
  116.         return raman, label
  117.  
  118.     def __len__(self):
  119.         # 获取数据集的长度
  120.         return len(self.label_list)
  121.  
  122.  
  123. if __name__ == '__main__':
  124.     # 准备数据集
  125.     train_data = './train_data.txt'
  126.     val_data = './val_data.txt'
  127.     
  128.  
  129.     # 标签
  130.     train_label = './train_labels.txt'
  131.  
  132.     val_label = './val_labels.txt'
  133.  
  134.     # 数据长度
  135.     test_data_length = 600
  136.     val_data_length = 1440
  137.  
  138.     # 分类的类别
  139.     class_num = 6  # 注意调整58行的函数中的class（分类类别）
  140.  
  141.     # 学习率
  142.     learning_rate = 0.00001
  143.     # 批处理大小
  144.     batch_size = 128
  145.  
  146.     # 数据加载器
  147.     train_dataset = MyDataset(train_data, train_label)
  148.     train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
  149.  
  150.     test_dataset = MyDataset(test_data, test_label)
  151.     test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True)
  152.  
  153.     val_dataset = MyDataset(val_data, val_label)
  154.     val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True)
  155.  
  156.     train_data_size = len(train_dataset)
  157.     val_data_size = len(val_dataset)
  158.  
  159.     # 创建网络模型
  160.     DenseNetOutput = DenseNet().cuda()  # .Cuda（）数据是指放到GPU上
  161.  
  162.     # 定义损失函数
  163.     loss_fn = nn.CrossEntropyLoss().cuda()  # 交叉熵函数
  164.  
  165.     # 定义优化器
  166.     optimizer = optim.Adam(DenseNetOutput.parameters(), lr=learning_rate)
  167.  
  168.     # 记录验证的次数
  169.     total_train_step = 0
  170.     total_val_step = 0
  171.     writer = SummaryWriter("logs_train")  # 记录训练的权重
  172.  
  173.     # 训练
  174.     epoch = 30  #
  175.     acc_list = np.zeros(epoch)
  176.     print("{0:-^27}".format('Train_Model'))
  177.     for i in range(epoch):
  178.         print("----------epoch={}----------".format(i + 1))
  179.         DenseNetOutput.train()
  180.         for data in train_dataloader:  # data 是batch大小
  181.             raman_train_data, t_labels = data
  182.             raman_train_data = raman_train_data.cuda()
  183.             t_labels = t_labels.cuda()
  184.             output = DenseNetOutput(raman_train_data)
  185.             loss = loss_fn(output, t_labels)
  186.  
  187.             # 优化器优化模型
  188.             optimizer.zero_grad()  # 梯度清零
  189.             loss.backward()  # 反向传播
  190.             optimizer.step()  # 优化更新参数
  191.  
  192.             total_train_step = total_train_step + 1
  193.             print("train_times:{},Loss:{}".format(total_train_step, loss.item()))
  194.  
  195.         # 测试步骤开始
  196.         DenseNetOutput.eval()
  197.         total_val_loss = 0
  198.         total_accuracy = 0
  199.         with torch.no_grad():  # 测试的时候不需要对梯度进行调整，所以梯度设置不调整
  200.             for data in val_dataloader:
  201.                 raman_val_data, v_labels = data
  202.                 raman_val_data = raman_val_data.cuda()
  203.                 v_labels = v_labels.cuda()
  204.                 outputs = DenseNetOutput(raman_val_data)
  205.                 loss = loss_fn(outputs, v_labels)
  206.                 total_val_loss = total_val_loss + loss.item()  # 计算损失值的和
  207.                 accuracy = 0
  208.  
  209.                 for j in v_labels:  # 计算精确度的和
  210.  
  211.                     if outputs.argmax(1)[j] == v_labels[j]:
  212.                         accuracy = accuracy + 1
  213.  
  214.                 # accuracy = (outputs.argmax(1) == v_labels).sum()  # 计算一个数据的精确度
  215.                 total_accuracy = total_accuracy + accuracy
  216.  
  217.         val_acc = float(total_accuracy / val_data_size) * 100
  218.         acc_list[i] = val_acc  # 记录验证集的正确率
  219.         print('the_classification_is_correct :', total_accuracy, val_data_length)
  220.         print("val_Loss:{}".format(total_val_loss))
  221.         print("val_acc:{}".format(val_acc), '%')
  222.         
  223.         total_val_step += 1
  224.         torch.save(DenseNetOutput, "DenseNet_{}.pth".format(i + 1))
  225.         print("{0:-^24}".format('Model_Saved'), '\n')
  226.  
  227.         print('val_max=', max(acc_list), '%')  # 验证集的最高正确率

注意！在代码的93行：

x = torch.Tensor.view(x, (-1, 1, 1022))  # 1022的位置要根据自己的数据集大小取调整 

测试代码：

  1. import torch
  2. import numpy as np
  3. from ResNet import Bottlrneck, ResNet
  4.  
  5. # from DenseNet_SpatialAttention import DenseNet, DenseLayer, DenseBlock
  6.  
  7. device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')  # 判断是否有GPU
  8.  
  9. test_data = np.loadtxt('./test_data.txt')  # 测试集的路径
  10.  
  11. model = ResNet().to(device)
  12. model.load_state_dict(torch.load('ResNet_100.pth'))  # 加载模型
  13.  
  14. # model = DenseNet().to(device)
  15. # model.load_state_dict(torch.load('DenseNet_100.pth'))  # 加载模型
  16.  
  17. test_length = test_data.shape[0]
  18.  
  19. for i in range(test_length):
  20.     td = torch.from_numpy(test_data[i]).float().to(device)
  21.     Predict_output = model(td).to(device)
  22.  
  23.     _, predicted = Predict_output.max(1)
  24.     pred_type = predicted.item()
  25.     print('pred_type:', pred_type)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/73068
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号