语义分割之deeplab

最新推荐文章于 2024-09-20 14:23:31 发布
最新推荐文章于 2024-09-20 14:23:31 发布
阅读量745 收藏 5
点赞数
分类专栏： python 神经网络 tensorflow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41485242/article/details/106056122
版权
python 同时被 3 个专栏收录
34 篇文章 2 订阅
订阅专栏
tensorflow
23 篇文章 0 订阅
订阅专栏
神经网络
20 篇文章 0 订阅
订阅专栏

deeplab和之前的几个segnet，unet，pspnet结构不太一样，他的编码网络部分主体变为了Xception， 然后再进行不同层次的卷积，产生的特征包含两个部分，一个是Xception输出，一个是不同卷积后输出。因此解码器也包含两个部分。整个结构如下图

Xception.py Xception网络结构

from keras.models import Model
from keras import layers
from keras.layers import Input
from keras.layers import Lambda
from keras.layers import Activation
from keras.layers import Concatenate
from keras.layers import Add
from keras.layers import Dropout
from keras.layers import BatchNormalization
from keras.layers import Conv2D
from keras.layers import DepthwiseConv2D
from keras.layers import ZeroPadding2D
from keras.layers import GlobalAveragePooling2D


def _conv2d_same(x, filters, prefix, stride=1, kernel_size=3, rate=1):
    # 计算padding的数量，hw是否需要收缩
    if stride == 1:
        return Conv2D(filters,
                      (kernel_size, kernel_size),
                      strides=(stride, stride),
                      padding='same', use_bias=False,
                      dilation_rate=(rate, rate),
                      name=prefix)(x)
    else:
        kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
        pad_total = kernel_size_effective - 1
        pad_beg = pad_total // 2
        pad_end = pad_total - pad_beg
        x = ZeroPadding2D((pad_beg, pad_end))(x)
        return Conv2D(filters,
                      (kernel_size, kernel_size),
                      strides=(stride, stride),
                      padding='valid', use_bias=False,
                      dilation_rate=(rate, rate),
                      name=prefix)(x)


def SepConv_BN(x, filters, prefix, stride=1, kernel_size=3, rate=1, depth_activation=False, epsilon=1e-3):
    # 计算padding的数量，hw是否需要收缩
    if stride == 1:
        depth_padding = 'same'
    else:
        kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
        pad_total = kernel_size_effective - 1
        pad_beg = pad_total // 2
        pad_end = pad_total - pad_beg
        x = ZeroPadding2D((pad_beg, pad_end))(x)
        depth_padding = 'valid'
    
    # 如果需要激活函数
    if not depth_activation:
        x = Activation('relu')(x)

    # 分离卷积，首先3x3分离卷积，再1x1卷积
    # 3x3采用膨胀卷积
    x = DepthwiseConv2D((kernel_size, kernel_size), strides=(stride, stride), dilation_rate=(rate, rate),
                        padding=depth_padding, use_bias=False, name=prefix + '_depthwise')(x)
    x = BatchNormalization(name=prefix + '_depthwise_BN', epsilon=epsilon)(x)
    if depth_activation:
        x = Activation('relu')(x)

    # 1x1卷积，进行压缩
    x = Conv2D(filters, (1, 1), padding='same',
               use_bias=False, name=prefix + '_pointwise')(x)
    x = BatchNormalization(name=prefix + '_pointwise_BN', epsilon=epsilon)(x)
    if depth_activation:
        x = Activation('relu')(x)

    return x


