Pytorch学习（六）

利用PyTorch完成Cifar10图像分类

分类网络的基本结构

• 先加载数据&＃xff0c;然后将这个数据进行重组&＃xff0c;组合成我们神经网络所需要的数据的形式&＃xff08;数据预处理/数据增强&＃xff09;。
• 我们将数据丢到一个CNN网络中进行特征的提取。在特征提取完之后我们会得到一个N维的向量&＃xff0c;而这N个向量就表示我们想要分的N个类别。
• 通过一个损失函数来计算网络当前的损失&＃xff0c;通过这个损失对网络进行反向传播&＃xff0c;从而对参数进行调整。在进行BP的时候我们就需要定义我们网络的优化器&＃xff0c;如梯度下降法等来完成对网络参数的迭代。迭代到模型收敛的时候&＃xff0c;即loss很小或是loss几乎不变的时候&＃xff0c;参数就训练完成了。
• 有了这些参数&＃xff0c;就可以构建一个网络。从而对我们接下来输入数据的一个推理。
• 训练的过程是求解网络参数的过程
• 推理的过程是已知网络结构&＃xff0c;并且经过训练过程我们已经拿到网络参数&＃xff0c;这个时候我们就构建出了前向推理的函数。利用这个函数&＃xff0c;给定其输入数据x&＃xff0c;就可以计算出预测的结果。

数据加载模块

• 在pytorch中channel是优先排列的&＃xff0c;我们需要将数据转换成 channel * h * w的数据

数据增强

• 是一种将已有的数据进行一种扩充的手段&＃xff0c;为了解决数据集不足的问题
• 常见的一些数据增强的方法&＃xff1a;进行一些随机的翻转/旋转 / 修改图像的亮度 饱和度 对比度等
• 我们使用的是pytorch下的transformer类
  

网络结构

类别概率分布

• N维度向量对应N个类别
• 采用FC层&＃xff08;对图像尺寸敏感&＃xff09;&＃xff0c;将其拉成一个向量。也可以使用卷积层&＃xff08;对图像尺寸敏感&＃xff09;或者是pooling层&＃xff08;pooling层无参数&＃xff0c;所以对shape不敏感&＃xff09;
• 通过一个softmax函数&＃xff0c;将这N维向量映射到概率分布上面去 Si&＃61;ei/∑jejS_i &＃61; e^i / \sum_j e^jSi​&＃61;ei/∑j​ej

损失

• 使用交叉熵损失 nn.CrossEntropyLoss
• 在分类问题中需要定义label。从标签转化为向量的是One-hot编码
• [1,0,0]第一类 [0,1,0] 第二类 但是这种方式太硬了&＃xff0c;所以需要label smoothing

分类问题常用指标

• PR曲线 ROC曲线 AUC曲线
  

优化器

• 推荐使用Adam&＃xff0c;学习率衰减采用指数衰减
  

cifar10数据介绍——读取——处理

cifar10数据介绍

• cifar10是完成一个10分类&＃xff0c;cifar100是完成一个100分类
• cifar10数据集中一共有六万张图片&＃xff0c;其中五万张是训练集&＃xff08;每个类别有5000张图片&＃xff09;&＃xff0c;一万张是测试集。图片大小是32*32
• 数据集获取地址

cifar10数据的读取与保存

import os
import cv2
import numpy as np
import pickle def unpickle(file):with open(file, &＃39;rb&＃39;) as fo:dict &＃61; pickle.load(fo, encoding&＃61;&＃39;bytes&＃39;)return dictlabel_name &＃61; ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]import glob
train_list &＃61; glob.glob("cifar-10-batches/data_batch_*")
test_list &＃61; glob.glob("cifar-10-batches/test_batch")
save_path &＃61; "cifar-10-batches/train"
test_path &＃61; "cifar-10-batches/test"
# for l in train_list:
# l_dict &＃61; unpickle(l)
# #print( l_dict.keys() )
# for im_idx, im_data in enumerate(l_dict[b&＃39;data&＃39;]):
# #print(im_idx)
# #print(im_data) #这里显示的是一个向量&＃xff0c;所以我们需要reshape一下 3*32*32# im_label &＃61; l_dict[b&＃39;labels&＃39;][im_idx]
# im_name &＃61; l_dict[b&＃39;filenames&＃39;][im_idx] # #print(im_label, im_name, im_data)
# im_label_name &＃61; label_name[im_label]
# im_data &＃61; np.reshape(im_data, [3,32,32])
# im_data &＃61; np.transpose(im_data, (1,2,0))# #cv2.imshow("im_data", cv2.resize(im_data, (200,200) ) )
# #cv2.waitKey(0)# if not os.path.exists("{}/{}".format(save_path, im_label_name)):
# os.mkdir("{}/{}".format(save_path, im_label_name))# cv2.imwrite("{}/{}/{}".format(save_path, im_label_name, im_name.decode("utf-8")), im_data)for l in test_list:l_dict &＃61; unpickle(l)#print( l_dict.keys() )for im_idx, im_data in enumerate(l_dict[b&＃39;data&＃39;]):#print(im_idx)#print(im_data) #这里显示的是一个向量&＃xff0c;所以我们需要reshape一下 3*32*32im_label &＃61; l_dict[b&＃39;labels&＃39;][im_idx]im_name &＃61; l_dict[b&＃39;filenames&＃39;][im_idx] #print(im_label, im_name, im_data)im_label_name &＃61; label_name[im_label]im_data &＃61; np.reshape(im_data, [3,32,32])im_data &＃61; np.transpose(im_data, (1,2,0))#cv2.imshow("im_data", cv2.resize(im_data, (200,200) ) )#cv2.waitKey(0)if not os.path.exists("{}/{}".format(test_path, im_label_name)):os.mkdir("{}/{}".format(test_path, im_label_name))cv2.imwrite("{}/{}/{}".format(test_path, im_label_name, im_name.decode("utf-8")), im_data)


