PyTorch搭建预训练AlexNet、DenseNet、ResNet、VGG实现猫狗图片分类

已于 2023-02-12 11:01:07 修改
阅读量5.1k 收藏 100
点赞数 13
分类专栏： PyTorch DL 文章标签： pytorch resnet vgg densenet 分类
于 2022-10-22 11:29:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyril_ki/article/details/127454254
版权
PyTorch 同时被 2 个专栏收录
39 篇文章 206 订阅
订阅专栏
DL
36 篇文章 147 订阅
订阅专栏
本文介绍了如何使用预训练的深度学习模型AlexNet、DenseNet、ResNet和VGG进行猫狗图片分类。通过PyTorch库加载模型，调整最后一层以适应二分类任务，并进行了训练和验证。实验在不同硬件环境下运行，如3050Ti和Tesla T4 GPU。最终，每个模型的输出层被修改以输出两个类别，分别对应猫和狗。
摘要由CSDN通过智能技术生成

目录

前言

在之前的文章中，利用一个简单的三层CNN猫狗图片分类，正确率不高，详见：
CNN简单实战：PyTorch搭建CNN对猫狗图片进行分类

本文利用torchvision中预训练的模型来实现猫狗图片分类。其中AlexNet和ResNet均在笔记本电脑上运行，GPU为3050Ti；DenseNet和VGG在colab上运行，显卡为Tesla T4：
在这里插入图片描述

AlexNet

导入AlexNet：

from torchvision.models import alexnet
model = alexnet(pretrained=True)

输出模型：

AlexNet(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))
    (1): ReLU(inplace=True)
    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU(inplace=True)
    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (7): ReLU(inplace=True)
    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): ReLU(inplace=True)
    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))
  (classifier): Sequential(
    (0): Dropout(p=0.5, inplace=False)
    (1): Linear(in_features=9216, out_features=4096, bias=True)
    (2): ReLU(inplace=True)
    (3): Dropout(p=0.5, inplace=False)
    (4): Linear(in_features=4096, out_features=4096, bias=True)
    (5): ReLU(inplace=True)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

最后分类结果输出是1000，改成二分类：

model.classifier._modules['6'] = nn.Sequential(nn.Linear(4096, 2))

epochs=30, lr=0.0001, batch_size=50：

def train(model, Dtr, Val, path, lr):
    model = model.to(device)
    print('train...')
    epoch_num = 30
    best_model = None
    min_epochs = 5
    min_val_loss = 5
    optimizer = optim.Adam(model.parameters(), lr=lr)
    criterion = nn.CrossEntropyLoss().to(device)
    # criterion = nn.BCELoss().to(device)
    for epoch in tqdm(range(epoch_num), ascii=True):
        train_loss = []
        for batch_idx, (data, target) in enumerate(Dtr, 0):
            data, target = Variable(data).to(device), Variable(target.long()).to(device)
            # target = target.view(target.shape[0], -1)
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
            train_loss.append(loss.cpu().item())
        # validation
        val_loss = get_val_loss(model, Val)
        model.train()
        if epoch + 1 > min_epochs and val_loss < min_val_loss:
            min_val_loss = val_loss
            best_model = copy.deepcopy(model)

        tqdm.write('Epoch {:03d} train_loss {:.5f} val_loss {:.5f}'.format(epoch, np.mean(train_loss), val_loss))

    torch.save(best_model.state_dict(), path)

    return best_model

测试：

def test(model, Dte, path):
    model.load_state_dict(torch.load(path), False)
    model = model.to(device)
    model.eval()
    total = 0
    current = 0
    for (data, target) in Dte:
        data, target = data.to(device), target.to(device)
        outputs = model(data)
        predicted = torch.max(outputs.data, 1)[1].data
        total += target.size(0)
        current += (predicted == target).sum()

    print('Accuracy:%d%%' % (100 * current / total))

在这里插入图片描述

DensNet

from torchvision.models import densenet121
model = densenet121(pretrained=True)

输出模型：

DenseNet(
  (features): Sequential(
    (conv0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (norm0): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu0): ReLU(inplace=True)
    (pool0): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
    (denseblock1): _DenseBlock(
      (denselayer1): _DenseLayer(
        (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu1): ReLU(inplace=True)
        (conv1): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu2): ReLU(inplace=True)
        (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      )
      (denselayer2): _DenseLayer(
        (norm1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu1): ReLU(inplace=True)
        (conv1): Conv2d(96, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu2): ReLU(inplace=True)
        (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      )
      (denselayer3): _DenseLayer(
        (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu1): ReLU(inplace=True)
        (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu2): ReLU(inplace=True)
        (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      )
      ...
  (classifier): Linear(in_features=1024, out_features=1000, bias=True)
)

修改模型如下：

model.classifier = nn.Linear(1024, 2)

epochs=30, lr=0.0001, batch_size=32：
在这里插入图片描述

ResNet

导入模型：

from torchvision.models import resnet18
model = resnet18(pretrained=True)

输出模型：

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=1000, bias=True)
)

模型修改：

model.fc = nn.Sequential(nn.Linear(512, 2))

epochs=30, lr=0.0001, batch_size=50：
在这里插入图片描述

VGG

导入模型：

from torchvision.models import vgg16
model = vgg16(pretrained=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(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)
  )
)
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): Sequential(
      (0): Linear(in_features=4096, out_features=2, bias=True)
    )
  )
)

