语义分割—3 SPSNet

最新推荐文章于 2022-04-20 20:11:38 发布
最新推荐文章于 2022-04-20 20:11:38 发布
阅读量333 收藏 1
点赞数
分类专栏： 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35732321/article/details/114366865
版权

SPSNet


PSPnet采用了PSP模块。金字塔池化模块(Pyramid Pooling Module)能够聚合不同区域的上下文信息，从而提高获取全局信息的能力。PSP结构典型情况下，会将输入进来的特征层划分成6x6，3x3，2x2，1x1的网格，然后对每个子区域进行平均池化，再对上一步结果上采样到统一大小，最后把特征堆叠起来就获取了不同区域的上下文信息。

1 PSPnet结构

1.1. backbone：MobileNetV2

a. 结构

# 1.bottleneck
input
↓
CBA(1*1, 升维)
↓
DBA(3*3，s=1/2)
↓
CB(1*1, 降维)
↓
if skip_connection:add(input)

# 2.MobileNetV2
input
↓
conv2d(f=32,s=2)
↓
bottleneck*1(expand=1,f=16,s=1)
↓
bottleneck*2(expand=6,f=24,s=2)
↓
bottleneck*3(expand=6,f=32,s=2)
↓
bottleneck*4(expand=6,f=64,s=2)
↓
bottleneck*3(expand=6,f=96,s=1)
↓
bottleneck*3(expand=6,f=160,s=2)->f4
↓
bottleneck*1(expand=6,f=320,s=1)->f5
↓
conv2d(1*1,f=1280,s=1)
↓
avgpool(7*7)
↓
conv2d(1*1,f=clc)

b. 代码

from keras import layers
from keras.activations import relu
from keras.layers import (Activation, Add, BatchNormalization, Concatenate,
                          Conv2D, DepthwiseConv2D, Dropout,
                          GlobalAveragePooling2D, Input, Lambda, ZeroPadding2D)
from keras.models import Model


def _make_divisible(v, divisor, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v

def relu6(x):
    return relu(x, max_value=6)

def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id, skip_connection, rate=1):
    in_channels = inputs.shape[-1].value
    pointwise_filters = _make_divisible(int(filters * alpha), 8)
    prefix = 'expanded_conv_{}_'.format(block_id)

    x = inputs

    #----------------------------------------------------#
    #   利用1x1卷积根据输入进来的通道数进行通道数上升
    #----------------------------------------------------#
    if block_id:
        x = Conv2D(expansion * in_channels, kernel_size=1, padding='same',
                   use_bias=False, activation=None,
                   name=prefix + 'expand')(x)
        x = BatchNormalization(epsilon=1e-3, momentum=0.999,
                               name=prefix + 'expand_BN')(x)
        x = Activation(relu6, name=prefix + 'expand_relu')(x)
    else:
        prefix = 'expanded_conv_'

    #----------------------------------------------------#
    #   利用深度可分离卷积进行特征提取
    #----------------------------------------------------#
    x = DepthwiseConv2D(kernel_size=3, strides=stride, activation=None,
                        use_bias=False, padding='same', dilation_rate=(rate, rate),
                        name=prefix + 'depthwise')(x)
    x = BatchNormalization(epsilon=1e-3, momentum=0.999,name=prefix + 'depthwise_BN')(x)
    x = Activation(relu6, name=prefix + 'depthwise_relu')(x)

    #----------------------------------------------------#
    #   利用1x1的卷积进行通道数的下降
    #----------------------------------------------------#
    x = Conv2D(pointwise_filters,
               kernel_size=1, padding='same', use_bias=False, activation=None,
               name=prefix + 'project')(x)
    x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'project_BN')(x)

    #----------------------------------------------------#
    #   添加残差边
    #----------------------------------------------------#
    if skip_connection:
        return Add(name=prefix + 'add')([inputs, x])
    return x

