项目地址：

一、准备数据

在Pytorch中构建图片数据管道通常有三种方法

  1. 第一种是使用torchvision中的datasets.ImageFolder来读取图片，然后用DataLoader来并行加载。
  2. 第二种是通过继承torch.utils.data.Dataset实现用户自定义读取逻辑然后用DataLoader来并行加载。
  3. 第三种方法是读取用户自定义数据集的通用方法，既可以读取图片数据集，也可以读取文本数据集。

这里使用第一种方法

  1. import torch 
  2. import torch.nn as nn
  3. from torch.utils.data import Dataset, DataLoader
  4. from torchvision import transforms,datasets
  8. transform_train = transforms.Compose(
  9.                              [transforms.ToTensor()])
  10. transform_valid = transforms.Compose(
  11.                              [transforms.ToTensor()])
  13. ds_train = datasets.ImageFolder("../data/cifar2/train/",
  14.                                transform = transform_train, target_transform = lambda t: torch.tensor([t]).float())
  15. ds_valid = datasets.ImageFolder("../data/cifar2/test/",
  16.             transform = transform_valid,target_transform= lambda t:torch.tensor([t]).float())
  18. print(ds_train.class_to_idx)
  21. dl_train = DataLoader(ds_train, batch_size = 50, shuffle = True, num_workers = 3)
  22. dl_valid = DataLoader(ds_train, batch_size = 50, shuffle = True, num_workers = 3)

查看部分样本

  1. from matplotlib import pyplot as plt
  3. plt.figure(figsize=(8,8))
  4. for i in range(9):
  5.     img, label = ds_train[i]
  6.     img = img.permute(1,2,0)
  7.     ax = plt.subplot(3,3,i+1)
  8.     ax.imshow(img.numpy())
  9.     ax.set_title("label = %d"%label.item())
  10.     ax.set_xticks([])
  11.     ax.set_yticks([])
  13. plt.show()

pytorch 的图片默认顺序是： Batch, Channel, Width, Height

  1. for x, y in dl_train:
  2.     print(x.shape, y.shape)
  3.     break
  5. >>> torch.Size([50, 3, 32, 32]) torch.Size([50, 1])

二，定义模型

使用Pytorch通常有三种方式构建模型：

  1. 使用nn.Sequential 按层顺序构建模型（nn.Sequential）
  2. 继承nn.Module基类构建自定义模型(nn.ModuleList)
  3. 继承nn.Module基类构建模型并辅助应用模型容器(nn.ModuleDict)
  1. #测试AdaptiveMaxPool2d的效果
  3. pool = nn.AdaptiveMaxPool2d((1,1))
  4. t = torch.randn(10,8,32,32)
  5. pool(t).shape
  1. class Net(nn.Module):
  3.     def __init__(self):
  4.         super(Net, self).__init__()
  5.         self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3)
  6.         self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
  7.         self.conv2 = nn.Conv2d(in_channels=32, out_channles=64, kernel_size=5)
  8.         self.dropout = nn.Dropout2d(p=0.1)
  9.         self.adaptive_pool = nn.AdaptiveMaxPool2d((1,1))
  10.         self.flatten = nn.Flatten()
  11.         self.linear1 = nn.Linear(64,32)
  12.         self.relu = nn.ReLU()
  13.         self.linear2 = nn.Linear(32,1)
  14.         self.sigmoid = nn.Sigmoid()
  16.     def forward(self, x):
  17.         x = self.conv1(x)
  18.         x = self.pool(x)
  19.         x = self.conv2(x)
  20.         x = self.pool(x)
  21.         x = self.dropout(x)
  22.         x = self.adaptive_pool(x)
  23.         x = self.flatten(x)
  24.         x = self.linear1(x)
  25.         x = self.relu(x)
  26.         y = self.sigmoid(x)
  28.         return y
  31. net = Net()
  32. print(net)

