class ConvBNReLU(nn.Sequential):def __init__(self, in_channel, out_channel, kernel_size=3, stride=1, groups=1):padding = (kernel_size - 1) // 2  # 保证输入和输出的图片大小不变super(ConvBNReLU, self).__init__(nn.Conv2d(in_channel, out_channel, kernel_size, stride, padding, groups=groups, bias=False),nn.BatchNorm2d(out_channel),nn.ReLU6(inplace=True))

class InvertedResidual(nn.Module):# expand ratio 扩展因子def __init__(self, in_channel, out_channel, stride, expand_ratio):super(InvertedResidual, self).__init__()hidden_channel = in_channel * expand_ratio  # 第一层卷积层卷积核的个数self.use_shortcut = stride == 1 and in_channel == out_channellayers = []if expand_ratio != 1:layers.append(ConvBNReLU(in_channel, hidden_channel, kernel_size=1))layers.extend([# 3*3 DW 卷积ConvBNReLU(hidden_channel, hidden_channel, stride=stride, groups=hidden_channel),# 1*1 PW 卷积(Linear激活函数==不添加激活函数)nn.Conv2d(hidden_channel, out_channel, kernel_size=1, bias=False),nn.BatchNorm2d(out_channel)])self.conv = nn.Sequential(*layers)def forward(self, x):if self.use_shortcut:return x + self.conv(x)else:return self.conv(x)

class MobileNetV2(nn.Module):# alpha 卷积核个数的倍率def __init__(self, num_classes=1000, alpha=1.0, round_nearest=8):super(MobileNetV2, self).__init__()block = InvertedResidual# 将输入通道数调整为8的倍数最近的整数值input_channel = _make_divisible(32 * alpha, round_nearest)  # 第一层卷积层所使用卷积核的个数，下一层的深度last_channel = _make_divisible(1280 * alpha, round_nearest)inverted_residual_setting = [# t,c,n,s[1, 16, 1, 1],[6, 24, 2, 2],[6, 32, 3, 2],[6, 64, 4, 2],[6, 96, 3, 1],[6, 160, 3, 2],[6, 320, 1, 1],]features = []# conv1 layerfeatures.append(ConvBNReLU(3, input_channel, stride=2)) # kernel size 默认为3# building inverted residual settingfor t, c, n, s in inverted_residual_setting:output_channel = _make_divisible(c * alpha, round_nearest)for i in range(n):stride = s if i == 0 else 1features.append(block(input_channel, output_channel, stride, expand_ratio=t))input_channel = output_channel# building last several layerfeatures.append(ConvBNReLU(input_channel, last_channel, 1))# combine feature layersself.features = nn.Sequential(*features)# building classifierself.avgpool = nn.AdaptiveAvgPool2d((1, 1))self.classifier = nn.Sequential(nn.Dropout(0.2),nn.Linear(last_channel, num_classes),)# weight initializationfor m in self.modules():if isinstance(m, nn.Conv2d):nn.init.kaiming_normal_(m.weight, mode='fan_out')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)def forward(self, x):x = self.features(x)x = self.avgpool(x)x = torch.flatten(x, 1)x = self.classifier(x)return x

net = MobileNetV2(num_classes=5)
model_weight_path = 'mobilenet_v2-pre.pth'
pre_weights = torch.load(model_weight_path)
pre_dict = {k: v for k, v in pre_weights.items() if "classifier" not in k}
# 加载除了最后一层的权重
missing_keys, unexpected_keys = net.load_state_dict(pre_dict, strict=False)
print('missing_keys: {}, unexpected_keys: {}'.format(missing_keys, unexpected_keys))# 冻结特征提取的权重
for param in net.features.parameters():param.requires_grad = Falsenet.to(device)'''
missing_keys: ['classifier.1.weight', 'classifier.1.bias'], unexpected_keys: []
'''

params = [p for p in net.parameters() if p.requires_grad]
optimizer = torch.optim.Adam(params, lr=0.0001)