def _xception_block(inputs, depth_list, prefix, skip_connection_type, stride,
                    rate=1, depth_activation=False, return_skip=False):

    residual = inputs
    for i in range(3):
        residual = SepConv_BN(residual,
                              depth_list[i],
                              prefix + '_separable_conv{}'.format(i + 1),
                              stride=stride if i == 2 else 1,
                              rate=rate,
                              depth_activation=depth_activation)
        if i == 1:
            skip = residual
    if skip_connection_type == 'conv':    # entry flow的残差是先1*1 conv再连接
        shortcut = _conv2d_same(inputs, depth_list[-1], prefix + '_shortcut',
                                kernel_size=1,
                                stride=stride)
        shortcut = BatchNormalization(name=prefix + '_shortcut_BN')(shortcut)
        outputs = layers.add([residual, shortcut])
    elif skip_connection_type == 'sum':  #middle flow的残差是直接连接
        outputs = layers.add([residual, inputs])
    elif skip_connection_type == 'none':  #exit flow 没有连接
        outputs = residual
    if return_skip:
        return outputs, skip
    else:
        return outputs


#Xceptption 模块
def Xception(inputs,alpha=1,OS=16):
    if OS == 8:
        entry_block3_stride = 1
        middle_block_rate = 2  # ! Not mentioned in paper, but required
        exit_block_rates = (2, 4)
        atrous_rates = (12, 24, 36)
    else:
        entry_block3_stride = 2
        middle_block_rate = 1
        exit_block_rates = (1, 2)
        atrous_rates = (6, 12, 18)
#---------------------------------------------entry flow-------------------------------------------
    # 256,256,32
    x = Conv2D(32, (3, 3), strides=(2, 2),
                name='entry_flow_conv1_1', use_bias=False, padding='same')(inputs)
    x = BatchNormalization(name='entry_flow_conv1_1_BN')(x)
    x = Activation('relu')(x)

    # 256,256,64
    x = _conv2d_same(x, 64, 'entry_flow_conv1_2', kernel_size=3, stride=1)
    x = BatchNormalization(name='entry_flow_conv1_2_BN')(x)
    x = Activation('relu')(x)

    # 256,256,128 -> 256,256,128 -> 128,128,128
    x = _xception_block(x, [128, 128, 128], 'entry_flow_block1',
                        skip_connection_type='conv', stride=2,
                        depth_activation=False)
    
    # 128,128,256 -> 128,128,256 -> 64,64,256
    # skip = 128,128,256
    x, skip1 = _xception_block(x, [256, 256, 256], 'entry_flow_block2',
                                skip_connection_type='conv', stride=2,
                                depth_activation=False, return_skip=True)

    x = _xception_block(x, [728, 728, 728], 'entry_flow_block3',
                        skip_connection_type='conv', stride=entry_block3_stride,
                        depth_activation=False)
#-----------------------------------------------middle flow------------------------------------------------------

    for i in range(16):
        x = _xception_block(x, [728, 728, 728], 'middle_flow_unit_{}'.format(i + 1),
                            skip_connection_type='sum', stride=1, rate=middle_block_rate,
                            depth_activation=False)

#----------------------------------------------exit flow---------------------------------------------------------
    x = _xception_block(x, [728, 1024, 1024], 'exit_flow_block1',
                        skip_connection_type='conv', stride=1, rate=exit_block_rates[0],
                        depth_activation=False)
    x = _xception_block(x, [1536, 1536, 2048], 'exit_flow_block2',
                        skip_connection_type='none', stride=1, rate=exit_block_rates[1],
                        depth_activation=True)
    return x,atrous_rates,skip1

deeplab.py 解码及整个模型连接

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf
from Xception import Xception
from keras.models import Model
from keras import layers
from keras.layers import Input
from keras.layers import Lambda
from keras.layers import Activation
from keras.layers import Softmax,Reshape
from keras.layers import Concatenate
from keras.layers import Add
from keras.layers import Dropout
from keras.layers import BatchNormalization
from keras.layers import Conv2D
from keras.layers import DepthwiseConv2D
from keras.layers import ZeroPadding2D
from keras.layers import GlobalAveragePooling2D
from keras.utils.data_utils import get_file
from keras import backend as K
from keras.activations import relu
from keras.applications.imagenet_utils import preprocess_input

