Pytorch基础-05-迁移学习-01(自定义VGGNet之猫狗分类)

最新推荐文章于 2023-07-15 09:45:00 发布
最新推荐文章于 2023-07-15 09:45:00 发布
阅读量882 收藏 5
点赞数 1
分类专栏： Pytorch基础 文章标签： Kaggle猫狗分类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Galen_xia/article/details/108797407
版权
  • 什么是迁移学习？

在深度神经网络 算法的应用过程中，如果我们面对的是数据规模较大的问题，那么在搭 建好深度神经网络模型后，我们势必要花费大量的算力和时间去训练模 型和优化参数，最后耗费了这么多资源得到的模型只能解决这一个问 题，性价比非常低。如果我们用这么多资源训练的模型能够解决同一类 问题，那么模型的性价比会提高很多，这就促使使用迁移模型解决同一 类问题的方法出现。因为该方法的出现，我们通过对一个训练好的模型 进行细微调整，就能将其应用到相似的问题中，最后还能取得很好的效 果；另外，对于原始数据较少的问题，我们也能够通过采用迁移模型进 行有效解决，所以，如果能够选取合适的迁移学习方法，则会对解决我 们所面临的问题有很大的帮助。

下面我们以Kaggle网站上的“Dogs vs.Cats”竞赛项目为例，对迁移学习进行学习。此数据集以免费公开。在这个数据集的训练数据集中一共有 25000张猫和狗的图片，其中包含12500张猫的图片和12500张狗的图 片。在测试数据集中有12500张图片，不过其中的猫狗图片是无序混杂 的，而且没有对应的标签。这些数据集将被用于对模型进行训练和对参 数进行优化，以及在最后对模型的泛化能力进行验证。 数据下载链接：https://download.csdn.net/download/Galen_xia/12888565

1 .数据准备
数据集下载完后，我们从猫狗图片中各抽取2000张，共4000张作为验证数据集。文件结构如下：

|-DvC
    |-train
        |- cat
        |- dog
    |-valid
        |- cat
        |- dog

2 .数据预处理、载入和预览

import torch
from torchvision import datasets,transforms
import os
import time
from torch.autograd import Variable

data_dir = 'DvC'
data_transform = {
    x:transforms.Compose([transforms.Resize([64,64]),transforms.ToTensor()]) for x in ['train','valid']
}

image_datasets = {
    x:datasets.ImageFolder(root=os.path.join(data_dir,x),transform = data_transform[x]) for x in ['train','valid']
}

dataloader = {
    x:torch.utils.data.DataLoader(dataset=image_datasets[x],batch_size=16,shuffle=True) for x in ['train','valid']
}

在进行数据的载入时我们使用torch.transforms中的Resize类将原始图 片的大小统一缩放至64×64。在以上代码中对数据的变换和导入都使用 了字典的形式，因为我们需要分别对训练数据集和验证数据集的数据载 入方法进行简单定义，所以使用字典可以简化代码，也方便之后进行相 应的调用和操作。

os.path.join就是来自之前提到的 os包的方法，它的作用是将输入参数中的两个名字拼接成一个完整的文件路径。其他常用的os.path类方法查看下面这个链接：
https://blog.csdn.net/Galen_xia/article/details/108800213

下面获取一个批次的数据并进行数据预览和分析，代码如下：

x_example,y_example = next(iter(dataloader['train']))
print ('x_example个数{}'.format(len(x_example)))
print ('y_example个数{}'.format(len(y_example)))

x_example个数16
y_example个数16

以上代码通过next和iter迭代操作获取一个批次的装载数据。
x_example是Tensor数据类型的变量，因为做了图片大小的缩放变换，所以现在图片的大小全部是64×64了，那么X_example的维度就是（16, 3, 64, 64），16代表在这个批次中有16张图片；3代表色彩通道数，因为原始图片是彩色的，所以使用了R、G、B这三个通道；64代表图片的宽度值和高度值。
y_example也是Tensor数据类型的变量，不过其中的元素全部是0和 1。为什么会出现0和1？这是因为在进行数据装载时已经对dog文件夹和cat文件夹下的内容进行了独热编码（One-Hot Encoding），所以这时的0和1不仅是每张图片的标签，还分别对应猫的图片和狗的图片。我们可以做一个简单的打印输出，来验证这个独热编码的对应关系，代码如下：

