语义分割示例—FCN识别路面灌缝区域（2）FCN

最新推荐文章于 2024-04-02 06:48:58 发布
最新推荐文章于 2024-04-02 06:48:58 发布
阅读量408 收藏 1
点赞数
分类专栏： DL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinjiang666/article/details/118571754
版权

一、FCN介绍

这个介绍挺好的：https://zhuanlan.zhihu.com/p/31428783

笔者觉得，FCN有开创效果：用卷积层代替全连接层。

优点很直接：图像尺寸任意；避免了像素块的重复存储与计算，效率提高。

缺点也很明显：结果有待提高，细节不敏感；像素间的关系缺乏一致性，表现为锯齿。

二、代码

源码见：https://blog.csdn.net/u014453898/article/details/92080859

xj1ModelFCN.py

# coding=utf-8
import numpy as np
import torch
import torch.nn as nn
import torchvision
from torchvision.models.vgg import VGG


# Vgg-Net config # Vgg网络结构配置
# cropped version from https://github.com/pytorch/vision/blob/master/torchvision/models/vgg.py
cfg = {
    'vgg11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    'vgg13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
    'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
}

# 由cfg构建VGG_Net
def make_layers(cfg, batch_norm=False):
    layers = []
    in_channels = 3
    for v in cfg:
        if v == 'M':
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            if batch_norm:
                layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
            else:
                layers += [conv2d,nn.ReLU(inplace=True)]
            in_channels = v
    return nn.Sequential(*layers)
    #torch.nn.Sequential: 一个有序的容器，
    # 神经网络模块将按照在传入构造器的顺序依次被添加到计算图中执行，
    # 同时以神经网络模块为元素的有序字典也可以作为传入参数。
    #通过Squential将网络层和激活函数结合起来，输出激活后的网络节点。


ranges = {
    'vgg11': ((0, 3), (3, 6), (6, 11), (11, 16), (16, 21)),
    'vgg13': ((0, 5), (5, 10), (10, 15), (15, 20), (20, 25)),
    'vgg16': ((0, 5), (5, 10), (10, 17), (17, 24), (24, 31)),
    'vgg19': ((0, 5), (5, 10), (10, 19), (19, 28), (28, 37))
}


class VGG_Net(VGG):
    def __init__(self, pretrained=False, model='vgg16',
                 requires_grad=True, remove_fc=True, show_params=False):
        super().__init__(make_layers(cfg[model]))
        self.ranges = ranges[model]

        if pretrained:
            exec("self.load_state_dice(models.%s(pretrained=False).state_dice())" % model)

        if not requires_grad:
            for param in super().parameters():
                param.requires_grad = False

        # 删除最后的全连接层，节省内存
        if remove_fc:
            del self.classifier

        if show_params:
            for name, param in self.named_parameters():
                print(name, param.size())

    def forward(self, x):
        output = {}
        # get the output of ecah maxpooling layer(5 maxpool in VGG)
        for idx,(begin,end) in enumerate(self.ranges):
            for layer in range(begin, end):
                x = self.features[layer](x)
            output["x%d" % (idx+1)] = x
        return output


'''
VGG-16网络参数
Sequential(
  (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (1): ReLU(inplace)
  (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (3): ReLU(inplace)
  (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (6): ReLU(inplace)
  (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (8): ReLU(inplace)
  (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (11): ReLU(inplace)
  (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (13): ReLU(inplace)
  (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (15): ReLU(inplace)
  (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (18): ReLU(inplace)
  (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (20): ReLU(inplace)
  (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (22): ReLU(inplace)
  (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (25): ReLU(inplace)
  (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (27): ReLU(inplace)
  (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (29): ReLU(inplace)
  (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
'''