def SepConv_BN(x, filters, prefix, stride=1, kernel_size=3, rate=1, depth_activation=False, epsilon=1e-3):
    # 计算padding的数量，hw是否需要收缩
    if stride == 1:
        depth_padding = 'same'
    else:
        kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
        pad_total = kernel_size_effective - 1
        pad_beg = pad_total // 2
        pad_end = pad_total - pad_beg
        x = ZeroPadding2D((pad_beg, pad_end))(x)
        depth_padding = 'valid'
    
    # 如果需要激活函数
    if not depth_activation:
        x = Activation('relu')(x)

    # 分离卷积，首先3x3分离卷积，再1x1卷积
    # 3x3采用膨胀卷积
    x = DepthwiseConv2D((kernel_size, kernel_size), strides=(stride, stride), dilation_rate=(rate, rate),
                        padding=depth_padding, use_bias=False, name=prefix + '_depthwise')(x)
    x = BatchNormalization(name=prefix + '_depthwise_BN', epsilon=epsilon)(x)
    if depth_activation:
        x = Activation('relu')(x)

    # 1x1卷积，进行压缩
    x = Conv2D(filters, (1, 1), padding='same',
               use_bias=False, name=prefix + '_pointwise')(x)
    x = BatchNormalization(name=prefix + '_pointwise_BN', epsilon=epsilon)(x)
    if depth_activation:
        x = Activation('relu')(x)

    return x

def Deeplabv3(input_shape=(512, 512, 3), classes=21, alpha=1.,OS=16):

    img_input = Input(shape=input_shape)
#----------------------------------------------Xception结构串行空洞卷积-------------------------------------------
    # x=32, 32, 2048     
    x,atrous_rates,skip1 = Xception(img_input,alpha,OS=OS)

#----------------------------------------------4个并行空洞卷积--------------------------------------------
    # 全部求平均后，再利用expand_dims扩充维度，1x1
    b4 = GlobalAveragePooling2D()(x)

    b4 = Lambda(lambda x: K.expand_dims(x, 1))(b4)
    b4 = Lambda(lambda x: K.expand_dims(x, 1))(b4)
    
    # 压缩filter
    b4 = Conv2D(256, (1, 1), padding='same',
                use_bias=False, name='image_pooling')(b4)
    b4 = BatchNormalization(name='image_pooling_BN', epsilon=1e-5)(b4)
    b4 = Activation('relu')(b4)

    size_before = tf.keras.backend.int_shape(x)
    # 直接利用resize_images扩充hw
    # b4 = 64,64,256
    b4 = Lambda(lambda x: tf.image.resize_images(x, size_before[1:3]))(b4)
    # 调整通道
    b0 = Conv2D(256, (1, 1), padding='same', use_bias=False, name='aspp0')(x)
    b0 = BatchNormalization(name='aspp0_BN', epsilon=1e-5)(b0)
    b0 = Activation('relu', name='aspp0_activation')(b0)
	
	# 并行空洞卷积
    # rate值与OS相关，SepConv_BN为先3x3膨胀卷积，再1x1卷积，进行压缩
    # 其膨胀率就是rate值
    # rate = 6 (12)
    b1 = SepConv_BN(x, 256, 'aspp1',
                    rate=atrous_rates[0], depth_activation=True, epsilon=1e-5)
    # rate = 12 (24)
    b2 = SepConv_BN(x, 256, 'aspp2',
                    rate=atrous_rates[1], depth_activation=True, epsilon=1e-5)
    # rate = 18 (36)
    b3 = SepConv_BN(x, 256, 'aspp3',
                    rate=atrous_rates[2], depth_activation=True, epsilon=1e-5)

    # 其实实际的意义就是对Xception的输出结果进行
    x = Concatenate()([b4, b0, b1, b2, b3])