index_classes = image_datasets['train'].class_to_idx
print (index_classes)

{‘cat’: 0, ‘dog’: 1}

不过，为了增加之后绘制的图像标签的可识别性，我们还需要通过image_datasets[“train”].classes将原始标签的结果存储在名为example_clasees的变量中。代码如下：

example_classes = image_datasets['train'].classes
print (example_classes)

[‘cat’, ‘dog’]

我们使用Matplotlib对一个批次的图片进行绘制，具体的代码如下：

import matplotlib.pyplot as plt
%matplotlib inline

img = torchvision.utils.make_grid(x_example)
img = img.numpy().transpose([1,2,0])
print ([example_classes[i.item()] for i in y_example])
plt.imshow(img)
plt.show()

[‘dog’, ‘dog’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘dog’, ‘dog’, ‘cat’, ‘cat’, ‘dog’, ‘dog’, ‘cat’, ‘cat’, ‘cat’, ‘dog’]

在这里插入图片描述
3 .模型搭建和参数优化

自定义VGGNet：基于VGG16架构来搭建一个简化版的VGGNet模型，这个简化版模型要求输入的图片大小全部缩放到64×64，而在标准的VGG16架构模型中输入的图片大小应当是224×224的；同时简化版模型删除了VGG16最后的三个卷积层和池化层，也改变了全连接层中的连接参数，这一系列的改变都是为了减少整个模型参与训练的参数数量。简化版模型的搭建代码如下：

