ResNet101识别CIFAR10数据集(Pytorch实战)

最新推荐文章于 2023-07-23 22:31:11 发布
最新推荐文章于 2023-07-23 22:31:11 发布
阅读量700 收藏 3
点赞数 2
分类专栏： # 图像分类 深度学习 文章标签： pytorch 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42888638/article/details/122022423
版权

文章目录

1.导库

import os
import time

import numpy as np
import pandas as pd

import torch
import torch.nn as nn
import torch.nn.functional as F

from torch.utils.data import Dataset
from torch.utils.data import DataLoader

from torchvision import datasets
from torchvision import transforms

import matplotlib.pyplot as plt
from PIL import Image


DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")

2.获取数据集


batch_size = 64
train_dataset = datasets.CIFAR10(root='data', 
                                 train=True, 
                                 transform=transforms.ToTensor(),
                                 download=True)

test_dataset = datasets.CIFAR10(root='data', 
                                train=False, 
                                transform=transforms.ToTensor())


train_loader = DataLoader(dataset=train_dataset, 
                          batch_size=batch_size, 
                          shuffle=True)

test_loader = DataLoader(dataset=test_dataset, 
                         batch_size=batch_size, 
                         shuffle=False)

3.创建ResNet101模型

def conv3x3(in_planes, out_planes, stride=1):
    """3x3 convolution with padding"""
    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
                     padding=1, bias=False)


class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
                               padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * 4)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        residual = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

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

        out = self.conv3(out)
        out = self.bn3(out)

        if self.downsample is not None:
            residual = self.downsample(x)

        out += residual
        out = self.relu(out)

        return out




class ResNet(nn.Module):

    def __init__(self, block, layers, num_classes, grayscale):
        self.inplanes = 64
        if grayscale:
            in_dim = 1
        else:
            in_dim = 3
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(in_dim, 64, kernel_size=7, stride=2, padding=3,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
        self.avgpool = nn.AvgPool2d(7, stride=1)
        self.fc = nn.Linear(512 * block.expansion, num_classes)



    def _make_layer(self, block, planes, blocks, stride=1):
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * block.expansion),
            )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        # because MNIST is already 1x1 here:
        # disable avg pooling
        #x = self.avgpool(x)
        
        x = x.view(x.size(0), -1)
        logits = self.fc(x)
        probas = F.softmax(logits, dim=1)
        return logits, probas



def resnet101(num_classes):
    """Constructs a ResNet-34 model."""
    model = ResNet(block=Bottleneck, 
                   layers=[3, 4, 23, 3],
                   num_classes=num_classes,
                   grayscale=False)
    return model

4.开启训练

NUM_EPOCHS = 16

model = resnet101(num_classes=10)

model = model.to(DEVICE)

#原先这里选用SGD训练，但是效果很差，换成Adam优化就好了
optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)


valid_loader = test_loader


def compute_accuracy_and_loss(model, data_loader, device):
    correct_pred, num_examples = 0, 0
    cross_entropy = 0.
    for i, (features, targets) in enumerate(data_loader):
            
        features = features.to(device)
        targets = targets.to(device)

        logits, probas = model(features)
        cross_entropy += F.cross_entropy(logits, targets).item()
        _, predicted_labels = torch.max(probas, 1)
        num_examples += targets.size(0)
        correct_pred += (predicted_labels == targets).sum()
    return correct_pred.float()/num_examples * 100, cross_entropy/num_examples
    

start_time = time.time()
train_acc_lst, valid_acc_lst = [], []
train_loss_lst, valid_loss_lst = [], []

for epoch in range(NUM_EPOCHS):
    
    model.train()
    
    for batch_idx, (features, targets) in enumerate(train_loader):
    
        ### PREPARE MINIBATCH
        features = features.to(DEVICE)
        targets = targets.to(DEVICE)
            
        ### FORWARD AND BACK PROP
        logits, probas = model(features)
        cost = F.cross_entropy(logits, targets)
        optimizer.zero_grad()
        
        cost.backward()
        
        ### UPDATE MODEL PARAMETERS
        optimizer.step()
        
        ### LOGGING
        if not batch_idx % 200:
            print (f'Epoch: {epoch+1:03d}/{NUM_EPOCHS:03d} | '
                   f'Batch {batch_idx:04d}/{len(train_loader):04d} |' 
                   f' Cost: {cost:.4f}')

    # no need to build the computation graph for backprop when computing accuracy
    model.eval()
    with torch.set_grad_enabled(False):
        train_acc, train_loss = compute_accuracy_and_loss(model, train_loader, device=DEVICE)
        valid_acc, valid_loss = compute_accuracy_and_loss(model, valid_loader, device=DEVICE)
        train_acc_lst.append(train_acc)
        valid_acc_lst.append(valid_acc)
        train_loss_lst.append(train_loss)
        valid_loss_lst.append(valid_loss)
        print(f'Epoch: {epoch+1:03d}/{NUM_EPOCHS:03d} Train Acc.: {train_acc:.2f}%'
              f' | Validation Acc.: {valid_acc:.2f}%')
        
    elapsed = (time.time() - start_time)/60
    print(f'Time elapsed: {elapsed:.2f} min')
  