模型修改：

model.classifier._modules['6'] = nn.Sequential(nn.Linear(4096, 2))

epochs=30, lr=0.0001, batch_size=32：
在这里插入图片描述

Cyril_KI
关注
  • 13
    点赞
  • 踩
  • 100
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
【pytorch】预训练模型的使用
一起来学深度学习鸭的博客
10-28 1049
pytorch自带有一些高级的复杂模型，我们可以通过调用，例如就调用了densenet169的预训练模型。见获取详细信息。
Pytorch 图像分类（AlexNet，VGGNet，Inception，ResNet，DenseNet，MobileNet）
平凡简单的执着
04-16 4775
4.定义网络（AlexNet） [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ggMczuOs-1587022068848)(attachment:image.png)] AlexNet 结构： 输入层：图像大小为 227×227×3，其中 3 表示输入图像的 channel 数（R，G，B）为 3。 卷积层：filter 大小 11×11，filter 个数 9...
猫狗分类自写.zip
12-17
初学神经网络，网上下载了好多猫狗分类的代码都是各种问题，最大的就是版本不兼容，代码有问题。这里我放一个已经调试好的，并且给出tensorflow版本和keras与python的版本，后来的小伙伴就可以不用踩坑了、 里面内置了一个小小的测试库，猫狗分类全库太大，只取了十几张。需要的可以去官网下载。 tensorflow==2.2 keras==2.4.2 Python==3.8 cuda==10.1 显卡：GTX1650 Win10 Pytharm社区版
预训练AlexNet模型参数
09-13
深度学习AlexNet模型预训练参数，.npy格式，深度学习入门可尝试练习
PyTorch从入门到实战一次学会
12-29
【超实用课程内容】 本课程从pytorch安装开始讲起，从基本计算结构到深度学习各大神经网络，全程案例代码实战，一步步带大家入门如何使用深度学习框架pytorch，玩转pytorch模型训练等所有知识点。最后通过 kaggle 项目：猫狗分类，实战pytorch深度学习工具。【课程如何观看？】 PC端：https://edu.csdn.net/course/detail/27286 移动端：CSDN 学院APP（注意不是CSDN APP哦）本课程为录播课，课程永久观看，大家可以抓紧时间学习后一起讨论哦~【学员专享增值服务】 源码开放 课件、课程案例代码完全开放给你，你可以根据所学知识，自行修改、优化下载方式：电脑登录https://edu.csdn.net/course/detail/27286，点击右下方课程资料、代码、课件等打包下载
经典卷积模型回顾27—利用模型量化对DenseNet201进行处理，并实现图像分类（Pytorch）
爱分享数据的一个人的博客
03-17 628
在图像的数字化处理中，为了减少数据存储量和传输带宽等因素，通常会对图像进行量化处理，即将连续的变化量化成离散的值。因此，在需要还原图像的精度和质量时，需要进行反量化处理，将离散化的值重新转换为连续的数值，恢复图像原有的信息和细节。4. 针对量化后的模型进行微调：由于量化会导致精度损失，需要对量化后的模型进行微调，以尽可能地恢复精度。3. 量化模型激活值：将模型输入和中间层的输出进行量化，同样可以采用线性量化、对数量化等方法。2. 量化模型参数：将模型中的参数进行量化，常见的量化方法有线性量化、对数量化等。
Pytorch采用AlexNet实现猫狗数据集分类（训练与预测）
DJ_Novitskiy的博客
09-10 5766
Pytorch采用AlexNet实现猫狗数据集分类（训练与预测）介绍AlexNet网络模型猫狗数据集AlexNet网络训练训练全代码预测预测图片 介绍 AlexNet模型是CNN网络中经典的网络模型，适合初学者学习，本文对AlexNet结构参数初步说明，详细可以下载论文。通过AlexNet对Kaggle的猫狗数据集进行训练和预测，相关资料为搜集总结。 AlexNet网络模型 如图是2012年AlexNet网络模型结构，由于之前GPU内存小，当时网络是采用了两块GPU，现在训练是不需要的，AlexNet的
pytorch-使用AlexNet完成模型的训练，微调
AI新手程序员
04-20 4486
1. AlexNet的网络结构 AlexNet总共包含8层变换，分别为5层卷积层、2个全连接层和一个全连接输出层 第一层卷积窗口的形状为11*11 第二层卷积窗口的形状缩减为5*5 第三层到第五层卷积窗口均为3*3 第六层全连接层输入为25655，输出为4096，激活函数采用了ReLu 第七层全连接层输入为4096，输出为4096，激活函数采用了ReLu 由于原模型是使用imagenet数据集...
图像分类篇——使用pytorch搭建AlexNet
weixin_43872060的博客
05-11 664
目录1. AlexNet网络详解1.1 AlexNet网络概述1.2 Dropout1.3 AlexNet网络结构和详细参数2. Pytorch搭建2.1 model.py2.2 train.py2.3 predict.py 本文为学习记录和备忘录，对代码进行了详细注释，以供学习。 内容来源： ★github：https://github.com/WZMIAOMIAO/deep-learning-for-image-processing ★b站：https://space.bilibili.com/1816
深度学习作业-基于resnet50和vgg16网络pytorch框架实现猫狗分类完整源码+代码注释+实验报告.zip
12-14
深度学习作业_基于resnet50和vgg16网络pytorch框架实现猫狗分类完整源码+代码注释+实验报告.zip 猫狗分类，使用Kaggle猫狗分类的原始数据集，实现模型最终的准确率达到90%及以上。本实验的目的： 为了进一步掌握...
基于resnet50和vgg16网络pytorch框架实现猫狗分类-源码
10-11
在本项目中，我们将深入探讨如何使用深度学习的两种著名模型——ResNet50和VGG16，结合PyTorch框架实现一个猫狗分类器。PyTorch是一款流行的开源机器学习库，它提供了灵活的架构，使得研究人员和开发者能够轻松地...
使用AlexNet训练自己的分类数据集，使用VGG结合迁移学习训练自己的分类数据集
乌鸦向北的博客
06-15 1828
迁移学习：1.从官方加载预训练模型进行迁移学习；2自己对一个数据集训练好一个模型后，迁移到另一个数据集上进行学习
基于Alexnet网络实现猫狗数据集分类（Keras框架）
ZHW-鲜橙大AI课题组的博客
06-08 3894
程敬，女，西安工程大学电子信息学院，2022级研究生研究方向：电子信息电子邮件：1105719037@qq.com陈梦丹，女，西安工程大学电子信息学院，2022级硕士研究生，张宏伟人工智能课题组研究方向：机器视觉与人工智能电子邮件：1169738496@qq.comLeNet于1998年提出的，是最早的神经网络之一，用于解决手写识别的问题。传承了LeNet ，AlexNet是于2012年提出的一个深度学习卷积神经网络模型。
TorchVision中通过AlexNet网络进行图像分类
网络资源是无限的
11-27 2623
TorchVision中给出了AlexNet的pretrained模型，模型存放位置为https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth ，可通过models.alexnet函数下载，此函数实现在torchvision/models/alexnet.py中，下载后在Ubuntu上存放在~/.cache/torch/hub/checkpoints目录下，在Windows上存放在C:\Users\spring\.cache\tor...
【PyTorch实战演练】基于AlexNet的预训练模型介绍
最新发布
m0_49963403的博客
01-08 2190
基于PyTorch框架的AlexNet预训练实例介绍，附带完整代码。
【图像分类】猫狗分类实战—基于pytorch框架的迁移学习(ResNet50模型实现分类实战）
weixin_45736855的博客
03-09 5997
ResNet50分类实战，猫狗分类实战，图像分类、迁移学习
pytorch预训练模型加载与使用(以AlexNet为例)
gy的博客
08-17 9123
目录1. 概况2. 代码讲解2.1 加载必要的包2.2 设置GPU和transform2.3 数据预处理2.4 引入模型2.5 训练模型2.6 测试模型2.7 保存模型3. 完整代码 本文主要是提供过程，不要在意结果。 1. 概况 pytorch 中有许多已经训练好的模型提供给我们使用，一下以AlexNet为例说明pytorch中的模型怎么用。 如下： import torchvision.models as models # pretrained=True：加载网络结构和预训练参数 resnet18
PyTorch——应用一个已训练好的图片分类网络——AlexNet
lqm1094583745的博客
12-23 1133
ImageNet数据集是由一个Stanford大学维护的包含1400多万幅图像的非常大的数据集，所有的图像都用来自WordNet数据集的名词层次结构标记，而WordNet数据集又是一个大型的英语词汇数据库。
在matlab下使用预训练模型Alex Net进行迁移学习的实验与分析
weixin_44487892的博客
03-05 2159
在matlab下使用预训练模型Alex Net进行迁移学习的实验与分析 摘要： 针对预训练模型对于个性化图片分类准确度很低，应用了迁移学习的方法，在训练集照片达到30张时，在测试集上就能达到80以上的正确率。 一：研究背景 深度学习(DL, Deep Learning)是机器...
使用Pytorch训练猫狗分类
03-04
好的，我来讲一下如何使用PyTorch进行猫狗分类。 首先，我们需要准备数据集。可以从Kaggle上下载一个包含猫和狗的图片的数据集，然后将其分成训练集和验证集。 然后，我们需要定义一个PyTorch数据集类，用于加载和预处理图像数据。这个类需要实现__len__和__getitem__方法，其中__len__返回数据集的大小，__getitem__返回指定索引的数据样本。 接下来，我们需要定义一个PyTorch模型类，用于构建我们的猫狗分类模型。可以使用预训练的模型，如ResNet或VGG，作为我们的基础模型，并添加自定义头部来适应我们的数据集。 然后，我们需要定义一个PyTorch训练循环，用于训练我们的模型。这个循环包括数据加载、前向传递、损失计算、反向传播和参数更新等步骤。 最后，我们需要定义一个PyTorch验证循环，用于测试我们的模型的性能。这个循环包括数据加载、前向传递和结果输出等步骤。 以下是一个示例代码，展示了如何使用PyTorch进行猫狗分类： ``` import torch import torchvision import torchvision.transforms as transforms import torch.nn as nn import torch.optim as optim # 定义数据集类 class CatDogDataset(torch.utils.data.Dataset): def __init__(self, data_dir, transform=None): self.data = [] self.targets = [] self.transform = transform for img_file in os.listdir(data_dir): img_path = os.path.join(data_dir, img_file) target = 0 if img_file.startswith('cat') else 1 self.data.append(img_path) self.targets.append(target) def __len__(self): return len(self.data) def __getitem__(self, idx): img_path = self.data[idx] target = self.targets[idx] img = Image.open(img_path).convert('RGB') if self.transform: img = self.transform(img) return img, target # 定义模型类 class CatDogModel(nn.Module): def __init__(self, base_model): super().__init__() self.base_model = base_model self.head = nn.Sequential( nn.Linear(1000, 256), nn.ReLU(), nn.Linear(256, 2) ) def forward(self, x): x = self.base_model(x) x = self.head(x) return x # 定义训练循环 def train(model, train_loader, criterion, optimizer): model.train() train_loss = 0 train_acc = 0 for inputs, targets in train_loader: inputs, targets = inputs.to(device), targets.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) loss.backward() optimizer.step() train_loss += loss.item() * inputs.size(0) train_acc += (outputs.argmax(dim=1) == targets).sum().item() train_loss /=
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cyril_KI

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值