生成一段Mobielnetv3网络分类高光谱图像的代码

下面是一个基于PyTorch实现的MobileNetV3网络分类高光谱图像的代码：

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

class MobileNetV3(nn.Module):
    def __init__(self, n_classes=10, input_channels=128):
        super(MobileNetV3, self).__init__()
        self.n_classes = n_classes
        self.input_channels = input_channels
        
        self.conv1 = nn.Conv2d(input_channels, 16, kernel_size=3, stride=2, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(16)
        self.hs1 = nn.Hardswish(inplace=True)
        
        self.bottlenecks = nn.Sequential(
            Bottleneck(16, 16, 16, nn.Hardswish(inplace=True), 1),
            Bottleneck(16, 72, 24, nn.Hardswish(inplace=True), 2),
            Bottleneck(24, 88, 24, nn.Hardswish(inplace=True), 1),
            Bottleneck(24, 96, 40, nn.Hardswish(inplace=True), 2),
            Bottleneck(40, 240, 40, nn.Hardswish(inplace=True), 1),
            Bottleneck(40, 240, 40, nn.Hardswish(inplace=True), 1),
            Bottleneck(40, 120, 48, nn.Hardswish(inplace=True), 1),
            Bottleneck(48, 144, 48, nn.Hardswish(inplace=True), 1),
            Bottleneck(48, 288, 96, nn.Hardswish(inplace=True), 2),
            Bottleneck(96, 576, 96, nn.Hardswish(inplace=True), 1),
            Bottleneck(96, 576, 96, nn.Hardswish(inplace=True), 1)
        )
        
        self.conv2 = nn.Conv2d(96, 576, kernel_size=1, stride=1, padding=0, bias=False)
        self.bn2 = nn.BatchNorm2d(576)
        self.hs2 = nn.Hardswish(inplace=True)
        
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.classifier = nn.Sequential(
            nn.Linear(576, 1280, bias=True),
            nn.Hardswish(inplace=True),
            nn.Dropout(p=0.2, inplace=True),
            nn.Linear(1280, n_classes, bias=True)
        )
        
        self._initialize_weights()
    
    def forward(self, x):
        x = self.hs1(self.bn1(self.conv1(x)))
        x = self.bottlenecks(x)
        x = self.hs2(self.bn2(self.conv2(x)))
        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x
    
    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.zeros_(m.bias)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.ones_(m.weight)
                nn.init.zeros_(m.bias)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.zeros_(m.bias)

class Bottleneck(nn.Module):
    def __init__(self, in_channels, out_channels, exp_channels, activation=nn.ReLU(inplace=True), stride=1):
        super(Bottleneck, self).__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.exp_channels = exp_channels
        self.activation = activation
        self.stride = stride
        
        self.conv1 = nn.Conv2d(in_channels, exp_channels, kernel_size=1, stride=1, padding=0, bias=False)
        self.bn1 = nn.BatchNorm2d(exp_channels)
        self.hs1 = nn.Hardswish(inplace=True)
        
        self.depthwise_conv = nn.Conv2d(exp_channels, exp_channels, kernel_size=3, stride=stride, padding=1, groups=exp_channels, bias=False)
        self.bn2 = nn.BatchNorm2d(exp_channels)
        self.hs2 = nn.Hardswish(inplace=True)
        
        self.conv2 = nn.Conv2d(exp_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
        self.bn3 = nn.BatchNorm2d(out_channels)
        
        self.shortcut = nn.Sequential()
        if stride == 1 and in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False),
                nn.BatchNorm2d(out_channels)
            )
        
    def forward(self, x):
        out = self.hs1(self.bn1(self.conv1(x)))
        out = self.hs2(self.bn2(self.depthwise_conv(out)))
        out = self.bn3(self.conv2(out))
        out = out + self.shortcut(x)
        out = self.activation(out)
        return out

这个网络定义了一个MobileNetV3分类器，输入尺寸为$128\times 128$，输入通道数为128，输出分类数为10。其中，bottlenecks是MobileNetV3的核心组件，由多个Bottleneck块组成。每个Bottleneck块由两个卷积层和一个shortcut组成，其中卷积层采用深度可分离卷积，shortcut可以是一个恒等映射或者一个卷积层。最后通过全局平均池化和一个全连接层得到分类结果。