2024年大数据最新PyTorch ResNet 实现图片分类_return torch(1)，2024中级大数据开发开发面试解答

最新推荐文章于 2024-05-24 20:38:21 发布
最新推荐文章于 2024-05-24 20:38:21 发布
阅读量780 收藏 28
点赞数 26
分类专栏： 程序员 文章标签： 大数据 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84573042/article/details/138823787
版权

img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

torch.nn.AvgPool2d(2),  # 池化

torch.nn.Flatten(),  # 平铺层

# 全连接层
torch.nn.Linear(512, 100)  # 100类

)


### 获取数据

def get_data():
“”“获取数据”“”

# 获取测试集
train = torchvision.datasets.CIFAR100(root="./data", train=True, download=True,
                                   transform=torchvision.transforms.Compose([
                                       torchvision.transforms.ToTensor(),  # 转换成张量
                                       torchvision.transforms.Normalize((0.1307,), (0.3081,))  # 标准化
                                   ]))
train_loader = DataLoader(train, batch_size=batch_size)  # 分割测试集

# 获取测试集
test = torchvision.datasets.CIFAR100(root="./data", train=False, download=True,
                                  transform=torchvision.transforms.Compose([
                                      torchvision.transforms.ToTensor(),  # 转换成张量
                                      torchvision.transforms.Normalize((0.1307,), (0.3081,))  # 标准化
                                  ]))
test_loader = DataLoader(test, batch_size=batch_size)  # 分割训练

# 返回分割好的训练集和测试集
return train_loader, test_loader


### 训练

def train(model, epoch, train_loader):
“”“训练”“”

# 训练模式
model.train()

# 迭代
for step, (x, y) in enumerate(train_loader):
    # 加速
    if use_cuda:
        model = model.cuda()
        x, y = x.cuda(), y.cuda()

    # 梯度清零
    optimizer.zero_grad()

    output = model(x)

    # 计算损失
    loss = F.cross_entropy(output, y)

    # 反向传播
    loss.backward()

    # 更新梯度
    optimizer.step()

    # 打印损失
    if step % 10 == 0:
        print('Epoch: {}, Step {}, Loss: {}'.format(epoch, step, loss))


### 测试

def test(model, test_loader):
“”“测试”“”

# 测试模式
model.eval()

# 存放正确个数
correct = 0

with torch.no_grad():
    for x, y in test_loader:

        # 加速
        if use_cuda:
            model = model.cuda()
            x, y = x.cuda(), y.cuda()

        # 获取结果
        output = model(x)

        # 预测结果
        pred = output.argmax(dim=1, keepdim=True)

        # 计算准确个数
        correct += pred.eq(y.view_as(pred)).sum().item()

# 计算准确率
accuracy = correct / len(test_loader.dataset) * 100

# 输出准确
print("Test Accuracy: {}%".format(accuracy))


## 完整代码


![在这里插入图片描述](https://img-blog.csdnimg.cn/20210701135832659.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjI3NDE2OA==,size_16,color_FFFFFF,t_70#pic_center)


完整代码:

import torch
import torchvision
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchsummary import summary

class BasicBlock(torch.nn.Module):
“”“残差块”“”

def __init__(self, inplanes, planes, stride=1):
    """初始化"""

    super(BasicBlock, self).__init__()

    self.conv1 = torch.nn.Conv2d(in_channels=inplanes, out_channels=planes, kernel_size=(3, 3),
                                 stride=(stride, stride), padding=1)  # 卷积层1
    self.bn1 = torch.nn.BatchNorm2d(planes)  # 标准化层1


    self.conv2 = torch.nn.Conv2d(in_channels=planes, out_channels=planes, kernel_size=(3, 3), padding=1)  # 卷积层2
    self.bn2 = torch.nn.BatchNorm2d(planes)  # 标准化层2

    # 如果步长不为1, 用1*1的卷积实现下采样
    if stride != 1:
        self.downsample = torch.nn.Sequential(
            # 下采样
            torch.nn.Conv2d(in_channels=inplanes, out_channels=planes, kernel_size=(1, 1), stride=(stride, stride)))
    else:
        self.downsample = lambda x: x  # 返回x

def forward(self, input):
    """前向传播"""
    out = self.conv1(input)
    out = self.bn1(out)
    out = F.relu(out)

    out = self.conv2(out)
    out = self.bn2(out)

    identity = self.downsample(input)
    output = torch.add(out, identity)
    output = F.relu(output)

    return output

ResNet_18 = torch.nn.Sequential(
# 初始层
torch.nn.Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1)), # 卷积
torch.nn.BatchNorm2d(64),
torch.nn.ReLU(),
torch.nn.MaxPool2d((2, 2)), # 池化

