2.构建模型

2.1定义模型类

要求：

补充如下代码的空白处

主要完成：

1. 实现1个卷积层和1个ReLU激活函数的定义

2. 实现ResidualBlockBase和ResidualBlock模块的残差连接，并补全self.layer4的参数

导入mindspore训练环节（包括模型构建、激活函数、反向传播、损失函数等需要的库）

from mindspore import Model
from mindspore import context
import mindspore.ops as ops
from mindspore import Tensor, nn, set_context, GRAPH_MODE, train
from mindspore import load_checkpoint, load_param_into_net
from typing import Type, Union, List, Optional
from mindspore import nn, train
from mindspore.common.initializer import Normal

初始化：weight_init = Normal(mean=0, sigma=0.02) 用于初始化卷积层；

gamma_init = Normal(mean=1, sigma=0.02) 用于初始化批归一化层

weight_init = Normal(mean=0, sigma=0.02)
gamma_init = Normal(mean=1, sigma=0.02)

2.1.1 基础块ResidualBlockBase

conv1 和 conv2 的参数设置：

conv1 负责处理输入数据的空间下采样（通过 stride 参数）或通道数变换（通过 out_channels），同时进行第一次特征提取。

conv2 固定为 3×3 卷积，不改变空间尺寸（默认 stride=1），仅对 conv1 的输出进一步提取特征。

（卷积层当池化层用）

class ResidualBlockBase(nn.Cell):
    expansion: int = 1

    def __init__(self, in_channel: int, out_channel: int,
                 stride: int = 1, norm: Optional[nn.Cell] = None,
                 down_sample: Optional[nn.Cell] = None) -> None:
        super(ResidualBlockBase, self).__init__()
        if not norm:
            self.norm = nn.BatchNorm2d(out_channel)
        else:
            self.norm = norm
        # 要点2-1-1:实现1个卷积层和一个ReLU激活函数的定义
        # 1. Conv2d:
        #    in_channels (int) - Conv2d层输入Tensor的空间维度。
        #    out_channels (int) - Conv2d层输出Tensor的空间维度。
        #    kernel_size (Union[int, tuple[int]]) - 指定二维卷积核的高度和宽度, 卷积核大小为3X3;
        #    stride (Union[int, tuple[int]]，可选) - 二维卷积核的移动步长。
        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                               kernel_size=3, stride=stride,
                               weight_init=weight_init)
        self.conv2 = nn.Conv2d(in_channel, out_channel,
                               kernel_size=3, weight_init=weight_init)
        # 2. ReLU：逐元素计算ReLU（Rectified Linear Unit activation function）修正线性单元激活函数。需要调用MindSpore的相关API.
        self.relu = nn.ReLU()
        self.down_sample = down_sample
        
    def construct(self, x):
        """ResidualBlockBase construct."""
        identity = x

        out = self.conv1(x)
        out = self.norm(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.norm(out)

        if self.down_sample is not None:
            identity = self.down_sample(x)
        # 要点2-1-2: 
        # 1. 实现ResidualBlockBase模块的残差连接
        out = out+identity  # 输出为主分支与shortcuts之和
        out = self.relu(out)

        return out

ResidualBlockBase代码解析

核心类定义：ResidualBlockBase

作用：实现残差网络的基础块（Basic Block），包含主分支（卷积路径）和短路连接（Shortcut），解决深层网络梯度消失问题。

输入：

in_channel ：输入特征图通道数

out_channel ：输出特征图通道数

stride ：卷积步长（控制特征图尺寸变化，用于下采样）

norm ：归一化层（默认使用 BatchNorm2d）

down_sample ：下采样模块（用于调整短路连接的维度，确保与主分支输出维度一致）

要点 2-1-1：定义卷积层和 ReLU 激活函数

Conv2d 层实现

self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                       kernel_size=3, stride=stride,  # 3x3卷积核，步长由参数控制
                       weight_init=weight_init)     # 权重初始化（正态分布，sigma=0.02）
self.conv2 = nn.Conv2d(in_channel, out_channel,  # 第二个卷积层输入通道仍为in_channel（残差块基础版）
                       kernel_size=3, weight_init=weight_init)

