pytorch学习2：搭建VGG16网络，利用预训练权重网络进行训练

#微调预训练的VGG16网络


import numpy as np
import pandas as pd
from sklearn.metrics import accuracy_score,confusion_matrix,classification_report
import matplotlib.pyplot as plt
import seaborn as sns
import hiddenlayer as hl
import torch
import torch.nn as nn
from torch.optim import SGD,Adam
import torch.utils.data as Data
from torchvision import models
from  torchvision import transforms
from  torchvision.datasets import ImageFolder




#导入与与训练好的VGG16网络

vgg16 = models.vgg16(pretrained=True)
#获取VGG16的特征提取层
vgg = vgg16.features
#将vgg16的特征提取层参数冻结，不对其进行更细腻
for param in vgg.parameters():
    param.requires_grad_(False)

#使用VGG16的特征提取层+新的全连接层组成新的网络
class MyVggModel(nn.Module):
    def __init__(self):
        super(MyVggModel,self).__init__()
        #预训练的Vgg16的特征提取层
        self.vgg = vgg
        #添加新的全连接层
        self.classifier = nn.Sequential(
            nn.Linear(25088,512),
            nn.ReLU(),
            nn.Dropout(p = 0.5),
            nn.Linear(512,256),
            nn.ReLU(),
            nn.Dropout(p = 0.5),
            nn.Linear(256,10),

        )

    #定义网络的前向传播
    def forward(self,x):
        x = self.vgg(x)
        x = x.view(x.size(0),-1)
        output = self.classifier(x)
        return output


#输出网络结构
Myvggc = MyVggModel()



#使用10类猴子的数据集进行训练，先对数据进行预处理
#训练集
train_data_transforms = transforms.Compose(
    [
        transforms.RandomResizedCrop(224),#随机长宽比裁剪为224*224
        transforms.RandomHorizontalFlip(),#按照概率为0.5水平翻转
        transforms.ToTensor(),#转化为张量并进行归一化至【0，-1}
        #图像标准化处理
        transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])

    ]
)

#验证集
val_data_transforms = transforms.Compose(
    [
        transforms.Resize((256,256)),#重置图像分辨率
        transforms.CenterCrop(224),#依据给定的size从图片中心裁剪
        transforms.ToTensor(),#转化为张量并进行归一化至【0，-1}
        #图像标准化处理
        transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])

    ]
)


#读取训练集图像
train_data_dir = "data/chap6/10-monkey-species/training"
train_data = ImageFolder(train_data_dir,transform=train_data_transforms)
train_data_loader = Data.DataLoader(train_data,batch_size=32,shuffle=True,num_workers=0)
#读取验证集
val_data_dir = "data/chap6/10-monkey-species/validation"
val_data = ImageFolder(val_data_dir,transform=val_data_transforms)
val_data_loader = Data.DataLoader(val_data,batch_size=32,shuffle=True,num_workers=0)

print("训练集样本数；",len(train_data.targets))
print("验证集样本数",len(val_data.targets))


#获得一个batch的数据
for step,(b_x,b_y) in enumerate(train_data_loader):
    if step > 0:
        break

    mean = np.array([0.485,0.456,0.406])
    std = np.array([0.229,0.224,0.225])
    plt.figure(figsize=(12,6))
    for ii in np.arange(len(b_y)):
        plt.subplot(4,8,ii+1)
        image =b_x[ii,:,:,:].numpy().transpose((1,2,0))
        image = std*image+mean
        image = np.clip(image,0,1)
        plt.imshow(image)
        plt.title(b_y[ii].data.numpy())
        plt.axis('off')


    plt.subplots_adjust(hspace=0.3)
    plt.show()

#定义优化器
optimizer = torch.optim.Adam(Myvggc.parameters(),lr=0.003)
loss_func = nn.CrossEntropyLoss()#损失函数
#记录训练过程指标
historyl = hl.History()
#使用Canves进行可视化
canvasl = hl.Canvas()
#对模型进行迭代训练，对所有的数据训练epoch轮
for epoch in range(10):
    train_loss_epoch = 0
    val_loss_epoch = 0
    train_corrects = 0
    val_corrects = 0
    #对训练数据的加载器进行迭代计算
    Myvggc.train()
    for step,(b_x,b_y) in enumerate(train_data_loader):
        print(step)
        ##计算每个batch的损失
        output = Myvggc(b_x)
        loss = loss_func(output,b_y)#交叉熵损失函数
        pre_lab = torch.argmax(output,1)
        optimizer.zero_grad()#每个迭代步的梯度初始化为0
        loss.backward()#损失的后向传播，计算梯度
        optimizer.step()#使用梯度进行优化
        train_loss_epoch += loss.item()*b_x.size(0)
        train_corrects += torch.sum(pre_lab == b_y.data)

    #计算一个epoch的损失和精度
    train_loss = train_loss_epoch/len(train_data.targets)
    train_acc = train_corrects.double()/len(train_data.targets)

    #计算在验证集上的表现
    Myvggc.eval()
    for step,(val_x,val_y) in enumerate(val_data_loader):
        output = Myvggc(val_x)
        loss = loss_func(output,val_y)
        pre_lab = torch.argmax(output,1)
        val_loss_epoch += loss.item()*val_x.size(0)
        val_corrects += torch.sum(pre_lab == val_y.data)

    #计算一个epoch上的输出loss和acc
    val_loss = val_loss_epoch/len(val_data.targets)
    val_acc = val_corrects.double()/len(val_data.targets)

    #保存每个epoch上的输出loss和acc
    historyl.log(epoch,train_loss=train_loss,val_loss = val_loss,train_acc = train_acc.item(),val_acc = val_acc.item())
    #可视化网络训练的过程
    with canvasl:
        canvasl.draw_plot([historyl["train_loss"],historyl["val_loss"]])
        canvasl.draw_plot([historyl["train_acc"],historyl["val_acc"]])