# 8个block(每个为两层)
BasicBlock(64, 64, stride=1),
BasicBlock(64, 64, stride=1),
BasicBlock(64, 128, stride=2),
BasicBlock(128, 128, stride=1),
BasicBlock(128, 256, stride=2),
BasicBlock(256, 256, stride=1),
BasicBlock(256, 512, stride=2),
BasicBlock(512, 512, stride=1),
torch.nn.AvgPool2d(2),  # 池化

torch.nn.Flatten(),  # 平铺层

# 全连接层
torch.nn.Linear(512, 100)  # 100类

)

定义超参数

batch_size = 1024 # 一次训练的样本数目
learning_rate = 0.0001 # 学习率
iteration_num = 20 # 迭代次数
network = ResNet_18
optimizer = torch.optim.Adam(network.parameters(), lr=learning_rate) # 优化器

GPU 加速

use_cuda = torch.cuda.is_available()

if use_cuda:
network.cuda()
print(“是否使用 GPU 加速:”, use_cuda)
print(summary(network, (3, 32, 32)))

def get_data():
“”“获取数据”“”

# 获取测试集
train = torchvision.datasets.CIFAR100(root="./data", train=True, download=True,
                                   transform=torchvision.transforms.Compose([
                                       torchvision.transforms.ToTensor(),  # 转换成张量
                                       torchvision.transforms.Normalize((0.1307,), (0.3081,))  # 标准化
                                   ]))
train_loader = DataLoader(train, batch_size=batch_size)  # 分割测试集

# 获取测试集
test = torchvision.datasets.CIFAR100(root="./data", train=False, download=True,
                                  transform=torchvision.transforms.Compose([
                                      torchvision.transforms.ToTensor(),  # 转换成张量
                                      torchvision.transforms.Normalize((0.1307,), (0.3081,))  # 标准化
                                  ]))
test_loader = DataLoader(test, batch_size=batch_size)  # 分割训练

# 返回分割好的训练集和测试集
return train_loader, test_loader

def train(model, epoch, train_loader):
“”“训练”“”

# 训练模式
model.train()

# 迭代
for step, (x, y) in enumerate(train_loader):
    # 加速
    if use_cuda:
        model = model.cuda()
        x, y = x.cuda(), y.cuda()

    # 梯度清零
    optimizer.zero_grad()

    output = model(x)

    # 计算损失
    loss = F.cross_entropy(output, y)

    # 反向传播
    loss.backward()

    # 更新梯度
    optimizer.step()

    # 打印损失
    if step % 10 == 0:
        print('Epoch: {}, Step {}, Loss: {}'.format(epoch, step, loss))

def test(model, test_loader):
“”“测试”“”

# 测试模式
model.eval()

# 存放正确个数
correct = 0

with torch.no_grad():
    for x, y in test_loader:

        # 加速
        if use_cuda:
            model = model.cuda()
            x, y = x.cuda(), y.cuda()

        # 获取结果
        output = model(x)

        # 预测结果
        pred = output.argmax(dim=1, keepdim=True)

        # 计算准确个数
        correct += pred.eq(y.view_as(pred)).sum().item()

# 计算准确率
accuracy = correct / len(test_loader.dataset) * 100

# 输出准确
print("Test Accuracy: {}%".format(accuracy))

