Unet系列+Resnet模型（Pytorch)

最新推荐文章于 2025-04-04 23:33:51 发布
最新推荐文章于 2025-04-04 23:33:51 发布
阅读量1.6w 收藏 200
点赞数 27
文章标签： pytorch 深度学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54255111/article/details/125625991
版权

Unet系列+Resnet模型（Pytorch)

一.Unet

1.模型简介

在这里插入图片描述

Unet的结构如图所示，网络是一个经典的全卷积网络，模型与FCN类似没有全连接层，但是相比于FCN逐点相加，Unet使用torch.cat将特征在channel维度进行拼接，使得特征可以重复利用达到了更好的图像分割效果。

2.代码实现

为了使得代码简单明了，可以将双卷积单独作为一个Block处理。

import torch
import torch.nn as nn

class VGGBlock(nn.Module):
    def __init__(self, in_channels, middle_channels, out_channels):
        super().__init__()
        self.first = nn.Sequential(
            nn.Conv2d(in_channels, middle_channels, 3, padding=1),
            nn.BatchNorm2d(middle_channels),
            nn.ReLU()
        )
        self.second = nn.Sequential(
            nn.Conv2d(middle_channels, out_channels, 3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU()
        )

    def forward(self, x):
        out = self.first(x)
        out = self.second(out)

     	return out
    
class UNet(nn.Module):
    def __init__(self, num_classes, input_channels=3):
        super().__init__()

        nb_filter = [64, 128, 256, 512,1024]

        self.pool = nn.MaxPool2d(2, 2)
        self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)

        self.conv0_0 = VGGBlock(input_channels, nb_filter[0], nb_filter[0])
        self.conv1_0 = VGGBlock(nb_filter[0], nb_filter[1], nb_filter[1])
        self.conv2_0 = VGGBlock(nb_filter[1], nb_filter[2], nb_filter[2])
        self.conv3_0 = VGGBlock(nb_filter[2], nb_filter[3], nb_filter[3])
        self.conv4_0 = VGGBlock(nb_filter[3], nb_filter[4], nb_filter[4])

        self.conv3_1 = VGGBlock(nb_filter[3]+nb_filter[4], nb_filter[3], nb_filter[3])
        self.conv2_2 = VGGBlock(nb_filter[2]+nb_filter[3], nb_filter[2], nb_filter[2])
        self.conv1_3 = VGGBlock(nb_filter[1]+nb_filter[2], nb_filter[1], nb_filter[1])
        self.conv0_4 = VGGBlock(nb_filter[0]+nb_filter[1], nb_filter[0], nb_filter[0])

        self.final = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)


    def forward(self, input):
        x0_0 = self.conv0_0(input)
        x1_0 = self.conv1_0(self.pool(x0_0))
        x2_0 = self.conv2_0(self.pool(x1_0))
        x3_0 = self.conv3_0(self.pool(x2_0))
        x4_0 = self.conv4_0(self.pool(x3_0))

        x3_1 = self.conv3_1(torch.cat([x3_0, self.up(x4_0)], 1))
        x2_2 = self.conv2_2(torch.cat([x2_0, self.up(x3_1)], 1))
        x1_3 = self.conv1_3(torch.cat([x1_0, self.up(x2_2)], 1))
        x0_4 = self.conv0_4(torch.cat([x0_0, self.up(x1_3)], 1))

        output = self.final(x0_4)
        return output

二.Unet++

1.模型简介.

Unet++继承了Unet的结构,最大的改动是在Unet模型的中央添加了稠密连接方式，看起来更像一个巢式结构。有点类似于Densenet。其中还有一个创新点就是可以连接多个Loss,例如X0_4可以输出一个结果，X0_3也可以连接Loss输出结果。在这里插入图片描述

2.代码实现

import torch
import torch.nn as nn

class VGGBlock(nn.Module):
    def __init__(self, in_channels, middle_channels, out_channels):
        super().__init__()
        self.first = nn.Sequential(
            nn.Conv2d(in_channels, middle_channels, 3, padding=1,bias = False),
            nn.BatchNorm2d(middle_channels),
            nn.ReLU(inplace = True)
        )
        self.second = nn.Sequential(
            nn.Conv2d(middle_channels, out_channels, 3, padding=1,bias = False),       
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace = True)
        )

    def forward(self, x):
        out = self.first(x)
        out = self.second(out)

     	return out

