2D UNet3+ Pytorch实现 脑肿瘤分割

已于 2023-10-02 13:24:15 修改
阅读量8.8k 收藏 113
点赞数 9
分类专栏： # 医学影像分割 文章标签： pytorch 深度学习 人工智能
于 2020-06-07 02:17:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40519315/article/details/106599680
版权

一、网络介绍

论文下载地址及论文翻译与解读:

玖零猴：UNet3+(UNet+++)论文翻译与详细解读

原代码链接: 链接

二、BraTs数据预处理

本文用的训练集和验证集均来自BraTs2018的训练集(其中HGG:210个病人,LGG:75个病人)

但由于BraTs只公开训练集数据,没有测试集数据,如果在训练集中再拆一部分用来作测试集的话,那训练集便少了许多,训练数据如果过少,容易出现过拟合现象,即在训练集中表现好,而在测试集中表现差,此时的网络泛化能力变差了.为了解决数据少的问题,灵机一动的我想出了一个办法.

因为BraTs2019的训练集在BraTs2018的基础上增多了,其中HGG增加了49例,LGG增加了1例,那么我就把这些新增的作为我的测试集

下面我提供百度云盘给大家下载,这是原始数据

        BraTs18数据集下载地址(不包含测试集,提供的验证集无GT) 
链接：https://pan.baidu.com/s/1Ry41OVl9VLOMzhQQR9qXuA 提取码：qvmo
BraTs19数据集下载地址如下(不包含测试集,提供的验证集无GT) 
链接: https://pan.baidu.com/s/1S5XGTdHkwFnagKS-5vWYBg 提取码: 2333

数据的预处理以及实现代码

把上面两年的数据下下来,然后我对数据的预处理方法是链接

完整的实现代码(jupyter notebook打开)

https://github.com/Merofine/BraTS2Dpreprocessing

  1. GetTrainingSets.ipynb——>训练集和验证集
  2. GetTestingSetsFrom2019.ipynb-—>测试集

代码执行完后,获得npy数据

v2-31cb53c7a1a959205b2a5c4682bb0c2f_b.png

<如果大家嫌麻烦,我这里提供预处理好的npy数据>

        链接:https://pan.baidu.com/s/1W3rcl9I-Y8DwWu5p4o--cw  密码:hfe7

三、运行环境的安装

1、系统环境 WIN10 + CUDA 92 + CUDNN7 + ANACONDA

2、ANACONDA指令快速配置环境,先下载下面文件

https://download.csdn.net/downl

v2-11fd1748f117e9449cfab9bae4b5939c_b.jpg

四、核心代码

        # -*- coding: utf-8 -*-