'''
epoch [1/5], loss: 1.369: 100%|██████████| 207/207 [00:28<00:00,  7.20it/s]
epoch [1/5], acc: 280.0]: 100%|██████████| 23/23 [00:03<00:00,  7.39it/s]
epoch [1/5], train loss: 1.4112, val acc: 0.7692
Saving new best model
epoch [2/5], loss: 1.058: 100%|██████████| 207/207 [00:15<00:00, 13.05it/s]
epoch [2/5], acc: 299.0]: 100%|██████████| 23/23 [00:01<00:00, 11.91it/s]
epoch [2/5], train loss: 1.1245, val acc: 0.8214
Saving new best model
epoch [3/5], loss: 0.790: 100%|██████████| 207/207 [00:16<00:00, 12.75it/s]
epoch [3/5], acc: 297.0]: 100%|██████████| 23/23 [00:01<00:00, 13.01it/s]
epoch [3/5], train loss: 0.9590, val acc: 0.8159
epoch [4/5], loss: 1.184: 100%|██████████| 207/207 [00:16<00:00, 12.90it/s]
epoch [4/5], acc: 307.0]: 100%|██████████| 23/23 [00:01<00:00, 12.48it/s]
epoch [4/5], train loss: 0.8449, val acc: 0.8434
Saving new best model
epoch [5/5], loss: 0.813: 100%|██████████| 207/207 [00:15<00:00, 13.59it/s]
epoch [5/5], acc: 301.0]: 100%|██████████| 23/23 [00:02<00:00, 11.07it/s]
epoch [5/5], train loss: 0.7603, val acc: 0.8269
Finished Training
'''

model = MobileNetV2(num_classes=5)
model_weight_path = './MobileNetV2.pth'
model.load_state_dict(torch.load(model_weight_path, map_location=torch.device('cpu')))model.eval()with torch.no_grad():output = model(img)output = torch.squeeze(output, dim=0)predict = torch.softmax(output, dim=-1)idx = torch.argmax(predict, dim=-1).numpy()print('classes:{}, predict result:{:.3f}'.format(json_str[str(idx)], predict[idx].item()))'''
classes:tulips, predict result:0.872
'''