关键参数：

kernel_size=3：固定使用 3x3 卷积核，符合残差块基础设计（如 ResNet-18/34 的 Basic Block）。

stride=stride：第一个卷积层的步长由外部传入（用于下采样），第二个卷积层步长固定为 1（保持尺寸）。

weight_init=weight_init：使用正态分布初始化权重（Normal(mean=0, sigma=0.02)），避免梯度爆炸 / 消失。

ReLU 激活函数

self.relu = nn.ReLU()  # 直接调用MindSpore的ReLU模块，逐元素计算max(0, x)

作用：引入非线性，避免网络退化为线性层，同时缓解梯度消失。

要点 2-1-2：实现残差连接

if self.down_sample is not None:
    identity = self.down_sample(x)  # 下采样：调整短路连接的维度（通道数/尺寸）
out = out + identity  # 残差连接核心：主分支输出与短路连接相加
out = self.relu(out)   # 最后一次ReLU激活，输出非线性特征

残差连接逻辑：

短路连接（Identity Mapping）：当输入x的维度（通道数 / 尺寸）与主分支输出out一致时，直接相加（identity = x）。

若维度不一致（如通道数增加或尺寸缩小），通过down_sample模块对x进行下采样（通常是 1x1 卷积 + 步长调整），确保形状匹配。

相加操作：

核心公式：输出 = 主分支输出 + 短路连接，强制保留原始输入信息，使梯度能直接回传至浅层。

激活函数位置：相加后再进行一次 ReLU 激活，确保输出为非线性特征，符合 ResNet 设计规范。

关键模块解析

1. 归一化层（Norm）处理

if not norm:
    self.norm = nn.BatchNorm2d(out_channel)  # 默认使用BatchNorm2d
else:
    self.norm = norm  # 支持自定义归一化层（如GroupNorm）

作用：对卷积输出进行归一化，加速训练并提升模型鲁棒性。

位置：每个卷积层后立即接归一化层，再接 ReLU 激活（Conv→Norm→ReLU 顺序）。

2. 下采样模块（down_sample）

self.down_sample = down_sample  # 由外部传入，通常是1x1卷积+步长

触发场景：当in_channel ≠ out_channel或stride > 1时，需通过下采样调整短路连接的维度。

典型实现：

down_sample = nn.SequentialCell([
    nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=stride, weight_init=weight_init),
    nn.BatchNorm2d(out_channel)
])

通过 1x1 卷积调整通道数，步长调整尺寸，确保与主分支输出形状一致。

3. 权重初始化策略

weight_init = Normal(mean=0, sigma=0.02)  # 卷积层权重初始化
gamma_init = Normal(mean=1, sigma=0.02)    # BatchNorm的γ参数初始化（未在当前代码中使用）

正态分布初始化：较小的标准差（σ=0.02）避免初始权重过大导致激活值饱和，符合深度学习框架的常见实践（如 PyTorch 的默认初始化）。

2.1.2 瓶颈块ResidualBlock

class ResidualBlock(nn.Cell):
    expansion = 4

    def __init__(self, in_channel: int, out_channel: int,
                 stride: int = 1, down_sample: Optional[nn.Cell] = None) -> None:
        super(ResidualBlock, self).__init__()

        self.conv1 = nn.Conv2d(in_channel, out_channel,
                               kernel_size=1, weight_init=weight_init)
        self.norm1 = nn.BatchNorm2d(out_channel)
        self.conv2 = nn.Conv2d(out_channel, out_channel,
                               kernel_size=3, stride=stride,
                               weight_init=weight_init)
        self.norm2 = nn.BatchNorm2d(out_channel)
        self.conv3 = nn.Conv2d(out_channel, out_channel * self.expansion,
                               kernel_size=1, weight_init=weight_init)
        self.norm3 = nn.BatchNorm2d(out_channel * self.expansion)

        self.relu = nn.ReLU()
        self.down_sample = down_sample

    def construct(self, x):

        identity = x

        out = self.conv1(x)
        out = self.norm1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.norm2(out)
        out = self.relu(out)
        out = self.conv3(out)
        out = self.norm3(out)

        if self.down_sample is not None:
            identity = self.down_sample(x)
        # 2. 实现ResidualBlock模块的残差连接
        out = out+identity  # 输出为主分支与shortcuts之和
        out = self.relu(out)

        return out

