Cityscapes怎么做！DeepLabv3参见！

标签：__ 参见 nn Cityscapes channels DeepLabv3 size self out

项目场景：

问题描述：使用计算机视觉技术和英特尔® AI 分析工具套件为自动驾驶车辆开发实时对象检测模型。参赛团队需要创建一个深度学习模型，用于准确检测行人、车辆、交通标志和交通信号等对象。该模型需要具有高准确度和低延迟，能够满足自动驾驶车辆安全导航的需求。

预期解决方案：：

使用英特尔® AI 分析工具套件中的适当组件开发一个深度学习模型，用于准确、快速检测并对道路上的对象进行分割。：
使用包括挑战赛指定的真实场景（如各种天气条件、光线条件和道路环境）的数据集测试模型。：
尝试进行模型优化，以实现低延迟，以支持自动驾驶车辆进行实时对象检测。：
鼓励参赛团队使用英特尔CPU或英特尔GPU完成项目。

数据集：：城市景观数据集：这个数据集包含高分辨率的城市场景图像，专门用于城市场景语义理解任务。该数据集包含 30 类对象（行人、汽车、公共汽车、自行车等）的 5,000 幅图像，并带有精细注释。：本次挑战赛使用下列两个数据集文件：原始图片leftImg8bit_trainvaltest.zip 和标记文件gtFine_trainvaltest.zip。请使用该数据集内默认的训练、验证和测试集的划分，禁止把测试集加入到训练集中。： *本次挑战的数据源于https://www.cityscapes-dataset.com/ ，使用时请遵循相关网站的使用条款及使用符合规定的企业或机构邮箱完成注册，进入Download页面获取本次挑战赛指定的上述数据集。

参考资料：：英特尔AI参考套件中提供了类似解决参考代码及方案：https://github.com/idz-cn/Drone-navigation

评选规则：：

代码质量： • 代码易于理解且可重现： • 代码经过良好测试，功能无错误： • 代码有详细记录：
技术实现： • 开发人员适当利用和使用英特尔® AI 分析工具包： • 检测道路上的对象时能实现高准确率，参考测试集中图片平均像素交并比（Intersection over Union， IoU ）、像素精度（Pixel Accuracy， PA ）数值。： • 尽可能地实现低延迟对象检测，参考测试集中单张图片的平均预测时间。： • 鼓励使用英特尔CPU 或英特尔 GPU。：
创造力和原创性： • 解决方案是原创的，与同类提交的方案明显不同： • 解决方案创造了超越竞争的明显附加价值：

模型选择

由于个人算力有限，而本人长期从事于手机或者其他移动设备的研发，希望在本次比赛研发出的模型能够用移动设备的算力，也能够很好的进行推理。因此我选择了模型参数很小的DeepLabv3

Deeplabv3改进在于引入了ASPP模块和改进的decoder模块。ASPP模块是一种多尺度特征融合的方法，它可以在不同尺度上对特征进行采样和池化。

该项目中我用的模型如下

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

class DeepLabV3(nn.Module):
    def __init__(self, n_classes):
        super(DeepLabV3, self).__init__()
        self.n_classes = n_classes
        self.backbone = torchvision.models.resnet50(pretrained=True)
        self.aspp = ASPP(2048, 256, [6, 12, 18])
        self.decoder = Decoder(256, 256, n_classes)
    
    def forward(self, x):
        x = self.backbone.conv1(x)
        x = self.backbone.bn1(x)
        x = self.backbone.relu(x)
        x = self.backbone.maxpool(x)

        x1 = self.backbone.layer1(x)
        x2 = self.backbone.layer2(x1)
        x3 = self.backbone.layer3(x2)
        x4 = self.backbone.layer4(x3)

        x = self.aspp(x4)
        x = self.decoder(x, x3)

        x = F.interpolate(x, size=x.size()[2:], mode='bilinear', align_corners=True)
        
        return x

class ASPP(nn.Module):
    def __init__(self, in_channels, out_channels, atrous_rates):
        super(ASPP, self).__init__()
        self.conv1x1 = nn.Conv2d(in_channels, out_channels, kernel_size=1)
        self.conv3x3_1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=atrous_rates[0], dilation=atrous_rates[0])
        self.conv3x3_2 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=atrous_rates[1], dilation=atrous_rates[1])
        self.conv3x3_3 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=atrous_rates[2], dilation=atrous_rates[2])
        self.conv3x3_4 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=atrous_rates[3], dilation=atrous_rates[3])
        self.bn = nn.BatchNorm2d(out_channels)
    
    def forward(self, x):
        feat1x1 = self.conv1x1(x)
        feat3x3_1 = self.conv3x3_1(x)
        feat3x3_2 = self.conv3x3_2(x)
        feat3x3_3 = self.conv3x3_3(x)
        feat3x3_4 = self.conv3x3_4(x)

        out = torch.cat((feat1x1, feat3x3_1, feat3x3_2, feat3x3_3, feat3x3_4), dim=1)
        out = self.bn(out)
        
        return F.relu(out)

class Decoder(nn.Module):
    def __init__(self, in_channels, mid_channels, out_channels):
        super(Decoder, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, mid_channels, kernel_size=1)
        self.bn1 = nn.BatchNorm2d(mid_channels)
        self.conv2 = nn.Conv2d(mid_channels, mid_channels, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(mid_channels)
        self.conv3 = nn.Conv2d(mid_channels, out_channels, kernel_size=1)
        self.bn3 = nn.BatchNorm2d(out_channels)
    
    def forward(self, x, skip):
        x = F.interpolate(x, size=skip.size()[2:], mode='bilinear', align_corners=True)
        skip = self.conv1(skip)
        skip = self.bn1(skip)
        x = torch.cat((x, skip), dim=1)
        
        x = self.conv2(x)
        x = self.bn2(x)
        
        x = self.conv3(x)
        x = self.bn3(x)
        
        return F.relu(x)

模型训练：

该模型在leftImg8bit训练集上训练了100个epoch。显卡为：3090 24GB显存 batch_size：64

import torch
import torch.nn as nn
import torch.optim as optim

model = DeepLabV3(n_classes=19)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(num_epochs):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print('Epoch %d loss: %.3f' % (epoch + 1, running_loss / len(trainloader)))

模型测试：

在该项目中，我使用了交叉熵作为评估标准，同时保留每次训练最佳的模型。因此可以达到较好的识别效果。

可视化结果展示如下：

Cityscapes怎么做！DeepLabv3参见！_DeepLabv3

One AI套件使用

VTune Profiler分析PyTorch*程序的性能瓶颈，并进行优化。

步骤：

安装Intel® VTune™ Profiler，并启动。
在VTune Profiler中创建一个新的性能分析项目。

3 .选择“Python*”作为分析类型，并选择要分析的Python脚本。

4.在“高级设置”中，选择“PyTorch*”作为框架，并选择要使用的Python版本和PyTorch版本。

开始分析，并等待分析结果。
在分析结果中，选择“热点”视图，查看程序的性能瓶颈。
根据热点视图中的数据，进行代码优化，例如减少数据传输、使用更高效的算法等。
重新运行程序，并使用VTune Profiler进行性能测试，以验证优化效果。

标签：__,参见,nn,Cityscapes,channels,DeepLabv3,size,self,out
From： https://blog.51cto.com/u_11876373/7323703