def get_mobilenet_encoder(inputs_size, downsample_factor=8):
    if downsample_factor == 16:  # 下采样4次，即宽高压缩4次
        block4_dilation = 1
        block5_dilation = 2
        block4_stride = 2
    elif downsample_factor == 8:  # 下采样3次，即宽高压缩3次
        block4_dilation = 2
        block5_dilation = 4
        block4_stride = 1
    else:
        raise ValueError('Unsupported factor - `{}`, Use 8 or 16.'.format(downsample_factor))
    
    # 473,473,3
    inputs = Input(shape=inputs_size)

    alpha=1.0
    first_block_filters = _make_divisible(32 * alpha, 8)

    # 473,473,3 -> 237,237,32
    x = Conv2D(first_block_filters,
                kernel_size=3,
                strides=(2, 2), padding='same',
                use_bias=False, name='Conv')(inputs)
    x = BatchNormalization(epsilon=1e-3, momentum=0.999, name='Conv_BN')(x)
    x = Activation(relu6, name='Conv_Relu6')(x)

    # 237,237,32 -> 237,237,16
    x = _inverted_res_block(x, filters=16, alpha=alpha, stride=1,
                            expansion=1, block_id=0, skip_connection=False)

    #---------------------------------------------------------------#
    # 237,237,16 -> 119,119,24
    x = _inverted_res_block(x, filters=24, alpha=alpha, stride=2,
                            expansion=6, block_id=1, skip_connection=False)
    x = _inverted_res_block(x, filters=24, alpha=alpha, stride=1,
                            expansion=6, block_id=2, skip_connection=True)
                            
    #---------------------------------------------------------------#
    # 119,119,24 -> 60,60.32
    x = _inverted_res_block(x, filters=32, alpha=alpha, stride=2,
                            expansion=6, block_id=3, skip_connection=False)
    x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1,
                            expansion=6, block_id=4, skip_connection=True)
    x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1,
                            expansion=6, block_id=5, skip_connection=True)

    #---------------------------------------------------------------#
    # 60,60,32 -> 30,30.64
    x = _inverted_res_block(x, filters=64, alpha=alpha, stride=block4_stride,
                            expansion=6, block_id=6, skip_connection=False)
    x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=block4_dilation,
                            expansion=6, block_id=7, skip_connection=True)
    x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=block4_dilation,
                            expansion=6, block_id=8, skip_connection=True)
    x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=block4_dilation,
                            expansion=6, block_id=9, skip_connection=True)

    # 30,30.64 -> 30,30.96
    x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=block4_dilation,
                            expansion=6, block_id=10, skip_connection=False)
    x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=block4_dilation,
                            expansion=6, block_id=11, skip_connection=True)
    x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=block4_dilation,
                            expansion=6, block_id=12, skip_connection=True)
    # 辅助分支训练
    f4 = x

    #---------------------------------------------------------------#
    # 30,30.96 -> 30,30,160 -> 30,30,320
    x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=block4_dilation,
                            expansion=6, block_id=13, skip_connection=False)
    x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=block5_dilation,
                            expansion=6, block_id=14, skip_connection=True)
    x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=block5_dilation,
                            expansion=6, block_id=15, skip_connection=True)

    x = _inverted_res_block(x, filters=320, alpha=alpha, stride=1, rate=block5_dilation,
                            expansion=6, block_id=16, skip_connection=False)
    f5 = x
    return inputs, f4, f5

1.2. neck：PSP

a. 结构

input->AveragePooling2D(k=30,s=30)->CBA->resize->[30,30,80]->p1
input->AveragePooling2D(k=15,s=15)->CBA->resize->[30,30,80]->p2
input->AveragePooling2D(k=10,s=10)->CBA->resize->[30,30,80]->p3
input->AveragePooling2D(k=5, s=5 )->CBA->resize->[30,30,80]->p4
↓
concatenate([p1,p2,p3,p4])

b. 代码