ResidualBlock代码解释

核心类定义：ResidualBlock（瓶颈块）

作用：实现深层残差网络的瓶颈结构，通过 “降维 - 特征提取 - 升维” 减少计算量，支持构建更深的网络（如 50 层以上）。

核心参数：

expansion=4 ：升维因子（固定为 4，符合 ResNet 设计规范），即最后一个 1x1 卷积将通道数扩展为out_channel×4。

in_channel ：输入特征图通道数

out_channe ：中间层特征图通道数（经 1x1 卷积降维后的通道数）

stride ：3x3 卷积的步长（控制特征图尺寸变化，用于下采样）

down_sample ：下采样模块（调整短路连接的维度，确保与主分支输出维度一致）

要点：瓶颈块的结构设计

瓶颈块通过三层卷积实现 “降维→特征提取→升维”，显著减少计算量（对比基础块的两层 3x3 卷积）：

第一层：1x1 卷积（降维）

self.conv1 = nn.Conv2d(in_channel, out_channel, kernel_size=1, weight_init=weight_init)

作用：将输入通道数从in_channel降为out_channel（如输入 256→输出 64），减少后续 3x3 卷积的计算量。

卷积核大小：1x1，仅改变通道数，不改变特征图尺寸（stride=1，无填充）。

第二层：3x3 卷积（特征提取）

self.conv2 = nn.Conv2d(out_channel, out_channel, kernel_size=3, stride=stride, weight_init=weight_init)

作用：在降维后的低维空间提取空间特征（如边缘、纹理）。

关键参数：stride=stride：支持下采样（如 stride=2 时特征图尺寸减半），由外部传入（用于构建不同 stage 的残差块）。

kernel_size=3：保持 3x3 卷积核，确保感受野与基础块一致。

第三层：1x1 卷积（升维）

self.conv3 = nn.Conv2d(out_channel, out_channel * self.expansion, kernel_size=1, weight_init=weight_init)

作用：将通道数从out_channel升至out_channel×expansion（如 64→256），与短路连接维度匹配（因 ResNet 的 stage 设计中，输出通道数通常是输入的 4 倍）。

核心公式：输出通道数 = out_channel × expansion（此处expansion=4是 ResNet 瓶颈块的固定设计）。

要点：残差连接与维度匹配

if self.down_sample is not None:
    identity = self.down_sample(x)  # 调整短路连接的维度
out = out + identity  # 残差连接核心：主分支输出与短路连接相加
out = self.relu(out)   # 最后一次ReLU激活

触发下采样的场景：

当以下任意条件成立时，需通过down_sample调整短路连接：输入通道数in_channel ≠ 输出通道数out_channel×expansion（升维导致通道数不匹配）。

stride > 1（特征图尺寸缩小，短路连接需同步下采样）。

下采样模块实现（通常由外部传入）：

down_sample = nn.SequentialCell([
    nn.Conv2d(in_channel, out_channel*self.expansion, kernel_size=1, stride=stride, weight_init=weight_init),
    nn.BatchNorm2d(out_channel*self.expansion)
])

通过 1x1 卷积调整通道数，步长调整尺寸，确保identity与主分支输出out形状一致（通道数、高度、宽度均相同）。

归一化层与激活函数的顺序

# 每一层的处理流程：Conv → BatchNorm → ReLU
out = self.conv1(x)       # 1x1卷积（降维）
out = self.norm1(out)     # BatchNorm2d
out = self.relu(out)      # ReLU激活
out = self.conv2(out)     # 3x3卷积（特征提取）
out = self.norm2(out)     # BatchNorm2d
out = self.relu(out)      # ReLU激活
out = self.conv3(out)     # 1x1卷积（升维）
out = self.norm3(out)     # BatchNorm2d（升维后归一化）

