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

本文简单教学一下Pytorch实现对数据的DNN、RNN、CNN等操作（基于面向对象的CPU版本）_dnn torch 实现

作者：酷酷是懒虫 | 2024-07-29 04:32:37

赞

踩

dnn torch 实现

1.导入模块、库和框架

  1. import numpy as np
  2. from sklearn.datasets import load_iris, load_digits
  3. import torch
  4. from sklearn.metrics import accuracy_score, classification_report
  5. from sklearn.model_selection import train_test_split
  6. from transformers import get_cosine_schedule_with_warmup
  7. from transformers import AdamW
  8. import warnings
  9. import torch.nn.functional as F
  10. warnings.filterwarnings('ignore')

2.定义一个类用来设置随机种子以及复现代码

  1. class SetSeed:
  2.     def same_seeds(self, seed):
  3.         torch.manual_seed(seed)  # 固定随机种子（CPU）
  4.         if torch.cuda.is_available():  # 固定随机种子（GPU)
  5.             torch.cuda.manual_seed(seed)  # 为当前GPU设置
  6.             torch.cuda.manual_seed_all(seed)  # 为所有GPU设置
  7.         np.random.seed(seed)  # 保证后续使用random函数时，产生固定的随机数
  8.         torch.backends.cudnn.benchmark = False  # GPU、网络结构固定，可设置为True
  9.         torch.backends.cudnn.deterministic = True  # 固定网络结构
'
运行

3. 定义数据处理类

  1. class ProcessData: # 数据处理类
  2.     def __init__(self):
  3.         self.dataX, self.dataY = load_digits(return_X_y=True) # 导入数据：手写字体数据集（分类任务）
  4.         self.dataX, self.dataY = np.float32(self.dataX), torch.Tensor(self.dataY).long() # 将数字转为tensor或者可以输入进网络的格式
  5.  
  6.     def dataToLoader(self): # 这个方法可以作为DataLoader的中间件，其中包含数据集划分等操作
  7.         self.trainDataX, self.midDataX, self.trainDataY, self.midDataY = train_test_split(
  8.             self.dataX,
  9.             self.dataY,
  10.             stratify=self.dataY, # 采样分布同总体一样，克服采样不均匀问题
  11.             random_state=1,
  12.             test_size=0.2
  13.         )
  14.         self.testDataX, self.devDataX, self.testDataY, self.devDataY = train_test_split(
  15.             self.midDataX,
  16.             self.midDataY,
  17.             stratify=self.midDataY,
  18.             random_state=1,
  19.             test_size=0.5
  20.         )
  21.         trainDataForLoader = list(zip(self.trainDataX, self.trainDataY))
  22.         devDataForLoader = list(zip(self.devDataX, self.devDataY))
  23.         testDataForLoader = list(zip(self.testDataX, self.testDataY))
  24.  
  25.         self.trainLoader = torch.utils.data.DataLoader(dataset=trainDataForLoader,
  26.                                                        batch_size=8,
  27.                                                        # collate_fn=False,
  28.                                                        shuffle=True,
  29.                                                        drop_last=True)
  30.         self.devLoader = torch.utils.data.DataLoader(dataset=devDataForLoader,
  31.                                                      batch_size=8,
  32.                                                      # collate_fn=False,
  33.                                                      shuffle=True,
  34.                                                      drop_last=True)
  35.         self.testLoader = torch.utils.data.DataLoader(dataset=testDataForLoader,
  36.                                                       batch_size=8,
  37.                                                       # collate_fn=False,
  38.                                                       shuffle=True,
  39.                                                       drop_last=True)
  40.         return self.trainLoader, self.devLoader, self.testLoader
'
运行

