【猫狗数据集】定义模型并进行训练模型

2020.3.10

发现数据集没有完整的上传到谷歌的colab上去，我说怎么计算出来的step不对劲。

测试集是完整的。

训练集中cat的确是有10125张图片，而dog只有1973张，所以完成一个epoch需要迭代的次数为：

(10125+1973)/128=94.515625，约等于95。

顺便提一下，有两种方式可以计算出数据集的量：

第一种：print(len(train_dataset))

第二种：在../dog目录下，输入ls | wc -c

今天重新上传dog数据集。

分割线-----------------------------------------------------------------

数据集下载地址：

链接：https://pan.baidu.com/s/1l1AnBgkAAEhh0vI5_loWKw 提取码：2xq4

之前准备好了数据集：

创建数据集：https://www.cnblogs.com/xiximayou/p/12398285.html

读取数据集：https://www.cnblogs.com/xiximayou/p/12422827.html

这节我们要定义模型然后开始进行训练啦。

首先还是在谷歌colab中的目录如下：

其中rdata是我们读取数据的文件，将其进行改造一下：

from torch.utils.data import DataLoader
import torchvision
import torchvision.transforms as transforms
import torch

def load_dataset(batch_size):
  #预处理
  transform = transforms.Compose([transforms.RandomResizedCrop(224),transforms.ToTensor()])
  path = "/content/drive/My Drive/colab notebooks/data/dogcat"
  train_path=path+"/train"
  test_path=path+"/test"
  #使用torchvision.datasets.ImageFolder读取数据集指定train和test文件夹
  train_data = torchvision.datasets.ImageFolder(train_path, transform=transform)
  train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True, num_workers=1)
  
  test_data = torchvision.datasets.ImageFolder(test_path, transform=transform)
  test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=True, num_workers=1)
  """
  print(train_data.classes)  #根据分的文件夹的名字来确定的类别
  print(train_data.class_to_idx) #按顺序为这些类别定义索引为0,1...
  print(train_data.imgs) #返回从所有文件夹中得到的图片的路径以及其类别

  print(test_data.classes)  #根据分的文件夹的名字来确定的类别
  print(test_data.class_to_idx) #按顺序为这些类别定义索引为0,1...
  print(test_data.imgs) #返回从所有文件夹中得到的图片的路径以及其类别
  """
  return train_loader,test_loader,train_data,test_data

进行数据增强时，我们暂时只选择两种，一是将图片随机切割成224×224大小，因为大多数网络的输入大小是这个，同时将其转换成tensor。这里需要注意的是：ToTensor()要在所有的数据增强之后，除了标准化。因为ToTensor()会将图像转换为pytorch的tensor类型，同时还会将每个像素转换为0-1之间的数值。

最终我们要返回的是train_loader,test_loader,train_data,test_data。

train_loader,test_loader：就不必多说了，用于加载数据集的

train_data,test_data：传过去这个是为了获取数据集的长度。

然后在train.py中就可以定义模型并进行训练了。

resnet.py中是存储的resnet的模型，这里是从pytorch中的torchvision中的resnet拷贝过来的，当然我们也可以直接使用torchvision中的模型，里面封装了很多模型。

模型结构：

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=2, bias=False)
)

在train.py中，我们一步步来解析：

import sys
#为了避免找不到相应目录下的文件，将该目录加入到path中
sys.path.append("/content/drive/My Drive/colab notebooks")
from utils import rdata
from model import resnet
import torch.nn as nn
import torch
import numpy as np
import torchvision

#设置随机种子
np.random.seed(0)
torch.manual_seed(0)
torch.cuda.manual_seed_all(0)

#torch.backends.cudnn.deterministic一般设置成True即可
#如果网络的结构不是经常变换的，也就是固定的，将
#torch.backends.cudnn.benchmark设置True
torch.backends.cudnn.deterministic = True
#torch.backends.cudnn.benchmark = False
torch.backends.cudnn.benchmark = True

#将模型和数据放入到gpu中有两种方式，一种是model.to(device)，另一种是model.cuda()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

#就是每次输入到网络中图像的个数
batch_size=128
#读取数据
train_loader,test_loader,train_data,test_data=rdata.load_dataset(batch_size)
#为了方便起见，我们直接从torchvision中获得模型，但是该模型默认是imagenet数据集，类别有1000类，我们通过以下方式获取非预训练的模型，并修改最后全连接层为2类
model =torchvision.models.resnet18(pretrained=False)
model.fc = nn.Linear(model.fc.in_features,2,bias=False)
model.cuda()
#print(model) 

#定义训练的epochs
num_epochs=50
#定义学习率
learning_rate=0.01
#定义损失函数
criterion=nn.CrossEntropyLoss()
#optimizer #=torch.optim.Adam(model.parameters(),lr=learning_rate)
#定义优化方法，简单起见，就是用带动量的随机梯度下降
optimizer = torch.optim.SGD(params=model.parameters(), lr=0.1, momentum=0.9,
                          weight_decay=1*1e-4)
# 计算step
total_step = len(train_loader)
#定义模型训练函数
def train():
  #打印每一个epoch的输出
  for epoch in range(num_epochs):
      #为了计算每个epoch的损失
      tot_loss = 0.0
      #计算每个epoch的正确的个数
      correct = 0
      #i是step，images是图片张量，lables是标签
      for i ,(images, labels) in enumerate(train_loader):
          #将数据放入到GPU中
          images = images.cuda()
          labels = labels.cuda()

          # Forward pass
          #图片张量送入网络计算输出
          outputs = model(images)
          #取得概率大的那个结果
          _, preds = torch.max(outputs.data,1)
          loss = criterion(outputs, labels)

          # Backward and optimizer
          #反向传播优化网络参数
          optimizer.zero_grad()
          loss.backward()
          optimizer.step()
          #累加每个step的损失
          tot_loss += loss.data
          #每隔2个step就打印当前损失
          if (i+1) % 2 == 0:
              print('Epoch: [{}/{}], Step: [{}/{}], Loss: {:.4f}'
                    .format(epoch+1, num_epochs, i+1, total_step, loss.item()))
          #统计正确的个数
          correct += torch.sum(preds == labels.data).to(torch.float32)
      ### Epoch info ####
      #epoch损失
      epoch_loss = tot_loss/len(train_data)
      print('train loss: ', epoch_loss)
      #epoch准确率
      epoch_acc = correct/len(train_data)
      print('train' + ' acc: ', epoch_acc)
train()

关于step、epoch、batch_size之间的关系可以看：

https://www.cnblogs.com/xiximayou/p/12405485.html

最后，我们在test.ipynb中输入命令进行训练，不过先要进入到train目录下：

cd /content/drive/My Drive/colab notebooks/train

然后输入：

!python train.py

看下部分结果：

然后到第一个epoch完成：

再到最后一个epoch完成：

有93%的准确率了。这还仅仅是简单的训练。

发现train loss和train acc中输出不太好，这样处理一下：

epoch_loss = tot_loss/len(train_data)

print('train loss: {:.4f}'.format(epoch_loss))

epoch_acc = correct/len(train_data)

print('train acc: {:.4f}',.format(epoch_acc))

下一节：存储模型并进行测试。