设计原则：符合 ResNet 的 “Post-Normalization” 架构，即在卷积后立即归一化，再激活，确保每一层输入处于稳定分布，加速训练收敛。

权重初始化策略

weight_init = Normal(mean=0, sigma=0.02)  # 与基础块一致，小方差初始化避免梯度爆炸

作用：对 1x1 和 3x3 卷积的权重进行正态分布初始化，确保初始权重较小，激活值不会因过大输入导致饱和（如 ReLU 的负数区域失活）。

与基础残差块（ResidualBlockBase）的区别

2.1.3 构建层

根据给定参数构建由指定数量残差块组成的网络层，包括处理下采样及层间连接等

def make_layer(last_out_channel, block: Type[Union[ResidualBlockBase, ResidualBlock]],
               channel: int, block_nums: int, stride: int = 1):
    down_sample = None


    if stride != 1 or last_out_channel != channel * block.expansion:

        down_sample = nn.SequentialCell([
            nn.Conv2d(last_out_channel, channel * block.expansion,
                      kernel_size=1, stride=stride, weight_init=weight_init),
            nn.BatchNorm2d(channel * block.expansion, gamma_init=gamma_init)
        ])

    layers = []
    layers.append(block(last_out_channel, channel, stride=stride, down_sample=down_sample))

    in_channel = channel * block.expansion

    for _ in range(1, block_nums):

        layers.append(block(in_channel, channel))

    return nn.SequentialCell(layers)

构建层代码说明

功能定位

ResNet 的整体架构就是通过make_layer函数不断堆叠残差块，形成多个 stage，每个 stage 内部保持相同的通道数，相邻 stage 之间通过下采样调整尺寸和通道数，最终构建出深度神经网络。

输入参数：

last_out_channel ：上一层输出的特征图通道数（用于判断是否需要下采样）。

block ：残差块类型（ResidualBlockBase基础块或ResidualBlock瓶颈块，通过Type[Union]支持两种类型）。

channel ：当前 stage 的基础通道数（瓶颈块中为降维后的通道数，基础块中为输出通道数）。

block_nums ：当前 stage 包含的残差块数量（如 ResNet-50 的每个 stage 包含 3/4/6/3 个瓶颈块）。

stride ：当前 stage 第一个残差块的卷积步长（控制下采样，默认 1 表示不采样）。

输出：

由多个残差块组成的nn.SequentialCell序列（可直接作为网络的一个 stage，如 ResNet 的layer1、layer2等）。

核心代码逻辑解析

1. 下采样模块（down_sample）的条件判断与创建（核心考点）

if stride != 1 or last_out_channel != channel * block.expansion:
    down_sample = nn.SequentialCell([
        nn.Conv2d(last_out_channel, channel * block.expansion,
                  kernel_size=1, stride=stride, weight_init=weight_init),
        nn.BatchNorm2d(channel * block.expansion, gamma_init=gamma_init)
    ])

触发条件（满足任意一条即需下采样）：

stride != 1：需要对特征图尺寸进行下采样（如 stride=2 时尺寸减半）。

last_out_channel != channel * block.expansion：输入通道数与当前 stage 输出通道数不一致（瓶颈块中输出通道是channel×4，基础块中是channel×1）。

下采样实现：

通过1x1 卷积调整通道数（从last_out_channel到channel×block.expansion）。

卷积步长设为stride，同步调整特征图尺寸（与主分支的 3x3 卷积步长一致）。

接 BatchNorm 层归一化，确保短路连接的输出分布稳定。

核心作用：保证短路连接（identity）的维度与主分支输出一致，使out + identity操作可行。

2. 残差块序列的构建

layers = []
# 添加第一个残差块（可能包含下采样）
layers.append(block(last_out_channel, channel, stride=stride, down_sample=down_sample))
# 更新输入通道为当前stage的输出通道（block.expansion倍）
in_channel = channel * block.expansion
# 添加后续残差块（无下采样，stride=1，通道数已对齐）
for _ in range(1, block_nums):
    layers.append(block(in_channel, channel))  # 输入通道为上一个块的输出通道

第一个块的特殊性：

