迁移学习：自己预训练的resnet18模型在Unet上的实现（pytorch版）（有待完善）

最新推荐文章于 2024-08-23 11:07:44 发布
最新推荐文章于 2024-08-23 11:07:44 发布
阅读量4.1k 收藏 21
点赞数 6
分类专栏： ai 文章标签： 迁移学习 pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ye1391/article/details/122367609
版权

文末有resnet18网络结构

下面上一张unet的网络结构

 然后根据以上的网络结构图，搭建pytorch模型

def Conv2RELU(inchannels, outchannels, kernel, padding):
    return nn.Sequential(
        nn.Conv2d(inchannels, outchannels, kernel, padding=padding),
        nn.ReLU(inplace=True),
    )

class UnetResNet(nn.Module):
    def __init__(self, n_class, out_size):
        super().__init__()

        self.out_size = out_size
        # if the imageNet pretrained model is needed, please set the augment "pretrained" equals to True
        self.backbone = models.resnet18(pretrained=False)
        self.baseLayer = list(self.backbone.children())

        self.layer0 = nn.Sequential(*self.baseLayer[:3])
        self.layer1 = nn.Sequential(*self.baseLayer[3:5])
        self.layer2 = self.baseLayer[5]
        self.layer3 = self.baseLayer[6]
        self.layer4 = self.baseLayer[7]

        self.layerup3 = nn.ConvTranspose2d(512, 256, 2, 2)
        self.layerup2 = nn.ConvTranspose2d(256, 128, 2, 2)
        self.layerup1 = nn.ConvTranspose2d(128, 64, 2, 2 )

        self.layerupConV3 = nn.Conv2d(512, 256, 3)
        self.layerupConV2 = nn.Conv2d(256, 128, 3)
        self.layerupConV1 = nn.Conv2d(128, 64, 3)

        self.ReLu = nn.ReLU()

        self.endlayer = nn.Conv2d(64, n_class, 1)

    def Crop(self, encode_features, x):
        _, _, H, W = x.shape
        return torchvision.transforms.CenterCrop([H, W])(encode_features)

    def ConvBlock(self, layer, x):
        conv = self.ReLu(layer(x))
        return self.ReLu(conv)

    def forward(self, input_x):

        layer0 = self.layer0(input_x)
        layer1 = self.layer1(layer0)
        layer2 = self.layer2(layer1)
        layer3 = self.layer3(layer2)
        layer4 = self.layer4(layer3)

        x = self.layerup3(layer4)
        layer3skip = self.Crop(layer3, x)
        x = torch.cat([x, layer3skip], dim=1)
        x = self.ConvBlock(self.layerupConV3, x)

        x = self.layerup2(x)
        layer2skip = self.Crop(layer2, x)
        x = torch.cat([x, layer2skip], dim=1)
        x = self.ConvBlock(self.layerupConV2, x)

        x = self.layerup1(x)
        layer1skip = self.Crop(layer1, x)
        x = torch.cat([x, layer1skip], dim=1)
        x = self.ConvBlock(self.layerupConV1, x)

        x = self.endlayer(x)

        out = F.interpolate(x, self.out_size)

        return out

载入预训练模型时使用一下的操作

# 4.create model
model = UnetResNet(num_class, [512, 512]).to(device)
#model = ResNetUSCL(base_model='resnet18', out_dim=256, pretrained=pretrained)
state_dict = torch.load(state_dict_path)
new_dict = {k: state_dict[k] for k in list(state_dict.keys())
            if not (k.startswith('l')
                    | k.startswith('fc'))}  # # discard MLP and fc
model_dict = model.state_dict()

model_dict.update(new_dict)
model.load_state_dict(model_dict, strict=False)

# frozen the pretrained model parameters
for Pname in model.baseLayer:
    for param in Pname.parameters():
        param.requires_grad = False

以下resnet18的网络结构

 

list(base_model.children())

[Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False),
 BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True),
 ReLU(inplace),
 MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False),
 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)
     (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)
     (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)
   )
 ),
 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)
     (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)
     (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)
   )
 ),
 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)
     (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)
     (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)
   )
 ),
 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)
     (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)
     (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)
   )
 ),
 AvgPool2d(kernel_size=7, stride=1, padding=0),
 Linear(in_features=512, out_features=1000, bias=True)]
summary(base_model, input_size=(3, 224, 224))
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 112, 112]           9,408
       BatchNorm2d-2         [-1, 64, 112, 112]             128
              ReLU-3         [-1, 64, 112, 112]               0
         MaxPool2d-4           [-1, 64, 56, 56]               0
            Conv2d-5           [-1, 64, 56, 56]          36,864
       BatchNorm2d-6           [-1, 64, 56, 56]             128
              ReLU-7           [-1, 64, 56, 56]               0
            Conv2d-8           [-1, 64, 56, 56]          36,864
       BatchNorm2d-9           [-1, 64, 56, 56]             128
             ReLU-10           [-1, 64, 56, 56]               0
       BasicBlock-11           [-1, 64, 56, 56]               0
           Conv2d-12           [-1, 64, 56, 56]          36,864
      BatchNorm2d-13           [-1, 64, 56, 56]             128
             ReLU-14           [-1, 64, 56, 56]               0
           Conv2d-15           [-1, 64, 56, 56]          36,864
      BatchNorm2d-16           [-1, 64, 56, 56]             128
             ReLU-17           [-1, 64, 56, 56]               0
       BasicBlock-18           [-1, 64, 56, 56]               0
           Conv2d-19          [-1, 128, 28, 28]          73,728
      BatchNorm2d-20          [-1, 128, 28, 28]             256
             ReLU-21          [-1, 128, 28, 28]               0
           Conv2d-22          [-1, 128, 28, 28]         147,456
      BatchNorm2d-23          [-1, 128, 28, 28]             256
           Conv2d-24          [-1, 128, 28, 28]           8,192
      BatchNorm2d-25          [-1, 128, 28, 28]             256
             ReLU-26          [-1, 128, 28, 28]               0
       BasicBlock-27          [-1, 128, 28, 28]               0
           Conv2d-28          [-1, 128, 28, 28]         147,456
      BatchNorm2d-29          [-1, 128, 28, 28]             256
             ReLU-30          [-1, 128, 28, 28]               0
           Conv2d-31          [-1, 128, 28, 28]         147,456
      BatchNorm2d-32          [-1, 128, 28, 28]             256
             ReLU-33          [-1, 128, 28, 28]               0
       BasicBlock-34          [-1, 128, 28, 28]               0
           Conv2d-35          [-1, 256, 14, 14]         294,912
      BatchNorm2d-36          [-1, 256, 14, 14]             512
             ReLU-37          [-1, 256, 14, 14]               0
           Conv2d-38          [-1, 256, 14, 14]         589,824
      BatchNorm2d-39          [-1, 256, 14, 14]             512
           Conv2d-40          [-1, 256, 14, 14]          32,768
      BatchNorm2d-41          [-1, 256, 14, 14]             512
             ReLU-42          [-1, 256, 14, 14]               0
       BasicBlock-43          [-1, 256, 14, 14]               0
           Conv2d-44          [-1, 256, 14, 14]         589,824
      BatchNorm2d-45          [-1, 256, 14, 14]             512
             ReLU-46          [-1, 256, 14, 14]               0
           Conv2d-47          [-1, 256, 14, 14]         589,824
      BatchNorm2d-48          [-1, 256, 14, 14]             512
             ReLU-49          [-1, 256, 14, 14]               0
       BasicBlock-50          [-1, 256, 14, 14]               0
           Conv2d-51            [-1, 512, 7, 7]       1,179,648
      BatchNorm2d-52            [-1, 512, 7, 7]           1,024
             ReLU-53            [-1, 512, 7, 7]               0
           Conv2d-54            [-1, 512, 7, 7]       2,359,296
      BatchNorm2d-55            [-1, 512, 7, 7]           1,024
           Conv2d-56            [-1, 512, 7, 7]         131,072
      BatchNorm2d-57            [-1, 512, 7, 7]           1,024
             ReLU-58            [-1, 512, 7, 7]               0
       BasicBlock-59            [-1, 512, 7, 7]               0
           Conv2d-60            [-1, 512, 7, 7]       2,359,296
      BatchNorm2d-61            [-1, 512, 7, 7]           1,024
             ReLU-62            [-1, 512, 7, 7]               0
           Conv2d-63            [-1, 512, 7, 7]       2,359,296
      BatchNorm2d-64            [-1, 512, 7, 7]           1,024
             ReLU-65            [-1, 512, 7, 7]               0
       BasicBlock-66            [-1, 512, 7, 7]               0
        AvgPool2d-67            [-1, 512, 1, 1]               0
           Linear-68                 [-1, 1000]         513,000