4.定义一些基础的模型类

  1. class FNN(torch.nn.Module):
  2.     def __init__(self):
  3.         super(FNN, self).__init__()
  4.         self.fc = torch.nn.Linear(64, 256)
  5.         self.fc2 = torch.nn.Linear(256, 10)
  6.         self.softmax = torch.nn.Softmax()
  7.         self.dropout = torch.nn.Dropout(p=0.5)
  8.         self.tanh = torch.nn.Tanh()
  9.         # self.bn = torch.nn.BatchNorm1d()
  10.  
  11.     def forward(self, x):
  12.         # out = self.bn(x)
  13.         # print(x)
  14.         out = self.fc(x)
  15.         out = self.dropout(out)
  16.         out = self.tanh(out)
  17.         out = self.fc2(out)
  18.         out = self.dropout(out)
  19.         logits = self.tanh(out)
  20.         # print(logits)
  21.         # prob = self.softmax(logits)
  22.         return logits
  23.  
  24. class SelfAttention(torch.nn.Module):
  25.     def __init__(self, hidden_dim):
  26.         super().__init__()
  27.         self.projection = torch.nn.Sequential(
  28.             torch.nn.Linear(hidden_dim, 64),
  29.             torch.nn.ReLU(True),
  30.             torch.nn.Linear(64, 1))
  31.  
  32.     def forward(self, encoder_outputs):
  33.         energy = self.projection(encoder_outputs)  # (B, L, H) -> (B , L, 1)
  34.         weights = F.softmax(energy, dim=1)
  35.         outputs = encoder_outputs * weights  # (B, L, H)
  36.         return outputs
  37.  
  38.  
  39. class RNN(torch.nn.Module):
  40.     def __init__(self):
  41.         super(RNN, self).__init__()
  42.         self.fc = torch.nn.Linear(200, 10)
  43.         self.fc2 = torch.nn.Linear(256, 10)
  44.         self.softmax = torch.nn.Softmax()
  45.         self.dropout = torch.nn.Dropout(p=0.5)
  46.         self.tanh = torch.nn.Tanh()
  47.         self.bn = torch.nn.BatchNorm1d(64)
  48.         self.lstm = torch.nn.LSTM(64, 100, 2, bidirectional=True, batch_first=True, dropout=0.5)
  49.  
  50.     def forward(self, x):
  51.         # out = self.bn(x)
  52.         x = x.unsqueeze(dim=1)
  53.         out, _ = self.lstm(x)
  54.         out = self.tanh(out)
  55.         out = self.fc(out)
  56.         out = self.dropout(out)
  57.         out = self.tanh(out)
  58.         # out = self.fc2(out)
  59.         # out = self.tanh(out)
  60.         # logits = self.dropout(out)
  61.         # prob = self.softmax(logits)
  62.         prob = out.squeeze(dim=1)
  63.         return prob
  64.  
  65. class RNN_ATT(torch.nn.Module):
  66.     def __init__(self):
  67.         super(RNN_ATT, self).__init__()
  68.         self.fc = torch.nn.Linear(200, 10)
  69.         self.fc2 = torch.nn.Linear(256, 10)
  70.         self.softmax = torch.nn.Softmax()
  71.         self.dropout = torch.nn.Dropout(p=0.5)
  72.         self.tanh = torch.nn.Tanh()
  73.         self.bn = torch.nn.BatchNorm1d(64)
  74.         self.lstm = torch.nn.LSTM(64, 100, 2, bidirectional=True, batch_first=True, dropout=0.5)
  75.         self.attention = SelfAttention(100 * 2)
  76.  
  77.     def forward(self, x):
  78.         # out = self.bn(x)
  79.         x = x.unsqueeze(dim=1)
  80.         out, _ = self.lstm(x)
  81.         out = self.tanh(out)
  82.         out=self.attention(out)
  83.         out = self.tanh(out)
  84.         out = self.fc(out)
  85.         out = self.dropout(out)
  86.         out = self.tanh(out)
  87.         # out = self.fc2(out)
  88.         # out = self.tanh(out)
  89.         # logits = self.dropout(out)
  90.         # prob = self.softmax(logits)
  91.         prob = out.squeeze(dim=1)
  92.         return prob
  93.  
  94.  
  95. class CNN(torch.nn.Module):
  96.     def __init__(self):
  97.         super(CNN, self).__init__()
  98.         self.fc = torch.nn.Linear(64, 256)
  99.         self.fc2 = torch.nn.Linear(64, 10)
  100.         self.softmax = torch.nn.Softmax()
  101.         self.dropout = torch.nn.Dropout(p=0.5)
  102.         self.tanh = torch.nn.Tanh()
  103.         self.conv1d = torch.nn.Conv1d(64, 10, kernel_size=1)
  104.         self.conv1d_t = torch.nn.Conv1d(8, 8, kernel_size=1)
  105.         # self.maxpool1d = torch.nn.MaxPool1d(kernel_size=4, stride=None, padding=0, dilation=1,
  106.         #                                     return_indices=False, ceil_mode=False)
  107.         self.flatten = torch.nn.Flatten(start_dim=0, end_dim=1)
  108.         # self.bn = torch.nn.BatchNorm1d()
  109.  
  110.     def forward(self, x):
  111.         x = x.unsqueeze(dim=2)
  112.         print(x.size())
  113.         out = self.conv1d(x)
  114.         out = self.flatten(out)
  115.         prob = self.softmax(out)
  116.         # ------------------------------------
  117.         # x = x.unsqueeze(dim=0)
  118.         # out = self.conv1d_t(x)
  119.         # # out = self.maxpool1d(out)
  120.         # out = self.flatten(out)
  121.         # out = self.fc2(out)
  122.         # # print(out)
  123.         # # print(out.size())
  124.         # prob = self.softmax(out)
  125.         return prob
  126.  
  127.  
  128. class CNN2(torch.nn.Module):
  129.     def __init__(self):
  130.         super(CNN2, self).__init__()
  131.         self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=2)
  132.         self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=2)
  133.         self.conv2_drop = torch.nn.Dropout2d()
  134.         self.fc1 = torch.nn.Linear(720, 50)
  135.         self.fc2 = torch.nn.Linear(490, 10)
  136.         self.flatten = torch.nn.Flatten()
  137.  
  138.     def forward(self, x):
  139.         x = np.array(x)
  140.         x = x.reshape(8, 1, 8, 8)
  141.         x = np.float32(x)
  142.         x = torch.tensor(x)
  143.         x = self.conv1(x)
  144.         # x = F.dropout2d(x)
  145.         x = F.max_pool2d(x, kernel_size=1)
  146.         x = F.relu(x)
  147.         x = self.flatten(x)
  148.         x = F.dropout(x, training=self.training)
  149.         x = self.fc2(x)
  150.         return x