#---------------------------------decoder------------------------------------------------------------#
    # 利用conv2d压缩
    x = Conv2D(256, (1, 1), padding='same',
               use_bias=False, name='concat_projection')(x)
    x = BatchNormalization(name='concat_projection_BN', epsilon=1e-5)(x)
    x = Activation('relu')(x)
    x = Dropout(0.1)(x)

    # skip1.shape[1:3] 为 128,128
    # skip1 128, 128, 256
    x = Lambda(lambda xx: tf.image.resize_images(x, skip1.shape[1:3]))(x)
                                                    
    # 128, 128, 48
    dec_skip1 = Conv2D(48, (1, 1), padding='same',
                        use_bias=False, name='feature_projection0')(skip1)
    dec_skip1 = BatchNormalization(
        name='feature_projection0_BN', epsilon=1e-5)(dec_skip1)
    dec_skip1 = Activation('relu')(dec_skip1)
    
    # 128,128,304
    x = Concatenate()([x, dec_skip1])
    x = SepConv_BN(x, 256, 'decoder_conv0',
                    depth_activation=True, epsilon=1e-5)
    x = SepConv_BN(x, 256, 'decoder_conv1',
                    depth_activation=True, epsilon=1e-5)


    x = Conv2D(classes, (1, 1), padding='same')(x)
    
    size_before3 = tf.keras.backend.int_shape(img_input)
    x = Lambda(lambda xx:tf.image.resize_images(xx,size_before3[1:3]))(x)

    x = Reshape((-1,classes))(x)
    x = Softmax()(x)

    inputs = img_input
    model = Model(inputs, x, name='deeplabv3plus')

    return model

train.py 训练部分

from deeplab import Deeplabv3
from keras.utils.data_utils import get_file
from keras.optimizers import Adam
from keras.callbacks import TensorBoard, ModelCheckpoint, ReduceLROnPlateau, EarlyStopping
from PIL import Image
import keras
from keras import backend as K
import numpy as np

ALPHA = 1.0
#WEIGHTS_PATH_X = "https://github.com/bonlime/keras-deeplab-v3-plus/releases/download/1.1/deeplabv3_xception_tf_dim_ordering_tf_kernels.h5"
                    
NCLASSES = 2
HEIGHT = 416
WIDTH = 416

def generate_arrays_from_file(lines,batch_size):
    # 获取总长度
    n = len(lines)
    i = 0
    while 1:
        X_train = []
        Y_train = []
        # 获取一个batch_size大小的数据
        for _ in range(batch_size):
            if i==0:
                np.random.shuffle(lines)
            name = lines[i].split(';')[0]
            # 从文件中读取图像
            img = Image.open(r".\dataset2\jpg" + '/' + name)
            img = img.resize((WIDTH,HEIGHT))
            img = np.array(img)
            img = img/255
            X_train.append(img)

            name = (lines[i].split(';')[1]).replace("\n", "")
            # 从文件中读取图像
            img = Image.open(r".\dataset2\png" + '/' + name)
            img = img.resize((int(WIDTH),int(HEIGHT)))
            img = np.array(img)
            seg_labels = np.zeros((int(HEIGHT),int(WIDTH),NCLASSES))
            for c in range(NCLASSES):
                seg_labels[: , : , c ] = (img[:,:,0] == c ).astype(int)
            seg_labels = np.reshape(seg_labels, (-1,NCLASSES))
            Y_train.append(seg_labels)

            # 读完一个周期后重新开始
            i = (i+1) % n
        yield (np.array(X_train),np.array(Y_train))

def loss(y_true, y_pred):
    crossloss = K.binary_crossentropy(y_true,y_pred)
    loss = K.sum(crossloss)/HEIGHT/WIDTH
    return loss

