• dogs vs cats 二分类问题vgg16迁移学习

    在学习猫狗二分类问题时，我主要参考的是这篇博客：http://t.csdn.cn/J7L0n

    然后数据集下载的是：Dogs vs. Cats | Kaggle

    下载的数据集一共有25000张，这里采用CPU训练速度非常慢，25000张图片训练一次要4h，所以我们仅选取了200张dog，200张cat用来train，200张dog，200张cat作为test。（从原数据集的train中复制出自己的训练集）。

    数据集结构如下：

    • data1
      • train
        • cat（200）
        • dog（200）
      • test
        • cat（200）
        • dog（200）

    需要注意的是在以下代码中，train和test下必须要分类！

    文件：data1

    文件：dogs-vs-cats-迁移学习vgg16-train-small

    1. import torch
    2. import torchvision
    3. from torchvision import datasets,transforms,models
    4. import os
    5. import numpy as np
    6. import matplotlib.pyplot as plt
    7. from torch.autograd import Variable
    8. import time
    9.  
    10. path='data1'
    11.  
    12. transform=transforms.Compose([
    13.     transforms.CenterCrop(224),
    14.     transforms.ToTensor(),
    15.     transforms.Normalize([0.5, 0.5, 0.5],[0.5, 0.5, 0.5])
    16. ])
    17.  
    18. data_image={
    19.     x:datasets.ImageFolder(root=os.path.join(path,x),
    20.                          transform=transform)
    21.     for x in ["train","test"]
    22. }
    23.  
    24. data_loader_image={
    25.     x:torch.utils.data.DataLoader(dataset=data_image[x],
    26.                                   batch_size=4,
    27.                                   shuffle=True)
    28.     for x in ["train","test"]
    29. }
    30.  
    31. use_gpu=torch.cuda.is_available()
    32. print(use_gpu)
    33.  
    34. classes=data_image["train"].classes #按文件夹名字分类
    35. classes_index=data_image["train"].class_to_idx #文件夹类名所对应的链值
    36. print(classes)
    37. print(classes_index)
    38.  
    39. print("train data set:",len(data_image["train"]))
    40. print("test data set:",len(data_image["test"]))
    41.  
    42. x_train,y_train=next(iter(data_loader_image["train"]))
    43. mean=[0.5, 0.5, 0.5]
    44. std=[0.5, 0.5, 0.5]
    45. img=torchvision.utils.make_grid(x_train)
    46. img=img.numpy().transpose((1,2,0))
    47. img=img*std+mean
    48.  
    49. print([classes[i] for i in y_train])
    50. plt.imshow(img)
    51. plt.show()
    52.  
    53. #选择预训练好的模型vgg16
    54. model=models.vgg16(pretrained=True)
    55. print(model)
    56.  
    57. for parma in model.parameters():
    58.     parma.requires_grad=False   #预训练的网络不进行梯度更新
    59.     
    60. #改变模型的全连接层，从原模型的1000个类到本项目的2个类
    61. model.classifier=torch.nn.Sequential(
    62.     torch.nn.Linear(25088,4096),
    63.     torch.nn.ReLU(),
    64.     torch.nn.Dropout(p=0.5),
    65.     torch.nn.Linear(4096,4096),
    66.     torch.nn.ReLU(),
    67.     torch.nn.Dropout(p=0.5),
    68.     torch.nn.Linear(4096,2)
    69. )
    70.  
    71. for index,parma in enumerate(model.classifier.parameters()):
    72.     if index ==6:
    73.         parma.requires_grad=True
    74.         
    75. if use_gpu:
    76.     model=model.cuda()
    77. print(parma)
    78.  
    79. #定义代价函数和优化器
    80. cost=torch.nn.CrossEntropyLoss()
    81. optimizer=torch.optim.Adam(model.classifier.parameters())
    82.  
    83. print(model)
    84.  
    85. #开始训练模型
    86. n_epochs=1
    87. for epoch in range(n_epochs):
    88.     since=time.time()
    89.     print("Epoch{}/{}".format(epoch,n_epochs))
    90.     print("-"*10)
    91.     for param in ["train","test"]:
    92.         if param == "train":
    93.             model.train=True
    94.         else:
    95.             model.train=False
    96.             
    97.         running_loss=0.0
    98.         running_correct=0
    99.         batch=0
    100.         for data in data_loader_image[param]:
    101.             batch+=1
    102.             x,y=data
    103.             if use_gpu:
    104.                 x,y=Variable(x.cuda()),Variable(y.cuda())
    105.             else:
    106.                 x,y=Variable(x),Variable(y)
    107.             
    108.             optimizer.zero_grad()
    109.             y_pred=model(x)
    110.             _,pred=torch.max(y_pred.data,1)
    111.             
    112.             loss=cost(y_pred,y)
    113.             if param=="train":
    114.                 loss.backward()
    115.                 optimizer.step()
    116.             running_loss+=loss.item() #running_loss+=loss.data[0]
    117.             running_correct+=torch.sum(pred==y.data)
    118.             if batch%10==0 and param=="train":
    119.                 print("Batch{},Train Loss:{:.4f},Train Acc:{:.4f}%".format(
    120.                 batch,running_loss/(4*batch),100*running_correct/(4*batch)))
    121.                 
    122.         epoch_loss=running_loss/len(data_image[param])
    123.         epoch_correct=100*running_correct/len(data_image[param])
    124.         
    125.         print("{}Loss:{:.4f},Correct:{:.4f}%".format(param,epoch_loss,epoch_correct))
    126.     now_time=time.time()-since
    127.     print("Training time is:{:.0f}m {:.0f}s".format(now_time//60,now_time%60))
    128.     
    129. torch.save(model,'model.pth')
    130. #保存模型，备测试使用

    输出结果： 

    False
['cat', 'dog']
{'cat': 0, 'dog': 1}
train data set: 400
test data set: 400
['cat', 'cat', 'dog', 'cat']


    VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)
Parameter containing:
tensor([-0.0110, -0.0124], requires_grad=True)
VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU()
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=2, bias=True)
  )
)
Epoch0/1
----------
Batch10,Train Loss:1.3042,Train Acc:60.0000%
Batch20,Train Loss:1.0106,Train Acc:68.7500%
Batch30,Train Loss:1.1665,Train Acc:74.1667%
Batch40,Train Loss:1.1059,Train Acc:78.1250%
Batch50,Train Loss:0.9046,Train Acc:81.0000%
Batch60,Train Loss:1.4522,Train Acc:79.5833%
Batch70,Train Loss:1.8163,Train Acc:80.7143%
Batch80,Train Loss:1.6358,Train Acc:82.1875%
Batch90,Train Loss:1.5268,Train Acc:82.5000%
Batch100,Train Loss:1.4596,Train Acc:83.2500%
trainLoss:1.4596,Correct:83.2500%
testLoss:0.4573,Correct:92.7500%
Training time is:4m 33s

    文件：dogs-vs-cats-迁移学习vgg16-test-small

    1. import os
    2. import torch
    3. import torchvision
    4. from torchvision import datasets,transforms,models
    5. import numpy as np
    6. import matplotlib.pyplot as plt
    7. from torch.autograd import Variable
    8. import time
    9. model=torch.load('model.pth')
    10. path='data1'
    11.  
    12. transform=transforms.Compose([
    13.     transforms.CenterCrop(224),
    14.     transforms.ToTensor(),
    15.     transforms.Normalize([0.5, 0.5, 0.5],[0.5, 0.5, 0.5])
    16. ])
    17.  
    18. data_test_img=datasets.ImageFolder(
    19.     root="data1/test/",
    20.     transform=transform
    21. )
    22.  
    23. data_loader_test_img=torch.utils.data.DataLoader(
    24.     dataset=data_test_img,
    25.     batch_size=16,
    26.     shuffle=True
    27. )
    28.  
    29. classes=data_test_img.classes
    30.  
    31. image,label=next(iter(data_loader_test_img))
    32. images=Variable(image)
    33. y_pred=model(images)
    34. _,pred=torch.max(y_pred.data,1)
    35. print(pred)
    36.  
    37. img=torchvision.utils.make_grid(image)
    38. img=img.numpy().transpose(1,2,0)
    39. mean=[0.5, 0.5, 0.5]
    40. std=[0.5, 0.5, 0.5]
    41. img=img*std+mean
    42. print("Pred Label:",[classes[i] for i in pred])
    43. plt.imshow(img)
    44. plt.show()

    输出： 

    tensor([1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1])
Pred Label: ['dog', 'cat', 'cat', 'cat', 'cat', 'cat', 'cat', 'cat', 'cat', 'dog', 'dog', 'dog', 'dog', 'dog', 'dog', 'dog']

    200张cat和200张dog的训练效果已经很可观，有GPU条件下，可以采用更多的数据，效果会非常理想！ 

    2022/7/30

  • 相关阅读:
    milvus数据库搜索
    CuratorFrameworkFactory.builder()方法可配置属性
    2023年天津美术学院专升本专业课报名缴费时间及考试安排
    Linux之shell条件测试
    深度学习常用概念
    Java注释
    [Linux] 数据链路层-----以太网帧协议、ARP协议
    03梯度下降
    MySQL 开发规范
    架构与思维：一定需要微服务么？
  • 原文地址：https://blog.csdn.net/llvyeriji/article/details/126078794