pytorch之模型迁移

男娘i 2023-06-30 02:40 34阅读 0赞

参考的书目为《深度学习之pytorch实战计算机视觉》  
将猫狗大战中写好的VGGNet模型替换为VGG16，ResNet模型，前面首先给出完整的VGGNet模型代码，之后分别给出最另外两个模型的修改位置，并进行标注说明：

import torch
    import torchvision
    from torchvision import datasets, transforms
    import torch.utils.data as da#后面调用时出不来自动提示，故重命名了下
    from torch.autograd import Variable
    import os
    import matplotlib.pyplot as plt
    import time
    data_dir = "G:\pytorch\DogsVSCats"
    data_transform = {
        
        x:transforms.Compose([
            transforms.Scale([64, 64]),#放缩至64*64
            transforms.ToTensor()#类型转换
        ])
        for x in ["train", "test"]
    }
    image_datasets = {
        
        x:datasets.ImageFolder(root=os.path.join(data_dir, x),
                               transform= data_transform[x])
        #os.path.join将两个名字拼接成一个完整的文件路径
        for x in ["train","test"]
    }
    dataloader = {
        
        x:da.DataLoader(dataset=image_datasets[x],
                        batch_size= 16,
                        shuffle= True)
        for x in ["train", "test"]
    }
    X_example, Y_example = next(iter(dataloader["train"]))
    #为减少计算量，在模型中删除了最后三个卷积层和池化层
    class Models_VGG(torch.nn.Module):
        def __init__(self):
            super(Models_VGG, self).__init__()
            self.Conv = torch.nn.Sequential(
                torch.nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),
                torch.nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),
                torch.nn.MaxPool2d(kernel_size=2, stride=2),
    
                torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),
                torch.nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),
                torch.nn.MaxPool2d(kernel_size=2, stride=2),
    
                torch.nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),
                torch.nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),
                torch.nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),
                torch.nn.MaxPool2d(kernel_size=2, stride=2),
    
                torch.nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),
                torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),
                torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
                torch.nn.ReLU(),
                torch.nn.MaxPool2d(kernel_size=2, stride=2)
            )
            #全连接层优化
            self.Classes = torch.nn.Sequential(
                torch.nn.Linear(4*4*512, 1024),
                torch.nn.ReLU(),
                torch.nn.Dropout(p = 0.5),
                torch.nn.Linear(1024, 1024),
                torch.nn.ReLU(),
                torch.nn.Dropout(p = 0.5),
                torch.nn.Linear(1024, 2)
            )
    
        def forward(self, input):
            x = self.Conv(input)
            x = x.view(-1, 4*4*512)#扁平化处理
            x = self.Classes(x)
            return x
    model = Models_VGG()
    use_gpu = torch.cuda.is_available()#判断GPU是否可用
    #对模型进行优化
    loss_fuction = torch.nn.CrossEntropyLoss()#采用交叉嫡
    optimizer = torch.optim.Adam(model.parameters(), lr=0.00001)
    if use_gpu:
    	model = model1.cuda()
    epoch_n = 10
    time_start = time.time()
    for epoch in range(epoch_n):#训练次数
        print("Epoch {}/{}".format(epoch, epoch_n-1))
        print("-"*20)
    
        for phase in ["train", "test"]:#选择数据集
            if phase is "train":
                print("Traing...")
                model.train(True)
            else:
                print("Validing...")
                model.train(False)
            running_loss = 0.0
            running_corrects = 0
    #下面对数据集中的数据进行训练或验证
            for batch, data in enumerate(dataloader[phase], 1):
                X, y = data
                #如果是GPU
                if use_gpu:
               	    X, y = Variable(X.cuda()), Variable(y.cuda())
               	else:
                	X, y = Variable(X), Variable(y)
                y_pred = model(X)
                _,pred = torch.max(y_pred.data, 1)
                optimizer.zero_grad()
                loss = loss_fuction(y_pred, y)
                if phase is "train":
                    loss.backward()
                    optimizer.step()
                running_loss += loss.data
                running_corrects += torch.sum(pred == y.data)
                if batch%500 is 0 and phase is "train":
                    print("Batch {}, Tarin Loss{:.4f}, Train Accur{:.4f}".format(batch, running_loss/batch, 100*running_corrects/(16*batch)))
            epoch_loss = running_loss*16/len(image_datasets[phase])
            epoch_acc = 100*running_corrects/len(image_datasets[phase])
            print("{} Loss:{:.4f} Acc {:.4f}%".format(phase, epoch_loss, epoch_acc))
        time_use = time.time() - time_start
    print(time_use)

在CPU上运行耗时比较旧，我的电脑是X220 i5-2520m，跑一个epoch用了四十五分钟…  
——————————————————————————————  
下面是模型迁移代码：  
1）迁移到VGG16

#将VGGNet上的模型迁移到VGG16中，下载的模型已经优化好了
    model = models.vgg16(pretrained= True)
    #冻结卷积神经网络中全连接层之前的网络层次,即梯度不修改
    for parma in model.parameters():
        parma.requires_grad = False
    #调参只需要在全连接层进行
    model.classifier = torch.nn.Sequential(
        torch.nn.Linear(25088, 4096),
        torch.nn.ReLU(),
        torch.nn.Dropout(p=0.5),
        torch.nn.Linear(4096, 4096),
        torch.nn.ReLU(),
        torch.nn.Dropout(p=0.5),
        torch.nn.Linear(4096, 2)
    )

在VGG16中输出的结果是1000个，但猫狗大战这里只需输出2个，所以做了修该。  
2）迁移到ResNet中：

#将VGGNet上的模型迁移到ResNet50中，下载的模型已经优化好了
    model = models.resnet50(pretrained= True)
    #冻结卷积神经网络中全连接层之前的网络层次
    for parma in model.parameters():
        parma.requires_grad = False
    #对全连接层进行调整，只有一行
    model.fc = torch.nn.Linear(2048, 2)

输出结果只有两个，所以全连接层是个2