使用pytorch写的mobilenet v2代码，详细注释，可以生成训练集和测试集的损失和准确率的折线图

import torch import torchvision import torchvision.models from matplotlib import pyplot as plt from tqdm import tqdm from torch import nn from torch.utils.data import DataLoader from torchvision.transforms import transforms data_transform = { "train": transforms.Compose([transforms.RandomResizedCrop(120), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]), "val": transforms.Compose([transforms.Resize((120, 120)), # cannot 224, must (224, 224) transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])} train_data = torchvision.datasets.ImageFolder(root = "./data/train" , transform = data_transform["train"]) traindata = DataLoader(dataset=train_data, batch_size=128, shuffle=True, num_workers=0) # 将训练数据以每次32张图片的形式抽出进行训练 test_data = torchvision.datasets.ImageFolder(root = "./data/val" , transform = data_transform["val"]) train_size = len(train_data) # 训练集的长度 test_size = len(test_data) # 测试集的长度 print(train_size) #输出训练集长度看一下，相当于看看有几张图片 print(test_size) #输出测试集长度看一下，相当于看看有几张图片 testdata = DataLoader(dataset=test_data, batch_size=128, shuffle=True, num_workers=0) # 将训练数据以每次32张图片的形式抽出进行测试 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("using {} device.".format(device)) def _make_divisible(ch, divisor=8, min_ch=None): """ This function is taken from the original tf repo. It ensures that all layers have a channel number that is divisible by 8 It can be seen here: https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py """ if min_ch is None: min_ch = divisor new_ch = max(min_ch, int(ch + divisor / 2) // divisor * divisor) # Make sure that round down does not go down by more than 10%. if new_ch < 0.9 * ch: new_ch += divisor return new_ch 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): 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_channel layers = [] if expand_ratio != 1: # 1x1 pointwise conv layers.append(ConvBNReLU(in_channel, hidden_channel, kernel_size=1)) layers.extend([ # 3x3 depthwise conv ConvBNReLU(hidden_channel, hidden_channel, stride=stride, groups=hidden_channel), # 1x1 pointwise conv(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): def __init__(self, num_classes=2, alpha=1.0, round_nearest=8): super(MobileNetV2, self).__init__() block = InvertedResidual 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 layer features.append(ConvBNReLU(3, input_channel, stride=2)) # building inverted residual residual blockes for 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 1 features.append(block(input_channel, output_channel, stride, expand_ratio=t)) input_channel = output_channel # building last several layers features.append(ConvBNReLU(input_channel, last_channel, 1)) # combine feature layers self.features = nn.Sequential(*features) # building classifier self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.classifier = nn.Sequential( nn.Dropout(0.2), nn.Linear(last_channel, num_classes) ) # weight initialization 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.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 mobilenet = MobileNetV2(num_classes=2) #将模型命名为mobilenet mobilenet.to(device) print(mobilenet.to(device)) #输出模型结构 test1 = torch.ones(64, 3, 120, 120) # 测试一下输出的形状大小 输入一个64,3,120,120的向量 test1 = mobilenet(test1.to(device)) #将向量打入神经网络进行测试 print(test1.shape) #查看输出的结果 epoch = 1 # 迭代次数即训练次数 learning = 0.0001 # 学习率 optimizer = torch.optim.Adam(mobilenet.parameters(), lr=learning) # 使用Adam优化器-写论文的话可以具体查一下这个优化器的原理 loss = nn.CrossEntropyLoss() # 损失计算方式，交叉熵损失函数 train_loss_all = [] # 存放训练集损失的数组 train_accur_all = [] # 存放训练集准确率的数组 test_loss_all = [] # 存放测试集损失的数组 test_accur_all = [] # 存放测试集准确率的数组 for i in range(epoch): #开始迭代 train_loss = 0 #训练集的损失初始设为0 train_num = 0.0 # train_accuracy = 0.0 #训练集的准确率初始设为0 mobilenet.train() #将模型设置成 训练模式 train_bar = tqdm(traindata) #用于进度条显示，没啥实际用处 for step, data in enumerate(train_bar): #开始迭代跑， enumerate这个函数不懂可以查查，将训练集分为 data是序号，data是数据 img, target = data #将data 分位 img图片，target标签 optimizer.zero_grad() # 清空历史梯度 outputs = mobilenet(img.to(device)) # 将图片打入网络进行训练,outputs是输出的结果 loss1 = loss(outputs, target.to(device)) # 计算神经网络输出的结果outputs与图片真实标签target的差别-这就是我们通常情况下称为的损失 outputs = torch.argmax(outputs, 1) #会输出10个值，最大的值就是我们预测的结果 求最大值 loss1.backward() #神经网络反向传播 optimizer.step() #梯度优化 用上面的abam优化 train_loss = train_loss + loss1.item() #将所有损失的绝