传入stride和down_sample，处理当前 stage 的下采样和通道对齐（如 ResNet 中layer2的第一个块 stride=2，实现尺寸减半）。

若无需下采样（stride=1 且通道数匹配），down_sample=None，短路连接直接使用输入x。

后续块的一致性：

输入通道in_channel固定为channel×block.expansion（即上一个块的输出通道）。

不再传入stride（默认 1）和down_sample（无需下采样，通道数已对齐），所有后续块仅做恒等残差连接。

2.1.4 定义不同组合(block，layer_nums)的ResNet网络实现

from mindspore import load_checkpoint, load_param_into_net
from mindspore import ops

class ResNet(nn.Cell):
    def __init__(self, block: Type[Union[ResidualBlockBase, ResidualBlock]],
                 layer_nums: List[int], num_classes: int, input_channel: int) -> None:
        super(ResNet, self).__init__()

        self.relu = nn.ReLU()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, weight_init=weight_init)
        self.norm = nn.BatchNorm2d(64)
        self.max_pool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same')
        self.layer1 = make_layer(64, block, 64, layer_nums[0])
        self.layer2 = make_layer(64 * block.expansion, block, 128, layer_nums[1], stride=2)
        self.layer3 = make_layer(128 * block.expansion, block, 256, layer_nums[2], stride=2)
        self.layer4 = make_layer(256 * block.expansion, block, 512, layer_nums[3], stride=2) # 要点2-1-3：layer4的输出通道参数‘512’的含义
        self.avg_pool = ops.ReduceMean(keep_dims=True)
        self.flatten = nn.Flatten()
        self.fc = nn.Dense(in_channels=input_channel, out_channels=num_classes)

    def construct(self, x):
        
        x = self.conv1(x)
        x = self.norm(x)
        x = self.relu(x)
        x = self.max_pool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        x = self.avg_pool(x,(2,3))
        
        x = self.flatten(x)
        x = self.fc(x)

        return x

ResNet组建类代码解析

1. 类定义与核心参数

class ResNet(nn.Cell):
    def __init__(self, block: Type[Union[ResidualBlockBase, ResidualBlock]],
                 layer_nums: List[int], num_classes: int, input_channel: int) -> None:
        super(ResNet, self).__init__()

block：残差块类型（基础块ResidualBlockBase或瓶颈块ResidualBlock），决定网络层数和计算复杂度。

layer_nums：各 stage 的残差块数量（如[3, 4, 6, 3]对应 ResNet-50）。

num_classes：分类任务的类别数（如中药材分类的 12 类）。

input_channel：全连接层输入通道数（由最后一个 stage 的输出通道决定，如瓶颈块下为512×4=2048）。

2. 主干网络结构

输入层与初始特征提取

self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, weight_init=weight_init)  # 7x7卷积
self.norm = nn.BatchNorm2d(64)  # 归一化
self.max_pool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same')  # 最大池化

7x7 卷积：输入 3 通道（RGB 图像），输出 64 通道，步长 2，初步提取特征并降采样（尺寸减半）。

最大池化：核大小 3x3，步长 2，pad_mode='same'保持空间尺寸对称减半（如 224→112→56）。

四个 stage（layer1-layer4）

self.layer1 = make_layer(64, block, 64, layer_nums[0])  # stride=1（默认）
self.layer2 = make_layer(64 * block.expansion, block, 128, layer_nums[1], stride=2)  # 下采样
self.layer3 = make_layer(128 * block.expansion, block, 256, layer_nums[2], stride=2)
self.layer4 = make_layer(256 * block.expansion, block, 512, layer_nums[3], stride=2)  # 关键考点：补全layer4参数

make_layer功能：动态构建残差块序列，每个 stage：第一个块通过stride=2实现下采样（layer2-layer4），通道数翻倍（如 64→128→256→512）。

block.expansion控制通道升维（基础块 = 1，瓶颈块 = 4），例如瓶颈块下64×4=256作为下 stage 输入。

输出层

self.avg_pool = ops.ReduceMean(keep_dims=True)  # 全局平均池化
self.flatten = nn.Flatten()  # 展平特征
self.fc = nn.Dense(in_channels=input_channel, out_channels=num_classes)  # 全连接分类