if __name__ == "__main__":
    log_dir = "logs/"
    # 获取model
    model = Deeplabv3(classes=2,input_shape=(HEIGHT,WIDTH,3))
    # model.summary()

    #weights_path = get_file('deeplabv3_xception_tf_dim_ordering_tf_kernels.h5',
                                    #WEIGHTS_PATH_X,
                                    #cache_subdir='models')
    weight_path = log_dir + 'deeplabv3_xception_tf_dim_ordering_tf_kernels.h5' 
    model.load_weights(weight_path,by_name=True)

    # 打开数据集的txt
    with open(r".\dataset2\train.txt","r") as f:
        lines = f.readlines()

    # 打乱行，这个txt主要用于帮助读取数据来训练
    # 打乱的数据更有利于训练
    np.random.seed(10101)
    np.random.shuffle(lines)
    np.random.seed(None)

    # 90%用于训练，10%用于估计。
    num_val = int(len(lines)*0.1)
    num_train = len(lines) - num_val

    # 保存的方式，1世代保存一次
    checkpoint_period = ModelCheckpoint(
                                    log_dir + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5',
                                    monitor='val_loss', 
                                    save_weights_only=True, 
                                    save_best_only=True, 
                                    period=1
                                )
    # 学习率下降的方式，val_loss 1次不下降就下降学习率继续训练
    reduce_lr = ReduceLROnPlateau(
                            monitor='val_loss', 
                            factor=0.5, 
                            patience=3, 
                            verbose=1
                        )
    # 是否需要早停，当val_loss一直不下降的时候意味着模型基本训练完毕，可以停止
    early_stopping = EarlyStopping(
                            monitor='val_loss', 
                            min_delta=0, 
                            patience=10, 
                            verbose=1
                        )

    # 交叉熵
    model.compile(loss = loss,
            optimizer = Adam(lr=1e-3),
            metrics = ['accuracy'])
            
    batch_size = 1
    print('Train on {} samples, val on {} samples, with batch size {}.'.format(num_train, num_val, batch_size))
    
    # 开始训练
    model.fit_generator(generate_arrays_from_file(lines[:num_train], batch_size),
            steps_per_epoch=max(1, num_train//batch_size),
            validation_data=generate_arrays_from_file(lines[num_train:], batch_size),
            validation_steps=max(1, num_val//batch_size),
            epochs=50,
            initial_epoch=0,
            callbacks=[checkpoint_period, reduce_lr])

    model.save_weights(log_dir+'last1.h5')

predict.py 预测部分

from deeplab import Deeplabv3
from PIL import Image
import numpy as np
import random
import copy
import os


class_colors = [[0,0,0],[0,255,0]]
NCLASSES = 2
HEIGHT = 416
WIDTH = 416


model = model = Deeplabv3(classes=2,input_shape=(HEIGHT,WIDTH,3))
model.load_weights("logs/deeplabv3_xception_tf_dim_ordering_tf_kernels.h5")
imgs = os.listdir("./img")

for jpg in imgs:

    img = Image.open("./img/"+jpg)
    old_img = copy.deepcopy(img)
    orininal_h = np.array(img).shape[0]
    orininal_w = np.array(img).shape[1]

    img = img.resize((WIDTH,HEIGHT))
    img = np.array(img)
    img = img/255
    img = img.reshape(-1,HEIGHT,WIDTH,3)
    pr = model.predict(img)[0]

    pr = pr.reshape((int(HEIGHT), int(WIDTH),NCLASSES)).argmax(axis=-1)

    seg_img = np.zeros((int(HEIGHT), int(WIDTH),3))
    colors = class_colors

    for c in range(NCLASSES):
        seg_img[:,:,0] += ( (pr[:,: ] == c )*( colors[c][0] )).astype('uint8')
        seg_img[:,:,1] += ((pr[:,: ] == c )*( colors[c][1] )).astype('uint8')
        seg_img[:,:,2] += ((pr[:,: ] == c )*( colors[c][2] )).astype('uint8')

    seg_img = Image.fromarray(np.uint8(seg_img)).resize((orininal_w,orininal_h))

    image = Image.blend(old_img,seg_img,0.3)
    image.save("./img_out/"+jpg)

 

吃不胖的粥
关注
专栏目录
DeepLab一家
qq_36326840的博客
04-04 4550
DeepLab是谷歌为了语义分割又做的一系列工作，在多个开源数据集中都取得了不错的成果，DeepLabv1发表于2014年，后于2016、2017、2018分别提出了V2，V3以及V3+的版本，在mmsegmentation里面主要集成了V3以及V3+的版本，应该也是DeepLab这一家里面效果最好的两个了。 作为当前工业以及学术上都用的比较广泛的模型，DeepLab这一家究竟优势在哪里呢，参考mmLab官方的讲解视频，可以发现DeepLab有三宝，分别是： 1、使用空洞卷积解决网络下采样的问题
Deeplab
Cindy_lxy的博客
12-16 1676
有什么问题欢迎留言指正~~~ Deeplab至今总共有四个版本： deeplabv1: https://arxiv.org/abs/1412.7062 由于这个版本时间太早，同时主要说的CRF在后面的版本里也被删除了，这里就不进行过多介绍了。 deeplabv2: https://arxiv.org/pdf/1606.00915.pdf 主要引入了空洞卷积（atrous convol...
深度学习 Deeplab 系列语义分割街景图像分割识别
最新发布
09-20 1222
Deeplab V3主要优化问题有： a. Feature map的分辨率过低导致后续恢复为原图的分辨率不够精确b. 对多尺度物体检测表现不好 1. 针对以上两个问题，提出了： a. 空洞卷积c. ASPP。
DeepLab
rosefun96的博客
10-24 8389
空洞卷积的使用 CRF在语义分割上的应用 传统上，CRF已被用于平滑噪声分割图。通常，这些模型包含耦合相邻节点的能量项，有利于相同标签分配空间近端像素。定性的说，这些短程的CRF主要功能是清除在手工特征基础上建立的弱分类器的虚假预测。 简要概述 空洞卷积可以在不增加参数的情况下增加感受野。 通过两种方式来进行多尺度的处理：A.将原始图像的多种尺度喂给网络进行训练。B.通过平行的不同空洞率的空洞卷积...
CV-DeepLab
09-07 379
DeepLab 是一系列用于图像分割的深度学习模型，由 Google 提出的。DeepLab 模型的主要版本包括 DeepLab v1、DeepLab v2、DeepLab v3 和 DeepLab v3+。DeepLab 系列模型在语义分割任务中表现出色，通过引入空洞卷积、深度可分离卷积以及编码器-解码器结构，不断改进了分割精度和效率。DeepLab v3+ 是最新的版本，综合了多种先进的技术，适用于需要高精度分割的各种应用场景。
deeplab介绍
热门推荐
u010451780的专栏
10-26 1万+
■ 论文 | Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation ■ 链接 | https://www.paperweekly.site/papers/1676 DeepLab 是结合了深度卷积神经网络（DCNNs）和概率图模型（DenseCRFs）的方法。 在实验中发现 DCNNs 做语义分割时精准度不够的问题，根本原因是 DCNNs 的高级特征的平移不变性，即高层次特征映射，根源于.
C++ 实现 语义分割 deeplab_v3
01-06
https://github.com/tensorflow/models/blob/master/research/deeplab/g3doc/model_zoo.md 中有许多个模型。 先下一个试试效果如何：...
自爆绝缘子语义分割，deeplab_v3+完整pytorch工程代码
04-22
采用pytorch深度学习框架实现的deeplab_v3+语义分割任务，谷歌deeplab系列性能最好也是最复杂的一个版本，可满足绝大部分基础语义分割场景。主干网络在算力不足时可选择轻量版的mobilenet_v2，算力足够时可选择...
win图像语义分割deeplab-v3程序
02-16
在这个场景下，我们关注的是一个名为"win图像语义分割deeplab-v3程序"的工具，它是基于DeepLab v3模型的Windows实现。DeepLab是一个由Google AI团队开发的深度学习模型，专门用于图像语义分割。 DeepLab v3的核心是...
语义分割网络DeepLab-v3的架构设计思想和TensorFlow实现
07-05
DeepLab-v3是谷歌研究团队为解决这一问题提出的一种先进网络架构，它在语义分割方面表现出色。本文将深入探讨DeepLab-v3的架构设计思想及其在TensorFlow中的实现。 DeepLab-v3的核心设计理念是通过结合不同级别的...
DeepLab语义分割
夏日山间过
09-12 1145
参考： DeepLab V1 V2 V3 V3+及pytorch实现 V1 DeepLab是针对语义分割任务提出的模型，主要使用了DCNN、CRF、空洞卷积做密集预测。 DeepLab是结合了深度卷积神经网络DCNNs和概率图模型DenseCRFs的方法。 DCNNs做语义分割时精度不够，原因是DCNNs的高级特征的平移不变性，也叫作高层次特征映射。平移不变性增强了对数据分层抽象的能力，但是也会...
Deeplab v2
11-13
deeplab-v2 　基于ｖｇｇ训练自己的数据的ｐｒｏｔｏｔｘｔ　和ｃｉｔｙｓｃａｐｅｓ的ｐｒｏｔｏｔｘｔ
『图像分割』DeepLab
libo-coder
05-20 404
文章目录一、Deeplabv31.1 主要变化二、Deeplabv3+2.1 改进之处 一、Deeplabv3 1.1 主要变化 （1）使用了 Multi-Grid 策略，即在模型后端多加几层不同 rate 的空洞卷积。 空洞卷积： Dilated Covolution，使得 backbone 在保持参数量不变，每个阶段的卷积层视野不变的前提下，靠后的卷积层也可保持较大的 feature maps 尺寸，从而有利于对小目标的检测，提高模型的整体性能。 （2）将 batch normalization
DeepLab: 使用深度卷积网络、空洞卷积和全连接 CRF 进行语义图像分割
weixin_46831727的博客
08-31 855
DCNN网络中的特征分辨率降低会影响定位精度，同时为解决多尺度物体问题，对同一图像进行多种尺度的重新采样（缩放），然后将这些不同尺度的图像输入到深度卷积神经网络（DCNN）中，使得计算复杂度高，存储和内存消耗大以及训练和推理时间延长。在ASPP中，特征整合通过不同空洞率的卷积操作生成多尺度特征图，然后将这些特征图拼接在一起，形成一个包含丰富上下文信息的综合特征表示。卷积层等操作进一步融合这些特征。
DeepLab系列
sinoai
03-28 1013
一.资源 DeelLab系列：DeepLabv1、DeepLabv2及运行、DeepLabv3、DeepLabv3+及运行。 二.模型结构 图2-1[v3+图2] DeepLabv3+是在DeepLabv3的基础上扩展出的一个编解码器结构。 三.编码器 编码器是Deeplabv3模型的logits前的部分。 四.解码器 让空洞卷积提取更稠密的特征有助于恢复边界细节，但计算量会剧增...
语义分割网络系列3——DeepLab
xiaotiig的博客
06-15 961
DeepLab1 介绍1.1 背景1.2 Deeplab V1介绍1.3 结构1.4 特点1.4.1 空洞卷积的使用1.4.2 CRF的应用1.5 DeepLab系列总结2 代码3 总结参考资料 1 介绍 相比于传统的视觉算法(SIFT或HOG)，Deep-CNN以其end-to-end方式获得了很好的效果。这样的成功部分可以归功于Deep-CNN对图像转换的平移不变性(invariance)，这根本是源于重复的池化和下采样组合层。平移不变性增强了对数据分层抽象的能力，但同时可能会阻碍低级(low-lev
深度学习语义图像分割：DeepLab与空洞卷积
空洞卷积能够扩展滤波器的视野，使网络能捕获更大的上下文信息，这对于密集预测任务，如语义分割，至关重要。 2. 空洞空间金字塔池化（Atrous Spatial Pyramid Pooling, ASPP）：为了解决不同大小物体的分割问题，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值