ResNet18识别MNIST数据集(Pytorch实战)

最新推荐文章于 2024-05-17 01:26:41 发布
最新推荐文章于 2024-05-17 01:26:41 发布
阅读量3.8k 收藏 36
点赞数 5
分类专栏： # 图像分类 深度学习 文章标签： pytorch 深度学习 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42888638/article/details/121983065
版权

文章目录

1.导库

import time
import os

import numpy as np

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


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

from PIL import Image
import matplotlib.pyplot as plt

import argparse

import numpy as np
import torch
import torchvision
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data as Data
import matplotlib.pyplot as plt
from PIL import Image
import torch.nn as nn
import torch.nn.functional as F
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets

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

2.获取数据集

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

test_dataset = datasets.MNIST(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.创建Resnet18模型

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 BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(BasicBlock, self).__init__()
        self.conv1 = conv3x3(inplanes, planes, stride)
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = conv3x3(planes, planes)
        self.bn2 = nn.BatchNorm2d(planes)
        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)

        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 resnet18(num_classes):
    """Constructs a ResNet-18 model."""
    model = ResNet(block=BasicBlock, 
                   layers=[2, 2, 2, 2],
                   num_classes=num_classes,
                   grayscale=True)
    return model

net = resnet18(10)
print(net)
# print(net(torch.randn([1,1,28,28])))

简单查看一下网络结构

ResNet(
  (conv1): Conv2d(1, 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): AvgPool2d(kernel_size=7, stride=1, padding=0)
  (fc): Linear(in_features=512, out_features=10, bias=True)
)

4.开启训练

NUM_EPOCHS = 10

model = resnet18(num_classes=10)