class UNetplusplus(nn.Module):
    def __init__(self, num_classes, input_channels=3, deep_supervision=False, **kwargs):
        super().__init__()

        nb_filter = [64, 128, 256, 512,1024]

        self.deep_supervision = deep_supervision

        self.pool = nn.MaxPool2d(2, 2)
        self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)

        self.conv0_0 = VGGBlock(input_channels, nb_filter[0], nb_filter[0])
        self.conv1_0 = VGGBlock(nb_filter[0], nb_filter[1], nb_filter[1])
        self.conv2_0 = VGGBlock(nb_filter[1], nb_filter[2], nb_filter[2])
        self.conv3_0 = VGGBlock(nb_filter[2], nb_filter[3], nb_filter[3])
        self.conv4_0 = VGGBlock(nb_filter[3], nb_filter[4], nb_filter[4])

        self.conv0_1 = VGGBlock(nb_filter[0]+nb_filter[1], nb_filter[0], nb_filter[0])
        self.conv1_1 = VGGBlock(nb_filter[1]+nb_filter[2], nb_filter[1], nb_filter[1])
        self.conv2_1 = VGGBlock(nb_filter[2]+nb_filter[3], nb_filter[2], nb_filter[2])
        self.conv3_1 = VGGBlock(nb_filter[3]+nb_filter[4], nb_filter[3], nb_filter[3])

        self.conv0_2 = VGGBlock(nb_filter[0]*2+nb_filter[1], nb_filter[0], nb_filter[0])
        self.conv1_2 = VGGBlock(nb_filter[1]*2+nb_filter[2], nb_filter[1], nb_filter[1])
        self.conv2_2 = VGGBlock(nb_filter[2]*2+nb_filter[3], nb_filter[2], nb_filter[2])

        self.conv0_3 = VGGBlock(nb_filter[0]*3+nb_filter[1], nb_filter[0], nb_filter[0])
        self.conv1_3 = VGGBlock(nb_filter[1]*3+nb_filter[2], nb_filter[1], nb_filter[1])

        self.conv0_4 = VGGBlock(nb_filter[0]*4+nb_filter[1], nb_filter[0], nb_filter[0])

        if self.deep_supervision:
            self.final1 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
            self.final2 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
            self.final3 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
            self.final4 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
        else:
            self.final = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)


    def forward(self, input):
        x0_0 = self.conv0_0(input)
        x1_0 = self.conv1_0(self.pool(x0_0))
        x0_1 = self.conv0_1(torch.cat([x0_0, self.up(x1_0)], 1))

        x2_0 = self.conv2_0(self.pool(x1_0))
        x1_1 = self.conv1_1(torch.cat([x1_0, self.up(x2_0)], 1))
        x0_2 = self.conv0_2(torch.cat([x0_0, x0_1, self.up(x1_1)], 1))

        x3_0 = self.conv3_0(self.pool(x2_0))
        x2_1 = self.conv2_1(torch.cat([x2_0, self.up(x3_0)], 1))
        x1_2 = self.conv1_2(torch.cat([x1_0, x1_1, self.up(x2_1)], 1))
        x0_3 = self.conv0_3(torch.cat([x0_0, x0_1, x0_2, self.up(x1_2)], 1))
        x4_0 = self.conv4_0(self.pool(x3_0))
        x3_1 = self.conv3_1(torch.cat([x3_0, self.up(x4_0)], 1))
        x2_2 = self.conv2_2(torch.cat([x2_0, x2_1, self.up(x3_1)], 1))
        x1_3 = self.conv1_3(torch.cat([x1_0, x1_1, x1_2, self.up(x2_2)], 1))
        x0_4 = self.conv0_4(torch.cat([x0_0, x0_1, x0_2, x0_3, self.up(x1_3)], 1))

        if self.deep_supervision:               #多个输出
            output1 = self.final1(x0_1)
            output2 = self.final2(x0_2)
            output3 = self.final3(x0_3)
            output4 = self.final4(x0_4)
            return [output1, output2, output3, output4]

        else:
            output = self.final(x0_4)
            return output