class FCN32s(nn.Module):
    def __init__(self, pretrained_net, n_class):
        super(FCN32s, self).__init__()
        self.n_class = n_class
        self.pretrained_net = pretrained_net
        self.relu = nn.ReLU(inplace=True)
        self.deconv1 = nn.ConvTranspose2d(512,512,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn1 = nn.BatchNorm2d(512)
        self.deconv2 = nn.ConvTranspose2d(512,256,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn2 = nn.BatchNorm2d(256)
        self.deconv3 = nn.ConvTranspose2d(256,128,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.deconv4 = nn.ConvTranspose2d(128,64,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn4 = nn.BatchNorm2d(64)
        self.deconv5 = nn.ConvTranspose2d(64,32,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn5 = nn.BatchNorm2d(32)
        self.classifier = nn.Conv2d(32,n_class,kernel_size=1)
    def forward(self,x):
        output = self.pretrained_net(x)
        x5 = output['x5'] #size=(N, 512, x.H/32, x.W/32)
        score = self.bn1(self.relu(self.deconv1(x5)))  #size=(N, 512, x.H/16, x.W/16)
        score = self.bn2(self.relu(self.deconv2(score))) #size=(N, 256, x.H/8, x.W/8)
        score = self.bn3(self.relu(self.deconv3(score))) #size=(N, 128, x.H/4, x.W/4)
        score = self.bn4(self.relu(self.deconv4(score))) #size=(N,  64, x.H/2, x.W/2)
        score = self.bn5(self.relu(self.deconv5(score))) #size=(N,  32, x.H/1, x.W/1)
        score = self.classifier(score) #size=(N, n_class, x.H/1, x.W/1)

        return score #size=(N, n_class, x.H/1, x.W/1)


class FCN16s(nn.Module):
    def __init__(self, pretrained_net, n_class):
        super(FCN16s, self).__init__()
        self.n_class = n_class
        self.pretrained_net = pretrained_net
        self.relu = nn.ReLU(inplace=True)
        self.deconv1 = nn.ConvTranspose2d(512,512,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn1 = nn.BatchNorm2d(512)
        self.deconv2 = nn.ConvTranspose2d(512,256,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn2 = nn.BatchNorm2d(256)
        self.deconv3 = nn.ConvTranspose2d(256,128,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.deconv4 = nn.ConvTranspose2d(128,64,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn4 = nn.BatchNorm2d(64)
        self.deconv5 = nn.ConvTranspose2d(64,32,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn5 = nn.BatchNorm2d(32)
        self.classifier = nn.Conv2d(32,n_class,kernel_size=1)
    def forward(self,x):
        output = self.pretrained_net(x)
        x5 = output['x5'] #size=(N, 512, x.H/32, x.W/32)
        x4 = output['x4'] #size=(N, 512, x.H/16, x.W/16)
        score = self.relu(self.deconv1(x5)) #size=(N, 512, x.H/16, x.W/16)
        score = self.bn1(score + x4)  #element-wise add, size=(N, 512, x.H/16, x.W/16)
        score = self.bn2(self.relu(self.deconv2(score))) #size=(N, 256, x.H/8, x.W/8)
        score = self.bn3(self.relu(self.deconv3(score))) #size=(N, 128, x.H/4, x.W/4)
        score = self.bn4(self.relu(self.deconv4(score))) #size=(N,  64, x.H/2, x.W/2)
        score = self.bn5(self.relu(self.deconv5(score))) #size=(N,  32, x.H/1, x.W/1)
        score = self.classifier(score) #size=(N, n_class, x.H/1, x.W/1)

        return score #size=(N, n_class, x.H/1, x.W/1)


class FCN8s(nn.Module):
    def __init__(self, pretrained_net, n_class):
        super(FCN8s, self).__init__()
        self.n_class = n_class
        self.pretrained_net = pretrained_net
        self.relu = nn.ReLU(inplace=True)
        self.deconv1 = nn.ConvTranspose2d(512,512,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn1 = nn.BatchNorm2d(512)
        self.deconv2 = nn.ConvTranspose2d(512,256,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn2 = nn.BatchNorm2d(256)
        self.deconv3 = nn.ConvTranspose2d(256,128,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.deconv4 = nn.ConvTranspose2d(128,64,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn4 = nn.BatchNorm2d(64)
        self.deconv5 = nn.ConvTranspose2d(64,32,kernel_size=3,stride=2,padding=1,dilation=1,output_padding=1)
        self.bn5 = nn.BatchNorm2d(32)
        self.classifier = nn.Conv2d(32,n_class,kernel_size=1)
    def forward(self,x):
        output = self.pretrained_net(x)
        x5 = output['x5'] #size=(N, 512, x.H/32, x.W/32)
        x4 = output['x4'] #size=(N, 512, x.H/16, x.W/16)
        x3 = output['x3'] #size=(N, 256, x.H/8, x.W/8)
        score = self.relu(self.deconv1(x5)) #size=(N, 512, x.H/16, x.W/16)
        score = self.bn1(score + x4)  #element-wise add, size=(N, 512, x.H/16, x.W/16)
        score = self.relu(self.deconv2(score)) #size=(N, 256, x.H/8, x.W/8)
        score = self.bn2(score + x3) ## element-wise add, size=(N, 256, x.H/8, x.W/8)
        score = self.bn3(self.relu(self.deconv3(score))) #size=(N, 128, x.H/4, x.W/4)
        score = self.bn4(self.relu(self.deconv4(score))) #size=(N,  64, x.H/2, x.W/2)
        score = self.bn5(self.relu(self.deconv5(score))) #size=(N,  32, x.H/1, x.W/1)
        score = self.classifier(score) #size=(N, n_class, x.H/1, x.W/1)

        return score #size=(N, n_class, x.H/1, x.W/1)



class FCNs(nn.Module):
    def __init__(self, pretrained_net, n_class):
        super().__init__()
        self.n_class = n_class
        self.pretrained_net = pretrained_net
        self.relu = nn.ReLU(inplace=True)
        self.deconv1 = nn.ConvTranspose2d(512, 512, kernel_size=3, stride=2, padding=1, dilation=1, output_padding=1)
        self.bn1 = nn.BatchNorm2d(512)
        self.deconv2 = nn.ConvTranspose2d(512, 256, kernel_size=3, stride=2, padding=1, dilation=1, output_padding=1)
        self.bn2 = nn.BatchNorm2d(256)
        self.deconv3 = nn.ConvTranspose2d(256, 128, kernel_size=3, stride=2, padding=1, dilation=1, output_padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.deconv4 = nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1, dilation=1, output_padding=1)
        self.bn4 = nn.BatchNorm2d(64)
        self.deconv5 = nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, dilation=1, output_padding=1)
        self.bn5 = nn.BatchNorm2d(32)
        self.classifier = nn.Conv2d(32, n_class, kernel_size=1)

    def forward(self, x):
        output = self.pretrained_net(x)
        x5 = output['x5']  # size=(N, 512, x.H/32, x.W/32)
        x4 = output['x4']  # size=(N, 512, x.H/16, x.W/16)
        x3 = output['x3']  # size=(N, 256, x.H/8,  x.W/8)
        x2 = output['x2']  # size=(N, 128, x.H/4,  x.W/4)
        x1 = output['x1']  # size=(N, 64, x.H/2,  x.W/2)

        score = self.bn1(self.relu(self.deconv1(x5)))  # size=(N, 512, x.H/16, x.W/16)
        score = score + x4  # element-wise add, size=(N, 512, x.H/16, x.W/16)
        score = self.bn2(self.relu(self.deconv2(score)))  # size=(N, 256, x.H/8, x.W/8)
        score = score + x3  # element-wise add, size=(N, 256, x.H/8, x.W/8)
        score = self.bn3(self.relu(self.deconv3(score)))  # size=(N, 128, x.H/4, x.W/4)
        score = score + x2  # element-wise add, size=(N, 128, x.H/4, x.W/4)
        score = self.bn4(self.relu(self.deconv4(score)))  # size=(N, 64, x.H/2, x.W/2)
        score = score + x1  # element-wise add, size=(N, 64, x.H/2, x.W/2)
        score = self.bn5(self.relu(self.deconv5(score)))  # size=(N, 32, x.H, x.W)
        score = self.classifier(score)  # size=(N, n_class, x.H/1, x.W/1)

        return score  # size=(N, n_class, x.H/1, x.W/1)

累了就要打游戏
关注
专栏目录
MATLAB算法实战应用案例精讲-【人工智能】语义分割（补充篇）(附matlab代码实现)
qq_36130719的博客
01-01 2052
语义分割是从粗推理到精推理的自然步骤：原点可以定位在分类，分类包括对整个输入进行预测。下一步是本地化/检测，它不仅提供类，还提供关于这些类的空间位置的附加信息。最后，语义分割通过对每个像素进行密集的预测、推断标签来实现细粒度的推理，从而使每个像素都被标记为其封闭对象矿石区域的类别。更具体地说，语义图像分割的目标是给图像中的每个像素都贴上对应的一类所代表的内容的标签。因为我们要对图像中的每个像素进行预测，所以这个任务通常被称为密集预测。
基于MATLAB的车道线识别、自动驾驶识别
zsnlnl123的博客
04-11 8336
Visual Perception Using Monocular Camera This example shows how to construct a monocular camera sensor simulation capable of lane boundary and vehicle detections. The sensor will report these detections in vehicle coordinate system. In this example, you w
路面语义分割
小白学视觉
12-02 4905
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达检测坑洼，水坑，不同类型的地形等本期是关于路面语义分割方法的。因此，这里的重点是路面模式，例如：车辆...
语义分割示例—FCN识别路面灌缝区域（3）训练与测试
累了就要打游戏
07-08 504
语义分割示例—FCN识别路面灌缝区域（3）训练与测试一、参数二、模型三、数据处理四、训练五、测试 笔者的训练代码总共有4个：（1）xj0paremeters.py用于存放参数；（2）xj1ModelFCN.py是FCN模型；（3）xj2ImageDataset.py用于数据处理；（4）xj3train.py用于训练。 一、参数 xj0paremeters.py import torch.cuda # 训练数据 dirTrainImage = 'E:/py/dataCrack/00AA1originalNo
语义分割 语义分类_路面语义分割
weixin_26752765的博客
09-07 3124
语义分割 语义分类Hello There! This post is about a road surface semantic segmentation approach. So the focus here is on the road surface patterns, like: what kind of pavement the vehicle is driving on or if t...
全卷积网络（FCN）实战：使用FCN实现语义分割
二爷的博客
03-20 2318
FCN对图像进行像素级的分类，从而解决了语义级别的图像分割（semantic segmentation）问题。与经典的CNN在卷积层之后使用全连接层得到固定长度的特征向量进行分类（全联接层＋softmax输出）不同，FCN可以接受任意尺寸的输入图像，采用反卷积层对最后一个卷积层的feature map进行上采样, 使它恢复到输入图像相同的尺寸，从而可以对每个像素都产生了一个预测, 同时保留了原始输入图像中的空间信息, 最后在上采样的特征图上进行逐像素分类。 下图是语义分割所采用的全卷积网络(FCN)的结构示
语义分割示例—FCN识别路面灌缝区域（1）解析json与准备数据
累了就要打游戏
07-08 571
管它用什么模型，有数据才是牛逼。 一、用labelme标注灌缝区域 二、json文件是这样的 json文件中包含的信息包括labelme的版本、label的名称、节点坐标、label的ID、label的形状、图像路径、行列等。 { "version": "4.5.2", "flags": {}, "shapes": [ { "label": "gf", "points": [ [ 3489.847715736040
【全卷积网络FCN革命】：开启图像分割新篇章
全卷积网络（FCN）作为深度学习在图像处理领域中的一项重要应用，已经成为图像分割任务的主流技术之一。本章将从理论上深入探讨FCN的构成和原理，为后续章节中对其关键技术的解析以及实现细节的深入讨论打下坚实的...
转移和规范化预测用于语义分割的内在属性约束
Ting Yao‡, Chong-Wah Ngo§, Dong Liu†, and Tao Mei‡{yihengzhang.chn, zhaofanqiu, tingyao.ustc}@gmail.comcscwngo@cityu.edu.hk, dongeliu@ustc.edu.cn, tmei@jd.com96210转移和规范化预测用于语义分割 ...
基于反射注意单元的FCN单图像水害检测
基于反射注意单元的FCN单图像水害检测Han Xiaofeng1，Chuong Nguyen2，3，4，Shaodi You2，3，andJianfeng Lu11南京理工大学，江苏2澳大利亚国立大学，堪培拉ACT 2600，澳大利亚3CSIRO DATA61，堪培拉ACT 2601，...
MATLAB图像语义分割实例（道路语义分割）
04-30
本教程利用MATLAB进行图像语义分割，从语义分割概念、模型搭建、图像标记、模型测试完整的展示了MATLAB语义分割的全过程。（本博主提供一对一技术支持服务，有需要的同学可以私信我哦）
基于深度学习的全卷积网络图像裂纹检测
02-07
基于深度学习的全卷积网络图像裂纹检测
FCN网络结构图.zip
12-06
基于PASCAL的FCN网络结构图，使用Caffe深度学习框架绘制，内容为FCN8s.png，FCN16s.png，FCN32s.png
TI TDA2x实现道路语义分割Semantic Segmenation
weixin_44724865的博客
06-30 576
语义分割 语义分割是当今计算机视觉领域的关键问题之一。从宏观上看，语义分割是一项高层次的任务，为实现场景的完整理解铺平了道路。场景理解作为一个核心的计算机视觉问题，其重要性在于越来越多的应用程序通过从图像中推断知识来提供营养。 其中一些应用包括自动驾驶汽车、人机交互、虚拟现实等，近年来随着深度学习的普及，许多语义分割问题正在采用深层次的结构来解决，最常见的是卷积神经网络，在精度上大大超过了其他方法。以及效率。 标题TDA2x Semantic Segmenation TITDA2x作为一款车规级芯片同样提供
全卷积网络（FCN）实战(1)，零基础Python入门
最新发布
2401_84002482的博客
04-02 871
🍅 硬核资料：关注即可领取PPT模板、简历模板、行业经典书籍PDF。🍅 技术互助：技术群大佬指点迷津，你的问题可能不是问题，求资源在群里喊一声。🍅 面试题库：由技术群里的小伙伴们共同投稿，热乎的大厂面试真题，持续更新中。🍅 知识体系：含编程语言、算法、大数据生态圈组件（Mysql、Hive、Spark、Flink）、数据仓库、Python、前端等等。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！
DL之FCN：FCN算法的简介(论文介绍)、架构详解、案例应用等配图集合之详细攻略
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
07-31 6532
DL之FCN：FCN算法的简介(论文介绍)、架构详解、案例应用等配图集合之详细攻略 目录 FCN算法的简介(论文介绍) 0、FCN性能—实验结果 1、全卷积神经网络的特点、局限性、缺点 FCN算法的架构详解 FCN算法的案例应用 相关文章DL之FCN：FCN算法的简介(论文介绍)、架构详解、案例应用等配图集合之详细攻略DL之FCN：FC...
语义分割--Efficient Deep Models for Monocular Road Segmentation
AI小作坊 的博客
08-02 3062
Efficient Deep Models for Monocular Road Segmentation code: https://lmb.informatik.uni-freiburg.de/Publications/2016/OB16b/针对路面检测和分割问题，本文结合FCN 和 U-Net 提出一个网络，在速度和精度方面得到不错的效果 KITTI benchmark lane/ro
裂缝检测总结
Doreenqiuyue的博客
10-28 1381
图像相关的基础知识 二值图像、灰度图像、彩色图像 视频图像的一些简单处理 读取视频并获取视频信息、分帧保存—MATLAB 在视频上选取矩形区域，获取该区域的RGB均值信息—MATLAB Matlab读取视频并处理成帧保存 边缘检测相关算法 边缘提取算子总结—Matlab代码实现 Canny算子—MATLAB 图像边缘检测及提取方法总结（含Matlab代码） matlab图像边缘检测分析 python-opencv自带的检测函数 ...
【语义分割】算法理论梳理：基础理论/常见网络FCN、DeepLab、LR-ASPP、UNet、U2Net
ShiTianlei的博客
08-24 2894
图像分割中语义分割算法的理论梳理，主要针对算法的演化思路以及涉及到的专有名词（如转置卷积、膨胀卷积、mean IoU等)进行总结，想要对语义分割算法有一个框架式、全局掌握的小伙伴可以来看一眼。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

累了就要打游戏

把我养胖，搞代码

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值