================================================================
Total params: 11,689,512
Trainable params: 11,689,512
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 62.79
Params size (MB): 44.59
Estimated Total Size (MB): 107.96
----------------------------------------------------------------

ye1391
关注
专栏目录
UNet-model-for-Segmentation:一种使用U-Net模型分割图像的转移学习方法
05-11
在预先训练的模型上使用转移学习方法对医学数据进行细分的U-Net模型。 该存储库包含使用Keras的U-Net架构的实现，并在其背后支持Tensorflow，以使用“转移学习”方法对任何类型的医学数据进行细分。 神经网络结构是从描述的U-Net架构派生而来的。 转移学习方法用于通过使用较少数量的样本来微调预先训练的U-Net模型，因为注释医学数据通常是一项繁琐的工作。 在预训练期间以及对预训练模型进行微调时，将应用以下预处理： 灰度转换 标准化 对比度限制的自适应直方图均衡化（CLAHE） 伽玛调整 对预处理的完整图像的子图像（补丁）执行神经网络的训练。 尺寸为48x48的每个色块是通过在整个图像内随机选择其中心而获得的。 同样，选择部分或完全不在视场（FOV）之外的色块，通过这种方式，神经网络将学习如何从分割区域中区分出FOV边界。 一组1,90,000个补丁可用于获取预训练的
resnet101预训练模型.zip（pytorch版本）
08-02
总的来说，ResNet101预训练模型在PyTorch中的使用极大地简化了深度学习模型的开发流程，使得开发者可以快速地在各种计算机视觉任务上实现高性能的解决方案。无论是图像分类、目标检测、语义分割还是其他相关任务，都...
[深度学习] unet - resnet18 的使用Demo
comedate的专栏
02-18 1659
发现一个工业上，比较好用的网络：unet 与 resnet18 混合使用的例子：
Onnx使用预训练的 ResNet18 模型对输入图像进行分类，并将分类结果显示在图像上
最新发布
m0_53291740的博客
08-23 795
这段代码实现了一个图像分类系统，使用预训练的 ResNet18 模型对输入图像进行分类，并将分类结果显示在图像上。它包括以下主要步骤：读取一个包含类别名称和对应编号的文本文件，并将其存储在字典中。定义了几个函数，包括模型导出函数 resnet()、图像预处理函数 pre_process() 和加载 ONNX 模型进行分类的函数 loadOnnx()。在主程序中，指定输入图像路径，调用 loadOnnx() 函数对图像进行分类并显示结果。
ResNet+Unet模型
LYJ20010728的博客
04-07 5369
搭建模型结构代码 from tensorflow.keras import layers from tensorflow.keras import models def ResNet(image_input, is_training=True): dropout_rate = 0.5 if is_training else 1.0 # (512,512,3) -> (512,512,64) y = layers.Conv2D(64, kernel_size=4,
迁移学习
wp1988的博客
10-19 460
在现实中，几乎没有人从无到有后（随机初始化）的训练一个完整的卷积神经网络，因为拥有足够大的数据集是相当稀有的。然而，很常见的是在一个非常大的数据集上预训练一个ConvNet，并且使用这个ConvNet作为一个初始化或者一个固定特征的提取器在感兴趣的任务上。下面是迁移学习的主要三个阶段：         ConvNet作为一个固定特征提取器。用一个ConvNet在ImageNet上pret
segnet 迁移学习
menglanzeng的博客
07-28 740
本文主要参考博客https://blog.csdn.net/u012426298/article/details/81386817。 首先获取预训练模型，和相应的prototxt文件，连接就不上了，参考博客https://blog.csdn.net/u012426298/article/details/81386817 一、数据集 为了避免自己去标注太多的图片，所以采用了标注好了的nyu数据...
学习Unet的一些过程
weixin_30763397的博客
03-21 368
毕业设计的项目，需要用到手机作为控制端，这就需要用到Unity的网络模块。 因为只会设计到几个简单的按钮命令，所以不打算做多么复杂的功能，一开始打算用C#的Socket编程，但是考虑到多线程的关系觉得以后跟UI结合起来处理会比较麻烦，机智的我决定使用Unity提供的Unet网络模块。不需要太麻烦，只需要cs之间发送消息就行。 一开始我感觉自己掉进了一个坑，网上关于Une...
Pytorch实现：使用ResNet18网络训练Cifar10数据集，测试集准确率达到95.46%(从0开始，不使用预训练模型)
01-06
本文将介绍如何使用数据增强和模型修改的方式，在不使用任何预训练模型参数的情况下，在ResNet18网络上对Cifar10数据集进行分类任务。在测试集上，我们的模型准确率可以达到95.46%。在Kaggle的Cifar10比赛上，我训练...
人工智能-项目实践-迁移学习-基于resnet18的迁移学习分类网络，用于给bee和ant二分类.zip
12-15
读取torchvision中保存的resnet18网络模型，设置预训练pretrained=True，修改最后一个全连接层为my_resnet18.fc = nn.Linear(512, 2) 定义交叉熵损失函数criterion = nn.CrossEntropyLoss() 定义随机梯度下降优化...
pytorch的resnet-18在cifar-10的预训练模型
03-13
pytorch的resnet-18在cifar-10的预训练模型
使用pytorch实现论文中的unet网络
12-17
设计神经网络的一般步骤： 1. 设计框架 2. 设计骨干网络 Unet网络设计的步骤： 1. 设计Unet网络工厂模式 2. 设计编解码结构 3. 设计卷积模块 4. unet实例模块 Unet网络最重要的特征： 1. 编解码结构。 2. 解码结构，比FCN更加完善，采用连接方式。 3. 本质是一个框架，编码部分可以使用很多图像分类网络。 示例代码： import torch import torch.nn as nn class Unet(nn.Module): #初始化参数：Encoder,Decoder,bridge #bridge默认值为无，如果有参数传入，则用该参数替换None
VGG，V3，RESNET迁移学习，tensorflow
05-31
VGG，V3，RESNET迁移学习，tensorflow和keras写的程序
基于resnet+unet的皮肤病变分割
02-25
该工程使用resnet50/101+hypercolumn+scse+unet算法实现对皮肤病变的分割
Python-TernausNet带有VGG11编码器的UNet在ImageNet上预训练用于图像分割
08-11
TernausNet: 带有VGG11编码器的U-Net在ImageNet上预训练，用于图像分割
unet++ 预训练模型，conv2d
04-02
unet++ 预训练模型，conv2d
人工智能-项目实践-迁移学习-pytorch版-使用resnet50迁移学习实现皮肤病图片的二分类.zip
12-15
pytorch版—使用resnet50迁移学习实现皮肤病图片的二分类 代码目录介绍 args.py 存放训练和测试所用的各种参数。 --mode字段表示运行模式：train or test. --model_path字段是训练模型的保存路径。 其余字段都有...
增强UNet：通过迁移学习定制分割模型
Warmer_Sweeter
02-19 1151
引言本文着重于在PyTorch框架中实现基于迁移学习的UNET架构的变体。UNET架构最初由Olaf Ronneberger等人于2015年在德国弗莱堡大学进行生物医学图像分割时开发，其名称来源于其独特的收缩和扩展路径，形成了层次结构的U形。这种架构及其变体在许多应用中被证明能够有效捕捉复杂的细节并保留空间信息。然而，在不断追求性能提升的过程中，探索各种技术仍然是至关重要的，其中之一就是整合迁移学...
Unet 高阶分割网络实战、多类别分割、迁移学习（deeplab、resnet101等等）
Henry的博客
02-19 1580
Unet 图像分割之前介绍了不少，具体可以参考为了实现多类别的自适应分割，前段时间利用numpy的unique函数实现了一个项目。通过numpy函数将mask的灰度值提取出来，保存在txt文本里，这样txt里面就会有类似0 1 2 ...等等的灰度值。而有几个灰度值，就代表分割要分出几个类别。对于图像分割而言，仍有很多的分割网络（例如deeplab、retinaNet等等）在分割任务有不错的表现。这里将介绍几种torch自定义的高阶分割API。
用pytorch写一个用预训练ResNet18模型训练MNIST的代码
07-16
当然可以！以下是使用预训练的ResNet18模来训练MNIST数据集的代码示例： ```python import torch import torch.nn as nn import torch.optim as optim from torchvision import datasets, models, transforms # 设置随机种子以确保结果可复现 torch.manual_seed(42) # 设置设备（CPU或GPU） device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 数据预处理 transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) # 加载MNIST数据集 train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True) test_dataset = datasets.MNIST(root='./data', train=False, transform=transform) # 创建数据加载器 train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False) # 加载预训练的ResNet18模型（不包括最后一层） model = models.resnet18(pretrained=True) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 10) # 更改最后一层的输出为10个类别 # 将模型移动到设备上 model = model.to(device) # 定义损失函数和优化器 criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) # 训练模型 def train(model, dataloader, criterion, optimizer, device): model.train() running_loss = 0.0 correct = 0 total = 0 for inputs, labels in dataloader: inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() # 前向传播 outputs = model(inputs) loss = criterion(outputs, labels) # 反向传播和优化 loss.backward() optimizer.step() # 统计分类准确率 _, predicted = outputs.max(1) total += labels.size(0) correct += predicted.eq(labels).sum().item() running_loss += loss.item() train_loss = running_loss / len(dataloader) train_acc = correct / total return train_loss, train_acc # 测试模型 def test(model, dataloader, criterion, device): model.eval() running_loss = 0.0 correct = 0 total = 0 with torch.no_grad(): for inputs, labels in dataloader: inputs, labels = inputs.to(device), labels.to(device) # 前向传播 outputs = model(inputs) loss = criterion(outputs, labels) # 统计分类准确率 _, predicted = outputs.max(1) total += labels.size(0) correct += predicted.eq(labels).sum().item() running_loss += loss.item() test_loss = running_loss / len(dataloader) test_acc = correct / total return test_loss, test_acc # 训练和评估模型 num_epochs = 10 for epoch in range(num_epochs): train_loss, train_acc = train(model, train_loader, criterion, optimizer, device) test_loss, test_acc = test(model, test_loader, criterion, device) print(f"Epoch {epoch+1}/{num_epochs}:") print(f"Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}") print(f"Test Loss: {test_loss:.4f}, Test Acc: {test_acc:.4f}") print() ``` 这段代码首先加载MNIST数据集，并进行预处理。然后，使用预训练的ResNet18模型，将最后一层的输出更改为10个类别。接下来，定义损失函数和优化器。训练过程中，使用训练数据集对模型进行训练，并使用测试数据集对模型进行评估。最后，打印每个epoch的训练损失、训练准确率、测试损失和测试准确率。 请注意，这里的ResNet18模型是在ImageNet数据集上进行预训练的，因此可能需要更多的训练迭代来适应MNIST数据集。你可以根据需要调整超参数和训练迭代次数来获得更好的结果。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值