三.Resnet

Resnet的模型其实很简单，基本框架就是两部分。BasicBlock（双卷积）以及BottleNeck（三卷积）。当模型超过50层时选用BottleNeck来堆叠网络。另外一个需要注意的点是Resnet是直接相加add，所以相加时应保证channels相同，为保证维度相同可以使用kernel_size等于1的卷积核进行升维。

在这里插入图片描述

import torch
import torch.nn as nn

class BasicBlock(nn.Module):          
    expansion = 1
	'''
	expansion通道扩充比例
	out_channels就是输出的channel
	'''
    
    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()

        self.residual_function = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels * BasicBlock.expansion, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels * BasicBlock.expansion)
        )

        self.shortcut = nn.Sequential()


        if stride != 1 or in_channels != BasicBlock.expansion * out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels * BasicBlock.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels * BasicBlock.expansion)
            )

    def forward(self, x):
        return nn.ReLU(inplace=True)(self.residual_function(x) + self.shortcut(x))

    
    
    
    
    
class BottleNeck(nn.Module):
    expansion = 4
	
    
    '''
    espansion是通道扩充的比例
    注意实际输出channel = middle_channels * BottleNeck.expansion
    '''
    def __init__(self, in_channels, middle_channels, stride=1):
        super().__init__()
        self.residual_function = nn.Sequential(
            nn.Conv2d(in_channels, middle_channels, kernel_size=1, bias=False),
            nn.BatchNorm2d(middle_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(middle_channels, middle_channels, stride=stride, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(middle_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(middle_channels, middle_channels * BottleNeck.expansion, kernel_size=1, bias=False),
            nn.BatchNorm2d(middle_channels * BottleNeck.expansion),
        )

        self.shortcut = nn.Sequential()

        if stride != 1 or in_channels != middle_channels * BottleNeck.expansion:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, middle_channels * BottleNeck.expansion, stride=stride, kernel_size=1, bias=False),
                nn.BatchNorm2d(middle_channels * BottleNeck.expansion)
            )

    def forward(self, x):
        return nn.ReLU(inplace=True)(self.residual_function(x) + self.shortcut(x))

四.Resnet+Unet

参考这位大佬

但是他的模型不支持Resnet50以上的网络，自己对这个模型做了细小的调整。

import torch
import torch.nn as nn

class BasicBlock(nn.Module):          
    expansion = 1
	'''
	expansion通道扩充比例
	out_channels就是输出的channel
	'''
    
    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()

        self.residual_function = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels * BasicBlock.expansion, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels * BasicBlock.expansion)
        )

        self.shortcut = nn.Sequential()


        if stride != 1 or in_channels != BasicBlock.expansion * out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels * BasicBlock.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels * BasicBlock.expansion)
            )

    def forward(self, x):
        return nn.ReLU(inplace=True)(self.residual_function(x) + self.shortcut(x))

    
    
    
    
    