5.定义主类（包括训练、验证和测试方法）

  1. class Main(ProcessData, SetSeed):
  2.     def __init__(self, model):
  3.         super(Main, self).__init__()
  4.         self.model = model
  5.         self.trainLoader = self.dataToLoader()[0]
  6.         self.devLoader = self.dataToLoader()[1]
  7.         self.testLoader = self.dataToLoader()[2]
  8.         self.optimizer = AdamW(model.parameters(), lr=2e-5, weight_decay=1e-4)  # 使用Adam优化器
  9.         # 设置学习率
  10.         self.schedule = get_cosine_schedule_with_warmup(self.optimizer, num_warmup_steps=len(self.trainLoader),
  11.                                                         num_training_steps=10 * len(self.testLoader))
  12.         self.criterion = torch.nn.CrossEntropyLoss()
  13.  
  14.     def train(self):
  15.         self.same_seeds(20)
  16.         bestAcc = 0.0
  17.         for i in range(400):
  18.             self.model.train()  # 开始训练
  19.             print("***************Running training epoch{}************".format(i + 1))
  20.             train_loss_sum = 0.0
  21.             for idx, (X, y) in enumerate(self.trainLoader):
  22.                 yPred = self.model(X)
  23.                 # print(yPred)
  24.                 # print(y)
  25.                 loss = self.criterion(yPred, y)
  26.                 # loss=self.criterion()
  27.                 self.optimizer.zero_grad()
  28.                 loss.backward()
  29.                 self.optimizer.step()
  30.                 self.schedule.step()
  31.                 train_loss_sum += loss.item()
  32.             devAcc = self.__evaluate(self.model, self.devLoader)
  33.             print(devAcc)
  34.             if devAcc > bestAcc:
  35.                 bestAcc = devAcc
  36.                 torch.save(self.model.state_dict(), "checkpoint/best_model.pth")
  37.         testAcc = self.__predict(self.model, self.testLoader)
  38.         torch.save(self.model.state_dict(), "checkpoint/best_model2.pth")
  39.         print(testAcc)
  40.  
  41.     def __evaluate(self, model, data_loader):
  42.         model.eval()  # 防止模型训练改变权值
  43.         devTrue, devPred = [], []
  44.         with torch.no_grad():  # 计算的结构在计算图中,可以进行梯度反转等操作
  45.             for idx, (X, y) in enumerate(data_loader):  # 得到的y要转换一下数据格式
  46.                 yPred = model(X)  # 此时得到的是概率矩阵
  47.                 yPred = torch.argmax(yPred, dim=1).detach().cpu().numpy().tolist()  # 将概率矩阵转换成标签并变成list类型
  48.                 devPred.extend(yPred)  # 将标签值放入列表
  49.                 devTrue.extend(y.squeeze().cpu().numpy().tolist())  # 将真实标签转换成list放在列表中
  50.         return accuracy_score(devTrue, devPred)
  51.  
  52.     def __predict(self, model, data_loader):
  53.         model.eval()  # 防止模型训练改变权值
  54.         testTrue, testPred = [], []
  55.         with torch.no_grad():  # 计算的结构在计算图中,可以进行梯度反转等操作
  56.             for idx, (X, y) in enumerate(data_loader):  # 得到的y要转换一下数据格式
  57.                 yPred = model(X)  # 此时得到的是概率矩阵
  58.                 yPred = torch.argmax(yPred, dim=1).detach().cpu().numpy().tolist()  # 将概率矩阵转换成标签并变成list类型
  59.                 testPred.extend(yPred)  # 将标签值放入列表
  60.                 testTrue.extend(y.squeeze().cpu().numpy().tolist())  # 将真实标签转换成list放在列表中
  61.         return classification_report(testTrue, testPred)