cifar10数据的加载与处理

from torchvision import transforms
from torch.utils.data import DataLoader, Dataset
import os
from PIL import Image
import numpy as np
import globlabel_name &＃61; ["airplane", "automobile", "bird", "cat","deer","dog","frog","horse","ship","truck"]label_dict &＃61; {}for idx, name in enumerate(label_name):label_dict[name] &＃61; idxdef default_loader(path):return Image.open(path).covert("RGB")train_transform &＃61; transforms.Compose([transforms.RandomResizedCrop((28,28)),transforms.RandomHorizontalFlip(),transforms.RandomVerticalFlip(),transforms.RandomRotation(90),transforms.RandomGrayscale(0.1),transforms.ColorJitter(0.3, 0.3, 0.3, 0.3),transforms.ToTensor()
])class MyDataset(Dataset):def __init__(self, im_list, transform &＃61; None, loader &＃61; default_loader):super(MyDataset,self).__init__()imgs &＃61; []for im_item in im_list:im_label_name &＃61; im_item.split("/")[-2]imgs.append([im_item, label_dict[im_label_name]])self.imgs &＃61; imgsself.transform &＃61; transformself.loader &＃61; loader# 定义对数据的读取和对数据的增强&＃xff0c;然后返回图片的数据和labeldef __getitem__(self, index):im_path, im_label &＃61; self.imgs[index]im_data &＃61; self.loader(im_path)if self.transform is not None:im_data &＃61; self.transform(im_data)return im_data, im_labeldef __len__(self):return len(self.imgs)im_train_list &＃61; glob.glob("cifar-10-batches/train/*/*.png")
im_test_list &＃61; glob.glob("cifar-10-batches/test/*/*.png")train_dataset &＃61; MyDataset( im_train_list, transform &＃61; train_transform )
test_dataset &＃61; MyDataset( im_test_list, transform &＃61; transforms.ToTensor() )train_data_loader &＃61; DataLoader(dataset &＃61; train_dataset, batch_size &＃61; 66, shuffle &＃61; True, num_workers &＃61; 4)
test_data_loader &＃61; DataLoader(dataset &＃61; test_dataset, batch_size &＃61; 66, shuffle &＃61; False, num_workers &＃61; 4)print("num_of_train", len(train_dataset))
print("num_of_test", len(test_dataset))


使用VGGNet实现cifar10分类

网络定义的程序