使用torchkeras打印网络模型

  1. import torchkeras
  2. torchkears.summary(net, input_shape=(3, 32, 32))
  1. ----------------------------------------------------------------
  2.         Layer (type)               Output Shape         Param #
  3. ================================================================
  4.             Conv2d-1           [-1, 32, 30, 30]             896
  5.          MaxPool2d-2           [-1, 32, 15, 15]               0
  6.             Conv2d-3           [-1, 64, 11, 11]          51,264
  7.          MaxPool2d-4             [-1, 64, 5, 5]               0
  8.          Dropout2d-5             [-1, 64, 5, 5]               0
  9.  AdaptiveMaxPool2d-6             [-1, 64, 1, 1]               0
  10.            Flatten-7                   [-1, 64]               0
  11.             Linear-8                   [-1, 32]           2,080
  12.               ReLU-9                   [-1, 32]               0
  13.            Linear-10                    [-1, 1]              33
  14.           Sigmoid-11                    [-1, 1]               0
  15. ================================================================
  16. Total params: 54,273
  17. Trainable params: 54,273
  18. Non-trainable params: 0
  19. ----------------------------------------------------------------
  20. Input size (MB): 0.011719
  21. Forward/backward pass size (MB): 0.359634
  22. Params size (MB): 0.207035
  23. Estimated Total Size (MB): 0.578388
  24. ----------------------------------------------------------------

三，训练模型

有三种典型训练循环代码风格：

  1. 脚本形式训练循环
  2. 函数形式训练循环
  3. 类形式训练循环

函数形式循环训练

  1. import pandas as pd
  2. from sklearn.metrics import roc_auc_score
  4. model = net
  5. model.optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
  6. model.loss_func = torch.nn.BCELoss()
  7. modle.metric_func = lambda y_pred, y_true: roc_auc_score(y_true.data.numpy(), y_pred.data.numpy())
  8. modle.metric_name = "auc"
  11. def train_step(modle, features, labels):
  14.     # 训练模式， dropout层发生作用，使用model.train()
  15.     model.train()
  16.     # 梯度清零
  17.     model.optimizer.zero_grad()
  18.     # 正向传播求损失
  19.     predictions = model(features)
  20.     loss = model.loss_func(predictions, labels)
  21.     metric = model.metric_func(predictions, labels)
  23.     # 反向传播求梯度
  24.     loss.backward()
  25.     model.optimizer.step()
  27.     return loss.item(), metric.item()
  30. def valid_step(model, features, labels):
  32.     # 预测模式， dropout层不发生作用
  33.     model.eval()
  34.     # 关闭梯度计算
  35.     with torch.no_grad():
  36.         predictions = model(features)
  37.         loss = model.loss_func(predictions, labels)
  38.         metric = model.metric_func(predictions, labels)
  40.     return loss.item(), metric.item()
  42. # 测试train_step效果
  43. features, labels = next(iter(dl_train))
  44. train_step(model, features, labels)
  1. def train_model(model, epochs, dl_train, dl_valid, log_step_freq):
  3.     metric_name = model.metric_name
  4.     dfhistory = pd.DataFrame(columns = ["epoch", "loss", metric_name, "val_loss", "val_"+metric_name])
  5.     print("Start Training...")
  6.     nowtime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
  7.     print("==========="*8 + "%s"%nowtime)
  9.     for epoch in range(1, epochs+1):
  11.         # 1, 训练循环
  12.         loss_num = 0.0
  13.         metric_sum = 0.0
  14.         step = 1
  16.         for step, (features, labels) in enumerate(dl_train, 1):
  17.             loss, metric = train_step(model, features, labels)
  19.             loss_sum += loss
  20.             metric_sum += metric
  21.             if step%log_step_freq == 0:
  22.                 print(("[step = %d] loss: %.3f, "+metric_name+":%.3f")%
  23.                       (step, loss_sum/step, metric_sum/step)
  24.                 )
  26.         # 2, 验证循环
  27.         val_loss_sum = 0.0
  28.         val_metric_sum = 0.0
  29.         val_step = 1
  31.         for val_step, (features, labels) in enumerate(dl_valid, 1):
  32.             val_loss, val_metric = valid_step(model, features, labels)
  34.             val_loss_sum += val_loss
  35.             val_metric_sum += val_metric
  37.         # 3, 记录日志
  38.         info = (epoch, loss_sum/step, metric_sum/step,
  39.                      val_loss_sum/val_step, val_metric_sum/val_step)
  40.         dfhistory.loc[epoch-1] = info
  42.         # 打印epoch级别日志
  43.         print(("\nEPOCH = %d, loss = %.3f,"+ metric_name + \
  44.               "  = %.3f, val_loss = %.3f, "+"val_"+ metric_name+" = %.3f") 
  45.               %info)
  46.         nowtime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
  47.         print("\n"+"=========="*8 + "%s"%nowtime)