def main():
# 获取数据
train_loader, test_loader = get_data()

# 迭代
for epoch in range(iteration_num):
    print("\n================ epoch: {} ================".format(epoch))
    train(network, epoch, train_loader)
    test(network, test_loader)

if name == “main”:
main()


输出结果:

是否使用 GPU 加速: True
/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at /pytorch/c10/core/TensorImpl.h:1156.)
return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)

    Layer (type)               Output Shape         Param #

================================================================
Conv2d-1 [-1, 64, 30, 30] 1,792
BatchNorm2d-2 [-1, 64, 30, 30] 128
ReLU-3 [-1, 64, 30, 30] 0
MaxPool2d-4 [-1, 64, 15, 15] 0
Conv2d-5 [-1, 64, 15, 15] 36,928
BatchNorm2d-6 [-1, 64, 15, 15] 128
Conv2d-7 [-1, 64, 15, 15] 36,928
BatchNorm2d-8 [-1, 64, 15, 15] 128
BasicBlock-9 [-1, 64, 15, 15] 0
Conv2d-10 [-1, 64, 15, 15] 36,928
BatchNorm2d-11 [-1, 64, 15, 15] 128
Conv2d-12 [-1, 64, 15, 15] 36,928
BatchNorm2d-13 [-1, 64, 15, 15] 128
BasicBlock-14 [-1, 64, 15, 15] 0
Conv2d-15 [-1, 128, 8, 8] 73,856
BatchNorm2d-16 [-1, 128, 8, 8] 256
Conv2d-17 [-1, 128, 8, 8] 147,584
BatchNorm2d-18 [-1, 128, 8, 8] 256
Conv2d-19 [-1, 128, 8, 8] 8,320
BasicBlock-20 [-1, 128, 8, 8] 0
Conv2d-21 [-1, 128, 8, 8] 147,584
BatchNorm2d-22 [-1, 128, 8, 8] 256
Conv2d-23 [-1, 128, 8, 8] 147,584
BatchNorm2d-24 [-1, 128, 8, 8] 256
BasicBlock-25 [-1, 128, 8, 8] 0
Conv2d-26 [-1, 256, 4, 4] 295,168
BatchNorm2d-27 [-1, 256, 4, 4] 512
Conv2d-28 [-1, 256, 4, 4] 590,080
BatchNorm2d-29 [-1, 256, 4, 4] 512
Conv2d-30 [-1, 256, 4, 4] 33,024
BasicBlock-31 [-1, 256, 4, 4] 0
Conv2d-32 [-1, 256, 4, 4] 590,080
BatchNorm2d-33 [-1, 256, 4, 4] 512
Conv2d-34 [-1, 256, 4, 4] 590,080
BatchNorm2d-35 [-1, 256, 4, 4] 512
BasicBlock-36 [-1, 256, 4, 4] 0
Conv2d-37 [-1, 512, 2, 2] 1,180,160
BatchNorm2d-38 [-1, 512, 2, 2] 1,024
Conv2d-39 [-1, 512, 2, 2] 2,359,808
BatchNorm2d-40 [-1, 512, 2, 2] 1,024
Conv2d-41 [-1, 512, 2, 2] 131,584
BasicBlock-42 [-1, 512, 2, 2] 0
Conv2d-43 [-1, 512, 2, 2] 2,359,808
BatchNorm2d-44 [-1, 512, 2, 2] 1,024
Conv2d-45 [-1, 512, 2, 2] 2,359,808
BatchNorm2d-46 [-1, 512, 2, 2] 1,024
BasicBlock-47 [-1, 512, 2, 2] 0
AvgPool2d-48 [-1, 512, 1, 1] 0
Flatten-49 [-1, 512] 0
Linear-50 [-1, 100] 51,300

Total params: 11,223,140
Trainable params: 11,223,140
Non-trainable params: 0

Input size (MB): 0.01
Forward/backward pass size (MB): 3.74
Params size (MB): 42.81
Estimated Total Size (MB): 46.56

