ResNet: A Deep Residual Network for Image Classification

class ResNet(nn.Cell):
    def __init__(self, block, layers, num_classes=10):
        super(ResNet, self).__init__()
        self.in_channels = 64

        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, pad_mode='pad', has_bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU()
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same')
        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(kernel_size=1, stride=1, pad_mode='valid')  # 修改这里
        self.flatten = nn.Flatten()
        self.fc1 = nn.Dense(512, 100)
        self.fc2 = nn.Dense(100, num_classes)

    def make_layer(self, block, out_channels, blocks, stride=1):
        downsample = None
        if stride != 1 or self.in_channels != out_channels:
            downsample = nn.SequentialCell([
                nn.Conv2d(self.in_channels, out_channels, kernel_size=1, stride=stride, has_bias=False),
                nn.BatchNorm2d(out_channels)
            ])

        layers = []
        layers.append(block(self.in_channels, out_channels, stride, downsample))
        self.in_channels = out_channels
        for _ in range(1, blocks):
            layers.append(block(out_channels, out_channels))

        return nn.SequentialCell(layers)

    def construct(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)

        x = self.avgpool(x)
        x = self.flatten(x)
        x = self.fc1(x)
        x = self.fc2(x)

        return x

def load_model_from_ckpt(model, ckpt_file):
    '''
    Load model parameters from a checkpoint file.

    Args:
        model (nn.Cell): The model to load parameters into.
        ckpt_file (str): The path to the checkpoint file.

    Returns:
        None
    '''
    param_dict = load_checkpoint(ckpt_file)
    load_param_into_net(model, param_dict)
    print('Model parameters loaded from checkpoint file:', ckpt_file)

This code defines a ResNet model in MindSpore, a deep learning framework. It leverages the concept of residual connections to enhance the performance of deep neural networks.

The ResNet class is initialized with a specific block (building block of the network), layers (number of layers per stage), and num_classes (number of output classes). It then defines various layers including convolutional, batch normalization, activation, pooling, and fully connected layers. The make_layer function constructs a block of layers with residual connections.

The construct method defines the forward pass of the network, taking input x and processing it through the layers. The output is then returned.

The load_model_from_ckpt function facilitates loading pre-trained model parameters from a checkpoint file, enabling the reuse of trained weights for fine-tuning or transfer learning.

This code provides a fundamental structure of a ResNet model, which can be further customized and utilized for diverse image classification tasks.