SegNet在Camvid的复现 pytorch实现

已于 2023-08-22 16:00:38 修改
阅读量1.4k 收藏 20
点赞数 8
文章标签： 深度学习 pytorch 神经网络 人工智能 python
于 2023-04-28 14:02:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45708890/article/details/130424686
版权
文章介绍了使用Pytorch实现SegNet和Unet语义分割模型的过程，包括网络参数选择、编码器-解码器结构以及训练细节。在512*512的输入尺寸下，经过100个epoch的训练，SegNet的预测结果存在较多噪点，性能逊于Unet。ResNet-Unet和Biformer_tiny版本的Unet表现出更高的IoU指标，分别为66%和72.4%，显示了更好的分割效果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.数据来源：

https://github.com/alexgkendall/SegNet-Tutorial

2.网络参数选择

代码参考B导：憨批的语义分割重制版6——Pytorch 搭建自己的Unet语义分割平台_Bubbliiiing的博客-CSDN博客憨批的语义分割13——Pytorch 搭建自己的Unet语义分割平台注意事项学习前言什么是Unet模型代码下载Unet实现思路一、预测部分1、主干网络介绍2、加强特征提取结构3、利用特征获得预测结果二、训练部分1、训练文件详解2、LOSS解析训练自己的Unet模型注意事项这是重新构建了的Unet语义分割网络，主要是文件框架上的构建，还有代码的实现，和之前的语义分割网络相比，更加完整也更清晰一些。建议还是学习这个版本的Unet。学习前言还是快乐的pytorch人。什么是Unet模型Unet是一个https://blog.csdn.net/weixin_44791964/article/details/108866828

输入尺寸：512*512

Epoch:100

损失函数：CEloss

pytorch实现segnet：


import torch
import torch.nn as nn
import torch.nn.functional as F
# from collections import OrderedDict
#Encoder模块
 
class Encoder(nn.Module):
    def __init__(self):
        super(Encoder,self).__init__()
        #前13层是VGG16的前13层,分为5个stage
        #因为在下采样时要保存最大池化层的索引, 方便起见, 池化层不写在stage中
        self.stage_1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
        )
        
        self.stage_2 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
        )
        
        self.stage_3 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
        )     
        
        self.stage_4 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
        )   
        
        self.stage_5 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
        )     
        
    def forward(self, x):
        #用来保存各层的池化索引
        pool_indices = []
        x = x.float()
        
        x = self.stage_1(x)
        #pool_indice_1保留了第一个池化层的索引
        x, pool_indice_1 = nn.MaxPool2d( 2, stride=2, return_indices=True)(x)
        pool_indices.append(pool_indice_1)
        
        x = self.stage_2(x)
        x, pool_indice_2 = nn.MaxPool2d(2, stride=2, return_indices=True)(x)
        pool_indices.append(pool_indice_2)
        
        x = self.stage_3(x)
        x, pool_indice_3 = nn.MaxPool2d(2, stride=2, return_indices=True)(x)
        pool_indices.append(pool_indice_3)   
        
        x = self.stage_4(x)
        x, pool_indice_4 = nn.MaxPool2d(2, stride=2, return_indices=True)(x)
        pool_indices.append(pool_indice_4)
        
        x = self.stage_5(x)
        x, pool_indice_5 = nn.MaxPool2d(2, stride=2, return_indices=True)(x)
        pool_indices.append(pool_indice_5)
        
        return x, pool_indices
    
    
#SegNet网络, Encoder-Decoder
class SegNet(nn.Module):
    def __init__(self, num_classes):
        super(SegNet, self).__init__()
        #加载Encoder
        self.encoder = Encoder()
       #上采样 从下往上, 1->2->3->4->5
        self.upsample_1 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
        )
        
        self.upsample_2 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.Conv2d(512, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
        )
        
        self.upsample_3 = nn.Sequential(
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.Conv2d(256, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
        )
        
        self.upsample_4 = nn.Sequential(
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.Conv2d(128, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
        )
        
        self.upsample_5 = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, num_classes, kernel_size=3, stride=1, padding=1),
        )   
        
    def forward(self, x):
        x, pool_indices = self.encoder(x)
        
        #池化索引上采样
        x = nn.MaxUnpool2d(2, 2, padding=0)(x, pool_indices[4])
        x = self.upsample_1(x)
        
        x = nn.MaxUnpool2d(2, 2, padding=0)(x, pool_indices[3])
        x = self.upsample_2(x) 
        
        x = nn.MaxUnpool2d(2, 2, padding=0)(x, pool_indices[2])
        x = self.upsample_3(x)
        
        x = nn.MaxUnpool2d(2, 2, padding=0)(x, pool_indices[1])
        x = self.upsample_4(x)
        
        x = nn.MaxUnpool2d(2, 2, padding=0)(x, pool_indices[0])
        x = self.upsample_5(x)
        
        return x