import torch
import torch.nn as nn
import torch.nn.functional as Fclass VGGbase(nn.Module):def __init__(self):super(VGGbase, self).__init__()self.conv1 &＃61; nn.Sequrntial(nn.Conv2d(3, 64, kernal_size &＃61; 3, stride &＃61; 1, padding &＃61; 1),nn.BatchNorm2d(64),nn.ReLU())self.max_pooling1 &＃61; nn.MaxPool2d(kernel_size &＃61; 2, stride &＃61; 2)self.conv2_1 &＃61; nn.Sequrntial(nn.Conv2d(64, 128, kernal_size &＃61; 3, stride &＃61; 1, padding &＃61; 1),nn.BatchNorm2d(128),nn.ReLU())self.conv2_2 &＃61; nn.Sequrntial(nn.Conv2d(128, 128, kernal_size &＃61; 3, stride &＃61; 1, padding &＃61; 1),nn.BatchNorm2d(128),nn.ReLU())self.max_pooling2 &＃61; nn.MaxPool2d(kernel_size &＃61; 2, stride &＃61; 2)self.conv3_1 &＃61; nn.Sequrntial(nn.Conv2d(128, 256, kernal_size &＃61; 3, stride &＃61; 1, padding &＃61; 1),nn.BatchNorm2d(256),nn.ReLU())self.conv3_2 &＃61; nn.Sequrntial(nn.Conv2d(256, 256, kernal_size &＃61; 3, stride &＃61; 1, padding &＃61; 1),nn.BatchNorm2d(256),nn.ReLU())self.max_pooling3 &＃61; nn.MaxPool2d(kernel_size &＃61; 2, stride &＃61; 2, padding&＃61;1)self.conv4_1 &＃61; nn.Sequrntial(nn.Conv2d(256, 512, kernal_size &＃61; 3, stride &＃61; 1, padding &＃61; 1),nn.BatchNorm2d(256),nn.ReLU())self.conv4_2 &＃61; nn.Sequrntial(nn.Conv2d(512, 512, kernal_size &＃61; 3, stride &＃61; 1, padding &＃61; 1),nn.BatchNorm2d(512),nn.ReLU())self.max_pooling3 &＃61; nn.MaxPool2d(kernel_size &＃61; 2, stride &＃61; 2)#batchsize * 512 * 2 * 2 -- > batchsize * (512 * 4) self.fc &＃61; nn.Linear( 512 * 4, 10 )def forward(self, x):batchsize &＃61; x.size(0)out &＃61; self.conv1(x)out &＃61; self.max_pooling1(out)out &＃61; self.conv2_1(out)out &＃61; self.conv2_2(out)out &＃61; self.max_pooling2(out)out &＃61; self.conv3_1(out)out &＃61; self.conv3_2(out)out &＃61; self.max_pooling3(out)out &＃61; self.conv4_1(out)out &＃61; self.conv4_2(out)out &＃61; self.max_pooling4(out)out &＃61; out.view(batchsize, -1)out &＃61; self.fc(out)out &＃61; F.log_sofemax(out, dim&＃61;1)return out
def VGGNet():return VGGbase()


训练代码

import torch
import torch.nn as nn
import torchvision
from vggnet import VGGNet
from load_cifar10 import train_loader, test_loader
import os
import tensorboardX #学着使用tensorboarddevice &＃61; torch.device("cuda" if torch.cuda.is_available() else "cpu")epoch_num &＃61; 200
lr &＃61; 0.01
batch_size &＃61; 128net &＃61; VGGNet().to(device)#lossloss_func &＃61; nn.CrossEntropyLoss()#optimizeroptimizer &＃61; torch.optim.Adam( net.parameters(), lr &＃61; lr )scheduler &＃61; torch.optim.lr_scheduler.StepLR(optimizer, step_size&＃61;5, gamma&＃61;0.9)if not os.path.exists("log"):os.mkdir("log")
writer &＃61; tensorboardX.SummaryWriter("log")step_n &＃61; 0for epoch in range(epoch_num):print("epoch is", epoch)net.train() #train BN dropoutfor i, data in enumerate(train_loader):inputs, labels &＃61; datainputs, labels &＃61; inputs.to(device), labels.to(device)outputs &＃61; net(inputs)loss &＃61; loss_func(outputs, labels)optimizer.zero_grad()loss.backward()optimizer.step()_, pred &＃61; torch.max(outputs.data, dim&＃61;1)correct &＃61; pred.eq(labels.data).cpu().sum()print("step", i, "loss is:", loss.item(),"mini-batch correct is:", 100.0 * correct / batch_size)writer.add_scalar("train loss", loss.item(),global_step &＃61; step_n)writer.add_scalar("train correct", 100.0 * correct.item() / batch_size,global_step &＃61; step_n)step_n &＃43;&＃61; 1if not os.path.exists("models"):os.mkdir("models")torch.save(net.state_dict(), "models/{}.pth".format(epoch &＃43; 1)) secheduler.step()print("lr is ", optimizer.state_dict()["param_groups"][0]["lr"])#测试脚本sum_loss &＃61; 0sum_correct &＃61; 0for i, data in enumerate(test_loader):net.eval()inputs, labels &＃61; datainputs, labels &＃61; inputs.to(device), labels.to(device)outputs &＃61; net(inputs)loss &＃61; loss_func(outputs, labels)_, pred &＃61; torch.max(outputs.data, dim&＃61;1)correct &＃61; pred.eq(labels.data).cpu().sum()sum_loss &＃43;&＃61; loss.item()sum_correct &＃43;&＃61; correct.item()writer.add_scalar("test loss", loss.item(),global_step &＃61; step_n)writer.add_scalar("test correct", 100.0 * correct.item() / batch_size,global_step &＃61; step_n)#计算每个batch平均的loss和correcttest_loss &＃61; sum_loss * 1.0 / len(test_loader)test_correct &＃61; sum_correct * 100.0 / len(test_loader) / batch_sizeprint("epoch is", epoch &＃43; 1, "loss is:", test_loss,"test correct is:", test_correct)writer.close()