import torch
import torch.nn as nn
import torch.nn.functional as F
from layers import unetConv2
from init_weights import init_weights
'''
    UNet 3+
'''
class UNet_3Plus(nn.Module):

    def __init__(self, args):
        super(UNet_3Plus, self).__init__()
        self.args = args
        in_channels = 4
        n_classes = 3
        feature_scale = 4
        is_deconv = True
        is_batchnorm = True
        self.is_deconv = is_deconv
        self.in_channels = in_channels
        self.is_batchnorm = is_batchnorm
        self.feature_scale = feature_scale

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

        ## -------------Encoder--------------
        self.conv1 = unetConv2(self.in_channels, filters[0], self.is_batchnorm)
        self.maxpool1 = nn.MaxPool2d(kernel_size=2)

        self.conv2 = unetConv2(filters[0], filters[1], self.is_batchnorm)
        self.maxpool2 = nn.MaxPool2d(kernel_size=2)

        self.conv3 = unetConv2(filters[1], filters[2], self.is_batchnorm)
        self.maxpool3 = nn.MaxPool2d(kernel_size=2)

        self.conv4 = unetConv2(filters[2], filters[3], self.is_batchnorm)
        self.maxpool4 = nn.MaxPool2d(kernel_size=2)

        self.conv5 = unetConv2(filters[3], filters[4], self.is_batchnorm)

        ## -------------Decoder--------------
        self.CatChannels = filters[0]
        self.CatBlocks = 5
        self.UpChannels = self.CatChannels * self.CatBlocks

        '''stage 4d'''
        # h1->320*320, hd4->40*40, Pooling 8 times
        self.h1_PT_hd4 = nn.MaxPool2d(8, 8, ceil_mode=True)
        self.h1_PT_hd4_conv = nn.Conv2d(filters[0], self.CatChannels, 3, padding=1)
        self.h1_PT_hd4_bn = nn.BatchNorm2d(self.CatChannels)
        self.h1_PT_hd4_relu = nn.ReLU(inplace=True)

        # h2->160*160, hd4->40*40, Pooling 4 times
        self.h2_PT_hd4 = nn.MaxPool2d(4, 4, ceil_mode=True)
        self.h2_PT_hd4_conv = nn.Conv2d(filters[1], self.CatChannels, 3, padding=1)
        self.h2_PT_hd4_bn = nn.BatchNorm2d(self.CatChannels)
        self.h2_PT_hd4_relu = nn.ReLU(inplace=True)

        # h3->80*80, hd4->40*40, Pooling 2 times
        self.h3_PT_hd4 = nn.MaxPool2d(2, 2, ceil_mode=True)
        self.h3_PT_hd4_conv = nn.Conv2d(filters[2], self.CatChannels, 3, padding=1)
        self.h3_PT_hd4_bn = nn.BatchNorm2d(self.CatChannels)
        self.h3_PT_hd4_relu = nn.ReLU(inplace=True)

        # h4->40*40, hd4->40*40, Concatenation
        self.h4_Cat_hd4_conv = nn.Conv2d(filters[3], self.CatChannels, 3, padding=1)
        self.h4_Cat_hd4_bn = nn.BatchNorm2d(self.CatChannels)
        self.h4_Cat_hd4_relu = nn.ReLU(inplace=True)

        # hd5->20*20, hd4->40*40, Upsample 2 times
        self.hd5_UT_hd4 = nn.Upsample(scale_factor=2, mode='bilinear')  # 14*14
        self.hd5_UT_hd4_conv = nn.Conv2d(filters[4], self.CatChannels, 3, padding=1)
        self.hd5_UT_hd4_bn = nn.BatchNorm2d(self.CatChannels)
        self.hd5_UT_hd4_relu = nn.ReLU(inplace=True)

        # fusion(h1_PT_hd4, h2_PT_hd4, h3_PT_hd4, h4_Cat_hd4, hd5_UT_hd4)
        self.conv4d_1 = nn.Conv2d(self.UpChannels, self.UpChannels, 3, padding=1)  # 16
        self.bn4d_1 = nn.BatchNorm2d(self.UpChannels)
        self.relu4d_1 = nn.ReLU(inplace=True)

        '''stage 3d'''
        # h1->320*320, hd3->80*80, Pooling 4 times
        self.h1_PT_hd3 = nn.MaxPool2d(4, 4, ceil_mode=True)
        self.h1_PT_hd3_conv = nn.Conv2d(filters[0], self.CatChannels, 3, padding=1)
        self.h1_PT_hd3_bn = nn.BatchNorm2d(self.CatChannels)
        self.h1_PT_hd3_relu = nn.ReLU(inplace=True)

        # h2->160*160, hd3->80*80, Pooling 2 times
        self.h2_PT_hd3 = nn.MaxPool2d(2, 2, ceil_mode=True)
        self.h2_PT_hd3_conv = nn.Conv2d(filters[1], self.CatChannels, 3, padding=1)
        self.h2_PT_hd3_bn = nn.BatchNorm2d(self.CatChannels)
        self.h2_PT_hd3_relu = nn.ReLU(inplace=True)

        # h3->80*80, hd3->80*80, Concatenation
        self.h3_Cat_hd3_conv = nn.Conv2d(filters[2], self.CatChannels, 3, padding=1)
        self.h3_Cat_hd3_bn = nn.BatchNorm2d(self.CatChannels)
        self.h3_Cat_hd3_relu = nn.ReLU(inplace=True)

        # hd4->40*40, hd4->80*80, Upsample 2 times
        self.hd4_UT_hd3 = nn.Upsample(scale_factor=2, mode='bilinear')  # 14*14
        self.hd4_UT_hd3_conv = nn.Conv2d(self.UpChannels, self.CatChannels, 3, padding=1)
        self.hd4_UT_hd3_bn = nn.BatchNorm2d(self.CatChannels)
        self.hd4_UT_hd3_relu = nn.ReLU(inplace=True)

        # hd5->20*20, hd4->80*80, Upsample 4 times
        self.hd5_UT_hd3 = nn.Upsample(scale_factor=4, mode='bilinear')  # 14*14
        self.hd5_UT_hd3_conv = nn.Conv2d(filters[4], self.CatChannels, 3, padding=1)
        self.hd5_UT_hd3_bn = nn.BatchNorm2d(self.CatChannels)
        self.hd5_UT_hd3_relu = nn.ReLU(inplace=True)

        # fusion(h1_PT_hd3, h2_PT_hd3, h3_Cat_hd3, hd4_UT_hd3, hd5_UT_hd3)
        self.conv3d_1 = nn.Conv2d(self.UpChannels, self.UpChannels, 3, padding=1)  # 16
        self.bn3d_1 = nn.BatchNorm2d(self.UpChannels)
        self.relu3d_1 = nn.ReLU(inplace=True)

        '''stage 2d '''
        # h1->320*320, hd2->160*160, Pooling 2 times
        self.h1_PT_hd2 = nn.MaxPool2d(2, 2, ceil_mode=True)
        self.h1_PT_hd2_conv = nn.Conv2d(filters[0], self.CatChannels, 3, padding=1)
        self.h1_PT_hd2_bn = nn.BatchNorm2d(self.CatChannels)
        self.h1_PT_hd2_relu = nn.ReLU(inplace=True)

        # h2->160*160, hd2->160*160, Concatenation
        self.h2_Cat_hd2_conv = nn.Conv2d(filters[1], self.CatChannels, 3, padding=1)
        self.h2_Cat_hd2_bn = nn.BatchNorm2d(self.CatChannels)
        self.h2_Cat_hd2_relu = nn.ReLU(inplace=True)

        # hd3->80*80, hd2->160*160, Upsample 2 times
        self.hd3_UT_hd2 = nn.Upsample(scale_factor=2, mode='bilinear')  # 14*14
        self.hd3_UT_hd2_conv = nn.Conv2d(self.UpChannels, self.CatChannels, 3, padding=1)
        self.hd3_UT_hd2_bn = nn.BatchNorm2d(self.CatChannels)
        self.hd3_UT_hd2_relu = nn.ReLU(inplace=True)

        # hd4->40*40, hd2->160*160, Upsample 4 times
        self.hd4_UT_hd2 = nn.Upsample(scale_factor=4, mode='bilinear')  # 14*14
        self.hd4_UT_hd2_conv = nn.Conv2d(self.UpChannels, self.CatChannels, 3, padding=1)
        self.hd4_UT_hd2_bn = nn.BatchNorm2d(self.CatChannels)
        self.hd4_UT_hd2_relu = nn.ReLU(inplace=True)

        # hd5->20*20, hd2->160*160, Upsample 8 times
        self.hd5_UT_hd2 = nn.Upsample(scale_factor=8, mode='bilinear')  # 14*14
        self.hd5_UT_hd2_conv = nn.Conv2d(filters[4], self.CatChannels, 3, padding=1)
        self.hd5_UT_hd2_bn = nn.BatchNorm2d(self.CatChannels)
        self.hd5_UT_hd2_relu = nn.ReLU(inplace=True)

        # fusion(h1_PT_hd2, h2_Cat_hd2, hd3_UT_hd2, hd4_UT_hd2, hd5_UT_hd2)
        self.conv2d_1 = nn.Conv2d(self.UpChannels, self.UpChannels, 3, padding=1)  # 16
        self.bn2d_1 = nn.BatchNorm2d(self.UpChannels)
        self.relu2d_1 = nn.ReLU(inplace=True)

        '''stage 1d'''
        # h1->320*320, hd1->320*320, Concatenation
        self.h1_Cat_hd1_conv = nn.Conv2d(filters[0], self.CatChannels, 3, padding=1)
        self.h1_Cat_hd1_bn = nn.BatchNorm2d(self.CatChannels)
        self.h1_Cat_hd1_relu = nn.ReLU(inplace=True)

        # hd2->160*160, hd1->320*320, Upsample 2 times
        self.hd2_UT_hd1 = nn.Upsample(scale_factor=2, mode='bilinear')  # 14*14
        self.hd2_UT_hd1_conv = nn.Conv2d(self.UpChannels, self.CatChannels, 3, padding=1)
        self.hd2_UT_hd1_bn = nn.BatchNorm2d(self.CatChannels)
        self.hd2_UT_hd1_relu = nn.ReLU(inplace=True)

        # hd3->80*80, hd1->320*320, Upsample 4 times
        self.hd3_UT_hd1 = nn.Upsample(scale_factor=4, mode='bilinear')  # 14*14
        self.hd3_UT_hd1_conv = nn.Conv2d(self.UpChannels, self.CatChannels, 3, padding=1)
        self.hd3_UT_hd1_bn = nn.BatchNorm2d(self.CatChannels)
        self.hd3_UT_hd1_relu = nn.ReLU(inplace=True)

        # hd4->40*40, hd1->320*320, Upsample 8 times
        self.hd4_UT_hd1 = nn.Upsample(scale_factor=8, mode='bilinear')  # 14*14
        self.hd4_UT_hd1_conv = nn.Conv2d(self.UpChannels, self.CatChannels, 3, padding=1)
        self.hd4_UT_hd1_bn = nn.BatchNorm2d(self.CatChannels)
        self.hd4_UT_hd1_relu = nn.ReLU(inplace=True)

        # hd5->20*20, hd1->320*320, Upsample 16 times
        self.hd5_UT_hd1 = nn.Upsample(scale_factor=16, mode='bilinear')  # 14*14
        self.hd5_UT_hd1_conv = nn.Conv2d(filters[4], self.CatChannels, 3, padding=1)
        self.hd5_UT_hd1_bn = nn.BatchNorm2d(self.CatChannels)
        self.hd5_UT_hd1_relu = nn.ReLU(inplace=True)

        # fusion(h1_Cat_hd1, hd2_UT_hd1, hd3_UT_hd1, hd4_UT_hd1, hd5_UT_hd1)
        self.conv1d_1 = nn.Conv2d(self.UpChannels, self.UpChannels, 3, padding=1)  # 16
        self.bn1d_1 = nn.BatchNorm2d(self.UpChannels)
        self.relu1d_1 = nn.ReLU(inplace=True)

        # output
        self.outconv1 = nn.Conv2d(self.UpChannels, n_classes, 3, padding=1)

        # initialise weights
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                init_weights(m, init_type='kaiming')
            elif isinstance(m, nn.BatchNorm2d):
                init_weights(m, init_type='kaiming')

    def forward(self, inputs):
        ## -------------Encoder-------------
        h1 = self.conv1(inputs)  # h1->320*320*64

        h2 = self.maxpool1(h1)
        h2 = self.conv2(h2)  # h2->160*160*128

        h3 = self.maxpool2(h2)
        h3 = self.conv3(h3)  # h3->80*80*256

        h4 = self.maxpool3(h3)
        h4 = self.conv4(h4)  # h4->40*40*512

        h5 = self.maxpool4(h4)
        hd5 = self.conv5(h5)  # h5->20*20*1024

        ## -------------Decoder-------------
        h1_PT_hd4 = self.h1_PT_hd4_relu(self.h1_PT_hd4_bn(self.h1_PT_hd4_conv(self.h1_PT_hd4(h1))))
        h2_PT_hd4 = self.h2_PT_hd4_relu(self.h2_PT_hd4_bn(self.h2_PT_hd4_conv(self.h2_PT_hd4(h2))))
        h3_PT_hd4 = self.h3_PT_hd4_relu(self.h3_PT_hd4_bn(self.h3_PT_hd4_conv(self.h3_PT_hd4(h3))))
        h4_Cat_hd4 = self.h4_Cat_hd4_relu(self.h4_Cat_hd4_bn(self.h4_Cat_hd4_conv(h4)))
        hd5_UT_hd4 = self.hd5_UT_hd4_relu(self.hd5_UT_hd4_bn(self.hd5_UT_hd4_conv(self.hd5_UT_hd4(hd5))))
        hd4 = self.relu4d_1(self.bn4d_1(self.conv4d_1(
            torch.cat((h1_PT_hd4, h2_PT_hd4, h3_PT_hd4, h4_Cat_hd4, hd5_UT_hd4), 1)))) # hd4->40*40*UpChannels

        h1_PT_hd3 = self.h1_PT_hd3_relu(self.h1_PT_hd3_bn(self.h1_PT_hd3_conv(self.h1_PT_hd3(h1))))
        h2_PT_hd3 = self.h2_PT_hd3_relu(self.h2_PT_hd3_bn(self.h2_PT_hd3_conv(self.h2_PT_hd3(h2))))
        h3_Cat_hd3 = self.h3_Cat_hd3_relu(self.h3_Cat_hd3_bn(self.h3_Cat_hd3_conv(h3)))
        hd4_UT_hd3 = self.hd4_UT_hd3_relu(self.hd4_UT_hd3_bn(self.hd4_UT_hd3_conv(self.hd4_UT_hd3(hd4))))
        hd5_UT_hd3 = self.hd5_UT_hd3_relu(self.hd5_UT_hd3_bn(self.hd5_UT_hd3_conv(self.hd5_UT_hd3(hd5))))
        hd3 = self.relu3d_1(self.bn3d_1(self.conv3d_1(
            torch.cat((h1_PT_hd3, h2_PT_hd3, h3_Cat_hd3, hd4_UT_hd3, hd5_UT_hd3), 1)))) # hd3->80*80*UpChannels

        h1_PT_hd2 = self.h1_PT_hd2_relu(self.h1_PT_hd2_bn(self.h1_PT_hd2_conv(self.h1_PT_hd2(h1))))
        h2_Cat_hd2 = self.h2_Cat_hd2_relu(self.h2_Cat_hd2_bn(self.h2_Cat_hd2_conv(h2)))
        hd3_UT_hd2 = self.hd3_UT_hd2_relu(self.hd3_UT_hd2_bn(self.hd3_UT_hd2_conv(self.hd3_UT_hd2(hd3))))
        hd4_UT_hd2 = self.hd4_UT_hd2_relu(self.hd4_UT_hd2_bn(self.hd4_UT_hd2_conv(self.hd4_UT_hd2(hd4))))
        hd5_UT_hd2 = self.hd5_UT_hd2_relu(self.hd5_UT_hd2_bn(self.hd5_UT_hd2_conv(self.hd5_UT_hd2(hd5))))
        hd2 = self.relu2d_1(self.bn2d_1(self.conv2d_1(
            torch.cat((h1_PT_hd2, h2_Cat_hd2, hd3_UT_hd2, hd4_UT_hd2, hd5_UT_hd2), 1)))) # hd2->160*160*UpChannels

        h1_Cat_hd1 = self.h1_Cat_hd1_relu(self.h1_Cat_hd1_bn(self.h1_Cat_hd1_conv(h1)))
        hd2_UT_hd1 = self.hd2_UT_hd1_relu(self.hd2_UT_hd1_bn(self.hd2_UT_hd1_conv(self.hd2_UT_hd1(hd2))))
        hd3_UT_hd1 = self.hd3_UT_hd1_relu(self.hd3_UT_hd1_bn(self.hd3_UT_hd1_conv(self.hd3_UT_hd1(hd3))))
        hd4_UT_hd1 = self.hd4_UT_hd1_relu(self.hd4_UT_hd1_bn(self.hd4_UT_hd1_conv(self.hd4_UT_hd1(hd4))))
        hd5_UT_hd1 = self.hd5_UT_hd1_relu(self.hd5_UT_hd1_bn(self.hd5_UT_hd1_conv(self.hd5_UT_hd1(hd5))))
        hd1 = self.relu1d_1(self.bn1d_1(self.conv1d_1(
            torch.cat((h1_Cat_hd1, hd2_UT_hd1, hd3_UT_hd1, hd4_UT_hd1, hd5_UT_hd1), 1)))) # hd1->320*320*UpChannels

        d1 = self.outconv1(hd1)  # d1->320*320*n_classes
        return d1

