2. 使用机器学习或者深度学习对羽毛进行等级识别判断

最新推荐文章于 2024-02-08 20:45:00 发布

柯西没科气

最新推荐文章于 2024-02-08 20:45:00 发布

阅读量355

点赞数 1

分类专栏：高级人工智能课程作业文章标签：深度学习机器学习 pytorch

本文链接：https://blog.csdn.net/diligent_lee/article/details/123510233

版权

高级人工智能课程作业专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文探讨了如何使用机器学习中的ResNet34模型对羽毛球羽毛进行等级判断，通过预训练模型训练，实验结果显示74.6%的训练准确率，同时计算了各等级的召回率，发现1级羽毛召回率高达95%，但2-5级较低。

摘要由CSDN通过智能技术生成

使用机器学习或者深度学习对羽毛进行等级识别判断

1. 运行环境

CPU：I5-10400
内存：16GB
系统：Win10 64位专业版，20H2
IDE：Pycharm2020.1
Python：3.7.9
Pytorch：1.7.1

2. 实验目的

理解机器学习如何应用到实际场景。
掌握特征提取方法。

3. 实验内容

数据集介绍：在制作羽毛球时，羽毛会根据质量的高低而价格不同，因此存在根据羽毛的图片而对其分级的需求。本数据集种羽毛共分为 5 个级别，分别是1、2、3、4、56 级，其中1级有1353 张图片，2级有 432 张图片，3 级有 163 张图像，4 级有 172 张图像，56 级有 42 张图像。训练集验证集按 7:3 的比例划分，划分结果在train.txt与val.txt中保存。
在给出的训练图片上训练一个羽毛的等级判断模型，在验证集上进行测试，其中评价指标分为 2 个，第一个是准确率，第二个是每一级别的召回率（如 2 级羽毛共 100 根，实际测试，2 级的 100 根中有 80 根识别成了 2 级，则 2 级的召回率为 80%）。
采用深度学习的方法来自动提取特征然后进行训练。

4. 实验思路

选择 2015 年微软实验室提出的 ResNet 网络（残差网络）。

本实验采用ResNet34模型，结构如图1所示。ResNet提出残差结构，并搭建超深的网络结构；使用Batch Normalization加速训练。在ResNet网络提出之前，传统的卷积神经网络都是通过将一系列卷积层与下采样层进行堆叠得到的。但是当堆叠到一定网络深度时，就会出现两个问题。1）梯度消失或梯度爆炸。 2）退化问题(degradation problem)。在ResNet论文中说通过数据的预处理以及在网络中使用BN（Batch Normalization）层能够解决梯度消失或者梯度爆炸问题。但是对于退化问题（随着网络层数的加深，效果还会变差）并没有很好的解决办法，所以ResNet论文提出了residual结构（残差结构）来减轻退化问题。
使用给定的数据集，利用resnet34-pre.pth模型预训练的权重进行模型训练实验。
通过每轮迭代计算准确率，并根据训练好的模型计算每个级别的召回率。

图1 ResNet34层模型的结构简图

5. 实验步骤

整体实验步骤如图2所示。

图2 实验步骤

5.1 图像加载和处理

将图像随机裁剪为不同的大小和宽高比，缩放所裁剪得到的图像为制定的大小。然后以给定的概率随机水平旋转给定的 PIL 的图像，默认为 0.5。然后将图像转为 Tensor，并作归一化处理。

data_transform = {
        "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor(),
                                     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),
        "val": transforms.Compose([transforms.Resize(256),
                                   transforms.CenterCrop(224),
                                   transforms.ToTensor(),
                                   transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}

    data_root = os.path.abspath(os.path.join(os.getcwd()))  # get data root path
    image_path = os.path.join(data_root, "data_res")  # flower data set path
    assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
                                         transform=data_transform["train"])

5.2 定义卷积神经网络

这里使用的是 ResNet34 网络模型。