3.网络结果：

各类iou指标：

 预测结果：

4.总结：

预测会出现许多噪点，效果不太好，上述指标是在val上的结果，论文上指标好像是50几左右，整体来说还是unet比较扛一点，

用resnet_unet的miou都达到66%miou，

Biformer_tiny版本的unet更达到了72.4%的Miou。（参数量比rensnet_unet少一倍）

我没动鸭
关注
基于pytorch的segnet实现，使用camvid数据集训练
haohulala的博客
08-01 6127
程序结构基本与https://blog.csdn.net/haohulala/article/details/107660273这篇文章相似，有什么问题也可以参考这篇文章。 import torch from torch import nn import torch.nn.functional as f import torchvision import torchvision.transforms as tfs from torch.utils.data import DataLoader from to
pytorch实现segnet_SegNet网络的Pytorch实现
weixin_30357183的博客
01-17 1030
1 importtorch.nn as nn2 importtorch34 classconv2DBatchNormRelu(nn.Module):5 def __init__(self,in_channels,out_channels,kernel_size,stride,padding,bias=True,dilation=1,is_batchnorm=True):6 ...
SegNet-PyTorch
05-16
SegNet-PyTorch 该项目是的SegNet的实现，您可以通过访问作者提供的演示来找到更多详细信息。 环境 Ubuntu的：16.04 火炬：0.4.0 的Python：3.6.1 运行项目 sh run.sh
SegNet学习笔记(附Pytorch 代码)
xiaoxifei的专栏
03-21 1万+
SegNet 的应用 SegNet常用于图像的语义分割。什么是语义分割了？，我们知道图像分割大致可以划分为三类，一类是语义分割、一类是实例分割，一类是全景分割，另外还有一些可以归为超像素分割。打个比方，如果是有一群人的沙滩排球这样的一个场景，图像中有一群人，有蓝天，大海，沙滩，还有一些椰子树。语义分割就是将人从这张图中分出来，其他的全部认为是背景；实例分割，就是不仅仅要把人分出来，还要区别不同的人...
语义分割系列3-SegNet（pytorch实现）
yumaomi的博客
05-14 1万+
本文介绍了SegNet网络结构，基于pytorch构建了SegNet模型，并在Camvid数据集上复现。
pytorch实现segnet_pytorch版segnet复现实践
weixin_31133141的博客
01-17 1719
复现了github地址：https://github.com/nshaud/DeepNetsForEO的pytorch版本应用于遥感影像上的segnet模型。将配置环境时遇到的问题总结如下：1.在指定的conda虚拟环境运行Jupyter Notebook参考网址：https://blog.csdn.net/weixin_43593330/article/details/89856136#查看已有...
基于pytorch实现segnet的图像分割任务python源码.zip
05-06
在PyTorch中实现SegNet，首先需要导入必要的库，如`torch`、`torchvision`等。然后定义网络结构，包括编码器和解码器的各个层。编码器可以使用预训练的VGG16模型，只需要移除最后的全连接层。解码器部分则需要创建与...
分割中的解码编码结构-SegNet（包含代码复现）
shengweiit的博客
04-12 1199
SegNet经典分割网络
SegNet-Model(pytorch版本）
Major_S的博客
09-11 778
SegNet−Model(pytorch版本）SegNet-Model(pytorch版本）SegNet−Model(pytorch版本） import torch import torchvision.models as models from torch import nn vgg16_pretrained = models.vgg16(pretrained=False) def decoder(input_channel, output_channel, num=3): if num =
推荐开源项目：SegNet PyTorch
gitblog_00035的博客
06-15 436
推荐开源项目：SegNet PyTorch 项目地址:https://gitcode.com/gh_mirrors/se/segnet_pytorch 1、项目介绍 SegNet PyTorch 是一个基于 PyTorch 框架的深度学习模型实现，专注于图像分割任务。尽管该项目已被宣布为废弃并转至 Delta toolbox 进行进一步更新，但它仍然作为理解 SegNet 架构的一个宝贵资源，特别...
openseg.pytorch：OCNet系列和SegFix的Pytorch代码
02-14
openseg.pytorch 消息 2021/02/05支持pytorch-1.7，混合精度和分布式培训。 我们还将添加更多的分割模型，这些模型将基于paddlepaddle图像预先训练的权重，从而实现更好的性能。 例如，通过单尺度测试，我们在PASCAL-Context上获得2.61％的收益，而在COCO-Stuff上获得2.89％的收益。 请检出分支pytorch-1.7了解更多详细信息。 2020/08/16 支持了我们的HRNet + OCR。 2020/07/20来自AInnovation的研究人员通过使用半监督学习方案训练我们的HRNet + OCR，在上排名第一。 更多详细信息，请参。 2020/07/09 和已被ECCV-2020接受。 值得注意的是，英伟达的研究人员通过将HRNet + OCR与新的相结合，在Cityscapes排行榜上设置了新的最先进的性能：
semseg：常用的语义分割架构结构概述以及代码复现
02-04
塞姆塞格 主 语义图像分割，为图像中的每个对象分配语义标签（例如“道路”，“天空”，“人”，“狗”）的任务能够实现很多新应用，例如Pixel 2和Pixel 2 XL智能手机的初步模式中提供的合成浅景深效果和移动实时视频分割。 引用自 本仓库的开发计划见 下面将初步主要的论文整理表格以供后续进一步总结。 网络实现 FCN（VGG和ResNet的骨干网络），已实现，参考 RefineNet，已实现，参考 DUC，参考 DRN，已实现 PSPNet，参考 ENet，已实现 ErfNet，已实现 EDANet，已实现 LinkNet，已实现，参考 FC-DenseNet，已实现，参考 L
SegNet+tensorflow代码+数据集.rar
08-23
SegNet: A Deep Convolutional Encoder-Decoder Architecture for Image Segmentation tensorflow源代码+数据集
【图像分割】用pytorch实现SegNet算法
热门推荐
chenzhoujian_的博客
06-20 1万+
论文地址：https://arxiv.org/pdf/1511.00561.pdf 官方代码：https://github.com/alexgkendall/caffe-segnet 编码器 VGG-16的前13层 BN层的momentum=0.1 下采样时保留最大值的位置 以下是pytorch代码： class Encoder(nn.Module): def __init__(self, input_channels): super(Encoder, self).__init__(
SegNet_PyTorch 使用教程
最新发布
gitblog_00092的博客
08-20 427
SegNet_PyTorch 使用教程 segnet_pytorchSegNet implemetation using PyTorch项目地址:https://gitcode.com/gh_mirrors/se/segnet_pytorch 项目介绍 SegNet_PyTorch 是一个基于 PyTorch 实现的图像分割项目，它实现了 SegNet 这一深度卷积编码器-解码器架构。SegNe...
Pytorch：图像语义分割-FCN, U-Net, SegNet, 预训练网络
Jingmin Wei's Blog
03-21 6561
介绍了图像语义分割网络的基本概念，介绍了FCN, U-Net, SegNet的网络结构并用代码实现建模，使用预训练的语义分割网络完成颜色编码和图像分割。
SegNet_PyTorch 项目使用教程
gitblog_01047的博客
08-20 317
SegNet_PyTorch 项目使用教程 segnet_pytorchSegNet implemetation using PyTorch项目地址:https://gitcode.com/gh_mirrors/se/segnet_pytorch 1. 项目的目录结构及介绍 SegNet_PyTorch 项目的目录结构如下： segnet_pytorch/ ├── CamVid/ │ ├──...
Pytorch之经典神经网络语义分割(三) —— SegNet(Cityscapes)
hxxjxw的博客
08-13 1521
不要从字面意思上理解语义分割，它和语言没有任何关系 语义分割是一种像素级别的处理图像方式，对比于目标检测其更加精确，能够自动从图像中划分出对象区域并识别对象区域中的类别 例如 Alexnet、vgg-16、googlenet、resnet这些经典的深层网络通常被作为语义分割系统的基础 https://blog.csdn.net/weixin_40446557/article/details/85624579 ...
【SegNet搭建-pytorch】反池化上采样indices的记录
weixin_44994302的博客
07-09 952
【SegNet搭建-pytorch】加载预训练权重+利用反池化上采样记录indices 说明：该文章为个人笔记，存在不完整，敬请谅解~~~ 论文地址：https://arxiv.org/pdf/1511.00561.pdf 1 掌握 1、加载与训练权重 2、采用反池化进行上采样，记录使用indices方法 2 SegNet参考模型图 3、记录indices技巧（关键部分） import torch import torch.nn as nn from torchvision.models impo
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值