全局平均池化：替代全连接层前的全连接操作，减少参数数量，输出特征图尺寸为(batch, 512×expansion, 1, 1)。

全连接层：将特征映射到num_classes维空间，输出分类概率。

3. 前向传播逻辑

def construct(self, x):
    x = self.conv1(x) → self.norm(x) → self.relu(x) → self.max_pool(x)  # 初始特征提取
    x = self.layer1(x) → self.layer2(x) → self.layer3(x) → self.layer4(x)  # 四级残差块特征提取
    x = self.avg_pool(x, (2, 3))  # 对空间维度（H=2, W=3，假设输入为7x7）做平均池化
    x = self.flatten(x)  # 展平为一维向量（shape: [batch, input_channel]）
    x = self.fc(x)  # 分类输出
    return x

空间尺寸变化：假设输入 224x224，经过conv1(stride=2)和max_pool(stride=2)后尺寸为 56x56，每层 stage 若stride=2则尺寸减半（56→28→14→7），最终layer4输出 7x7。

通道数变化：随 stage 递增（64→128→256→512），经block.expansion后瓶颈块通道数为 256→512→1024→2048。

4. 核心要点与设计原则

layer4参数补全（题目要求）：输入通道为256×block.expansion（上一 stage 输出），当前 stage 基础通道512，stride=2实现最后一次下采样。

残差块类型兼容性：通过block参数支持基础块（浅层）和瓶颈块（深层），expansion自动适配通道逻辑（无需为不同块编写独立代码）。

下采样策略：每个 stage 的第一个块通过stride=2和1x1卷积调整通道 / 尺寸，保证残差连接维度匹配。

计算效率：瓶颈块通过1x1卷积降维减少 3x3 卷积计算量，使深层网络（如 ResNet-152）训练可行。

5. 代码关键作用

模块化构建：通过make_layer和残差块组合，快速搭建不同深度的 ResNet（如 50 层、101 层）。

特征提取流程：从浅层边缘检测到深层语义特征，逐层抽象，适应图像分类任务。

维度匹配：自动处理残差连接的通道和尺寸对齐，避免手动计算错误。

2.1.5 实例化resnet_xx网络

实例化resnet50

def _resnet(block: Type[Union[ResidualBlockBase, ResidualBlock]],
            layers: List[int], num_classes: int, pretrained: bool, pretrained_ckpt: str,
            input_channel: int):
    model = ResNet(block, layers, num_classes, input_channel)
    return model


def resnet50(num_classes: int = 1000, pretrained: bool = False):
    resnet50_ckpt = "./LoadPretrainedModel/resnet50_224_new.ckpt"
    return _resnet(ResidualBlock, [3, 4, 6, 3], num_classes,
                   pretrained, resnet50_ckpt, 2048)

实例化resnet_xx网络代码分析

ps：代码中‘ return _resnet(ResidualBlock, [3, 4, 6, 3], num_classes,

pretrained, resnet50_ckpt, 2048)’

为什么能跨函数识别到 pretrained参数？

在 Python 中，这是因为作用域的规则 。在resnet50函数中，pretrained是该函数的参数，属于局部作用域。当调用_resnet函数时，pretrained作为参数传递给_resnet函数，所以_resnet函数能够识别并使用这个参数

1. 通用模型构建函数 _resnet

def _resnet(block: Type[Union[ResidualBlockBase, ResidualBlock]],
            layers: List[int], num_classes: int, pretrained: bool, pretrained_ckpt: str,
            input_channel: int):
    model = ResNet(block, layers, num_classes, input_channel)
    return model

功能：通用 ResNet 模型构建接口，通过参数化残差块类型、层数、分类数等，灵活生成不同配置的 ResNet 模型。

参数解析：block：残差块类型（ResidualBlockBase基础块或ResidualBlock瓶颈块）。

layers：各 stage 的残差块数量列表（如[3,4,6,3]对应 ResNet-50 的四个 stage）。

num_classes：分类任务的类别数（如中药材的 12 类）。