class BottleNeck(nn.Module):
    expansion = 4
	
    
    '''
    espansion是通道扩充的比例
    注意实际输出channel = middle_channels * BottleNeck.expansion
    '''
    def __init__(self, in_channels, middle_channels, stride=1):
        super().__init__()
        self.residual_function = nn.Sequential(
            nn.Conv2d(in_channels, middle_channels, kernel_size=1, bias=False),
            nn.BatchNorm2d(middle_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(middle_channels, middle_channels, stride=stride, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(middle_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(middle_channels, middle_channels * BottleNeck.expansion, kernel_size=1, bias=False),
            nn.BatchNorm2d(middle_channels * BottleNeck.expansion),
        )

        self.shortcut = nn.Sequential()

        if stride != 1 or in_channels != middle_channels * BottleNeck.expansion:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, middle_channels * BottleNeck.expansion, stride=stride, kernel_size=1, bias=False),
                nn.BatchNorm2d(middle_channels * BottleNeck.expansion)
            )

    def forward(self, x):
        return nn.ReLU(inplace=True)(self.residual_function(x) + self.shortcut(x))

    
    
  
class VGGBlock(nn.Module):
    def __init__(self, in_channels, middle_channels, out_channels):
        super().__init__()
        self.first = nn.Sequential(
            nn.Conv2d(in_channels, middle_channels, 3, padding=1),
            nn.BatchNorm2d(middle_channels),
            nn.ReLU()
        )
        self.second = nn.Sequential(
            nn.Conv2d(middle_channels, out_channels, 3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU()
        )

    def forward(self, x):
        out = self.first(x)
        out = self.second(out)

     	return out
    
    
    
class UResnet(nn.Module):
    def __init__(self, block, layers, num_classes, input_channels=3):
        super().__init__()
        nb_filter = [64, 128, 256, 512, 1024]

        self.in_channel = nb_filter[0]

        self.pool = nn.MaxPool2d(2, 2)
        self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)

        self.conv0_0 = VGGBlock(input_channels, nb_filter[0], nb_filter[0])
        self.conv1_0 = self._make_layer(block,nb_filter[1], layers[0], 1)
        self.conv2_0 = self._make_layer(block,nb_filter[2], layers[1], 1)
        self.conv3_0 = self._make_layer(block,nb_filter[3], layers[2], 1)
        self.conv4_0 = self._make_layer(block,nb_filter[4], layers[3], 1)

        self.conv3_1 = VGGBlock((nb_filter[3] + nb_filter[4]) * block.expansion, nb_filter[3],
                            nb_filter[3] * block.expansion)
        self.conv2_2 = VGGBlock((nb_filter[2] + nb_filter[3]) * block.expansion, nb_filter[2],
                            nb_filter[2] * block.expansion)
        self.conv1_3 = VGGBlock((nb_filter[1] + nb_filter[2]) * block.expansion, nb_filter[1],
                            nb_filter[1] * block.expansion)
        self.conv0_4 = VGGBlock(nb_filter[0] + nb_filter[1] * block.expansion, nb_filter[0], nb_filter[0])

        self.final = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)

    def _make_layer(self, block,middle_channel, num_blocks, stride):
        '''
        middle_channels中间维度，实际输出channels = middle_channels * block.expansion
        num_blocks，一个Layer包含block的个数
        '''

        strides = [stride] + [1] * (num_blocks - 1)
        layers = []
        for stride in strides:
            layers.append(block(self.in_channel, middle_channel, stride))
            self.in_channel = middle_channel * block.expansion
        return nn.Sequential(*layers)


    def forward(self, input):
        x0_0 = self.conv0_0(input)
        x1_0 = self.conv1_0(self.pool(x0_0))
        x2_0 = self.conv2_0(self.pool(x1_0))
        x3_0 = self.conv3_0(self.pool(x2_0))
        x4_0 = self.conv4_0(self.pool(x3_0))

        x3_1 = self.conv3_1(torch.cat([x3_0, self.up(x4_0)], 1))
        x2_2 = self.conv2_2(torch.cat([x2_0, self.up(x3_1)], 1))
        x1_3 = self.conv1_3(torch.cat([x1_0, self.up(x2_2)], 1))
        x0_4 = self.conv0_4(torch.cat([x0_0, self.up(x1_3)], 1))

        output = self.final(x0_4)
        return output

如果要调用模型

UResnet34 = UResnet(block=BasicBlock,layers=[3,4,6,3],num_classes=2)      #这里我是做二分类

UResnet50 = UResnet(block=BottleNeck,layers=[3,4,6,3],num_classes=2)

UReset101 = UResnet(block=BottleNeck,layers=[3,4,23,3],num_classes=2)

UReset152 = UResnet(block=BottleNeck,layers=[3,8,36,3],num_classes=2)

五.Resnet+Unetplusplus

与Unet一样，都是将encode做替换

import torch
from torch import nn


class VGGBlock(nn.Module):
    def __init__(self, in_channels, middle_channels, out_channels):
        super().__init__()
        self.first = nn.Sequential(
            nn.Conv2d(in_channels, middle_channels, 3, padding=1,bias=False),
            nn.BatchNorm2d(middle_channels),
            nn.ReLU(inplace = True)
        )
        self.second = nn.Sequential(
            nn.Conv2d(middle_channels, out_channels, 3, padding=1,bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace = True)
        )

    def forward(self, x):
        out = self.first(x)
        out = self.second(out)


        return out

    