elapsed = (time.time() - start_time)/60
print(f'Total Training Time: {elapsed:.2f} min')

训练结果

Epoch: 001/016 | Batch 0000/0782 | Cost: 2.6448
Epoch: 001/016 | Batch 0200/0782 | Cost: 1.9297
Epoch: 001/016 | Batch 0400/0782 | Cost: 2.0488
Epoch: 001/016 | Batch 0600/0782 | Cost: 2.0431
Epoch: 001/016 Train Acc.: 39.93% | Validation Acc.: 36.83%
Time elapsed: 1.64 min
Epoch: 002/016 | Batch 0000/0782 | Cost: 1.6723
Epoch: 002/016 | Batch 0200/0782 | Cost: 1.5365
Epoch: 002/016 | Batch 0400/0782 | Cost: 1.6170
Epoch: 002/016 | Batch 0600/0782 | Cost: 1.3389
Epoch: 002/016 Train Acc.: 49.90% | Validation Acc.: 43.29%
Time elapsed: 3.29 min
Epoch: 003/016 | Batch 0000/0782 | Cost: 1.2280
Epoch: 003/016 | Batch 0200/0782 | Cost: 1.0847
Epoch: 003/016 | Batch 0400/0782 | Cost: 1.5266
Epoch: 003/016 | Batch 0600/0782 | Cost: 1.3456
Epoch: 003/016 Train Acc.: 56.43% | Validation Acc.: 48.08%
Time elapsed: 4.94 min
Epoch: 004/016 | Batch 0000/0782 | Cost: 1.4013
Epoch: 004/016 | Batch 0200/0782 | Cost: 1.2829
Epoch: 004/016 | Batch 0400/0782 | Cost: 1.2168
Epoch: 004/016 | Batch 0600/0782 | Cost: 1.2001
Epoch: 004/016 Train Acc.: 60.69% | Validation Acc.: 50.01%
Time elapsed: 6.58 min
Epoch: 005/016 | Batch 0000/0782 | Cost: 1.3680
Epoch: 005/016 | Batch 0200/0782 | Cost: 1.2036
Epoch: 005/016 | Batch 0400/0782 | Cost: 1.0483
Epoch: 005/016 | Batch 0600/0782 | Cost: 1.2299
Epoch: 005/016 Train Acc.: 67.86% | Validation Acc.: 54.16%
Time elapsed: 8.22 min
Epoch: 006/016 | Batch 0000/0782 | Cost: 1.1428
Epoch: 006/016 | Batch 0200/0782 | Cost: 0.9702
Epoch: 006/016 | Batch 0400/0782 | Cost: 1.0632
Epoch: 006/016 | Batch 0600/0782 | Cost: 1.2375
Epoch: 006/016 Train Acc.: 66.81% | Validation Acc.: 52.34%
Time elapsed: 9.86 min
Epoch: 007/016 | Batch 0000/0782 | Cost: 0.8962
Epoch: 007/016 | Batch 0200/0782 | Cost: 1.0879
Epoch: 007/016 | Batch 0400/0782 | Cost: 1.1377
Epoch: 007/016 | Batch 0600/0782 | Cost: 1.1011
Epoch: 007/016 Train Acc.: 72.14% | Validation Acc.: 55.30%
Time elapsed: 11.49 min
Epoch: 008/016 | Batch 0000/0782 | Cost: 0.8141
Epoch: 008/016 | Batch 0200/0782 | Cost: 0.6959
Epoch: 008/016 | Batch 0400/0782 | Cost: 0.9784
Epoch: 008/016 | Batch 0600/0782 | Cost: 1.1159
Epoch: 008/016 Train Acc.: 76.08% | Validation Acc.: 58.57%
Time elapsed: 13.14 min
Epoch: 009/016 | Batch 0000/0782 | Cost: 0.6706
Epoch: 009/016 | Batch 0200/0782 | Cost: 0.7745
Epoch: 009/016 | Batch 0400/0782 | Cost: 0.7790
Epoch: 009/016 | Batch 0600/0782 | Cost: 1.0540
Epoch: 009/016 Train Acc.: 78.26% | Validation Acc.: 58.76%
Time elapsed: 14.78 min
Epoch: 010/016 | Batch 0000/0782 | Cost: 0.4955
Epoch: 010/016 | Batch 0200/0782 | Cost: 0.5948
Epoch: 010/016 | Batch 0400/0782 | Cost: 0.7049
Epoch: 010/016 | Batch 0600/0782 | Cost: 0.6488
Epoch: 010/016 Train Acc.: 77.58% | Validation Acc.: 58.31%
Time elapsed: 16.43 min
Epoch: 011/016 | Batch 0000/0782 | Cost: 0.6648
Epoch: 011/016 | Batch 0200/0782 | Cost: 0.4936
Epoch: 011/016 | Batch 0400/0782 | Cost: 0.6123
Epoch: 011/016 | Batch 0600/0782 | Cost: 0.5989
Epoch: 011/016 Train Acc.: 86.26% | Validation Acc.: 60.56%
Time elapsed: 18.07 min
Epoch: 012/016 | Batch 0000/0782 | Cost: 0.3107
Epoch: 012/016 | Batch 0200/0782 | Cost: 0.4070
Epoch: 012/016 | Batch 0400/0782 | Cost: 0.5987
Epoch: 012/016 | Batch 0600/0782 | Cost: 0.6067
Epoch: 012/016 Train Acc.: 88.04% | Validation Acc.: 61.81%
Time elapsed: 19.71 min
Epoch: 013/016 | Batch 0000/0782 | Cost: 0.3936
Epoch: 013/016 | Batch 0200/0782 | Cost: 0.6761
Epoch: 013/016 | Batch 0400/0782 | Cost: 0.7042
Epoch: 013/016 | Batch 0600/0782 | Cost: 0.5793
Epoch: 013/016 Train Acc.: 80.50% | Validation Acc.: 55.80%
Time elapsed: 21.35 min
Epoch: 014/016 | Batch 0000/0782 | Cost: 0.3836
Epoch: 014/016 | Batch 0200/0782 | Cost: 0.3163
Epoch: 014/016 | Batch 0400/0782 | Cost: 0.5610
Epoch: 014/016 | Batch 0600/0782 | Cost: 0.4092
Epoch: 014/016 Train Acc.: 91.57% | Validation Acc.: 62.75%
Time elapsed: 23.00 min
Epoch: 015/016 | Batch 0000/0782 | Cost: 0.2652
Epoch: 015/016 | Batch 0200/0782 | Cost: 0.2393
Epoch: 015/016 | Batch 0400/0782 | Cost: 0.3272
Epoch: 015/016 | Batch 0600/0782 | Cost: 0.4533
Epoch: 015/016 Train Acc.: 92.90% | Validation Acc.: 61.18%
Time elapsed: 24.64 min
Epoch: 016/016 | Batch 0000/0782 | Cost: 0.1563
Epoch: 016/016 | Batch 0200/0782 | Cost: 0.2644
Epoch: 016/016 | Batch 0400/0782 | Cost: 0.3742
Epoch: 016/016 | Batch 0600/0782 | Cost: 0.2075
Epoch: 016/016 Train Acc.: 95.18% | Validation Acc.: 63.73%
Time elapsed: 26.29 min
Total Training Time: 26.29 min