None
Downloading https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz to ./data/cifar-100-python.tar.gz
169001984/? [00:07<00:00, 23425059.51it/s]

Extracting ./data/cifar-100-python.tar.gz to ./data
Files already downloaded and verified

================ epoch: 0 ================
Epoch: 0, Step 0, Loss: 4.73184871673584
Epoch: 0, Step 10, Loss: 4.262868881225586
Epoch: 0, Step 20, Loss: 3.946244239807129
Epoch: 0, Step 30, Loss: 3.7039854526519775
Epoch: 0, Step 40, Loss: 3.5138051509857178
Test Accuracy: 17.16%

================ epoch: 1 ================
Epoch: 1, Step 0, Loss: 3.3631155490875244
Epoch: 1, Step 10, Loss: 3.183103561401367
Epoch: 1, Step 20, Loss: 3.0515971183776855
Epoch: 1, Step 30, Loss: 2.913054943084717
Epoch: 1, Step 40, Loss: 2.8454060554504395
Test Accuracy: 26.76%

================ epoch: 2 ================
Epoch: 2, Step 0, Loss: 2.764857053756714
Epoch: 2, Step 10, Loss: 2.5304853916168213
Epoch: 2, Step 20, Loss: 2.3920257091522217
Epoch: 2, Step 30, Loss: 2.294809341430664
Epoch: 2, Step 40, Loss: 2.2125251293182373
Test Accuracy: 30.599999999999998%

================ epoch: 3 ================
Epoch: 3, Step 0, Loss: 2.15826678276062
Epoch: 3, Step 10, Loss: 1.9255717992782593
Epoch: 3, Step 20, Loss: 1.7490493059158325
Epoch: 3, Step 30, Loss: 1.6468313932418823
Epoch: 3, Step 40, Loss: 1.5404233932495117
Test Accuracy: 29.659999999999997%

================ epoch: 4 ================
Epoch: 4, Step 0, Loss: 1.4881120920181274
Epoch: 4, Step 10, Loss: 1.3130300045013428
Epoch: 4, Step 20, Loss: 1.119794249534607
Epoch: 4, Step 30, Loss: 1.07780921459198
Epoch: 4, Step 40, Loss: 0.9983140826225281
Test Accuracy: 27.04%

================ epoch: 5 ================
Epoch: 5, Step 0, Loss: 1.0429306030273438
Epoch: 5, Step 10, Loss: 0.9188315868377686
Epoch: 5, Step 20, Loss: 0.7664494514465332
Epoch: 5, Step 30, Loss: 0.8060574531555176
Epoch: 5, Step 40, Loss: 0.7700539231300354
Test Accuracy: 25.629999999999995%

================ epoch: 6 ================
Epoch: 6, Step 0, Loss: 0.8620188236236572
Epoch: 6, Step 10, Loss: 0.8017312288284302
Epoch: 6, Step 20, Loss: 0.6923062801361084

img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

h: 6, Step 0, Loss: 0.8620188236236572
Epoch: 6, Step 10, Loss: 0.8017312288284302
Epoch: 6, Step 20, Loss: 0.6923062801361084