class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()

        self.residual_function = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels * BasicBlock.expansion, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels * BasicBlock.expansion)
        )

        self.shortcut = nn.Sequential()


        if stride != 1 or in_channels != BasicBlock.expansion * out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels * BasicBlock.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels * BasicBlock.expansion)
            )

    def forward(self, x):
        return nn.ReLU(inplace=True)(self.residual_function(x) + self.shortcut(x))


class BottleNeck(nn.Module):
    expansion = 4

    def __init__(self, in_channels, out_channels, stride=1):
        super().__init__()
        self.residual_function = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels, stride=stride, kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels * BottleNeck.expansion, kernel_size=1, bias=False),
            nn.BatchNorm2d(out_channels * BottleNeck.expansion),
        )

        self.shortcut = nn.Sequential()

        if stride != 1 or in_channels != out_channels * BottleNeck.expansion:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels * BottleNeck.expansion, stride=stride, kernel_size=1, bias=False),
                nn.BatchNorm2d(out_channels * BottleNeck.expansion)
            )

    def forward(self, x):
        return nn.ReLU(inplace=True)(self.residual_function(x) + self.shortcut(x))


    
    
    
class NestedUResnet(nn.Module):
    def __init__(self,block,layers,num_classes, input_channels=3, deep_supervision=False):
        super().__init__()

        nb_filter = [64, 128, 256, 512, 1024]
        self.in_channels = nb_filter[0]
        self.relu = nn.ReLU()
        self.deep_supervision = deep_supervision

        self.pool = nn.MaxPool2d(2, 2)
        self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)

        self.conv0_0 = VGGBlock(input_channels, nb_filter[0], nb_filter[0])
        self.conv1_0 = self._make_layer(block,nb_filter[1],layers[0],1)
        self.conv2_0 = self._make_layer(block,nb_filter[2],layers[1],1)
        self.conv3_0 = self._make_layer(block,nb_filter[3],layers[2],1)
        self.conv4_0 = self._make_layer(block,nb_filter[4],layers[3],1)

        self.conv0_1 = VGGBlock(nb_filter[0] + nb_filter[1] * block.expansion, nb_filter[0], nb_filter[0])
        self.conv1_1 = VGGBlock((nb_filter[1] +nb_filter[2]) * block.expansion, nb_filter[1], nb_filter[1] * block.expansion)
        self.conv2_1 = VGGBlock((nb_filter[2] +nb_filter[3]) * block.expansion, nb_filter[2], nb_filter[2] * block.expansion)
        self.conv3_1 = VGGBlock((nb_filter[3] +nb_filter[4]) * block.expansion, nb_filter[3], nb_filter[3] * block.expansion)

        self.conv0_2 = VGGBlock(nb_filter[0]*2+nb_filter[1] * block.expansion, nb_filter[0], nb_filter[0])
        self.conv1_2 = VGGBlock((nb_filter[1]*2+nb_filter[2]) * block.expansion, nb_filter[1], nb_filter[1] * block.expansion)
        self.conv2_2 = VGGBlock((nb_filter[2]*2+nb_filter[3]) * block.expansion, nb_filter[2], nb_filter[2] * block.expansion)

        self.conv0_3 = VGGBlock(nb_filter[0]*3+nb_filter[1] * block.expansion, nb_filter[0], nb_filter[0])
        self.conv1_3 = VGGBlock((nb_filter[1]*3+nb_filter[2]) * block.expansion, nb_filter[1], nb_filter[1] * block.expansion)

        self.conv0_4 = VGGBlock(nb_filter[0]*4+nb_filter[1] * block.expansion, nb_filter[0], nb_filter[0])

        if self.deep_supervision:
            self.final1 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
            self.final2 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
            self.final3 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
            self.final4 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
        else:
            self.final = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)

    def _make_layer(self,block, middle_channels, num_blocks, stride):
        strides = [stride] + [1] * (num_blocks - 1)
        layers = []
        for stride in strides:
            layers.append(block(self.in_channels, middle_channels, stride))
            self.in_channels = middle_channels * block.expansion
        return nn.Sequential(*layers)

    def forward(self, input):
        x0_0 = self.conv0_0(input)
        x1_0 = self.conv1_0(self.pool(x0_0))
        x0_1 = self.conv0_1(torch.cat([x0_0, self.up(x1_0)], 1))

        x2_0 = self.conv2_0(self.pool(x1_0))
        x1_1 = self.conv1_1(torch.cat([x1_0, self.up(x2_0)], 1))
        x0_2 = self.conv0_2(torch.cat([x0_0, x0_1, self.up(x1_1)], 1))

        x3_0 = self.conv3_0(self.pool(x2_0))
        x2_1 = self.conv2_1(torch.cat([x2_0, self.up(x3_0)], 1))
        x1_2 = self.conv1_2(torch.cat([x1_0, x1_1, self.up(x2_1)], 1))
        x0_3 = self.conv0_3(torch.cat([x0_0, x0_1, x0_2, self.up(x1_2)], 1))
        x4_0 = self.conv4_0(self.pool(x3_0))
        x3_1 = self.conv3_1(torch.cat([x3_0, self.up(x4_0)], 1))

        x2_2 = self.conv2_2(torch.cat([x2_0, x2_1, self.up(x3_1)], 1))
        x1_3 = self.conv1_3(torch.cat([x1_0, x1_1, x1_2, self.up(x2_2)], 1))
        x0_4 = self.conv0_4(torch.cat([x0_0, x0_1, x0_2, x0_3, self.up(x1_3)], 1))

        if self.deep_supervision:
            output1 = self.final1(x0_1)
            output2 = self.final2(x0_2)
            output3 = self.final3(x0_3)
            output4 = self.final4(x0_4)
            return [output1, output2, output3, output4]

        else:
            output = self.final(x0_4)
            return output