完整代码

闲鱼APP - 搜索 - 玖零猴 医学图像分割

五、训练

        python train.py --arch=“unet3d” --dataset=“Jiu0Monkey”

六、测试

        python test.py --name="jiu0Monkey_unet3d_woDS"

七、与其它模型对比

v2-d51610ad8f31fa3333be3bcdf9ccfb78_b.jpg

玖零猴
关注
  • 9
    点赞
  • 踩
  • 113
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
MRI脑肿瘤分割matlab代码
11-01
MRI脑肿瘤分割matlab代码，内面的gui要重新编译才能运行
unet脑肿瘤分割完整代码
qq_45845375的博客
01-14 728
Unet脑肿瘤分割完整代码
语义分割Unet+pytorch源码+小批量数据集+网络简图
04-18
语义分割Unet+pytorch源码+小批量数据集+网络简图 适合深度学习语义分割方向高效学习测试Unet网络
UNet3plus_pth:UNet3 + UNet ++ UNet，用于Pytorth的深度自动人像抠像中
05-04
UNet3plus_pth UNet3 + / UNet ++ / UNet，用于Pytorth的深度自动人像抠像中 依存关系 Python 3.6 PyTorch> = 1.1.0 火炬视觉> = 0.3.0 未来0.18.2 matplotlib 3.1.3 的numpy 1.16.0 枕头6.2.0 protobuf 3.11.3 张量板1.14.0 tqdm == 4.42.1 数据 该模型从零开始使用18000张图像进行了训练（数据通过2000images进行了扩充）。训练数据集来自“ 。 您可以在百度云中下载 。 密码：ndg8仅用于学术交流，如果有报价，请告知原始作者！ 我们通过旋转和缩放来增加图像的数量。 使用四个旋转角{-45°，−22°，22°，45°}和四个刻度{0.6、0.8、1.2、1.5}。 我们还应用了四个不同的Gamma变换来增加颜色变
UNet(UNet网络的三个实现：大同小异 全是pytorch实现)
09-07
UNet(UNet网络的三个实现：大同小异 全是pytorch实现)，其中UNet文件中包含了原始的分割数据集
Brats2019:用于脑肿瘤分割的多步骤级联网络（tensorflow）
05-08
张量流的多步骤级联网络用于脑肿瘤分割 这是我们在Python3，tensorflow和Keras上的BraTS2019论文实现。 整个肿瘤....................................肿瘤核心......................增强肿瘤 拟议方法的示意图 要求 Python3.5，Tensorflow 1.12和其他常见软件包，可以在看到 入门 是配置文件。 是程序的主要功能。 建立模型，并负责培训和测试阶段。 提供了许多在程序中使用的有用功能。 提供了多层和模型构造的一些组合。 提供了一些API来计算指标，例如DIce，Sensitivity等。 训练 该网络接受了2019年脑肿瘤分割挑战赛（Brats2019）训练数据集的培训，该数据集可从Brats2019网页上下载。 （1）编辑parameters.ini ，使其与您的本地环境一致，
2D-FCN8s,FCN16s,FCN32s脑胶质瘤分割BraTs + Pytorch实现
程序客栈
04-01 3965
FCN讲解 玖零猴：FCN+与CNN的区别+三大技术+网络结构 BraTs数据准备 玖零猴：(2D网络)医学三维数据且又多模态多标签该如何预处理 运行环境的安装 windows10 64 bits、nvidia驱动、CUDA8.0、cudnn、anaconda 打开命令窗口, 分别输入以下指令: co...
unet脑肿瘤分割_2D UNet3+ Pytorch实现 脑肿瘤分割
weixin_39724441的博客
12-24 743
一、网络介绍论文下载地址及论文翻译与解读:玖零猴：UNet3+(UNet+++)论文翻译与详细解读​zhuanlan.zhihu.com原代码链接:链接二、BraTs数据预处理本文用的训练集和验证集均来自BraTs2018的训练集(其中HGG:210个病人,LGG:75个病人)但由于BraTs只公开训练集数据,没有测试集数据,如果在训练集中再拆一部分用来作测试集的话,那训练集便少了许多,训练数据如...
PyTorch：Unet网络实现脑肿瘤图像分割
Bob_lb的博客
10-24 1万+
1介绍 U-Net是一篇基本结构非常好的论文，主要是针对生物医学图片的分割，而且，在今后的许多对医学图像的分割网络中，很大一部分会采取U-Net作为网络的主干。相对于当年的，在EM segmentation challenge at ISBI 2012上做到比当时的best更好。而且速度也非常的快。其有一个很好的优点，就是在小数据集上也是能做得比较好的。就比如EM 2012这个数据集就只是30...
matlab图像分割肿瘤代码-Brain_Tumor_Segmentation_US_Images:Brain_Tumor_Segmentat
05-22
matlab图像分割肿瘤代码美国图像中的脑肿瘤分割 该代码是在我的论文项目范围内，在我的帝国理工学院计算机（软件工程）理学硕士课程的最后一个学期开发的。 项目描述：包含在 安装 在本地克隆此存储库。 最好使用python虚拟环境来安装所有必需的软件包。 为避免出现任何问题，请通过运行来更新pip pip install --upgrade pip 通过运行安装所有必需的软件包 pip install -r requirements.txt 用法 RAS网络 要训​​练RAS网络模型，请在RAS / train.py文件夹中指定训练数据集路径并运行 python3 train.py 要测试RAS模型，请在RAS / test.py文件夹中指定测试数据集路径并运行 python3 test.py CPD网络 要训​​练CPD模型，请在CPD / train.py文件夹中指定训练数据集路径（image_root，gt_root）并运行 python3 train.py 要测试CPD模型，请在CPD / test.py文件夹中指定dataset_path并运行 python3 test.py
分割-Unet+Pytorch实现训练自定义数据集-算法训练-优质项目实战.zip
02-19
分割_Unet+Pytorch实现训练自定义数据集_算法训练_优质项目实战
基于Pytorch的UNet语义分割模型与代码
12-26
模型在FloodNet数据集上进行了训练，mIOU在0.83左右，可训练自己的数据集 建议在训练网络的时候将输入的训练集其切分为384x384的小图片后，再来进行训练 模型采用标准的UNet，可以采用如下方式训练你自己的模型 数据集地址可以在train.py中修改为你自己的文件夹 python train.py -- --epochs 20 --batch-size 16 --learning-rate 2e-4 --scale 1 --validation 0.1 --classes 10 --amp 其中--amp为半精度训练 --scale是训练的时候对图片进行缩放，已经裁剪为384x384后就不需要再裁剪了
brain-segmentation-pytorch:PyTorch中的U-Net实现用于脑部MRI的FLAIR异常分割
05-02
U-Net进行脑部分割 PyTorch中的U-Net实现基于深度学习分割算法进行脑部MRI FLAIR异常分割，该算法用于。 该存储库是中官方MATLAB / Keras实现的全Python端口。 提供了经过训练的模型的权重，这些权重可用于对其他数据集进行推断或微调。 如果您使用此存储库中共享的代码或权重，请考虑引用： @article{buda2019association, title={Association of genomic subtypes of lower-grade gliomas with shape features automatically extracted by a deep learning algorithm}, author={Buda, Mateusz and Saha, Ashirbani and Mazurowski, Maciej A
matlab图像分割肿瘤代码-Brain-tumour-detection-and-classification:此源代码旨在根据患者的MRI
05-22
matlab图像分割肿瘤代码脑肿瘤检测与分类 此源代码旨在根据患者的MRI扫描检测脑肿瘤区域，然后根据通过matlab进行的机器学习将其分为良性和恶性类型。 %Source Code clc %% Input [I,path]=uigetfile('*.jpg;*.png','select a input image'); str=strcat(path,I); s=imread(str); %figure; %imshow(s); %title('Input image','FontSize',20); %% Filter num_iter = 10; delta_t = 1/7; kappa = 15; option = 2; disp('Preprocessing image please wait . . .'); inp = anisodiff(s,num_iter,delta_t,kappa,option); inp = uint8(inp); inp=imresize(inp,[256,256]); if size(inp,3)>1 inp=rgb2gray(inp);
u-net-brain-tumor：U-Net脑肿瘤分割
02-06
U-Net脑肿瘤分割 :rocket: ：2019年2月此仓库中的数据处理实现不是最快的方式（代码需要更新，欢迎您提供），您可以改用TensorFlow数据集API。 此仓库向您展示了如何训练U-Net进行脑肿瘤分割。 默认情况下，您需要下载数据集的训练集，该训练集具有210 HGG和75 LGG卷，并将data文件夹与所有脚本一起放置。 data -- Brats17TrainingData -- train_dev_all model.py train.py ... 关于数据 请注意，根据许可证，用户必须从BRAST应用数据集，请不要与我联系以获取数据集。 非常感谢。 图1：大脑图像
图像分割：Pytorch实现UNet++进行医学细胞分割
最新发布
04-15
本文《图像分割：Pytorch实现UNet++进行医学细胞分割》的完整项目代码
pytorch 编写unet网络用于图像分割
07-29
pytorch实现unet网络，专门用于进行图像分割训练。该代码打过kaggle上的 Carvana Image Masking Challenge from a high definition image.
[论文解读]U-Net+与FCN的区别+医学表现+网络详解+创新
热门推荐
程序客栈
05-20 1万+
前半部分作用是特征提取，后半部分是上采样,在一些文献中也把这样的结构叫做编码器-解码器结构,由于此网络整体结构类似于大写的英文字母U，故得名U-net。 ...
[概念]MICCAI+BraTS+多模态t1,t2,flair,t1c+HGG,LGG+WT,ET,TC
程序客栈
03-05 1万+
一、MICCAI MICCAI是由国际医学图像计算和计算机辅助干预协会(Medical Image Computing and Computer Assisted Intervention Society) 举办，跨医学影像计算(MIC)和计算机辅助介入 (CAI) 两个领域的综合性学术会议，是该领域的顶级会议 二、BraTS 2.1简介 脑部肿瘤分割(brain tumor s...
UNet3+ pytorch实现
06-07
以下是一个简单的UNet 3+的PyTorch实现，仅供参考： ```python import torch import torch.nn as nn import torch.nn.functional as F class DoubleConv(nn.Module): def __init__(self, in_channels, out_channels, mid_channels=None): super().__init__() if not mid_channels: mid_channels = out_channels self.double_conv = nn.Sequential( nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1), nn.BatchNorm2d(mid_channels), nn.ReLU(inplace=True), nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True) ) def forward(self, x): return self.double_conv(x) class Down(nn.Module): def __init__(self, in_channels, out_channels): super().__init__() self.maxpool_conv = nn.Sequential( nn.MaxPool2d(2), DoubleConv(in_channels, out_channels) ) def forward(self, x): return self.maxpool_conv(x) class Up(nn.Module): def __init__(self, in_channels, out_channels, bilinear=True): super().__init__() if bilinear: self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True) else: self.up = nn.ConvTranspose2d(in_channels // 2, in_channels // 2, kernel_size=2, stride=2) self.conv = DoubleConv(in_channels, out_channels) def forward(self, x1, x2): x1 = self.up(x1) # input is CHW diffY = x2.size()[2] - x1.size()[2] diffX = x2.size()[3] - x1.size()[3] x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2, diffY // 2, diffY - diffY // 2]) x = torch.cat([x2, x1], dim=1) return self.conv(x) class AttentionBlock(nn.Module): def __init__(self, F_g, F_l, F_int): super(AttentionBlock, self).__init__() self.W_g = nn.Sequential( nn.Conv2d(F_g, F_int, kernel_size=1, stride=1, padding=0, bias=True), nn.BatchNorm2d(F_int) ) self.W_x = nn.Sequential( nn.Conv2d(F_l, F_int, kernel_size=1, stride=1, padding=0, bias=True), nn.BatchNorm2d(F_int) ) self.psi = nn.Sequential( nn.Conv2d(F_int, 1, kernel_size=1, stride=1, padding=0, bias=True), nn.BatchNorm2d(1), nn.Sigmoid() ) self.relu = nn.ReLU(inplace=True) def forward(self, g, x): g1 = self.W_g(g) x1 = self.W_x(x) psi = self.relu(g1 + x1) psi = self.psi(psi) return x * psi class UNet3Plus(nn.Module): def __init__(self, in_channels=3, out_channels=1, bilinear=True): super().__init__() self.in_channels = in_channels self.out_channels = out_channels self.bilinear = bilinear self.down1 = Down(in_channels, 32) self.att1 = AttentionBlock(F_g=32, F_l=32, F_int=16) self.down2 = Down(32, 64) self.att2 = AttentionBlock(F_g=64, F_l=64, F_int=32) self.down3 = Down(64, 128) self.att3 = AttentionBlock(F_g=128, F_l=128, F_int=64) self.down4 = Down(128, 256) self.att4 = AttentionBlock(F_g=256, F_l=256, F_int=128) self.center = DoubleConv(256, 512) self.att5 = AttentionBlock(F_g=512, F_l=512, F_int=256) self.up4 = Up(512, 256, self.bilinear) self.att6 = AttentionBlock(F_g=256, F_l=256, F_int=128) self.up3 = Up(256, 128, self.bilinear) self.att7 = AttentionBlock(F_g=128, F_l=128, F_int=64) self.up2 = Up(128, 64, self.bilinear) self.att8 = AttentionBlock(F_g=64, F_l=64, F_int=32) self.up1 = Up(64, 32, self.bilinear) self.outc = nn.Conv2d(32, out_channels, kernel_size=1) def forward(self, x): x1 = self.down1(x) x2 = self.down2(x1) x3 = self.down3(x2) x4 = self.down4(x3) center = self.center(x4) center = self.att5(g=center, x=center) x4 = self.att4(g=center, x=x4) x3 = self.att3(g=x4, x=x3) x2 = self.att2(g=x3, x=x2) x1 = self.att1(g=x2, x=x1) x = self.up4(center, x4) x = self.att6(g=x, x=center) x = self.up3(x, x3) x = self.att7(g=x, x=x3) x = self.up2(x, x2) x = self.att8(g=x, x=x2) x = self.up1(x, x1) logits = self.outc(x) return logits ``` 在这个实现中，我们首先定义了一个双卷积块(DoubleConv)、下采样块(Down)和上采样块(Up)。然后定义了一个注意力块(AttentionBlock)来实现UNet 3+中的跨通道注意力机制。最后，我们将所有块组合在一起以定义UNet 3+网络。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

玖零猴

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值