[外链图片转存中…(img-LRk2nU14-1715613139707)]
[外链图片转存中…(img-93zR4suu-1715613139707)]
[外链图片转存中…(img-uVYLuvqJ-1715613139707)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

2401_84573042
关注
  • 26
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图像分类超详细的pytorch实现
LJC的博客
08-21 9030
1、定义各种参数 下面举例三种常见的参数 batch_size = 8 learning_rate = 1e-4 epoches = 100 2、利用官方的数据加载 指定训练、验证以及测试的文件夹的路径，其下一个目录的各个文件夹视为各个类别。下一个目录为了方便简单可以直接命名为0、1、2等。到时就可以对应0、1、2等类别。也可以按本身类别作为文件名，可能需要调试注意一下对应的类别0、1、2等。如： 0、1、2文件夹里放置对应类别的图像即可。主要调用的是torchvision.dataset
2024年大数据最全PyTorch ResNet 实现图片分类_return torch(3)，2024年最新大数据开发自学
2401_84185106的博客
05-09 327
batch_size = 1024 # 一次训练的样本数目learning_rate = 0.0001 # 学习率iteration_num = 20 # 迭代次数optimizer = torch.optim.Adam(network.parameters(), lr=learning_rate) # 优化器batch_size = 1024 # 一次训练的样本数目learning_rate = 0.0001 # 学习率。
Pytorch实战[实现对图像分类]
森宝的博客
05-25 3660
实现Pytorch完成类别识别 Object 基本掌握使用pytorch框架进行神经网络训练任务 使用Pycharm,Google Colab完成代码编写 本次实验只是来熟悉一下训练的流程，因此模型比较简单 1. 编写代码 数据集介绍 ​ CIFAR-10数据集包含6000张大小是(32,32)的图片数据,有10个类别。训练集有5000张，测试集1000张。 数据读取以及数据加载 # 创建一个transform transform = torchvision.transforms.Compose([
Pytorch训练分类器进行图像分类
最新发布
2301_76259531的博客
05-24 836
​​​return x​​torch.nntorch.nn是Pytorch的核心模块，专门用于构建和训练神经网络。它提供了许多预定义的神经网络层、激活函数、损失函数和其他相关工具。神经网络层线性层：如，实现全连接层（也称为密集层）。卷积层：如，实现二维卷积层，常用于图像处理任务。循环层：如和，用于处理序列数据。激活函数常见的激活函数如等。损失函数提供了多种损失函数，如等，用于评估模型的性能。容器：按顺序将多个层组合在一起，形成一个神经网络。和：用于存储和管理层的列表和字典。
度学习pytorch实战六：ResNet50网络图像分类篇自建花数据集图像分类（5类）超详细代码
qq_55433305的博客
06-12 1万+
1.数据集简介、训练集与测试集划分 2.模型相关知识 3.model.py——定义ResNet50网络模型 4.train.py——加载数据集并训练，训练集计算损失值loss，测试集计算accuracy，保存训练好的网络参数 5.predict.py——利用训练好的网络参数后，用自己找的图像进行分类测试
如何使用 PyTorch 进行图像分类
qq_39845931的博客
09-22 4548
如何使用 PyTorch 进行图像分类 跑代码 戳这里????: 如何使用 PyTorch 进行图像分类 有小伙伴问了：人工智能和深度学习到底有什么区别？ 深度学习一般是用 Python 写的，人工智能一般是用 PPT写的。 小伙伴：那我还是学深度学习好了，但是那些图片文件怎么就可以送到模型里面去呢？我需要打印出来吗？ 你不需要打印出来！ 数字图像由像素组成，像素由一系列代码表示的原色组合而成（例：红绿蓝三通道的彩色图像，单通道的黑白图像），通道是与彩色图像大小相同的灰度图像 黑白图像(单通道)和彩
Pytorch-Triplet_loss:用Pytorch实现三重损失
05-16
**Pytorch-Triplet_loss: 用Pytorch实现三重损失** 在深度学习领域，损失函数是模型训练的核心部分，它衡量模型预测结果与实际标签之间的差距。其中，三重损失（Triplet Loss）是一种在计算机视觉任务，尤其是人脸...
pytorch部署torchscript篇1
08-03
【PyTorch部署TorchScript篇1】 在PyTorch框架中，TorchScript是一种用于序列化和优化模型的方法，使得模型能够在不同的环境和语言中使用，包括C++。本篇将详细介绍如何在Windows平台上利用C++ API部署一个基于...
pytorch SENet实现案例
12-17
**PyTorch中的SENet实现** SENet（Squeeze-and-Excitation Networks）是由Huang等人在2017年提出的，它引入了一种新的结构——SE Block（Squeeze-and-Excitation Block），用于增强卷积神经网络（CNN）的性能，特别...
pytorch 准备、训练和测试自己的图片数据的方法
09-18
接下来，为了进行CNN（卷积神经网络）分类，我们需要将这些图片数据转换为PyTorch能处理的格式。这通常涉及到创建一个自定义的`Dataset`类，继承自`torch.utils.data.Dataset`，并重写`__getitem__`和`__len__`方法...
pytorch 搭建 LeNet 网络对 CIFAR-10 图片分类
10-24
通过这个流程，我们已经在PyTorch中成功实现了LeNet模型并应用到CIFAR-10图像分类任务上。这个简单的模型虽然在现代深度学习标准下显得较为基础，但它展示了卷积神经网络在处理图像识别问题上的基本原理，为后续的...
利用pytorch实现图像分类
TF666666的博客
01-21 6284
@[TOC]利用pytorch实现图像分类 其中包含的resnextefficientnet等图像分类网络 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 实现功能 基础功能利用pytorch实现图像分类 包含带有warmup的cosine学习率调整 warmup的step学习率优调整 添加label smooth的pytorch实现（标签平滑） 可视化特征层 运行环境 py
pytorch图像分类篇：4.VGG详解，感受野（自顶向下/自底向上）计算及网络搭建
fun1024
07-10 9962
VGG网络，感受野
【小练习】基于pytorch的简单CNN图像分类网络
tangbiubiu的博客
01-11 1496
一个简单的CNN网络，做个小练习。 不管是复杂的网络还是简单的网络，代码的结构都大同小异。从小的网络开始，加油！ 训练效果如下： 代码如下： import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from torchvision import datasets, transforms # ---------构建网络---------- # input: datase.
【PyTorch】PyTorch搭建神经网络处理图片分类的完整代码
Pam的博客
06-18 1万+
一个完整的处理图片分类的代码，包括以下几部分：导入需要的库，数据预处理，搭建神经网络模型，训练及测试，输出损失和正确率。 导入库 import torch import torchvision from torch.autograd import Variable from torchvision import datasets, transforms import os # os包集成了一些对文件路径和目录进行操作的类 import matplotlib.pyplot as pl
PyTorch图像分类
Asia-Lee
01-15 1万+
目录 一、torch和torchvision 1、torchvision.datasets 2、torchvision.models 3、torchvision.transforms 4、torchvision.utils 二、MNIST手写数字识别 1、获取MNIST训练集和测试集 2、数据装载 3、数据预览 4、构建卷积神经网络模型 5、对模型进行训练和参数优化 6、对...
Pytorch建立卷积神经网络进行图片分类
seven08290的专栏
06-25 2130
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True): kernel_size = _pair(kernel_size) stride = _pair(stride) pad...
基于pytorch和Fashion Mnist数据集建立简单的CNN网络来实现图片分类
hong615771420的博客
09-28 5652
写这篇文章，我主要是想要介绍一种流行的深度学习框架---Pytorch，并且完成一个简单的CNN网络例子来加深对它的认识，我们还使用到了Fashion Mnist数据集，完成这个DL领域的“Hello World”。 相比于TF，Pytorch有很多优点。这些可以自行Google来了解。总之，Pytorch更加符合python的特性，也更加好理解。 数据集 在这个项目中，我将使用Fashio...
【pytorch速成】Pytorch图像分类从模型自定义到测试
热门推荐
hacker_long的专栏
10-09 1万+
文章首发于微信公众号《与有三学AI》 【pytorch速成】Pytorch图像分类从模型自定义到测试 前面已跟大家介绍了Caffe和TensorFlow，链接如下。 【caffe速成】caffe图像分类从模型自定义到测试 【tensorflow速成】Tensorflow图像分类从模型自定义到测试 今天说说Pytorch。 作者&编辑|言有三 01 什么是 Py...
请帮我写出基于pytorch resnet实现图片2分类的代码
05-31
好的，以下是一个简单的基于PyTorch实现图片2分类的代码，使用的是ResNet18模型： ```python import torch import torch.nn as nn import torchvision.models as models # 定义ResNet18模型 class ResNet18(nn....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值