def _make_divisible(ch, divisor=8, min_ch=None):if min_ch is None:min_ch = divisornew_ch = max(min_ch, int(ch + divisor / 2) // divisor * divisor)if new_ch < 0.9 * ch:new_ch += divisorreturn new_ch

class ConvBNActivation(nn.Sequential):def __init__(self, in_channel, out_channel, kernel_size=3, stride=1, groups=1, norm_layer=None,activation_layer=None):padding = int((kernel_size - 1) // 2)if norm_layer is None:norm_layer = nn.BatchNorm2dif activation_layer is None:activation_layer = nn.ReLU6super(ConvBNActivation, self).__init__(nn.Conv2d(in_channel, out_channel, kernel_size, stride, padding, groups=groups, bias=False),norm_layer(out_channel),activation_layer(inplace=True))

class SqueezeExcitation(nn.Module):def __init__(self, input_c, squeeze_factor=4):super(SqueezeExcitation, self).__init__()squeeze_c = _make_divisible(input_c // squeeze_factor, 8)self.fc1 = nn.Conv2d(input_c, squeeze_c, kernel_size=1)self.fc2 = nn.Conv2d(squeeze_c, input_c, kernel_size=1)def forward(self, x):scale = F.adaptive_avg_pool2d(x, (1, 1))scale = self.fc1(scale)scale = F.relu(scale, inplace=True)scale = self.fc2(scale)scale = F.hardsigmoid(scale, inplace=True)return scale * x

class InvertedResidualConfig:def __init__(self, input_c, kernel, expand_c, out_c, use_se, activation, stride, width_multi=1.0):self.input_c = self.adjust_channels(input_c, width_multi)self.kernel = kernelself.expand_c = self.adjust_channels(expand_c, width_multi)self.out_c = self.adjust_channels(out_c, width_multi)self.use_se = use_seself.use_hs = activation == 'HS'self.stride = stride@staticmethoddef adjust_channels(channels, width_multi):return _make_divisible(channels * width_multi, 8)

class InvertedRedisual(nn.Module):def __init__(self, cnf, norm_layer):super(InvertedRedisual, self).__init__()self.use_shortcut = cnf.stride == 1 and cnf.input_c == cnf.out_clayers = []activation_layer = nn.Hardswish if cnf.use_hs else nn.ReLUif cnf.expand_c != cnf.input_c:layers.append(ConvBNActivation(cnf.input_c, cnf.expand_c, kernel_size=1, norm_layer=norm_layer,activation_layer=activation_layer))layers.append(ConvBNActivation(cnf.expand_c, cnf.expand_c, kernel_size=cnf.kernel, stride=cnf.stride, groups=cnf.expand_c,norm_layer=norm_layer, activation_layer=activation_layer))if cnf.use_se:layers.append(SqueezeExcitation(cnf.expand_c))layers.append(ConvBNActivation(cnf.expand_c, cnf.out_c, kernel_size=1, norm_layer=norm_layer,activation_layer=nn.Identity))self.block = nn.Sequential(*layers)def forward(self, x):result = self.block(x)if self.use_shortcut:result += xreturn result

class MobileNetV3(nn.Module):def __init__(self, inverted_residual_setting, last_channel, num_classes=1000, block=None, norm_layer=None):super(MobileNetV3, self).__init__()if block is None:block = InvertedRedisualif norm_layer is None:norm_layer = nn.BatchNorm2dlayers = []first_output_c = inverted_residual_setting[0].input_clayers.append(ConvBNActivation(in_channel=3, out_channel=first_output_c, kernel_size=3, stride=2, norm_layer=norm_layer,activation_layer=nn.Hardswish))for cnf in inverted_residual_setting:layers.append(block(cnf, norm_layer=norm_layer))lastconv_input_c = inverted_residual_setting[-1].out_clastconv_output_c = 6 * lastconv_input_clayers.append(ConvBNActivation(lastconv_input_c, lastconv_output_c, kernel_size=1, norm_layer=norm_layer,activation_layer=nn.Hardswish))self.features = nn.Sequential(*layers)self.avgpool = nn.AdaptiveAvgPool2d(1)self.classifier = nn.Sequential(nn.Linear(lastconv_output_c, last_channel),nn.Hardswish(inplace=True),nn.Dropout(0.2, inplace=True),nn.Linear(last_channel, num_classes))for m in self.modules():if isinstance(m, nn.Conv2d):nn.init.kaiming_normal_(m.weight, mode='fan_out')if m.bias is not None:nn.init.zeros_(m.bias)elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):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)def forward(self, x):x = self.features(x)x = self.avgpool(x)x = torch.flatten(x, 1)x = self.classifier(x)return x

def mobilenet_v3_large(num_classes=1000):bneck_conf = InvertedResidualConfiginverted_residual_setting = [# input_c, kernel, expanded_c, out_c, use_se, activation, stridebneck_conf(16, 3, 16, 16, False, "RE", 1),bneck_conf(16, 3, 64, 24, False, "RE", 2),  # C1bneck_conf(24, 3, 72, 24, False, "RE", 1),bneck_conf(24, 5, 72, 40, True, "RE", 2),  # C2bneck_conf(40, 5, 120, 40, True, "RE", 1),bneck_conf(40, 5, 120, 40, True, "RE", 1),bneck_conf(40, 3, 240, 80, False, "HS", 2),  # C3bneck_conf(80, 3, 200, 80, False, "HS", 1),bneck_conf(80, 3, 184, 80, False, "HS", 1),bneck_conf(80, 3, 184, 80, False, "HS", 1),bneck_conf(80, 3, 480, 112, True, "HS", 1),bneck_conf(112, 3, 672, 112, True, "HS", 1),bneck_conf(112, 5, 672, 160, True, "HS", 2),  # C4bneck_conf(160, 5, 960, 160, True, "HS", 1),bneck_conf(160, 5, 960, 160, True, "HS", 1),]last_channel = 1280return MobileNetV3(inverted_residual_setting=inverted_residual_setting, last_channel=last_channel,num_classes=num_classes)