六.写在最后

经过测试Unet++效果确实比Unet效果要好，同样以Resnet34作为encoder，Unet++的
IOU相比于Unet稍高。
Unet++的巢结构使得其内部连接更为紧密，同样，单纯的加深网络结构效果并没有
Unet的效果显著，接下来的改进方向可以添加自注意力机制，或许能获得更好的效果。

pytorch实现基于resnet的Unet
weixin_38410551的博客
02-16 5444
resnet可以作为Unet的编码模块，只要把最后的全连接层去掉即可，其它无需改变。 Unet网络的整体结构为编码模块，和解码模块。解码模块要将每个stage模块的中间输出保存下来，以便与对应的解码模块的stage相连接。 Unet的创新之处在于它的解码模块，所以代码实现的时候尤其要关注每个模块的输入输出信道数，解码模块中间几个模块的处理过程相同，可以用for循环处理，而作为解码模块的输入和输出...
【深度学习|语义分割之UNet】如何使用ResNet50 作为 U-Net 网络的骨干网络（backbone）并使用预训练的 ResNet50 模型。附代码及解读。
985小水博的摸鱼日常
12-15 2098
【深度学习|语义分割之UNet】如何使用ResNet50 作为 U-Net 网络的骨干网络（backbone）并使用预训练的 ResNet50 模型。附代码及解读。
深度学习 Unet+Resnet101 实战分割项目、多尺度训练、迁移学习、多类别分割：腹部多脏器5类别分割数据集
02-08
本项目为 Unet+Resnet101 多尺度分割实战项目（包含数据集），unet的backbone更换为resnet101 数据集采用腹部多脏器5类别分割数据集 项目介绍：总大小202MB 1.train 脚本会自动训练，代码会自动将数据随机缩放为设定尺寸的0.5-1.5倍之间，实现多尺度训练。为了实现多分割项目，utils中的compute_gray函数会将mask灰度值保存在txt文本，并且自动为UNET网络定义输出的channel 2.项目的预处理函数全部重新实现，可以在transforms.py自行查看。 3.网络训练了100个epochs，miou达到0.9左右，学习率采用cos衰减，训练集和测试集的损失和iou曲线可以在run_results文件内查看，图像由matplotlib库绘制。除此外，还保存了训练日志，最好权重等，在训练日志可以看到每个类别的iou、recall、precision以及全局像素点的准确率等等 4.预测脚本可以自动推理inference下所有图片 代码做了注释，自行下载查看，想要训练自己的数据，参考README文件，傻瓜式运行
基于pytorch、python实现的 Unet+Resnet对眼镜框的图像分割【约16000张数据集】
10-11
适用于python的深度学习医学十项全能分割、pytorch框架编写 代码详解：https://blog.csdn.net/qq_44886601/article/details/136053714 代码介绍： 【训练】train 脚本会自动训练，代码会自动将数据随机缩放为设定尺寸的0.5-1.5倍之间，实现多尺度训练。为了实现多分割项目，utils中的compute_gray函数会将mask灰度值保存在txt文本，并且自动为unet网络定义输出的channel 【介绍】学习率采用cos衰减，训练集和测试集的损失和iou曲线可以在run_results文件内查看，图像由matplotlib库绘制。除此外，还保存了训练日志，最好权重等，在训练日志可以看到每个类别的iou、recall、precision以及全局像素点的准确率等等 如果训练自己数据的话，直接摆好数据即可！ 更多分割项目参考：https://blog.csdn.net/qq_44886601/category_12102735.html
【UNET】
最新发布
ml_plgg的博客
04-04 1926
UNET教程
基于resnet+unet的皮肤病变分割
02-25
该工程使用resnet50/101+hypercolumn+scse+unet算法实现对皮肤病变的分割
【小白】基于Resnet+Unet的图像分割模型（by Pytorch）
热门推荐
weixin_43842265的博客
07-18 4万+
文章目录（一）Unet1.概述2.代码实现（二）Resnet1.概述2.代码实现（三）Resnet+Unet代码详解1.为什么可以这么做？2.分部代码详解3.整体代码 （一）Unet 1.概述 1.Unet是目前应用最广泛的图像（语义）分割模型。它采用了encode（编码）+decode（解码）的结构，先对图像进行多次conv（+Bn+Relu）+pooling下采样，再进行upsample上采样...
Unet+ResNet 实战分割项目、多尺度训练、多类别分割
Henry的博客
02-06 3679
VGG 的特征提取能力其实是不弱的，但网络较为臃肿，容易产生梯度消失或者梯度爆炸的问题。
【干货教学】unet进阶，如何在unet中加入resnet（残差连接）
BluErroR的博客
11-25 1万+
在本教程中，我们将探讨如何在经典的U-Net架构中融入ResNet的残差连接。这种结合了U-Net在图像分割领域的优势和ResNet的残差连接的混合模型，我们称之为ResUnet，旨在通过残差学习改善模型的训练效率和性能。
ResNet+Unet模型
LYJ20010728的博客
04-07 5662
搭建模型结构代码 from tensorflow.keras import layers from tensorflow.keras import models def ResNet(image_input, is_training=True): dropout_rate = 0.5 if is_training else 1.0 # (512,512,3) -> (512,512,64) y = layers.Conv2D(64, kernel_size=4,
当UNet遇见ResNet会发生什么？
小白学视觉
08-04 4857
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达1.前言这篇文章主要以几篇经典的分割论文为切入点，浅谈一下当Unet遇见ResNet会发生什么？2. UNet首先回顾一下UNet，UNet的结构如下图所示：UNet 网络结构「从UNet的网络结构我们会发现两个最主要的特点，一个是它的U型结构，一个是它的跳层连接。」 其中UNet的编码器一共有4次下采...
UNET ResNet50网络结构 caffe版本
03-06
UNET ResNet50网络结构 caffe版本，
基于ResNet的图像分类和基于Unet的图像分割
10-31
ResNet代码打开后位于net文件夹下，先使用train.py文件训练网络，再使用predict.py输出预测结果 Unet代码位于seg文件夹下，bladder为网络训练，valida为网络分割结果。 所有代码均可使用自己的数据集，对于分割网络需要标签 希望对大家毕设有帮助，任何问题可以私信问我。 网络训练可以使用GPU也可以使用CPU，默认笔记本使用CPU，若要用到GPU，将代码中.cpu改为cuda 详情见我的博文：https://blog.csdn.net/qq_52060635/article/details/134149072?spm=1001.2014.3001.5502 在ResNet网络中有如下几个亮点： 提出residual结构（残差结构），并搭建超深的网络结构(突破1000层) 使用Batch Normalization加速训练(丢弃dropout) Unet的好处是：网络层越深得到的特征图，有着更大的视野域，浅层卷积关注纹理特征，深层网络关注本质的那种特征
基于pytorch、python实现的 Unet+Resnet对x光照下的人体骨骼的图像分割【包含数据集】
08-16
适用于python的深度学习医学十项全能分割、pytorch框架编写 代码详解：https://blog.csdn.net/qq_44886601/article/details/136053714 代码介绍： 【训练】train 脚本会自动训练，代码会自动将数据随机缩放为设定...
【PyTorch项目实战】语义分割：U-Net、UNet++、U2Net
shinuone的博客
02-11 8375
图像分割：对图像中属于特定类别的像素进行分类（逐像素分类）。 图像分类：识别图像中存在的内容。 目标检测：识别图像中的内容和位置（通过边界框）。 语义分割：识别图像中存在的内容以及位置（通过查找属于它的所有像素）。
语义分割模型------unet unet++
m0_47405013的博客
10-20 867
unet unet++
[深度学习] unet - resnet18 的使用Demo
comedate的专栏
02-18 1900
发现一个工业上，比较好用的网络：unet 与 resnet18 混合使用的例子：
铁轨语义分割（Unet结合resnet系列）
搬砖小能手
02-01 1162
一类是图片，一类是图像标签。
【干货教学】unet进阶，如何在unet中加入resnet（残差连接）_resnet unet
2401_83817689的博客
04-09 219
【代码】【干货教学】unet进阶，如何在unet中加入resnet（残差连接）_resnet unet。
Unet Resnet50
03-14
### UNet与ResNet50结合使用的相关信息 #### 模型架构概述 UNet是一种常用于图像分割任务的卷积神经网络结构，其特点是通过编码器-解码器的设计来捕捉高分辨率的空间细节以及低分辨率的语义特征[^3]。而ResNet50作为一种经典的深度残差网络，能够有效缓解深层网络中的梯度消失问题并提升训练效率[^4]。 当UNet与ResNet50相结合时，通常会利用ResNet50作为UNet的编码器部分。这种设计可以充分利用ResNet50强大的特征提取能力，从而提高整个模型在复杂场景下的表现。具体来说，在UNet中采用ResNet50作为骨干网络意味着将原始输入经过一系列由ResNet定义的卷积层处理后再传递给后续的跳跃连接和上采样操作[^5]。 #### 实现方法详解 为了实现UNet与ResNet50的有效融合，开发者可以选择预训练好的ResNet50权重初始化编码路径上的参数，这样不仅加快收敛速度还能增强泛化性能[^6]。以下是基于PyTorch框架的一个简单示例： ```python import torch.nn as nn from torchvision import models class ResUnet(nn.Module): def __init__(self, out_channels=1): super(ResUnet, self).__init__() resnet = models.resnet50(pretrained=True) modules = list(resnet.children())[:-2] self.encoder = nn.Sequential(*modules) # Decoder layers (simplified example) self.upconv1 = nn.ConvTranspose2d(2048, 1024, kernel_size=2, stride=2) self.upconv2 = nn.ConvTranspose2d(1024, 512, kernel_size=2, stride=2) self.final_layer = nn.Conv2d(512, out_channels, kernel_size=1) def forward(self, x): encoder_output = self.encoder(x) decoder_output = self.upconv1(encoder_output) decoder_output = self.upconv2(decoder_output) output = self.final_layer(decoder_output) return output ``` 上述代码片段展示了如何构建一个基本版本的Res-Unet模型。其中`models.resnet50(pretrained=True)`加载了一个带有ImageNet预训练权值的标准ResNet50实例；随后我们移除了最后两层以便适配到UNet架构之中[^7]。 #### 应用案例分析 该组合广泛应用于医学影像领域内的各种任务当中，比如肿瘤检测、器官轮廓描绘等。例如，在脑部MRI扫描数据集上运用此类混合模型可以帮助医生更精确地标记病变区域位置[^8]。另外也有研究者尝试将其扩展至遥感图像分类或者自动驾驶汽车感知系统等领域取得不错的效果[^9]。
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值