深度神经网络Deeplabv3_resnet50详解

最新推荐文章于 2024-03-30 20:58:00 发布
最新推荐文章于 2024-03-30 20:58:00 发布
阅读量5.3k 收藏 48
点赞数 15
分类专栏： 神经网络 python 图像处理 文章标签： 神经网络 深度学习 pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44816589/article/details/115266935
版权

深度神经网络Deeplabv3_resnet50详解

深度神经网络Deeplabv3_resnet50详解

小编最近有个项目是用神经网络deeplabv3_resnet50完成，现在用简单易懂的方式进行梳理，帮助跟我当初一样的初学者也能看懂，节省时间。并且，依据data flow过程，用最基本的语句编写了复盘程序，可帮助读者理解每一步的实现。

论文及公开代码

论文下载：https://arxiv.org/pdf/1512.03385.pdf
git公开代码：https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
参考博客：
1、https://blog.csdn.net/qq_35435964/article/details/101470991
2、https://www.jiqizhixin.com/articles/042201
3、https://zhuanlan.zhihu.com/p/72226476?from_voters_page=true

我自己对网络框架的理解

特点：网络输入数据input（H， W）与网络输出数据output（H， W）相同。在数据经过整个网络中，先通过下采样，再通过上采样，即可获取这样的效果。
以resnet50作为backbone, 在加上ASPP和aux_classifier组成了deeplabv3。详细的机构图如下：
在这里插入图片描述

从图中可以看出，input数据先依次经过initial block, layer 1, layer 2, layer 3。从layer 3输出的数据分别保存为out(tensor 类型) 和 aux(tensor)。其中out继续经过layer 4和 ASPP一系列操作，输出仍赋值给out变量。而aux直接经过conv, BN, ReLU, dropout, conv操作，得到新的aux。此时的out和aux形状相同，且与input的形状相同。
注：也有解释说layer–>stage

下采样

**注释：使图像H，W缩小的操作，在此处统一理解为下采样。如下图黑色箭头指示处。
网络中出现两种形式的下采样：
1 典型的池化pool实现下采样
2 利用卷积特性特性下采样
需要注意的是：ASPP中的pool 为平均池化AdaptAvgPool2d(output_size=1)，输出尺寸为（B, N, 1, 1）
在这里插入图片描述

上采样

**注释：使图像H，W放大的操作，在此处统一理解为上采样。如下图黑色箭头指示处。
模型中共有三处上采样，并最总使得图像输出尺寸与输入尺寸相同。
需要注意的是：ASPP中的上采样是将尺寸为（B, N, 1, 1）的图像放大至与ASPP上面的4层数据形状相同（B, N, 48, 48），目的将在下面ASPP过程介绍
在这里插入图片描述

空洞卷积

网络中3个模块中出现空洞卷积：
Layer 3：采用固定dilation=（2，2）
Layer 4：采用不固定dilation=（2，2）；（4，4）；（4，4）
ASPP ：采用不固定dilation=（12，12）；（24，24）；（36，36）
相应的，每一个空洞卷积的padding与dilation保持一致。
图：带有黑色圆环的表示空洞卷积操作。
在这里插入图片描述
公式：带有dilation的卷积（空洞卷积）后图像尺寸计算公式，详情见pytorch doc链接：
在这里插入图片描述

ASPP: Atrous Spatial Pyramid Pooling

ASPP可以理解为一组按一定规律排列的空洞卷积组合。
是将5个Batch的数据按dim=1轴即通道channel轴进行拼接concat(dim=1)。得到的结果为（N，C*5，H，W）
在这里插入图片描述

流水代码

**注释：此代码仅供学习神经网络，若用于模型训练，请使用git上公开项目。
torch version: “1.6.0” ；代码已跑通，可直接使用。
P.S: 本代码第3行：x=torch.randn(2,1,384,384)中batch不能写用1，应为在ASPP中经过AdaptAvgpool后图像变为（1，C, 1, 1）, 做batchNorm操作时出错。而在torch的deeplabv3_resnet50框架中，做了相应的处理。图像尺寸设置为384*384， 是因为项目中应用尺寸。且与以上所有图中数据形状保持前后一致。读者可根据自己需要修改尺寸，只要是8的倍数即可。
如相关解释有误，请留言，我看到后会进行更正。