训练损失和测试损失关系图

在这里插入图片描述

训练精度和测试精度关系图

在这里插入图片描述

5.测试阶段

model.eval()
with torch.set_grad_enabled(False): # save memory during inference
    test_acc, test_loss = compute_accuracy_and_loss(model, test_loader, DEVICE)
    print(f'Test accuracy: {test_acc:.2f}%')

Test accuracy: 63.73%

6.查看效果图

from PIL import Image
import matplotlib.pyplot as plt
for features, targets in train_loader:
    break
#预测环节
_, predictions = model.forward(features[:8].to(DEVICE))
predictions = torch.argmax(predictions, dim=1)
print(predictions)

features = features[:7]
fig = plt.figure()
tname = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
# print(features[i].size())
for i in range(6):
    plt.subplot(2,3,i+1)
    plt.tight_layout()
    tmp = features[i]
    plt.imshow(np.transpose(tmp, (1, 2, 0)))
    plt.title("Actual value: {}".format(tname[targets[i]])+'\n'+"Prediction value: {}".format(tname[predictions[i]]),size = 10)
    
#     plt.title("Prediction value: {}".format(tname[targets[i]]))
plt.show()

在这里插入图片描述

pengege666
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深度学习Fashion-MNIST：由简到繁的pytorch图像分类（一） 卷积神经网络
qq_43234983的博客
02-11 1206
深度学习Fashion-MNIST：由简到繁的pytorch图像分类 完整代码会附在文章末尾，建议使用anaconda安装pytorch，本文不在赘述。具体安装可参考此处 Fashion-MNIST数据集 Fashion-MNIST是Zalando文章图像的数据集-包含60,000个示例的训练集和10,000个示例的测试集。每个示例都是一个28x28灰度图像，与来自10个类别的标签相关联。Fash...
CIFAR与ResNet卷积神经网络实战.zip
10-09
总的来说，"CIFAR与ResNet卷积神经网络实战"这个资源涵盖了深度学习的基础知识，包括卷积神经网络、数据集的使用、模型设计、模型训练以及性能评估等方面，对于初学者来说是一个很好的实践项目，有助于深入理解深度...
mnist数据集使用resnet50预训练网络进行微调
qq_44243059的博客
07-09 935
mnist数据集使用resnet50预训练网络进行微调
Resnet50卷积神经网络训练MNIST手写数字图像分类 Pytorch训练代码
02-05
# Resnet50卷积神经网络训练MNIST手写数字图像分类 Pytorch训练代码 1. 使用Pytorch定义ReNet50网络模型； 2. 使用Pytorch加载MNIST数据集，首次运行自动下载； 3. 实现训练MNIST手写数字图像分类，训练过程显示loss数值； 4. 训练完成后保存pth模型权重文件； 5. 在测试集上测试训练后模型的准确率。
Pytorch深度学习基础 实战天气图片识别（基于ResNet50预训练模型，超详细）
mengxianglong123的博客
10-15 1万+
🔥本项目使用Pytroch，并基于ResNet50模型，实现了对天气图片的识别，过程详细，十分适合基础阶段的同学阅读。项目目录结构核心步骤数据处理准备配置文件构建自定义DataSet及Dataloader构建模型训练模型编写预测模块效果展示。
【深度学习】：《PyTorch入门到项目实战》卷积神经网络2-8：残差神经网络（ResNet）基于Fashion-MNIST数据识别
热门推荐
阿里云专家博主、数据科学领域优质创作者、统计er在读
07-23 1万+
经过我们之前的介绍，我们发现对卷积神经网络而言，“越深越好”，这是有道理的，因为这样模型的能力应该更强（它们适应任何空间的灵活性都会提高，因为它们有更大的参数空间可以探索）。然而，很多实验发现，在一定深度之后，性能就会下降。 这是 VGG 的瓶颈之一，因为当神经网络中使用特定激活函数的层数越多，损失函数的梯度就会趋近于零，导致梯度消失和梯度爆炸问题，从而使网络难以训练。 最简单的解决方案是使用其他激活函数，例如 ReLU，它不会导致导数很小。而**残差神经网络（ResNet）**是另一种有效的解决方案。
Python与PyQt5结合CIFAR-10的图像识别的训练好的pth模型，准确率高达95.6%
最新发布
07-10
CIFAR-10数据集：利用torchvision.datasets.CIFAR10下载并加载数据集，进行必要的预处理。 模型设计与训练 架构选择：基于ResNet或DenseNet等先进架构，调整层数和参数以适应CIFAR-10的特性。 训练策略：采用批量...
pyTorch入门与实践
05-10
- **图像分类**：使用PyTorch实现经典的图像分类任务，如使用AlexNet、VGG、ResNet等模型在CIFAR-10或ImageNet数据集上的训练。 - **文本分类**：利用LSTM或Transformer等模型进行自然语言处理任务，如情感分析或...
【技术分享】对抗样本及其背后性质分析（实战导向） .pdf
09-05
在本文中，作者使用ILSVRC竞赛中的ImageNet数据集进行实践，通过PyTorch库加载预训练的ResNet18模型。对抗样本的生成方法之一是PGD（Projected Gradient Descent）攻击，这是一种一阶方法，它在模型的局部梯度信息...
deeplearning-with-pytorch
11-15
在PyTorch中，我们可以利用 torchvision 库来预处理图像数据，加载常见的数据集如MNIST、CIFAR-10或ImageNet，并利用预训练的模型进行迁移学习。同时， torchvision.models 提供了多种预训练的CNN模型，如ResNet、...
使用 Trasnfer 学习架构 ResNet50，CNN 模型实现手写数字识别
06-21
在本笔记本中，我使用的是 MNIST Digits 数据集。关于数据集：数据集由 10 类手写图像图片组成，每类图片的数字在 0-9 之间。使用 Trasnfer 学习架构 ResNet50，CNN 模型
Resnet 50 权重文件
12-02
Deeper neural networks are more difficult to train. We present a residual learning framework to ease the training of networks that are substantially deeper than those used previously. We explicitly reformulate the layers as learning residual functions with reference to the layer inputs, instead of learning unreferenced functions. We provide comprehensive empirical evidence showing that these residual networks are easier to optimize, and can gain accuracy from considerably increased depth. On the ImageNet dataset we evaluate residual nets with a depth of up to 152 layers---8x deeper than VGG nets but still having lower complexity. An ensemble of these residual nets achieves 3.57% error on the ImageNet test set. This result won the 1st place on the ILSVRC 2015 classification task. We also present analysis on CIFAR-10 with 100 and 1000 layers. The depth of representations is of central importance for many visual recognition tasks. Solely due to our extremely deep representations, we obtain a 28% relative improvement on the COCO object detection dataset. Deep residual nets are foundations of our submissions to ILSVRC & COCO 2015 competitions, where we also won the 1st places on the tasks of ImageNet detection, ImageNet localization, COCO detection, and COCO segmentation.
神经网络识别猫的项目代码
07-17
首先，我们需要一个数据集，通常包括标注好的训练样本，比如著名的ImageNet或者CIFAR-10数据集，这些数据集包含了大量不同类别图像，可以用于训练模型。在这个项目中，数据集可能包含了各种各样的猫的图片和其他非猫...
HCIA-AI V3.5.zip
05-05
- 数据集介绍：MNIST、CIFAR-10、IMDB等常见数据集的使用。 - 开发环境：TensorFlow、PyTorch等深度学习框架的安装和基本操作。 - 模型训练与调优：超参数调整、模型验证、交叉验证等技巧。 - 实战项目：通过...
cs231n课件.zip cs231n课件.zip
08-23
课程附带的数据集通常包括常用的计算机视觉基准数据集，如MNIST（手写数字识别）、CIFAR-10/100（多类别图像分类）、ImageNet（大规模图像分类和物体检测）等，这些数据集有助于学生进行模型训练和验证。 五、学习...
深度学习框架拾遗：【Pytorch（三）】——Pytorch结构化数据建模流程
u013010473的博客
03-07 1246
import os import datetime import numpy as np import pandas as pd import matplotlib.pyplot as plt import torch from torch import nn from torch.utils.data import Dataset,DataLoader,TensorDataset ## 打印时间 def printbar(): nowtime = datetime.datetime.now()
ResNet 基于迁移学习对CIFAR10 数据集的分类
Henry的博客
03-28 690
resnet 迁移学习对CIFAR10 的分类
图像分类数据集（Fashion-MNIST）
Bug_fuck的博客
01-07 1万+
1、获取数据集 这也是我第一次接触到图像分类问题，在jupyter notebook上实现之后，还想把它写在博客上，为了纪念一下吧！ 首先对于原著的敬意，那肯定是要分享链接http://zh.gluon.ai/的啦！ 1.1 获取数据集 首先导入需要的包和模块 In [1]: %matplotlib inline import gluonbook as gb fro...
Pytorch--ResNet识别MNIST数据集
不加辣椒的博客
06-27 6320
之前搭建了ResNet网络架构，所以用其识别MNIST数据集。 1、由于电脑的运行内存，在设计网络结构时，用了8层网络，分别是1个输入层，1个输出层，三个Block，每个Block中有1个Basicblock，每个Basicblock中有2层layer。 2、考虑到MNIST的数据集的大小为28 x 28，没经过第2个和都3个Block，大小都减半，也就是说，进入输出层时的大小为7 x 7，所以在最后用到的Average_pool的大小为7。 3、因为MNIST的channel数为1，所以in_channe
代码实现resnet50训练cifar10数据集
10-23
这份代码实现了使用ResNet50模型对CIFAR-100数据集进行图像分类的训练。具体实现包括以下几个方面： 1. 使用PyTorch调用CIFAR-100数据集，首次训练自动下载； 2. 包含训练代码，调用ResNet50模型进行训练，使用交叉熵损失和SGD优化器； 3. 数据集的处理：调用torchvision里面封装好的数据集进行数据的训练，并且利用官方已经做好的数据集分类是数据集的划分大小。进行了一些简单的数据增强，分别是随机的随机剪切和随机的水平拉伸操作。 4. 参数设置：包括训练的次数、训练的批次大小、数据集的分类类别数量、模型训练时的学习率大小、保存模型权重的路径和保存xml文件的路径。 具体实现细节可以参考代码中的注释和引用、、。如果您想了解更多关于ResNet50模型和CIFAR-100数据集的知识，可以参考相关文献和资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值