model = model.to(DEVICE)

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


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 % 300:
            print (f'Epoch: {epoch+1:03d}/{NUM_EPOCHS:03d} | '
                   f'Batch {batch_idx:03d}/{len(train_loader):03d} |' 
                   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/010 | Batch 000/938 | Cost: 2.5880
Epoch: 001/010 | Batch 300/938 | Cost: 0.2995
Epoch: 001/010 | Batch 600/938 | Cost: 0.0254
Epoch: 001/010 | Batch 900/938 | Cost: 0.0546
Epoch: 001/010 Train Acc.: 98.49% | Validation Acc.: 98.61%
Time elapsed: 0.50 min
Epoch: 002/010 | Batch 000/938 | Cost: 0.0118
Epoch: 002/010 | Batch 300/938 | Cost: 0.0618
Epoch: 002/010 | Batch 600/938 | Cost: 0.0279
Epoch: 002/010 | Batch 900/938 | Cost: 0.0147
Epoch: 002/010 Train Acc.: 98.89% | Validation Acc.: 98.82%
Time elapsed: 1.00 min
Epoch: 003/010 | Batch 000/938 | Cost: 0.0217
Epoch: 003/010 | Batch 300/938 | Cost: 0.0488
Epoch: 003/010 | Batch 600/938 | Cost: 0.0128
Epoch: 003/010 | Batch 900/938 | Cost: 0.0357
Epoch: 003/010 Train Acc.: 99.15% | Validation Acc.: 98.88%
Time elapsed: 1.51 min
Epoch: 004/010 | Batch 000/938 | Cost: 0.1168
Epoch: 004/010 | Batch 300/938 | Cost: 0.0824
Epoch: 004/010 | Batch 600/938 | Cost: 0.0131
Epoch: 004/010 | Batch 900/938 | Cost: 0.0212
Epoch: 004/010 Train Acc.: 99.22% | Validation Acc.: 99.04%
Time elapsed: 2.00 min
Epoch: 005/010 | Batch 000/938 | Cost: 0.0037
Epoch: 005/010 | Batch 300/938 | Cost: 0.0087
Epoch: 005/010 | Batch 600/938 | Cost: 0.0117
Epoch: 005/010 | Batch 900/938 | Cost: 0.0067
Epoch: 005/010 Train Acc.: 99.24% | Validation Acc.: 98.84%
Time elapsed: 2.50 min
Epoch: 006/010 | Batch 000/938 | Cost: 0.0020
Epoch: 006/010 | Batch 300/938 | Cost: 0.0038
Epoch: 006/010 | Batch 600/938 | Cost: 0.0264
Epoch: 006/010 | Batch 900/938 | Cost: 0.0038
Epoch: 006/010 Train Acc.: 99.38% | Validation Acc.: 99.06%
Time elapsed: 3.01 min
Epoch: 007/010 | Batch 000/938 | Cost: 0.0050
Epoch: 007/010 | Batch 300/938 | Cost: 0.0106
Epoch: 007/010 | Batch 600/938 | Cost: 0.0508
Epoch: 007/010 | Batch 900/938 | Cost: 0.0042
Epoch: 007/010 Train Acc.: 99.54% | Validation Acc.: 99.20%
Time elapsed: 3.50 min
Epoch: 008/010 | Batch 000/938 | Cost: 0.0098
Epoch: 008/010 | Batch 300/938 | Cost: 0.0012
Epoch: 008/010 | Batch 600/938 | Cost: 0.0073
Epoch: 008/010 | Batch 900/938 | Cost: 0.0016
Epoch: 008/010 Train Acc.: 99.47% | Validation Acc.: 99.19%
Time elapsed: 4.00 min
Epoch: 009/010 | Batch 000/938 | Cost: 0.0298
Epoch: 009/010 | Batch 300/938 | Cost: 0.0670
Epoch: 009/010 | Batch 600/938 | Cost: 0.0020
Epoch: 009/010 | Batch 900/938 | Cost: 0.0031
Epoch: 009/010 Train Acc.: 99.68% | Validation Acc.: 99.29%
Time elapsed: 4.50 min
Epoch: 010/010 | Batch 000/938 | Cost: 0.0005
Epoch: 010/010 | Batch 300/938 | Cost: 0.0556
Epoch: 010/010 | Batch 600/938 | Cost: 0.0012
Epoch: 010/010 | Batch 900/938 | Cost: 0.0044
Epoch: 010/010 Train Acc.: 99.44% | Validation Acc.: 99.11%
Time elapsed: 4.99 min
Total Training Time: 4.99 min

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

plt.plot(range(1, NUM_EPOCHS+1), train_loss_lst, label='Training loss')
plt.plot(range(1, NUM_EPOCHS+1), valid_loss_lst, label='Validation loss')
plt.legend(loc='upper right')
plt.ylabel('Cross entropy')
plt.xlabel('Epoch')
plt.show()

在这里插入图片描述

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

plt.plot(range(1, NUM_EPOCHS+1), train_acc_lst, label='Training accuracy')
plt.plot(range(1, NUM_EPOCHS+1), valid_acc_lst, label='Validation accuracy')
plt.legend(loc='upper left')
plt.ylabel('Cross entropy')
plt.xlabel('Epoch')
plt.show()

在这里插入图片描述

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: 99.11%

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()
# 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(targets[i])+'\n'+"Prediction value: {}".format(predictions[i]),size = 10)
    
#     plt.title("Prediction value: {}".format(tname[targets[i]]))
plt.show()

在这里插入图片描述

pengege666
关注
  • 5
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
PyTorch构建LeNet、AlexNet、VGGNet、GoogLeNet、ResNet训练MNIST数据集
09-25
1、MNIST数据集处理、加载、网络初始化、测试函数 2、训练函数、PyTorch构建LeNet网络 3、PyTorch从零构建AlexNet训练MNIST数据集 4、PyTorch从零构建VGGNet训练MNIST数据集 5、PyTorch从零构建GoogLeNet训练MNIST数据集 6、PyTorch从零构建ResNet训练MNIST数据集
现代卷积网络实战系列6：PyTorch从零构建ResNet训练MNIST数据集
机器学习与软件工程
09-22 495
现代卷积网络实战系列6：PyTorch从零构建ResNet训练MNIST数据集
MNIST 数据集详析：使用残差网络RESNET识别手写数字（文末送书）_数字识别用的数据集(2)
最新发布
2401_84302655的博客
05-17 450
MNIST手写数字数据库具有60,000个示例的训练集和10,000个示例的测试集，MNIST的图像，每张图片是包含28 像素× 28 像素的灰度图像（1 通道），各个像素的取值在0 到255 之间。每张图片都由一个28 ×28 的矩阵表示，每张图片都由一个784 维的向量表示（28*28=784）。
基于ResNet 18实现的MNIST数字多分类（pytorch 框架）
qq_53393298的博客
10-15 1121
基于ResNet 18实现的MNIST数字多分类
基于Resnet18的minist手写数字分类
ove_z的博客
06-19 4999
用Resnet18进行手写数字分类
MNIST 数据集详析：使用残差网络RESNET识别手写数字（文末送书）
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！
01-23 4809
MNIST手写数字数据库具有60,000个示例的训练集和10,000个示例的测试集，MNIST的图像，每张图片是包含28 像素× 28 像素的灰度图像（1 通道），各个像素的取值在0 到255 之间。每张图片都由一个28 ×28 的矩阵表示，每张图片都由一个784 维的向量表示（28*28=784）。
经典神经网络(6)ResNet及其在Fashion-MNIST数据集上的应用
qq_44665283的博客
05-31 1684
经典神经网络(6)ResNet及其在Fashion-MNIST数据集上的应用
用pytorch中的resnet18实现mnist手写数字识别
qq_45869258的博客
11-17 1101
在手写数字识别任务中，卷积神经网络（CNN）通常被认为是效果最好的网络之一。CNN 在图像识别领域有着卓越的表现，其结构能够有效提取图像的特征，并且对于手写数字的识别具有较高的准确率和鲁棒性。许多经典的手写数字识别模型，如LeNet、AlexNet、VGG、ResNet等，都是基于CNN结构构建的。因此，CNN 在手写数字识别中通常能够取得最好的效果。4.原文网站：https://arxiv.org/abs/1512.03385。这些神经网络和算法在手写数字识别中被广泛应用，并且在实践中取得了良好的效果。
基于ResNet50算法实现图像分类识别
Rocky006的博客
07-18 3560
ResNet50是一种基于深度卷积神经网络（Convolutional Neural Network，CNN）的图像分类算法。它是由微软研究院的Kaiming He等人于2015年提出的，是ResNet系列中的一个重要成员。ResNet50相比于传统的CNN模型具有更深的网络结构，通过引入残差连接（residual connection）解决了深层网络训练过程中的梯度消失问题，有效提升了模型的性能。深度卷积神经网络（CNN） CNN是一种专门用于图像处理的神经网络结构，具有层次化的特征提取能力。
Pytorch--ResNet识别MNIST数据集
不加辣椒的博客
06-27 6235
之前搭建了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
手把手教你：基于深度残差网络（ResNet）的水果分类识别系统
热门推荐
大雾的小屋的博客
02-14 1万+
本文主要介绍如何使用python搭建：一个基于深度残差网络（ResNet）的水果图像分类识别系统。 项目只是用水果分类作为抛砖引玉，其中包含了使用ResNet进行图像分类的相关代码。主要功能如下： - 数据预处理，生成用于输入TensorFlow模型的TFRecord的数据。 - 模型构建及训练，使用tensorflow.keras构建深度残差网络。 - 预测水果分类并进行模型评估。 如各位童鞋需要更换训练数据，完全可以根据源码将图像和标注文件更换即可直接运行。
ResNet50_fashion_mnist.py
04-27
用keras实现resnet50,用的数据集是fashion_mnist 实现后准确率是91.3%，损失率是53.7%
pytorch-resnet18和resnet50官方预训练模型
08-22
pytroch官网提供的预训练模型：resnet18：resnet18-5c106cde.pth和resnet50：resnet50-19c8e357.pth（两个文件打包在一起）
Resnet50卷积神经网络训练MNIST手写数字图像分类 Pytorch训练代码
02-05
# Resnet50卷积神经...2. 使用Pytorch加载MNIST数据集，首次运行自动下载； 3. 实现训练MNIST手写数字图像分类，训练过程显示loss数值； 4. 训练完成后保存pth模型权重文件； 5. 在测试集上测试训练后模型的准确率。
利用随机森林算法、MobileNet V1、ResNet-18、VGG16、DLA-34对Fashion MNIST数据集训练
11-18
在Pytorch环境下利用随机森林算法、MobileNet-V1、ResNet-18、VGG16以及DLA-34网络模型对Fashion MNIST数据集进行训练和测试。
Python基于pytorch深度学习的车型识别系统源码+使用说明
05-23
Python基于pytorch深度学习的车型识别系统源码+使用说明 训练模型主要分为五个模块：启动器、自定义数据加载器、网络模型、学习率/损失率调整以及训练可视化。 启动器是项目的入口，通过对启动器参数的设置，可以...
pytorch-resnet-mnist:https
05-24
PyTorch和PyTorch Lightning中MNIST的ResNet 有关详细说明/教程，请访问： :
基于PyTorch实现LeNet、AlexNet、ResNet完成MNIST手写字体识别任务
yongyi_的博客
05-01 800
本文基于PyTorch实现LeNet、AlexNet、ResNet完成MNIST手写字体识别任务。1节中说明了数据集的处理方法，2节说明了算法的设计思路，3节给出了LeNet、AlexNet、ResNet的实现代码，最后分析了采用Pytorch框架与自己手写的深度学习框架的不同，4节中对各个卷积网络进行训练，给出了训练结果和可视化结果，其中对LeNet网络结构进行了一些不同的调整和训练，5节中是本项目的一些总结，文末在附录中给出了本项目的所有代码。
通过MNIST理解batch_size的作用
weixin_44943389的博客
10-13 121
batch_size的选择在训练神经网络时是一个重要的超参数，它会影响训练的速度、模型的泛化能力以及内存的消耗。以下是不同batch_sizebatch_sizebatch_sizebatch_sizebatch_size总的来说，合适的batch_size可以提高训练效率、稳定性，同时避免内存消耗过大。在实践中，通常需要通过实验和调参来选择最合适的batch_size。
搭建resnet训练mnist数据集
05-11
好的，以下是使用PyTorch搭建ResNet模型并在MNIST数据集上进行训练的示例代码： ```python import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms # 定义ResNet模型 class ResNet(nn.Module): def __init__(self, num_classes=10): super(ResNet, self).__init__() self.conv1 = nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.layer1 = nn.Sequential( nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False), nn.BatchNorm2d(64) ) self.layer2 = nn.Sequential( nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=False), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1, bias=False), nn.BatchNorm2d(128) ) self.layer3 = nn.Sequential( nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1, bias=False), nn.BatchNorm2d(256), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False), nn.BatchNorm2d(256) ) self.layer4 = nn.Sequential( nn.Conv2d(256, 512, kernel_size=3, stride=2, padding=1, bias=False), nn.BatchNorm2d(512), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False), nn.BatchNorm2d(512) ) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(512, num_classes) def forward(self, x): x = self.conv1(x) x = self.bn1(x) x = self.relu(x) x = self.layer1(x) + x x = self.layer2(x) + x x = self.layer3(x) + x x = self.layer4(x) + x x = self.avgpool(x) x = torch.flatten(x, 1) x = self.fc(x) return x # 定义数据预处理 transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]) # 加载MNIST数据集 trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2) testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False, num_workers=2) # 定义优化器和损失函数 net = ResNet() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9) # 训练模型 for epoch in range(10): running_loss = 0.0 for i, data in enumerate(trainloader, 0): inputs, labels = data optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() if i % 100 == 99: # 每100个batch输出一次loss print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100)) running_loss = 0.0 print('Finished Training') # 在测试集上测试模型 correct = 0 total = 0 with torch.no_grad(): for data in testloader: images, labels = data outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy on test set: %d %%' % (100 * correct / total)) ``` 这段代码定义了一个ResNet模型，使用MNIST数据集进行训练，并在测试集上测试模型的准确率。你可以根据需要调整模型和训练参数以获得更好的性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值