import torch
# from torch import nn
x=torch.randn(2,1,384,384)  #   (batch, channels, H, W)
input_shape=x.shape
print("input_shape", input_shape)
conv2d=torch.nn.Conv2d(1, 64, kernel_size=(7,7), stride=(2,2), padding=(3,3), bias=False)
x=conv2d(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(64)
x=BN1(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)
maxpool = torch.nn.MaxPool2d(kernel_size=3, stride=2,padding=1,dilation=1,ceil_mode=False)
x=maxpool(x)
print(x.shape)
print("\nlayer 1 - bottleneck 0-------------------")
# downsample
down_conv=torch.nn.Conv2d(64, 256, kernel_size=(1,1), stride=(1,1), bias=False)
identity=down_conv(x)
print("downsample",identity.shape)
down_BN1=torch.nn.BatchNorm2d(256)
identity=down_BN1(identity)
print("downsample",identity.shape)

conv1=torch.nn.Conv2d(64, 64, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(64)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(64, 64, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(64)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(64, 256, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(256)
x=BN3(x)
print(x.shape)
x += identity
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 1 - bottleneck 1-------------------")
conv1=torch.nn.Conv2d(256, 64, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(64)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(64, 64, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(64)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(64, 256, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(256)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)
print("\nlayer 1 - bottleneck 2-------------------")
conv1=torch.nn.Conv2d(256, 64, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(64)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(64, 64, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(64)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(64, 256, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(256)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 2 - bottleneck 0-------------------")
# downsample
down_conv=torch.nn.Conv2d(256, 512, kernel_size=(1,1), stride=(2,2), bias=False)
identity=down_conv(x)
print("downsample",identity.shape)
down_BN1=torch.nn.BatchNorm2d(512)
identity=down_BN1(identity)
print("downsample",identity.shape)

conv1=torch.nn.Conv2d(256, 128, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(128)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(128, 128, kernel_size=(3,3), stride=(2,2), padding=(1,1), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(128)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(128, 512, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(512)
x=BN3(x)
print(x.shape)
x+=identity
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 2 - bottleneck 1-------------------")
conv1=torch.nn.Conv2d(512, 128, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(128)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(128, 128, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(128)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(128, 512, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(512)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 2 - bottleneck 2-------------------")
conv1=torch.nn.Conv2d(512, 128, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(128)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(128, 128, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(128)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(128, 512, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(512)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 2 - bottleneck 3-------------------")
conv1=torch.nn.Conv2d(512, 128, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(128)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(128, 128, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(128)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(128, 512, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(512)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 3 - bottleneck 0-------------------")
# downsample
down_conv=torch.nn.Conv2d(512, 1024, kernel_size=(1,1), stride=(1,1), bias=False)
identity=down_conv(x)
print("downsample",identity.shape)
down_BN1=torch.nn.BatchNorm2d(1024)
identity=down_BN1(identity)
print("downsample",identity.shape)

conv1=torch.nn.Conv2d(512, 256, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(256)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(256, 256, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(256)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(256, 1024, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(1024)
x=BN3(x)
print(x.shape)
x+=identity
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 3 - bottleneck 1-------------------")
conv1=torch.nn.Conv2d(1024, 256, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(256)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(256, 256, kernel_size=(3,3), stride=(1,1), padding=(2,2), dilation=(2,2), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(256)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(256, 1024, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(1024)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 3 - bottleneck 2-------------------")
conv1=torch.nn.Conv2d(1024, 256, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(256)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(256, 256, kernel_size=(3,3), stride=(1,1), padding=(2,2), dilation=(2,2), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(256)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(256, 1024, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(1024)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 3 - bottleneck 3-------------------")
conv1=torch.nn.Conv2d(1024, 256, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(256)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(256, 256, kernel_size=(3,3), stride=(1,1), padding=(2,2), dilation=(2,2), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(256)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(256, 1024, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(1024)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 3 - bottleneck 4-------------------")
conv1=torch.nn.Conv2d(1024, 256, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(256)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(256, 256, kernel_size=(3,3), stride=(1,1), padding=(2,2), dilation=(2,2), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(256)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(256, 1024, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(1024)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 3 - bottleneck 5-------------------")
conv1=torch.nn.Conv2d(1024, 256, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(256)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(256, 256, kernel_size=(3,3), stride=(1,1), padding=(2,2), dilation=(2,2), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(256)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(256, 1024, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(1024)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
aux=x            # TODO used for aux_classifier
print("aux.shape: ", aux.shape)
print(x.shape)

print("\nlayer 4 - bottleneck 0-------------------")
# downsample
down_conv=torch.nn.Conv2d(1024, 2048, kernel_size=(1,1), stride=(1,1), bias=False)
identity=down_conv(x)
print("downsample",identity.shape)
down_BN1=torch.nn.BatchNorm2d(2048)
identity=down_BN1(identity)
print("downsample",identity.shape)

conv1=torch.nn.Conv2d(1024, 512, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(512)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(512, 512, kernel_size=(3,3), stride=(1,1), padding=(2,2), dilation=(2,2), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(512)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(512, 2048, kernel_size=(1,1), stride=(1,1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(2048)
x=BN3(x)
print(x.shape)
x+=identity
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)


print("\nlayer 4 - bottleneck 1-------------------")
conv1=torch.nn.Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(512)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(4, 4), dilation=(4, 4), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(512)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(2048)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nlayer 4 - bottleneck 2-------------------")
conv1=torch.nn.Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
x=conv1(x)
print(x.shape)
BN1=torch.nn.BatchNorm2d(512)
x=BN1(x)
print(x.shape)
conv2=torch.nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(4, 4), dilation=(4, 4), bias=False)
x=conv2(x)
print(x.shape)
BN2=torch.nn.BatchNorm2d(512)
x=BN2(x)
print(x.shape)
conv3=torch.nn.Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
x=conv3(x)
print(x.shape)
BN3=torch.nn.BatchNorm2d(2048)
x=BN3(x)
print(x.shape)
relu=torch.nn.ReLU()
x=relu(x)
print(x.shape)

print("\nclassifier - ASPP sequential 0-------------------")
res=[]
conv2d=torch.nn.Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
ASPP0=conv2d(x)
BN=torch.nn.BatchNorm2d(256)
ASPP0=BN(ASPP0)
ASPP0=relu(ASPP0)
res.append(ASPP0)
print(ASPP0.shape)

print("\nclassifier - ASPP ASPPConv1-------------------")
conv2d=torch.nn.Conv2d(2048, 256, kernel_size=(3, 3), stride=(1, 1), padding=(12,12), dilation=(12,12), bias=False)
ASPP1=conv2d(x)
BN=torch.nn.BatchNorm2d(256)
ASPP1=BN(ASPP1)
ASPP1=relu(ASPP1)
res.append(ASPP1)
print(ASPP1.shape)

print("\nclassifier - ASPP ASPPConv2-------------------")
conv2d=torch.nn.Conv2d(2048, 256, kernel_size=(3, 3), stride=(1, 1), padding=(24,24), dilation=(24,24), bias=False)
ASPP2=conv2d(x)
BN=torch.nn.BatchNorm2d(256)
ASPP2=BN(ASPP2)
ASPP2=relu(ASPP2)
res.append(ASPP2)
print(ASPP2.shape)

print("\nclassifier - ASPP ASPPConv2-------------------")
conv2d=torch.nn.Conv2d(2048, 256, kernel_size=(3, 3), stride=(1, 1), padding=(36,36), dilation=(36,36), bias=False)
ASPP3=conv2d(x)
BN=torch.nn.BatchNorm2d(256)
ASPP3=BN(ASPP3)
ASPP3=relu(ASPP3)
res.append(ASPP3)
print(ASPP3.shape)

print("\nclassifier - ASPP ASPPpooling-------------------")
adaptiveavgpooling=torch.nn.AdaptiveAvgPool2d(1)                                                           # 下采样过程，输出（B, N ,1, 1）
ASPP4=adaptiveavgpooling(x)
conv2d=torch.nn.Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
ASPP4=conv2d(ASPP4)
BN=torch.nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
ASPP4=BN(ASPP4)           # 注意：如果batch_num即N等于1，则ASPP为（1,C,1,1）, 此条命令会出错，本验证程序将B设置为2。但是在Pytorch框架下的deeplabv3在此处做了处理，不再赘述
ASP4=relu(ASPP4)
ASPP4=torch.nn.functional.interpolate(ASPP4, size=ASPP3.shape[-2:], mode="bilinear", align_corners=False)   # 上采样过程，输出ASPP3形状  # 上采样，（1，1）-->（48，48）
res.append(ASPP4)
print(ASPP4.shape)

print("\nclassifier - ASPP result after torch.cat()-------------------")
res=torch.cat(res, dim=1)
print("res: ", res.shape)

print("\nclassifier -project-------------------")
conv2d=torch.nn.Conv2d(1280, 256, kernel_size=(1,1), stride=(1,1), bias=False)
out=conv2d(res)
BN=torch.nn.BatchNorm2d(256)
out=BN(out)
relu=torch.nn.ReLU()
out=relu(out)
dropout=torch.nn.Dropout(p=0.5, inplace=False)
out=dropout(out)

conv2d=torch.nn.Conv2d(256, 256, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
out=conv2d(out)
BN=torch.nn.BatchNorm2d(256)
out=BN(out)
relu=torch.nn.ReLU()
out=relu(out)
conv2d=torch.nn.Conv2d(256, 1, kernel_size=(1,1), stride=(1,1))
out=conv2d(out)
out=torch.nn.functional.interpolate(out, size=input_shape[-2:], mode="bilinear", align_corners=False)   # 上采样，（48，48）-->（384，384）
print("out.shape: ", out.shape)


print("\naux_classifier --------------------")
conv2d=torch.nn.Conv2d(1024, 256, kernel_size=(3,3), stride=(1,1), padding=(1,1), bias=False)
aux=conv2d(aux)
BN=torch.nn.BatchNorm2d(256)
aux=BN(aux)
relu=torch.nn.ReLU()
aux=relu(aux)
print(aux.shape)
dropout=torch.nn.Dropout(p=0.1, inplace=False)
aux=dropout(aux)
print(aux.shape)
conv2d=torch.nn.Conv2d(256, 1, kernel_size=(1,1), stride=(1,1))
aux=conv2d(aux)
aux=torch.nn.functional.interpolate(aux, size=input_shape[-2:], mode="bilinear", align_corners=False)   # 上采样，（48，48）-->（384，384）
print("aux.shape: ", aux.shape)

print("\nsigmoid --------------------")
logit=(aux+out)/2.0
print("logit.shape", logit.shape)
sigmoid=torch.nn.Sigmoid()
prob=sigmoid(out)
print("prob.shape", prob.shape)

输出：

D:\Program_Files\Anaconda3\envs\torch_gpu\python.exe "D:\Program Files (x86)\PyCharm Community Edition 2020.3\plugins\python-ce\helpers\pydev\pydevd.py" --multiproc --qt-support=auto --client 127.0.0.1 --port 51825 --file D:/python/first_B/test_test/deeplabv3.py
Connected to pydev debugger (build 203.5981.52)
input_shape torch.Size([2, 3, 384, 384])
torch.Size([2, 64, 192, 192])
torch.Size([2, 64, 192, 192])
torch.Size([2, 64, 192, 192])
torch.Size([2, 64, 96, 96])

layer 1 - bottleneck 0-------------------
downsample torch.Size([2, 256, 96, 96])
downsample torch.Size([2, 256, 96, 96])
torch.Size([2, 64, 96, 96])
torch.Size([2, 64, 96, 96])
torch.Size([2, 64, 96, 96])
torch.Size([2, 64, 96, 96])
torch.Size([2, 256, 96, 96])
torch.Size([2, 256, 96, 96])
torch.Size([2, 256, 96, 96])

layer 1 - bottleneck 1-------------------
torch.Size([2, 64, 96, 96])
torch.Size([2, 64, 96, 96])
torch.Size([2, 64, 96, 96])
torch.Size([2, 64, 96, 96])
torch.Size([2, 256, 96, 96])
torch.Size([2, 256, 96, 96])
torch.Size([2, 256, 96, 96])

layer 1 - bottleneck 2-------------------
torch.Size([2, 64, 96, 96])
torch.Size([2, 64, 96, 96])
torch.Size([2, 64, 96, 96])
torch.Size([2, 64, 96, 96])
torch.Size([2, 256, 96, 96])
torch.Size([2, 256, 96, 96])
torch.Size([2, 256, 96, 96])

layer 2 - bottleneck 0-------------------
downsample torch.Size([2, 512, 48, 48])
downsample torch.Size([2, 512, 48, 48])
torch.Size([2, 128, 96, 96])
torch.Size([2, 128, 96, 96])
torch.Size([2, 128, 48, 48])
torch.Size([2, 128, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])

layer 2 - bottleneck 1-------------------
torch.Size([2, 128, 48, 48])
torch.Size([2, 128, 48, 48])
torch.Size([2, 128, 48, 48])
torch.Size([2, 128, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])

layer 2 - bottleneck 2-------------------
torch.Size([2, 128, 48, 48])
torch.Size([2, 128, 48, 48])
torch.Size([2, 128, 48, 48])
torch.Size([2, 128, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])

layer 2 - bottleneck 3-------------------
torch.Size([2, 128, 48, 48])
torch.Size([2, 128, 48, 48])
torch.Size([2, 128, 48, 48])
torch.Size([2, 128, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])

layer 3 - bottleneck 0-------------------
downsample torch.Size([2, 1024, 48, 48])
downsample torch.Size([2, 1024, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])

layer 3 - bottleneck 1-------------------
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])

layer 3 - bottleneck 2-------------------
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])

layer 3 - bottleneck 3-------------------
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])

layer 3 - bottleneck 4-------------------
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])

layer 3 - bottleneck 5-------------------
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 256, 48, 48])
torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])
aux.shape:  torch.Size([2, 1024, 48, 48])
torch.Size([2, 1024, 48, 48])

layer 4 - bottleneck 0-------------------
downsample torch.Size([2, 2048, 48, 48])
downsample torch.Size([2, 2048, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 2048, 48, 48])
torch.Size([2, 2048, 48, 48])
torch.Size([2, 2048, 48, 48])

layer 4 - bottleneck 1-------------------
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 2048, 48, 48])
torch.Size([2, 2048, 48, 48])
torch.Size([2, 2048, 48, 48])

layer 4 - bottleneck 2-------------------
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 512, 48, 48])
torch.Size([2, 2048, 48, 48])
torch.Size([2, 2048, 48, 48])
torch.Size([2, 2048, 48, 48])

classifier - ASPP sequential 0-------------------
torch.Size([2, 256, 48, 48])

classifier - ASPP ASPPConv1-------------------
torch.Size([2, 256, 48, 48])

classifier - ASPP ASPPConv2-------------------
torch.Size([2, 256, 48, 48])

classifier - ASPP ASPPConv2-------------------
torch.Size([2, 256, 48, 48])

classifier - ASPP ASPPpooling-------------------
torch.Size([2, 256, 48, 48])

classifier - ASPP result after torch.cat()-------------------
res:  torch.Size([2, 1280, 48, 48])

classifier -project-------------------
out.shape:  torch.Size([2, 1, 384, 384])

aux_classifier --------------------
torch.Size([2, 256, 48, 48])
torch.Size([2, 1, 384, 384])

Process finished with exit code -1
那郎
关注
  • 15
    点赞
  • 踩
  • 48
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
DeepLabV3使用及源码讲解
@bangbang的博客
02-06 5203
博文介绍的DeepLabV3 代码主要来自于pytorch官方torchvision模块中的。
pytorch-deeplab-resnet：pytorch中的DeepLab resnet v2模型
02-05
pytorch-deeplab-resnet 模型实现。 deepLab-ResNet的体系结构已完全复制自caffe实现。 该体系结构可在多个比例（1x，0.75x，0.5x）上计算输入图像上的损耗。 在这三个等级上分别计算损失。 除了这3个损失外，在将3个标度上的输出得分图合并后，还会计算出一个损失。 将这4个损失相加以计算总损失。 更新 2017年7月18日 添加了另一个评估脚本evalpyt2.py 。 旧的评价脚本evalpyt.py使用不同的methodoloy拿白条平均比所使用的一个。 结果部分已更新，以纳入此更改。 2017年6月24日 现在，与caffe实现一样，可以共
deeplabv3-resnet50-coco torch
11-24
deeplabv3-resnet50-coco torch
Pytorch 基于 deeplabv3_resnet50 迁移训练自己的图像语义分割模型
小毕超博客
11-27 1036
图像语义分割是计算机视觉领域的一项重要任务，旨在将图像中的每个像素分配到其所属的语义类别，从而实现对图像内容的细粒度理解。与目标检测不同，图像语义分割要求对图像中的每个像素进行分类，而不仅仅是确定物体的边界框。deeplabv3_resnet50 就是一个常用的语义分割模型，它巧妙地将两个强大的神经网络架构融合在一起，为像素级别的图像理解提供了强大的解决方案。
【语义分割实战（2）】DeepLabV3+语义分割：训练自己的数据集
最新发布
m0_51579041的博客
03-30 1030
【语义分割实战（2）】DeepLabV3+语义分割：训练自己的数据集
最大约数和（洛谷）
六级不考550+不改名
10-12 611
题目描述 选取和不超过 S 的若干个不同的正整数，使得所有数的约数（不含它本身）之和最大。 输入格式 输入一个正整数 S。 输出格式 输出最大的约数之和。 输入样例 11 输出样例 9 数据范围 S ≤ 1000 样例说明 取数字 4 和 6，可以得到最大值 (1 + 2) + (1 + 2 + 3) = 9。 题解 01背包（空间优化）： #include <iostream> using namespace std; const int N = 1010; int n; int w[N
机器学习笔记 - 用于语义图像分割的空洞卷积DeepLabv3
学以致用 知行合一
01-06 1211
DeepLabv3 是用于语义分割任务的深度神经网络 (DNN) 架构。虽然不是多新的网络模型，但是也是分割模型里的杰出代表之一，所以还是值得深入了解。它使用Atrous（Dilated）卷积来控制感受野和特征图分辨率，而不增加参数总数。另一个主要属性是所谓的“Atrous Spatial Pyramid Pooling”，它可以有效地提取包含有用分割信息的多尺度特征。一般来说，网络能够捕获具有丰富远程信息的密集特征图，可用于准确分割图像。
Deeplabv3+-训练自己的数据集
qq_38766208的博客
12-27 2540
安装训练可视化工具visdom python -m visdom.server 训练网络 经过我的测试，使用deeplabv3plus_resnet50模型分割出来的效果比较好 num_classes设置为类别数+1 训练好的权重在checkpoints文件夹下 $ python main.py --model deeplabv3plus_resnet50 --enable_vis --vis_port 8097 --gpu_id 0 --year 2007 --crop_val --lr 0.01 --
deeplabv3_resnet50_coco-cd0a2569.zip
03-16
torchvison的deeplabv3_resnet50_coco-cd0a2569图像分割预训练模型，里面包含deeplabv3_resnet50和resnet50的预训练模型，二者缺一不可。如果使用torchvision自动下载比较慢的可以直接下载这个放在%USERPROFILE%.cache\torch\hub\checkpoints文件夹下。
Deeplab实战：使用deeplabv3实现对人物的抠图
AI浩
04-08 2996
摘要 在上一篇文章中我们使用UNet实现了二分类分割，训练了150个epoch，最后dice得分在0.87左右。今天我们使用更优秀的网络deeplabv3实现图像的二分类分割，dice得分大约在0.97左右。 关于二分类一般有两种做法： 第一种输出是单通道，即网络的输出 output 为 [batch_size, 1, height, width] 形状。其中 batch_szie 为批量大小，1 表示输出一个通道，height 和 width 与输入图像的高和宽保持一致。 在训练时，输出通道数是 1，网络
torchvision.models.segmentation.deeplabv3_resnet50实战
m0_57412861的博客
03-19 3748
最近在进行医学图像处理时，使用到了预训练好的deeplabv3-resnet50网络，在此记录一下应用（调参）的过程。 首先定义模型类，由于直接print网络结构可知，torchvision导入的预训练的模型最后一层是一个conv层，所以需要我们增添一个激活层。【注：导入模型的输出为字典格式，存在‘out’中】 由于最终输出结果为灰度图，是一种二分类逐像素预测，所以此处num_classes设置为2. class seg_(torch.nn.Module): def __init__(sel
解析DeepLabv3+的网络结构及代码【Pytorch版】
AI数据工厂
01-16 2万+
主要结合DeepLabv3+的网络结构和开源代码进行了对照解析。通过对网络结构中的每一块的作用及其代码实现中的细节进行了解，就能够对该网络模型有一个宏观和微观上的把握。
fenlei.rar_2PSG_nwpu resisc_resnet50_卷积神经网络_深度图像
07-15
利用深度学习进行遥感图像场景分类 这里我们对NWPU-RESISC45数据集的场景图像进行分类 我们将卷积神经网络应用于图像分类。我们从头开始训练数据集。此外，还应用了预先训练的VGG16 abd ResNet50进行迁移学习。
DeepLab-ResNet-101-深度学习代码类资源
05-09
完整工程案例：深度学习Tensorflow 图像语义分割（Image Segmentation）DeepLab基于ResNet101模型（tensorflow1.1以上、python3.5及以上）
dlib_face_recognition_resnet_model_v1.dat.zip_ResNet_dlib_face r
07-15
人脸识别中需要的resnet网络模型，用于处理人脸数据
detection_Resnet50_Final.pth, Resnet50_Final.pth
03-16
detection_Resnet50_Final.pth, Resnet50_Final.pth, md5: bce939bc22d8cec91229716dd932e
DeepLabV3网络简析
热门推荐
霹雳吧啦Wz
12-09 3万+
接着上篇DeepLab V2，本博文简单介绍下DeepLab V3（建议先去看下之前讲的DeepLab V1和DeepLab V2）。这是一篇2017年发表在CVPR上的文章。个人简单阅读完论文后感觉相比DeepLab V2有三点变化：1）引入了Multi-grid，2）改进了ASPP结构，3）把CRFs后处理给移除掉了。再吐槽一下，这篇论文看着感觉乱糟糟的。本篇博文就不按照论文的顺序去写了，直接按照我个人的想法去写。
deeplabV3+网络实现及解析
qq_39210987的博客
09-08 6845
deeplabV3+网络实现及解析 简介   DeepLab V3+通过添加一个简单而有效的解码器模块， 从而扩展了DeepLab V3，以优化分割结果，尤其是沿对象边界的分割结果。 我们进一步探索Xception模型，并将深度可分离卷积应用于 Atrous空间金字塔池和解码器模块，从而形成更快、更强大的编码器-解码器网络。 网络结构   DeepLab V3+的主要模型结构如下图：   这里的结构分为了两部分：encoder和decoder。encoder中连接的第一个模块是DCNN， 他代表的是
(Deeplab v3)——tensorflow-deeplab-resnet 原理及代码详解
咖啡味儿的咖啡
10-02 5013
在GitHub上找到一个不错的代码：https://github.com/DrSleep/tensorflow-deeplab-resnet 改代码的baseline是resnet101，使用了空洞卷积 前言： 代码的model.py，network.py是建立深度学习网络的部分，这部分代码风格与Faster-RCNN_TF那个程序的风格非常相似，也很简单，不再多做介绍。这里主要介绍train.p...
deeplabv3+参数量和模型大小
04-03
DeepLabv3 是一种经过优化的深度学习模型，主要用于图像分割任务。它的参数量和模型大小取决于所使用的具体架构和数据集大小，以下是一些常见的 DeepLabv3 架构和其参数量和模型大小的估计： 1. DeepLabv3+ (ResNet-101)：参数量为 58.6M，模型大小为 222.3 MB。 2. DeepLabv3 (MobileNetv2)：参数量为 2.2M，模型大小为 8.8 MB。 3. DeepLabv3 (Xception-65)：参数量为 41.3M，模型大小为 157.3 MB。 需要注意的是，这些数字仅作为参考，实际使用中可能会因为不同的优化方式、数据集等因素有所不同。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值