定义测试类，可供调试以及部署API模型

  1. class Test(SetSeed):
  2.     def __init__(self):
  3.         self.path = 'checkpoint/best_model2.pth'
  4.  
  5.     def test(self, model, data):
  6.         self.same_seeds(1)
  7.         data = torch.Tensor(data)
  8.         model = model
  9.         model.eval()
  10.         model.load_state_dict(torch.load(self.path))
  11.         y_pred_prob = model(data)  # 此时得到的是概率矩阵
  12.         y_pred = torch.argmax(y_pred_prob, dim=1).detach().cpu().numpy().tolist()
  13.         # print(y_pred_prob)
  14.         print('预测值：', y_pred[0])

6.主函数入口

  1. if __name__ == '__main__':
  2.     model = RNN_ATT()
  3.  
  4.     main = Main(model)
  5.     main.train()
  6.  
  7.     # index = 348
  8.     # dataX, _ = load_digits(return_X_y=True)
  9.     # dataMidList = []
  10.     # data = dataX[index, :].reshape(8, -1)
  11.     # print('真实数据：', _[index])
  12.     # import matplotlib.pyplot as plt
  13.  
  14.     # plt.imshow(data, cmap='gray', interpolation='none')
  15.     # plt.show()
  16.     # data = dataX[index, :]
  17.     # dataMidList.append(data)
  18.     # for _ in range(7):
  19.     #     vecMid = [0 for _ in range(64)]
  20.     #     dataMidList.append(vecMid)
  21.     # # print(dataMidList)
  22.     # # data = dataX[1, :].reshape(1, -1)
  23.     # data = np.array(dataMidList).reshape(8, 1, 8, 8)
  24.     # # print(data)
  25.     # test = Test()
  26.     # test.test(model, data)
  27.  
  28.     # data = torch.rand([3, 3])
  29.     # # print(data)
  30.     # data1 = data.unsqueeze(dim=0)
  31.     # print(data1)

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/897160
推荐阅读
相关标签

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

  

闽ICP备14008679号