pretrained：是否加载预训练权重（布尔值，True表示加载）。

pretrained_ckpt：预训练权重文件路径（如"./LoadPretrainedModel/resnet50_224_new.ckpt"）。

input_channel：全连接层输入维度（由最后一个 stage 的输出通道决定，如 ResNet-50 为 2048）。

2. 特定模型：ResNet-50 的封装 resnet50

def resnet50(num_classes: int = 1000, pretrained: bool = False):
    resnet50_ckpt = "./LoadPretrainedModel/resnet50_224_new.ckpt"
    return _resnet(ResidualBlock, [3, 4, 6, 3], num_classes,
                   pretrained, resnet50_ckpt, 2048)

功能：直接生成 ResNet-50 模型，固定了 ResNet-50 的核心配置（瓶颈块、各 stage 块数、输入通道）。

关键参数固定值：block=ResidualBlock：使用瓶颈块（Bottleneck Block），适用于深层网络（ResNet-50/101/152）。

layers=[3,4,6,3]：ResNet-50 的标准配置（四个 stage 分别包含 3、4、6、3 个瓶颈块）。

input_channel=2048：最后一个 stage 输出通道数（512 基础通道 × 瓶颈块 expansion=4）。

预训练支持：resnet50_ckpt指定了预训练权重路径（如用户需要加载 ImageNet 预训练权重，可通过pretrained=True启用）。

3. 代码设计核心价值

模块化与复用性：

_resnet作为通用构建函数，通过参数化残差块类型和层数，可扩展生成 ResNet-18（基础块 +[2,2,2,2]）、ResNet-101（[3,4,23,3]）等变体，避免重复代码。用户友好性：

resnet50函数封装了 ResNet-50 的具体配置，用户只需指定num_classes（分类数）和pretrained（是否加载预训练），即可快速获取模型，降低使用门槛。

2.2模型初始化

要求：

对定义的ResNet50模型进行实例化

实例化一个用于12分类的resnet50模型

# 要点2-2-1： 对定义的ResNet50模型进行实例化
network = resnet50(num_classes=12)
num_class = 12
in_channel = network.fc.in_channels
fc = nn.Dense(in_channels=in_channel, out_channels=num_class)
network.fc = fc

for param in network.get_parameters():
    param.requires_grad = True

模型初始化代码解析

1. 实例化 ResNet50 模型

network = resnet50(num_classes=12)

作用：调用resnet50函数创建 ResNet50 模型实例，指定分类数为 12（如中药材的 12 类）。

内部逻辑：

resnet50函数通过_resnet生成 ResNet50 模型，默认使用瓶颈块（ResidualBlock）和标准层数[3,4,6,3]，并将原 1000 类的全连接层（fc 层）初始化为 12 类输出（但需后续调整，见下文）。2. 替换全连接层适配新任务

num_class = 12  # 新任务的分类数（如中药材的12类）
in_channel = network.fc.in_channels  # 获取原fc层的输入通道数（ResNet50为2048）
fc = nn.Dense(in_channels=in_channel, out_channels=num_class)  # 新建12类输出的全连接层
network.fc = fc  # 替换原模型的fc层

背景：预训练 ResNet50 的 fc 层通常输出 1000 类（ImageNet 任务），需替换为新任务的分类数（12 类）。

关键操作：获取原 fc 层输入维度（in_channel=2048，由 ResNet50 的全局平均池化输出决定）。

新建全连接层fc，输入维度保持 2048，输出维度改为 12。

替换原模型的 fc 层，完成模型输出适配。

3. 启用所有参数训练 -- 全量微调

for param in network.get_parameters():
    param.requires_grad = True

作用：将模型所有参数的梯度计算标志（requires_grad）设为True，允许训练时更新所有参数。

场景意义：若使用预训练模型（pretrained=True），此操作表示 “端到端微调”（所有层参数均参与训练），适合新数据集与预训练数据分布差异较大的场景（如中药材分类 vs ImageNet 通用分类）。

若未使用预训练（pretrained=False），则模型从头开始训练，所有参数自然需要梯度更新。