def pool_block(feats, pool_factor, out_channel):
    h = K.int_shape(feats)[1]
    w = K.int_shape(feats)[2]
    #-----------------------------------------------------#
    #   分区域进行平均池化
    #   strides     = [30,30], [15,15], [10,10], [5, 5]
    #   poolsize    = 30/1=30  30/2=15  30/3=10  30/6=5
    #-----------------------------------------------------#
    pool_size = strides = [int(np.round(float(h)/pool_factor)),int(np.round(float(w)/pool_factor))]
    x = AveragePooling2D(pool_size , data_format=IMAGE_ORDERING , strides=strides, padding='same')(feats)

    #-----------------------------------------------------#
    #   利用1x1卷积进行通道数的调整
    #-----------------------------------------------------#
    x = Conv2D(out_channel//4, (1 ,1), data_format=IMAGE_ORDERING, padding='same', use_bias=False)(x)
    x = BatchNormalization()(x)
    x = Activation('relu')(x)

    #-----------------------------------------------------#
    #   利用resize扩大特征层面积
    #-----------------------------------------------------#
    x = Lambda(resize_images)([x, feats])
    return x

1.3 head

a. 结构

input(PSP)
↓
CBADropoutt
↓
Conv(f=cls,k=1)->O
↓
if aux_branch:
f4->CBAD->Conv(f=cls,k=1)->resize+A->f4

b. model代码

def pspnet(n_classes, inputs_size, downsample_factor=8, backbone='mobilenet', aux_branch=True):
    if backbone == "mobilenet":
        #----------------------------------#
        #   获得两个特征层
        #   f4为辅助分支    [30,30,96]
        #   o为主干部分     [30,30,320]
        #----------------------------------#
        img_input, f4, o = get_mobilenet_encoder(inputs_size, downsample_factor=downsample_factor)
        out_channel = 320
    elif backbone == "resnet50":
        img_input, f4, o = get_resnet50_encoder(inputs_size, downsample_factor=downsample_factor)
        out_channel = 2048
    else:
        raise ValueError('Unsupported backbone - `{}`, Use mobilenet, resnet50.'.format(backbone))

    #--------------------------------------------------------------#
    #	PSP模块，分区域进行池化
    #   分别分割成1x1的区域，2x2的区域，3x3的区域，6x6的区域
    #--------------------------------------------------------------#
    pool_factors = [1, 2, 3, 6]
    pool_outs = [o]
    for p in pool_factors:
        pooled = pool_block(o, p, out_channel)
        pool_outs.append(pooled)

    #--------------------------------------------------------------------------------#
    #   利用获取到的特征层进行堆叠
    #   30, 30, 320 + 30, 30, 80 + 30, 30, 80 + 30, 30, 80 + 30, 30, 80 = 30, 30, 640
    #--------------------------------------------------------------------------------#
    o = Concatenate(axis=MERGE_AXIS)(pool_outs)

    # 30, 30, 640 -> 30, 30, 80
    o = Conv2D(out_channel//4, (3,3), data_format=IMAGE_ORDERING, padding='same', use_bias=False)(o)
    o = BatchNormalization()(o)
    o = Activation('relu')(o)

    # 防止过拟合
    o = Dropout(0.1)(o)

    #---------------------------------------------------#
    #	利用特征获得预测结果
    #   30, 30, 80 -> 30, 30, 21 -> 473, 473, 21
    #---------------------------------------------------#
    o = Conv2D(n_classes,(1,1),data_format=IMAGE_ORDERING, padding='same')(o)
    o = Lambda(resize_images)([o, img_input])

    #---------------------------------------------------#
    #   获得每一个像素点属于每一个类的概率
    #---------------------------------------------------#
    o = Activation("softmax", name="main")(o)

    if aux_branch:
        # 30, 30, 96 -> 30, 30, 40 
        f4 = Conv2D(out_channel//8, (3,3), data_format=IMAGE_ORDERING, padding='same', use_bias=False, name="branch_conv1")(f4)
        f4 = BatchNormalization(name="branch_batchnor1")(f4)
        f4 = Activation('relu', name="branch_relu1")(f4)
        f4 = Dropout(0.1)(f4)
        #---------------------------------------------------#
        #	利用特征获得预测结果
        #   30, 30, 40 -> 30, 30, 21 -> 473, 473, 21
        #---------------------------------------------------#
        f4 = Conv2D(n_classes,(1,1),data_format=IMAGE_ORDERING, padding='same', name="branch_conv2")(f4)
        f4 = Lambda(resize_images, name="branch_resize")([f4, img_input])

        f4 = Activation("softmax", name="aux")(f4)
        model = Model(img_input,[f4,o])
        return model
    else:
        model = Model(img_input,[o])
        return model

2 损失

a. 损失函数

# 1.Cross Entropy Loss。
# 2.Dice Loss = 1 - Dice

Dice = 2(x*y)/(|x|+|y|)

b. 代码

def dice_loss_with_CE(beta=1, smooth = 1e-5):
    def _dice_loss_with_CE(y_true, y_pred):
        y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())

        CE_loss = - y_true[...,:-1] * K.log(y_pred)
        CE_loss = K.mean(K.sum(CE_loss, axis = -1))

        tp = K.sum(y_true[...,:-1] * y_pred, axis=[0,1,2])
        fp = K.sum(y_pred         , axis=[0,1,2]) - tp
        fn = K.sum(y_true[...,:-1], axis=[0,1,2]) - tp

        score = ((1 + beta ** 2) * tp + smooth) / ((1 + beta ** 2) * tp + beta ** 2 * fn + fp + smooth)
        score = tf.reduce_mean(score)
        dice_loss = 1 - score
        # dice_loss = tf.Print(dice_loss, [dice_loss, CE_loss])
        return CE_loss + dice_loss
    return _dice_loss_with_CE

def CE():
    def _CE(y_true, y_pred):
        y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())

        CE_loss = - y_true[...,:-1] * K.log(y_pred)
        CE_loss = K.mean(K.sum(CE_loss, axis = -1))
        # dice_loss = tf.Print(CE_loss, [CE_loss])
        return CE_loss
    return _CE
山居秋暝LS
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RGBD-semantic-segmentation:RGBD语义分割的纸质清单（处理）
05-16
RGBD语义分割 RGBD语义分割的纸质清单。 *最后更新：2021/04/09 更新日志 2020年5月-更新所有最新论文，并绘制一些有关RGBD语义分割历史的图表。 2020年/ 7月-更新了RGBD语义分割的一些最新论文（CVPR2020）。 2020年/ 8月-更新了有关RGBD语义分割的一些最新论文（ECCV2020）。 2020年/ 10月-更新了有关RGBD语义分割的一些最新论文（CVPR2020，WACV2020）。 2020年11月-更新了一些最新论文（ECCV2020，arXiv），以及论文和RGBD语义分割代码的链接。 2020年12月-更新了有关RGBD语义分割的一些最新论文（PAMI，PRL，arXiv，ACCV）。 2021 / February-更新了有关RGBD语义分割的一些最新论文（TMM，NeurIPS，arXiv）。 2021 / April-更新了
每天一篇论文 321/365 Incremental Class Discovery for Semantic Segmentation with RGBD Sensing
流浪机器人的博客
01-31 575
Incremental Class Discovery for Semantic Segmentation with RGBD Sensing 摘要 这项工作解决了开放世界语义分割的任务，使用RGBD感知来发现新的语义类。虽然现实世界中的对象类型很多，但现有的语义分割方法都是基于封闭世界的假设，只训练有限数量的对象类。针对一种更开放的方法，我们提出了一种增量学习新类的图像分割方法。该系统首先利用颜...
【论文阅读】——RGBD分割也能实时？Efficient RGB-D Semantic Segmentation for Indoor Scene Analysis
怡宝2号
01-18 2969
code:https://github.com/TUI-NICR/ESANet#time-inference 摘要: 摘要—全面分析场景对于在不同环境中行动的机器人至关重要。语义分割可以增强各种后续任务，例如（语义辅助）人的感知，（语义）自由空间检测，（语义）映射和（语义）导航。在本文中，我们提出了一种高效且强大的RGB-D分割方法，该方法可以使用NVIDIA TensorRT进行高度优化。我们表明RGB-D分割优于处理RGB仅用于图像，并且如果仍然可以实时执行网络架构是经过精心设计的。 1. 简介 .
使用Mask-RCNN在实例分割应用中克服过拟合
AI公园
11-26 1289
点击上方“AI公园”，关注公众号，选择加“星标“或“置顶”作者：Kayo Yin编译：ronghuaiyang导读只使用1349张图像训练Mask-RCNN，有代码。代码：https:/...
SPPnet
shine的博客
09-22 426
空间金字塔层池化网络（Spatial pyramid pooling networks,SSPnets）可以通过计算共享来加速R-CNN，SSPnet是先对整张图片做卷积，由于卷积池化之后得到的特征图与原图片的特征位置是相对应的，所以直接在特征图上截取候选框，然后再使用做不同尺寸的最大池化将得到的特征向量拼接得到最终的特征向量。SSPnet相比于R-CNN测试速度加速了10-100倍，训练时间较少了3倍。 ...
Segformer语义分割
最新发布
04-24
3. **Scale-Aware Tokenization**：不同于NLP任务，图像分割需要保持像素级别的精度。Segformer采用了一种尺度感知的分块策略，既能保持较高的分辨率，又能控制计算复杂度。 4. **Decoder Layer**：虽然Segformer...
VOCdevkit语义分割数据集.zip
09-24
VOCdevkit是广泛用于计算机视觉研究的数据集开发工具包，尤其在语义分割领域有着重要的应用。这个数据集，名为“VOC2007语义分割数据集”，是PASCAL VOC（Pattern Analysis, Statistical Modelling and ...
halcon语义分割标注工具.zip
09-08
halcon深度学习语义分割标注工具V1.0.0.1.rar(更新，绝对没有次数限制，免费！！！) 1、环境：halcon18.11，windows 64bit 2、功能：替代halcon代码式语义分割工具，增强使用方便性 3、记得每次退出标注前要点击...
遥感语义分割代码
04-21
遥感语义分割是计算机视觉领域的一个重要应用，它在遥感图像分析中扮演着关键角色。本项目主要关注如何利用深度学习技术对遥感影像进行精细化的像素级分类，即语义分割。在此，我们将深入探讨Unet和SEGNET这两种常见...
yolov7 语义分割权重文件
02-20
yolov7 语义分割权重文件
过拟合讨论
湾区人工智能
04-09 828
过拟合就是模型把数据学习的太彻底，以至于把噪声数据的特征也学习到了，这样就会导致在后期测试的时候不能够很好地识别数据，即不能正确的分类，模型泛化能力太差。过拟合原因：1 使用过于复杂的模型，2 数据噪声过大3 训练数据少降低过拟合方法：1 简化模型假设，或者使用惩罚项限制模型复杂度，或者减少神经网络隐藏层节点数2 进行数据清洗，减少噪声 （删除稀疏的特征）3 收集更多训练数据高斯核的使用增加模...
深度学习500问阅读笔记——如何解决过拟合与欠拟合？
xiashilin的博客
04-23 380
这是深度学习500问系列笔记之一，帮助我深入记忆知识，如有不足，随时欢迎交流和探讨。 8.如何解决过拟合与欠拟合？ 如何解决欠拟合： 1）添加其他特征项。组合、泛化、相关性、上下文特征、平台特征等特征是特征添加的重要手段，有时候特征项不够会导致模型欠拟合。 2）添加多项式特征。例如将线性模型添加二次项或三次项使模型泛化能力更强。例如，FM模型、FFM模型， ...
过拟合应该如何
u014535528的博客
10-09 198
1、增加训练数据，或者数据增强 2、正则化 L1正则化：是n个维w的绝对值加和 L2正则化：是n个维w的平方和 L1正则化是通过向成本函数中添加L1范数，使得学习的结果满足稀疏化，方便特征提取，这个过程更像是降维， L2正则化是通过让w值整体变小，防止过拟合，提高泛化能力。 3、dropout 4、神经网络可以减少网络层数，网络中的节点数，传统的方法，降低模型的复杂度 5、早停 6、batch n...
零基础入门语义分割-Task5 模型训练与验证
upon120的博客
03-04 644
一个成熟合格的深度学习训练流程至少具备以下功能： 在训练集上进行训练，并在验证集上进行验证； 模型可以保存最优的权重，并读取权重； 记录下训练集和验证集的精度，便于调参。 5 模型训练与验证 为此本章将从构建验证集、模型训练和验证、模型保存与加载和模型调参几个部分讲解，在部分小节中将会结合Pytorch代码进行讲解。 5.1 学习目标 理解验证集的作用，并使用训练集和验证集完成训练 学会使用Pytorch环境下的模型读取和加载，并了解调参流程 5.2 构造验证集 在机器学习模型（特别是深度学习模型）的训练过
resnet代码详解
qq_36027459的博客
12-14 1442
class Bottleneck(nn.Module): //一个残差块的结构。第一个1*1卷积会缩小通道数，第二个3*3卷积，第三个1*1卷积会变回原来的通道数 expansion = 4 //inplanes:输入通道； planes*expansion:输出通道； def __init__(self, inplanes, planes, stride=1,...
经典卷积模型(一)Resnet代码解析
sleepinghm的博客
09-02 2237
Resnet18/101 设计起因是认为网络增加反而梯度下降困难，因此加入残差结构。 残差块代码1：class BasicBlock(nn.Module): """ inplane是输入的通道数,plane是输出的通道数,expansion是对输出通道数的倍乘. """ expansion = 1 def __init__(self, inplanes, planes, stride=1, downsample=None): super(BasicBlock, self).
图像语义分割(11)-BiSeNet:用于实时语义分割的双向分割网络
kevin_zhao_zl的博客
12-10 4320
论文中提出了一种新的双向分割网络BiSeNet。首先，设计了一个带有小步长的空间路径来保留空间位置信息生成高分辨率的特征图；同时设计了一个带有快速下采样册率的语义路径来获取客观的感受野。在这两个模块之上引入一个新的特征融合模块将二者的特征图进行融合，实现速度和精度的平衡。
基于深度学习的计算机视觉：原理与实践（上部）
02-19
本课程适合具有一定深度学习基础，希望发展为深度学习之计算机视觉方向的算法工程师和研发人员的同学们。基于深度学习的计算机视觉是目前人工智能最活跃的领域，应用非常广泛，如人脸识别和无人驾驶中的机器视觉等。该领域的发展日新月异，网络模型和算法层出不穷。如何快速入门并达到可以从事研发的高度对新手和中级水平的学生而言面临不少的挑战。精心准备的本课程希望帮助大家尽快掌握基于深度学习的计算机视觉的基本原理、核心算法和当前的领先技术，从而有望成为深度学习之计算机视觉方向的算法工程师和研发人员。本课程系统全面地讲述基于深度学习的计算机视觉技术的原理并进行项目实践。课程涵盖计算机视觉的七大任务，包括图像分类、目标检测、图像分割（语义分割、实例分割、全景分割）、人脸识别、图像描述、图像检索、图像生成（利用生成对抗网络）。本课程注重原理和实践相结合，逐篇深入解读经典和前沿论文70余篇，图文并茂破译算法难点, 使用思维导图梳理技术要点。项目实践使用Keras框架(后端为Tensorflow)，学员可快速上手。通过本课程的学习，学员可把握基于深度学习的计算机视觉的技术发展脉络，掌握相关技术原理和算法，有助于开展该领域的研究与开发实战工作。另外，深度学习之计算机视觉方向的知识结构及学习建议请参见本人CSDN博客。本课程提供课程资料的课件PPT（pdf格式）和项目实践代码，方便学员学习和复习。本课程分为上下两部分，其中上部包含课程的前五章（课程介绍、深度学习基础、图像分类、目标检测、图像分割），下部包含课程的后四章（人脸识别、图像描述、图像检索、图像生成）。
双重角度看语义分割：传统语义分割方法 对比 深度学习语义分割方法
l love CV
04-20 5837
语义分割（Semantic segmentatio）是计算机视觉中的关键任务之 一。现实中，越来越多的应用场景需要从影像中推理出相关的知识或语义（即由具体到抽象 的过程）。作为计算机视觉的核心问题，语义分割对于场景理解的重要性日渐突出。
deeplavb3 语义分割
08-27
深度拉伸（DeepLab）是一种用于语义分割的深度学习模型。...通过使用 DeepLabv3 进行语义分割，可以实现对图像中不同物体的精确标注和分割，为许多计算机视觉任务提供基础支持，如图像分割、目标检测、图像编辑等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值