class Models(torch.nn.Module):
    def __init__(self):
        super(Models, 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

在搭建好模型后，通过print对搭建的模型进行打印输出来显示模
型中的细节，打印输出的代码如下：

model = Models()
print (model)
Models(
  (Conv): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (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()
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU()
    (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()
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU()
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU()
    (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()
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU()
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU()
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (Classes): Sequential(
    (0): Linear(in_features=8192, out_features=1024, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=1024, out_features=1024, bias=True)
    (4): ReLU()
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=1024, out_features=2, bias=True)
  )
)

然后，定义好模型的损失函数和对参数进行优化的优化函数，代码
如下：

loss_f = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)

epoch_n = 10
time_open = time.time()

for epoch in range(epoch_n):
    print('Epoch {}/{}'.format(epoch + 1, epoch_n))
    print('----' * 10)

    for phase in ['train', 'valid']:
        if phase == 'train':
            print('Training...')
            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
            x, y = Variable(x), Variable(y)
            y_pred = model(x)
            _, pred = torch.max(y_pred.data, 1)
            optimizer.zero_grad()
            loss = loss_f(y_pred, y)

            if phase == 'train':
                loss.backward()
                optimizer.step()

            running_loss += loss.data
            running_corrects += torch.sum(pred == y.data)

            if batch % 500 == 0 and phase == 'train':
                print('Batch {},Train Loss:{},Train ACC:{}'.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:{} ACC:{}'.format(phase, epoch_loss, epoch_acc))

time_end = time.time() - time_open
print(time_end)

在代码中优化函数使用的是Adam，损失函数使用的是交叉熵，训练次数总共是10 次，最后的输出结果如下：

......
Epoch 9/10
----------------------------------------
Training...
Batch 500,Train Loss:0.5421267151832581,Train ACC:72
Batch 1000,Train Loss:0.5455202460289001,Train ACC:72
train Loss:0.5441449284553528 ACC:72
Validing...
valid Loss:0.5180226564407349 ACC:74
Epoch 10/10
----------------------------------------
Training...
Batch 500,Train Loss:0.5260576009750366,Train ACC:73
Batch 1000,Train Loss:0.5251520872116089,Train ACC:73
train Loss:0.5234497785568237 ACC:73
Validing...
valid Loss:0.5083054900169373 ACC:75
15662.592585325241

虽然准确率差强人意，但因为全程使用了计算机的 CPU进行计算，所以整个过程非常耗时，下面我们对原始 代码进行适当调整，将在模型训练的过程中需要计算的参数全部迁移至 GPUs上，这个过程非常简单和方便，只需重新对这部分参数进行类型 转换就可以了，当然，在此之前，我们需要先确认GPUs硬件是否可 用，具体的代码如下：

use_gpu = torch.cuda.is_available()
print (use_gpu)

True

返回的值是True，这说明我们的GPUs已经具备了被使用的全部条件，新的训练代码如下：

use_gpu = torch.cuda.is_available()
if use_gpu:
    model = Models().cuda()
else:model = Models

loss_f = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)

epoch_n = 10
time_open = time.time()

for epoch in range(epoch_n):
    print('Epoch {}/{}'.format(epoch + 1, epoch_n))
    print('----' * 10)

    for phase in ['train', 'valid']:
        if phase == 'train':
            print('Training...')
            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
            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_f(y_pred, y)

            if phase == 'train':
                loss.backward()
                optimizer.step()

            running_loss += loss.data
            running_corrects += torch.sum(pred == y.data)

            if batch % 500 == 0 and phase == 'train':
                print('Batch {},Train Loss:{},Train ACC:{}'.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:{} ACC:{}'.format(phase, epoch_loss, epoch_acc))

time_end = time.time() - time_open
print(time_end)

在以上代码中，model = model.cuda()和
x, y =Variable(x.cuda()),Variable(y.cuda())就是参与迁移至GPUs的具体代码，在进行10次训练后，输出的结果如下：

......
Epoch 9/10
----------------------------------------
Training...
Batch 500,Train Loss:0.5389402508735657,Train ACC:72
Batch 1000,Train Loss:0.5377429127693176,Train ACC:72
train Loss:0.5390774607658386 ACC:72
Validing...
valid Loss:0.5216068029403687 ACC:74
Epoch 10/10
----------------------------------------
Training...
Batch 500,Train Loss:0.5351917743682861,Train ACC:72
Batch 1000,Train Loss:0.5298460721969604,Train ACC:73
train Loss:0.5265329480171204 ACC:73
Validing...
valid Loss:0.498246431350708 ACC:75
1019.3638801574707

与之前的训练相比，耗时大幅下降，明显比使用CPU进行参数计算在效率上高出不少。

下面我把完整代码贴出来：

import torch
from torchvision import datasets,transforms
import os
import time
from torch.autograd import Variable

data_dir = 'DvC'
data_transform = {
    x:transforms.Compose([transforms.Scale([64,64]),transforms.ToTensor()]) for x in ['train','valid']
}

image_datasets = {
    x:datasets.ImageFolder(root=os.path.join(data_dir,x),transform = data_transform[x]) for x in ['train','valid']
}

dataloader = {
    x:torch.utils.data.DataLoader(dataset=image_datasets[x],batch_size=16,shuffle=True) for x in ['train','valid']
}


class Models(torch.nn.Module):
    def __init__(self):
        super(Models, 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

use_gpu = torch.cuda.is_available()
if use_gpu:
    model = Models().cuda()
else:model = Models

loss_f = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)

epoch_n = 10
time_open = time.time()

for epoch in range(epoch_n):
    print('Epoch {}/{}'.format(epoch + 1, epoch_n))
    print('----' * 10)

    for phase in ['train', 'valid']:
        if phase == 'train':
            print('Training...')
            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
            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_f(y_pred, y)

            if phase == 'train':
                loss.backward()
                optimizer.step()

            running_loss += loss.data
            running_corrects += torch.sum(pred == y.data)

            if batch % 500 == 0 and phase == 'train':
                print('Batch {},Train Loss:{},Train ACC:{}'.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:{} ACC:{}'.format(phase, epoch_loss, epoch_acc))

time_end = time.time() - time_open
print(time_end)
骚火棍
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
实战：利用pytorch搭建VGG-16实现从数据获取到模型训练的猫狗分类网络
m0_52186223的博客
01-17 7542
利用pytorch搭建VGG16，代码中包含了注释和对一些函数的理解。同时附有数据集，教学视频等
Pytorch CIFAR-10分类（DenseNet）.ipynb
11-28
Pytorch CIFAR-10分类（DenseNet）
pytorch尝试入门VGG，实现猫狗分类的baseline
BohnLee的博客
01-01 696
照着教程【实战 VGG实现kaggle猫狗图片分类】完整流程 | 提供VGG11，VGG13，VGG16，VGG19 Pytorch 代码写了一下午。做一下学习笔记。 关于报错 第一反应去看评论区，没人提到这个问题，应该是我手残打错了。再看看报错信息，提示两个矩阵不能相乘。按照我浅薄的理解，因为模型的输入需要一个固定的大小，我们应该是在初始化MyDataset的时候就已经把输入图片的矩阵resize成(224, 224)的形状了. 为什么要用Xavier做初始化 为什么要r.
Pytorch：实现图像分类 VGG & ResNet（以猫狗数据集为例）
要相信光
03-17 1万+
文章目录准备数据集模型文件 VGG_hc.py训练 train.ipynb测试文件 Test.pyGitHub地址： 准备数据集 我是用的torchvision.datasets.ImageFolder加载的数据，就把数据集分成如下形式： 猫狗数据集里有25000张train数据，12500张test数据；我从train数据中随机抽取4000张图像作为val数据集。 import torchv...
Pytorch自定义模型实现猫狗分类
AI浩
12-01 6374
摘要 本例采用猫狗大战的部分数据作为数据集，模型是自定义的模型。 训练 1、构建数据集 在data文件夹下面新家train和val文件夹，分别在train和val文件夹下面新家cat和dog文件夹，并将图片放进去。如图： 2、导入库 # 导入库 import torch.nn.functional as F import torch.optim as optim import torch import torch.nn as nn import torch.nn.para.
Pytorch 学习笔记：迁移学习使用VGG16进行kaggle 猫狗分类
不解不惑
05-05 2174
kaggle上猫狗分类网址:https://www.kaggle.com/c/dogs-vs-cats 1.数据部分 分类工作的第一步是准确数据，从kaggle上面下载的dogs-vs-cats数据包含3个文件train.zip，test.zip和sample_submission.csv train.zip里面共25000张图片，猫狗各12500张，名称格式为：XXX.YYYYY.jpg...
人工智能-项目实践-迁移学习-pytorch版-使用resnet50迁移学习实现皮肤病图片的二分类.zip
12-15
pytorch版—使用resnet50迁移学习实现皮肤病图片的二分类 代码目录介绍 args.py 存放训练和测试所用的各种参数。 --mode字段表示运行模式：train or test. --model_path字段是训练模型的保存路径。 其余字段都有...
pytorch-grad-cam-master.zip
05-29
《PyTorch实现Grad-CAM：深度学习中的可视化与图像分类理解》 Grad-CAM（Gradient-weighted Class Activation Mapping）是一种在计算机视觉领域广泛应用的技术，它可以帮助我们理解深度学习模型在进行图像分类时...
利用VGG16对kaggle比赛提供的猫狗图片进行迁移学习-PyTorch版本
03-30
利用VGG16对kaggle比赛提供的猫狗图片进行迁移学习-PyTorch版本 1.已改写为gpu-cpu通用 2.数据集处理参考注释；含后续训练、训练集/验证集accuracy计算，图片测试 3.数据集请参考...
基于pytorch的猫狗分类
05-28
基于pytorch实现简单的猫狗分类。采用了全连接网络；可以用来了解数据加载过程，网络搭建、训练过程
Pytorch离线下载迁移学习模型方法（VGG，RESNET等）
12-21
就拿Resnet18举例 在程序中输入 from __future__ import print_function, division from torchvision import models model_ft = models.resnet18(pretrained=True) 然后运行，就会出现如下内容 再将这个网址复制到浏览器中，就可以直接下载Resnet18模型。下载结束后，将下载的文件放入你建立的python项目中，再运用如下代码就可以调用Resnet18模型。 model_ft = models.resnet18(pretrained=False) pre = torc
VGG，V3，RESNET迁移学习，tensorflow
05-31
VGG，V3，RESNET迁移学习，tensorflow和keras写的程序
PyTorch迁移学习入门——VGG16 图像分类
Breeze
03-31 1万+
前言 迁移学习指的是保存已有问题的解决模型，并将其利用在其他不同但相关问题上。 比如说，用来辨识汽车的知识也可以被用来提升识别卡车的能力。很多情况下迁移学习能够简化我构建机器学习和深度学习模型，降低模型构建的难度，甚至取得不错的结果。 本文将针对一个小的图片数据集，使用PyTorch进行迁移学习演示，包括如何使用预训练模型，并将结果自己搭建的卷积神经网络模型进行性能比较。 预训练模型 预训练模型是...
利用pytorch实现迁移学习之猫狗分类器(dog vs cat)
热门推荐
科研糖
04-23 1万+
迁移学习 迁移学习(Transfer learning) 就是把已学训练好的模型参数迁移到新的模型来帮助新模型训练。考虑到大部分数据或任务是存在相关性的，所以通过迁移学习我们可以将已经学到的模型参数（也可理解为模型学到的知识）通过某种方式来分享给新模型从而加快并优化模型的学习效率不用像大多数网络那样从零学习。 本文使用VGG16模型用于迁移学习，最终得到一个能对猫狗图片进行辨识的CNN（卷积神...
深度学习之PyTorch实战——迁移学习
qw_6918966011的博客
07-15 954
迁移学习（Transfer Learning）是一种机器学习方法，是把一个领域（即源领域）的知识，迁移到另外一个领域（即目标领域），使得目标领域能够取得更好的学习效果。
Pytorch(colab端)——基于VGG模型迁移学习的猫狗大战
zzy128的博客
11-21 936
简介 本次实验为 Kaggle 于2013年举办的猫狗大战比赛，即判断一张输入图像是“猫”还是“狗”。该实验使用在 ImageNet 上预训练 的 VGG 网络进行测试。因为原网络的分类结果是1000类，所以这里进行迁移学习，对原网络进行 fine-tune （即固定前面若干层，作为特征提取器，只重新训练最后两层）。大概步骤为下载比赛的测试集（包含2000张图片），利用fine-tune的VGG模型进行测试，按照比赛规定的格式输出，上传结果评测。 https://god.yanxishe.com/41 下
Pytorch实现迁移学习
qq_40922271的博客
10-28 3042
迁移学习 迁移学习是一种机器学习的方法，指的是一个预训练的模型被重新用在另一个任务中，它专注于存储已有问题的解决模型，并将其利用在其他不同但相关问题上。例如我在A的场景下训练了一个模型，而B、C、D等场景与A类似，那么我们就可以把A的模型使用在这些类似场景上，A中的工作相当于做了预训练了。很多情况下迁移学习能够简化或降低模型构建的难度，节省训练时间、硬件消耗等，甚至还能取得不错的准确度。 Pytorch VGG16迁移学习实战 torchvision 包含流行的数据集、模型架构和用于计算机视觉的常见图像转换
迁移学习-Transfer Learning
wmz545546的博客
08-26 1985
迁移学习两种类型： ConvNet as fixed feature extractor：利用在大数据集(如ImageNet)上预训练过的ConvNet(如AlexNet，VGGNet)，移除最后几层（一般是最后分类器），将剩下的ConvNet作为应用于新数据集的固定不变的特征提取器，输出特征称为CNN codes，如果在预训练网络上是经过ReLUd，那这些codes也要经过ReLUd（im
pytorch-迁移学习实战宝可精灵分类
最新发布
07-05
在PyTorch中，你可以使用已经训练好的卷积神经网络（CNN），如ResNet、VGG或Inception等，作为基础模型来进行迁移学习。对于宝可梦精灵分类，首先你需要： 1. **准备数据集**：收集并整理包含宝可梦图片的数据集，...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值