class ResNet(nn.Module):

    def __init__(self, block, blocks_num, num_classes=1000, include_top=True):
        super(ResNet, self).__init__()
        self.include_top = include_top
        self.in_channel = 64
        
        self.conv1 = nn.Conv2d(3, self.in_channel, kernel_size=7, stride=2,
                               padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(self.in_channel)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self._make_layer(block, 64, blocks_num[0])
        self.layer2 = self._make_layer(block, 128, blocks_num[1], stride=2)
        self.layer3 = self._make_layer(block, 256, blocks_num[2], stride=2)
        self.layer4 = self._make_layer(block, 512, blocks_num[3], stride=2)
        if self.include_top:
            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # output size = (1, 1)
            self.fc = nn.Linear(512 * block.expansion, num_classes)

def resnet34(num_classes=1000, include_top=True):
    return ResNet(BasicBlock, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)

5.3 定义损失函数和优化器

定义损失函数，CrossEntropyLoss 为交叉熵损失函数。定义 Adam 优化器，根据模型当前参数决定优化即调整参数的增减和幅度。Ir 为学习率。过大过小都会影响准确率。

loss_function = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.0001)

5.4 调用Model的API进行训练

选择 ResNet34 网络并加载预先下载好的 resnet34-pre.pth 模型权重。

net = resnet34()

model_weight_path = "./resnet34-pre.pth"

5.5 迭代输出训练准确率

遍历迭代 10 次。首先遍历数据集，返回数据 data 和步长 step。把 data 数组中的图像和标签分别赋值给变量 images 和 label，清空之前的梯度信息。然后开始进行正向传播，并把图像计算与设备进行绑定。训练得到预测输出之后与真实标签进行计算损失值。将 loss 反向传播到各个节点，更新每个节点参数。

for epoch in range(10):
    # train
    net.train()
    running_loss = 0.0
    for step, data in enumerate(train_loader, start=0):
        images, labels = data
        optimizer.zero_grad()
        logits = net(images.to(device))
        loss = loss_function(logits, labels.to(device))
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        rate = (step+1)/len(train_loader)
        a = "*" * int(rate * 50)
        b = "." * int((1 - rate) * 50)
        print("\rtrain loss: {:^3.0f}%[{}->{}]{:.4f}".format(int(rate*100), a, b, loss), end="")
    print()

每轮迭代的准确率计算：

net.eval()
acc = 0.0
with torch.no_grad():
    for val_data in validate_loader:
        val_images, val_labels = val_data
        outputs = net(val_images.to(device))
        
        predict_y = torch.max(outputs, dim=1)[1]
        acc += (predict_y == val_labels.to(device)).sum().item()
    val_accurate = acc / val_num
    if val_accurate > best_acc:
        best_acc = val_accurate
        torch.save(net.state_dict(), save_path)
    print('[epoch %d] train_loss: %.3f  test_accuracy: %.3f' %
          (epoch + 1, running_loss / step, val_accurate))

5.6 计算召回率

在测试集中分别为 1，2，3，4，56 类的图片分类计算召回率。

classes = ('1', '2', '3', '4', '56')
    N_CLASSES = 5
    class_correct = list(0. for i in range(N_CLASSES))
    class_total = list(0. for i in range(N_CLASSES))

    model.eval()
    total_correct = 0
    total_num = 0
    start = time.perf_counter()
    for x, label in validate_loader:
        x, label = x.to(device), label.to(device)
        logits = model(x)
        pred = logits.argmax(dim=1)
        total_correct += torch.eq(pred, label).float().sum().item()
        total_num += x.size(0)
        c = (pred == label).squeeze()
        for i in range(len(label)):
            _label = label[i]
            class_correct[_label] += c[i].item()
            class_total[_label] += 1

    acc = total_correct / total_num
    print('acc: ', acc)
    for i in range(N_CLASSES):
        print('Accuracy of %5s : %2d %%' % (
            classes[i], 100 * class_correct[i] / class_total[i]))
    end = time.perf_counter()
    print("FPS: %f" % (val_num / (end - start)))