Tensorflow2.6实现Unet结构神经网络（3D卷积）识别脑部肿瘤并实现模型并行

最新推荐文章于 2024-05-11 16:35:42 发布
最新推荐文章于 2024-05-11 16:35:42 发布
阅读量2.5k 收藏 46
点赞数 5
分类专栏： 人工神经网络 文章标签： 神经网络 深度学习 cnn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43385826/article/details/125271388
版权

Tensorflow2.6实现Unet结构神经网络（3D卷积）识别脑部肿瘤并实现模型并行

说明

以下神经网络结构和实验代码是从本人本科毕业设计中摘出来的，在基础上将模型的两部分放到两张GPU上进行模型并行训练，但是模型并行的版本并没有达到预期的效果，如果有大佬看到这篇文章，希望能指出错误，谢谢。

Unet神经网络

Unet 结构神经网络是通过卷积进行采样的，属于卷积神经网络的一种。在2015年在文章 U-Net: Convolutional Networks for Biomedical Image Segmentation 中被提出。

网络结构

采用3D卷积的方式实现 Unet 网络结构，原因是单个影像是 4 维的核磁共振影像，tensorflow2 实现的模型输入是 一定数量的影像，所以模型输入是一个 5 维的张量，张量形状是 （影像数量，影像维度1，影像维度2，影像维度3，影像维度4）。

网络结构如下。
Unet结构

图1 构建的3D卷积版本的 Unet 结构神经网络
层数神经网络层卷积核形状输出张量形状
Encoder1batchnormalization(batch size , 240, 240, 155, 4)
2conv3d(3,3,3)(batch size, 240, 240, 155, 8)
3batchnormalization(batch size, 240, 240, 155, 8)
4conv3d(3,3,3)(batch size, 240, 240, 155, 16)
5batchnormalization(batch size, 240, 240, 155, 16)
6conv3d(3,3,2)(batch size, 238, 238, 155, 16)
7batchnormalization(batch size, 238, 238, 155, 16)
8conv3d(3,3,1)(batch size, 118, 118, 77, 32)
9batchnormalization(batch size, 118, 118, 77, 32)
10conv3d(3,3,1)(batch size, 58, 58, 39, 64)
11batchnormalization(batch size, 58, 58, 39, 64)
12maxpooling3d(2,2,1)(batch size, 29, 29, 39, 64)
Decoder13batchnormalization(batch size,29,29,39,64)
14upsampling3d(2,2,1)(batch size,58,58,39,64)
15conv3dTranspose(3,3,1)(batch size,58,58,39,32)
16concat(batch size,58,58,39,128)
17batchnormalization(batch size,58,58,39,32)
18upsampling3d(2,2,2)(batch size,116,116,78,64)
19conv3dTranspose(3,3,1)(batch size,118,118,78,32)
20conv3d(3,3,3)(batch size,116,116,76,32)
21batchnormalization(batch size,116,116,76,32)
22conv3dTranspose(3,3,2)(batch size,118,118,77,16)
23concat(batch size,118,118,77,32)
24batchnormalization(batch size,118,118,77,16)
25upsampling3d(2,2,2)(batch size,236,236,154,16)
26conv3dTranspose(3,3,1)(batch size,238,238,154,16)
27concat(batch size,238,238,154,32)
28batchnormalization(batch size,238,238,154,16)
29conv3dTranspose(3,3,1)(batch size,240,240,154,8)
30conv3dTranspose(1,1,5)(batch size,240,240,158,4)
31conv3d(1,1,4)(batch size,240,240,155,1)
表1 构建的3D卷积版本的 Unet 结构神经网络每层信息

代码实现

  1. 框架加载
    from tensorflow.keras.layers import BatchNormalization,Conv3D,MaxPooling3D,Conv3DTranspose,UpSampling3D
import tensorflow as tf
  2. encoder部分实现
    class unet_encoder(tf.keras.Model):
    def __init__(self):
        super(unet_encoder,self).__init__()
        self.b1 = BatchNormalization()
        self.conv1 = Conv3D(8,3,activation='relu',padding='same')

        self.b2 = BatchNormalization()
        self.conv2 = Conv3D(16,3,activation='relu',padding='same')

        self.b3 = BatchNormalization()
        self.conv3 = Conv3D(16,(3,3,2),activation='relu')

        self.b4 = BatchNormalization()
        self.conv4 = Conv3D(32,(3,3,1),activation='relu',strides=2)

        self.b5 = BatchNormalization()
        self.conv5 = Conv3D(64,(3,3,1),activation='relu',strides=2)

        self.b6 = BatchNormalization()
        self.maxpool1 = MaxPooling3D((2,2,1))
    
    def call(self,x,features):
        x = self.b1(x)
        x = self.conv1(x)

        x = self.b2(x)
        x = self.conv2(x)

        x = self.b3(x)
        # 第一个连接特征图
        x = self.conv3(x)
        x = self.b4(x)
        features.append(x)
        # 第二个连接特征图
        x = self.conv4(x)
        x = self.b5(x)
        features.append(x)
        # 第三个连接特征图
        x = self.conv5(x)
        x = self.b6(x)
        features.append(x)
        # 输出变量
        outputs = self.maxpool1(x)

        return outputs
  3. decoder部分实现
    class unet_decoder(tf.keras.Model):
    def __init__(self):
        super(unet_decoder,self).__init__()
        self.b1 = BatchNormalization()
        self.up1 = UpSampling3D((2,2,1))
        self.conv1tp = Conv3DTranspose(64,(3,3,1),activation='relu',padding='same')

        self.b2 = BatchNormalization()
        self.up2 = UpSampling3D((2,2,2))
        self.conv2tp = Conv3DTranspose(32,(3,3,1),activation='relu')
        self.conv2 = Conv3D(32,3,activation='relu')

        self.b3 = BatchNormalization()
        self.conv3tp = Conv3DTranspose(16,(3,3,2),activation='relu')

        self.b4 = BatchNormalization()
        self.up4 = UpSampling3D((2,2,2))
        self.conv4tp = Conv3DTranspose(16,(3,3,1),activation='relu')

        self.b5 = BatchNormalization()
        self.conv5tp = Conv3DTranspose(8,(3,3,1),activation='relu')

        self.conv6tp = Conv3DTranspose(4,(1,1,5),activation='relu')
        self.conv_out = Conv3D(1,(1,1,4),activation='relu')

    def call(self,x,features):
        
        x = self.b1(x)
        x = self.up1(x)
        x = self.conv1tp(x)
        x = tf.concat((features[-1],x),axis=-1)

        x = self.b2(x)
        x = self.up2(x)
        x = self.conv2tp(x)
        x = self.conv2(x)

        x = self.b3(x)
        x = self.conv3tp(x)
        x = tf.concat((features[-2],x),axis=-1)

        x = self.b4(x)
        x = self.up4(x)
        x = self.conv4tp(x)
        x = tf.concat((features[-3],x),axis=-1)
        
        x = self.b5(x)
        x = self.conv5tp(x)
        x = self.conv6tp(x)

        x = self.conv_out(x)
        outputs = x
        
        return outputs
  4. 结合两个部分的整体类
    class Unet3D(tf.keras.Model):
    def __init__(self,encoder,decoder):
        super(Unet3D,self).__init__()
        self.features = []
        self.encoder = encoder
        self.decoder = decoder
    
    def call(self,x):
        x = self.encoder(x,self.features)
        outputs = self.decoder(x,self.features)
        return outputs

模型训练

训练环境

软件版本
Python3.8.11
Tensorflow2.6.0-gpu
CUDA11.2
cuDNN8.1.0
nibabel3.2.2
表2 主要的软件列表
处理器型号显存
GPUNVIDIA Geforce GTX 309024G
表3 显卡信息

数据加载处理

  1. 数据来源
    MSD脑瘤数据集（百度飞桨 AI Studio）

  2. 影像放缩
    使用nearest算法对影像的某些维度进行放缩（防止输入的影像张量形状与模型设计的输入张量形状不一致）。

    import nibabel as nib
import numpy as np	
def nearest_4d(img,size):
    res = np.zeros(size)
    for i in range(res.shape[0]):
        for j in range(res.shape[1]):
            for k in range(res.shape[2]):
                idx = i*img.shape[0] // res.shape[0]
                idy = j*img.shape[1] // res.shape[1]
                idz = k*img.shape[2] // res.shape[2]
                res[i,j,k,:] = img[idx,idy,idz,:]
    return res

  3. 数据生成器
    采用生成器和迭代器的方式，从硬盘中读取一定数量影像数据至内存。

    # 按照数据文件路径以迭代器的方式读取数据
class DataIterator:
    def __init__(self,image_paths,label_paths,size=None,transp_shape=[0,1,2,3],mode='nib'):
        self.image_paths = image_paths
        self.label_paths = label_paths
        self.size = size
        self.transp = transp_shape
        self.mode=mode

    def read_and_resize(self,img_path,lbl_path):
        if self.mode=='nib':
            img = nib.load(img_path)
            lbl = nib.load(lbl_path)

            img = img.get_fdata(caching='fill', dtype='float32')
            lbl = lbl.get_fdata(caching='fill', dtype='float32')
            
        elif self.mode == 'np':
            img = np.load(img_path)
            lbl = np.load(lbl_path)
        else:
            return None,None
        
        img /= np.max(img)
        lbl /= np.max(lbl)

        img = img.transpose(self.transp)
        if len(lbl.shape)<len(img.shape):
            lbl = np.expand_dims(lbl,axis=-1)
        lbl = lbl.transpose(self.transp)

        if self.size != None:
            if len(self.size) == 3:
                img = nearest_3d(img,self.size)
                lbl = nearest_3d(lbl,self.size)
            else:
                img = nearest_4d(img,self.size)
                lbl = nearest_4d(lbl,self.size)
        return img,lbl
    
    def __iter__(self):
        for img_path,lbl_path in zip(self.image_paths,self.label_paths):
            img,lbl = self.read_and_resize(img_path,lbl_path)
            if isinstance(img,np.ndarray) and isinstance(lbl,np.ndarray):
                yield (img,lbl)
            else:
                return
# 数据生成器，因为训练用的标签数据少了一个维度，所以在返回数据对象之前给数据对象扩充维度
class DataGenerator:
    def __init__(self,image_paths,label_paths,size=None,batch_size=32,transp_shape=[0,1,2,3],mode='nib'):
        dataiter = DataIterator(image_paths,label_paths,size,transp_shape,mode)
        self.batch_size = batch_size
        self.dataiter = iter(dataiter)
    
    def __iter__(self):
        while 1:
            i = 0
            imgs = []
            lbls = []
            for img,lbl in self.dataiter:
                imgs.append(img)
                lbls.append(lbl)
                i += 1
                if i >= self.batch_size:
                    break
            
            if i == 0:
                break
            imgs = np.stack(imgs)
            lbls = np.stack(lbls)
            if len(imgs.shape) < 5:
                imgs = np.expand_dims(imgs,axis=-1)
                lbls = np.expand_dims(lbls,axis=-1)
            
            yield (imgs,lbls)

训练

  1. 依赖加载
    import tensorflow as tf
from tensorflow.keras import losses,optimizers
from model import unet_encoder,unet_decoder,Unet3D

from DataGenerator import DataGenerator
from datetime import datetime
from time import time
import os
  2. 数据加载准备
    # 数据路径
image_dir_path = './data/train/'
label_dir_path = './data/labels/'

images_paths = os.listdir(image_dir_path)
labels_paths = os.listdir(label_dir_path)
image_paths = [image_dir_path+p for p in images_paths]
label_paths = [label_dir_path+p for p in labels_paths]
  3. 日志文件记录
    # 日志记录文件
log1 = open('./log/epoch_file_form','w',encoding='utf-8')
log2 = open('./log/step_file_form','w',encoding='utf-8')
date_mark = str(datetime.now())
log1.write(date_mark+'\n')
log2.write(date_mark+'\n')
  4. 模型定义
    # 模型定义
encoder_model = unet_encoder()
decoder_model = unet_decoder()
unet = Unet3D(encoder_model,decoder_model)
unet.build(input_shape=(None,240,240,155,4))
unet.summary()
  5. 优化器和损失函数
    优化器采用Adam算法，学习率1e-5，损失函数采用交叉熵函数（二分类）。
    # 设置优化器，损失函数
optimizer = optimizers.Adam(learning_rate=1e-5)
losser = losses.BinaryCrossentropy()
  6. 训练过程实现
    # 训练
epochs = 30
s1 = time()
for i in range(epochs):
    s2 = time()
    loss_sum = 0
    step = 0
    datagener = iter(DataGenerator(image_paths,label_paths,None,1,[0,1,2,3]))
    for batch in datagener:
        s3 = time()
        step += 1
        x = batch[0]
        y = batch[1]
        with tf.GradientTape() as tape:
            out = unet(x)
            loss = losser(y_pred=out,y_true=y)
        grads = tape.gradient(loss,unet.trainable_variables)
        optimizer.apply_gradients(zip(grads,unet.trainable_variables))
        e3 = time()
        loss_sum += loss
        
        info_step = f'step:{step:03}\tloss:{loss}\t running time: {e3-s3:.3f} s'
        log2.write(info_step+'\n')
        
        print('                                                                             ',end='\r')
        print(info_step,end='\r')
    e2 = time()
    avg_loss = loss_sum/step if step != 0 else 'non samples'

    info_epoch = f'epoch {i+1:02}\t average loss {avg_loss}\t running time {e2-s2:.3f} s'
    log1.write(info_epoch+'\n')

    print('                                                                                ',end='\r')
    print(info_epoch)
e1 = time()
all_time = f'Training time {e1-s1:.3f} s'
log1.write(all_time+' s\n')
log2.write(all_time+' s\n')
print(all_time)

log1.close()
log2.close()

# 保存模型
encoder_model.save_weights('./models/encoder_params_formal')
decoder_model.save_weights('./models/decoder_params_formal')
unet.save_weights('./models/unet_params_formal')

训练结果

  1. 30个epoch训练过程中，每个 epoch 训练平均损失值和训练时间可视化
    训练信息可视化
图2 训练信息可视化
  1. 不同训练 epoch 训练出的模型输出 对比
    不同训练批次的模型输出
图3 不同训练批次模型输出对比

模型并行版本

模型拆分

使用两块GPU，将 encoder 部分放置到GPU0上，decoder部分放置到GPU1上。

代码实现

  1. 模型实现
    from tensorflow.keras.layers import BatchNormalization,Conv3D,MaxPooling3D,Conv3DTranspose,UpSampling3D
import tensorflow as tf

def copy_tensor_to_gpu(tensor,gpu_id):
    with tf.device(f'/gpu: {gpu_id}'):
        res = tf.zeros_like(tensor)
    res = res + tensor
    return res
def copy_tensor_to_cpu(tensor,cpu_id):
    with tf.device(f'/cpu: {cpu_id}'):
        res = tf.zeros_like(tensor,cpu_id)
    res = res + tensor
    return res

class unet_encoder(tf.keras.Model):
    def __init__(self):
        super(unet_encoder,self).__init__()
        self.b1 = BatchNormalization()
        self.conv1 = Conv3D(8,3,activation='relu',padding='same')

        self.b2 = BatchNormalization()
        self.conv2 = Conv3D(16,3,activation='relu',padding='same')

        self.b3 = BatchNormalization()
        self.conv3 = Conv3D(16,(3,3,2),activation='relu')

        self.b4 = BatchNormalization()
        self.conv4 = Conv3D(32,(3,3,1),activation='relu',strides=2)

        self.b5 = BatchNormalization()
        self.conv5 = Conv3D(64,(3,3,1),activation='relu',strides=2)

        self.b6 = BatchNormalization()
        self.maxpool1 = MaxPooling3D((2,2,1))
    
    def call(self,x,features,gpu_id):
        x = self.b1(x)
        x = self.conv1(x)

        x = self.b2(x)
        x = self.conv2(x)

        x = self.b3(x)
        # 第一个连接特征图
        x = self.conv3(x)
        x = self.b4(x)
        features[0] = copy_tensor_to_gpu(x,gpu_id)
        # 第二个连接特征图
        x = self.conv4(x)
        x = self.b5(x)
        features[1] = copy_tensor_to_gpu(x,gpu_id)
        # 第三个连接特征图
        x = self.conv5(x)
        x = self.b6(x)
        features[2] = copy_tensor_to_gpu(x,gpu_id)
        # 输出变量
        outputs = self.maxpool1(x)

        return outputs

class unet_decoder(tf.keras.Model):
    def __init__(self):
        super(unet_decoder,self).__init__()
        self.b1 = BatchNormalization()
        self.up1 = UpSampling3D((2,2,1))
        self.conv1tp = Conv3DTranspose(64,(3,3,1),activation='relu',padding='same')

        self.b2 = BatchNormalization()
        self.up2 = UpSampling3D((2,2,2))
        self.conv2tp = Conv3DTranspose(32,(3,3,1),activation='relu')
        self.conv2 = Conv3D(32,3,activation='relu')

        self.b3 = BatchNormalization()
        self.conv3tp = Conv3DTranspose(16,(3,3,2),activation='relu')

        self.b4 = BatchNormalization()
        self.up4 = UpSampling3D((2,2,2))
        self.conv4tp = Conv3DTranspose(16,(3,3,1),activation='relu')

        self.b5 = BatchNormalization()
        self.conv5tp = Conv3DTranspose(8,(3,3,1),activation='relu')

        self.conv6tp = Conv3DTranspose(4,(1,1,5),activation='relu')
        self.conv_out = Conv3D(1,(1,1,4),activation='relu')

    def call(self,x,features):
        
        x = self.b1(x)
        x = self.up1(x)
        x = self.conv1tp(x)
        x = tf.concat((features[-1],x),axis=-1)

        x = self.b2(x)
        x = self.up2(x)
        x = self.conv2tp(x)
        x = self.conv2(x)

        x = self.b3(x)
        x = self.conv3tp(x)
        x = tf.concat((features[-2],x),axis=-1)

        x = self.b4(x)
        x = self.up4(x)
        x = self.conv4tp(x)
        x = tf.concat((features[-3],x),axis=-1)
        
        x = self.b5(x)
        x = self.conv5tp(x)
        x = self.conv6tp(x)

        x = self.conv_out(x)
        outputs = x
        
        return outputs

class Unet3DParallel(tf.keras.Model):
    def __init__(self,gpu_group):
        super(Unet3DParallel,self).__init__()
        self.gpus = gpu_group
        with tf.device(f'/gpu:{gpu_group[1]}'):
            self.features = [None for i in range(3)]
        with tf.device(f'/gpu:{gpu_group[0]}'):
            self.encoder = unet_encoder()
        with tf.device(f'/gpu:{gpu_group[1]}'):
            self.decoder = unet_decoder()
    
    def call(self,x):
        x = self.encoder(x,self.features,self.gpus[1])
        outputs = self.decoder(x,self.features)
        return outputs
  2. 训练过程同上，但是开启GPU显存使用增长
    import tensorflow as tf
gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu,True)

出现的问题

  1. 模型两部分可训练参数不同，encoder 少于 decoder，但是GPU0使用显存、使用率和功耗均多于GPU1。
    # 模型可训练参数统计
Model: "unet3d_parallel"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
unet_encoder (unet_encoder)  multiple                  32664     
_________________________________________________________________
unet_decoder (unet_decoder)  multiple                  121373    
=================================================================
Total params: 154,037
Trainable params: 153,149
Non-trainable params: 888
_________________________________________________________________
# 显卡使用情况监控
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 470.94       Driver Version: 470.94       CUDA Version: 11.4     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  NVIDIA GeForce ...  On   | 00000000:3E:00.0 Off |                  N/A |
| 59%   61C    P2   211W / 350W |  23746MiB / 24268MiB |     67%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
|   1  NVIDIA GeForce ...  On   | 00000000:88:00.0 Off |                  N/A |
| 46%   56C    P2   120W / 350W |   4504MiB / 24268MiB |     22%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
  2. 按理来说，模型差分后，两个GPU应该形成流水线，从训练第二步开始，单步训练时间应该少于单GPU训练单步时间。但是实验结果相反，单GPU每步训练时间大约在 0.7s 左右，模型拆分后单步训练时间却在 1.2s 左右（由于换了机器，训练时间跟上面训练信息可视化的图表时间不同）。
欲买桂载酒
关注
  • 5
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
探索PyTorch-3DUnet: 三维卷积神经网络的新里程
gitblog_00059的博客
03-24 907
探索PyTorch-3DUnet: 三维卷积神经网络的新里程 项目地址:https://gitcode.com/wolny/pytorch-3dunet 该项目[链接]由开发者Wolny创建，提供了一个强大的PyTorch实现，用于构建和训练3D U-Net模型。3D U-Net是一种在医学图像分割领域广泛应用的深度学习架构。这篇文章将深入探讨其技术原理、应用场景及独特优势，以鼓励更多的开发者和研...
3D-Unet:用于大脑分割的3D Unet的Chainer实现
04-27
3D网络 用于大脑分割的3D Unet的Chainer实现。 培训配置位于configs / base.yml。 由于GPU内存的限制，我们使用了基于补丁的方法。 要求 SimpleITK 连连看v4 yaml 网络架构 3D Unet架构 用法 训练训练3D unet。 python train.py -h optional arguments: -h, --help show this help message and exit --gpu GPU, -g GPU GPU ID (negative value indicates CPU) --base BASE, -B BASE base directory path of program files --config_path CONFIG_PATH
热门深度学习方法（卷积神经网络、迁移学习、自编码器、U-Net等）的基本原理及Python、Pytorch代码实现方法
最新发布
cyd20161117的博客
05-11 993
人工智能领域经典机器学习算法（BP神经网络、支持向量机、决策树、随机森林、变量降维与特征选择、群优化算法等）和热门深度学习方法（卷积神经网络、迁移学习、自编码器、U-Net等）的基本原理及Python、Pytorch代码实现方法
UNet（TensorFlow2）图像语义分割实战：训练自己的数据集
07-22
注意：本课程已从Keras更新至TensorFlow2U-Net是一种基于深度学习的图像语义分割方法，尤其在医学图像分割中表现优异。本课程将手把手地教大家使用labelme图像标注工具制作自己的数据集，生成Mask图像，并使用U-Net训练自己的数据集，从而能开展自己的图像分割应用。本课程有三个项目实践：(1) Kaggle盐体识别比赛 ：利用U-Net进行Kaggle盐体识别(2) Pothole语义分割：对汽车行驶场景中的路坑进行标注和语义分割(3) Kaggle细胞核分割比赛 ：利用U-Net进行Kaggle细胞核分割本课程使用TensorFlow2版本的U-Net，在Ubuntu系统上用Jupyter Notebook做项目演示。 包括：数据集标注、数据集格式转换和Mask图像生成、编写U-Net程序文件、训练自己的数据集、测试训练出的网络模型、性能评估。项目代码也可在Windows上运行，课程提供Windows环境搭建方法。 本课程提供项目的数据集和Python程序代码。相关课程：UNet（PyTorch）图像语义分割实战：训练自己的数据集 https://edu.csdn.net/course/detail/36198
【3D图像分割】基于 Pytorch 的 3D 图像分割3（3D UNet 模型篇）
钱多多先森
11-03 5162
3D UNet 模型的搭建，提供了思路，帮助你快速而全面的了解该模型，并通过预测试方式，了解模型情况
UNet-3D个人理解及代码实现（PyTorch）
张壮壮的博客
04-07 2万+
以下内容均为个人理解，如有错误，欢迎指正。 UNet-3D 论文链接：地址 网络结构 UNet-3D和UNet-2D的基本结构是差不多的，分成小模块来看，也是有连续两次卷积，下采样，上采样，特征融合以及最后一次卷积。 UNet-2D可参考：VGG16+UNet个人理解及代码实现（Pytorch） 不同的是，UNet-3D的卷积是三维的卷积。 关于2D卷积和3D卷积的区别可参见这篇文章：链接 需要注意的是，UNet-3D的连续两次卷积操作中，第一次卷积和第二次卷积的输出通道数是不同的（UNet-2D的连续两
医学图像处理算法学习——3DUnetCNN（1）
weixin_50961326的博客
10-08 2713
3DUnetCNN代码注释详解笔记
tensorflow2.7实现UNet
11-21
基于tensorflow2.7实现UNet并对图像进行语义分割
基于卷积神经网络UNet构建糖尿病性黄斑水肿自动识别模型.pdf
09-25
"基于卷积神经网络UNet构建糖尿病性黄斑水肿自动识别模型.pdf" 这篇论文的主要内容是介绍基于卷积神经网络UNet构建糖尿病性黄斑水肿自动识别模型。糖尿病性黄斑水肿（Diabetic Macular Edema，DME）是糖尿病引起...
基于Tensorflow实现UNet.zip
03-27
UNet最初由Ronneberger等人在2015年提出，其设计灵感来自于卷积神经网络（CNN）的对称结构，特别适合处理像素级别的预测问题，如医学图像分析、遥感图像分割和自动驾驶场景的理解。 ### UNet概述 UNet的核心特点...
卷积神经网络+网络结构+绘制网络结构图
11-15
资源适用于对展示卷积神经网络具体结构有需求的研究人员，用户在下载本项目后按照README官方教程中的Getting Started部分进行使用，简单学习过语法后便可以通过test_simple.py代码绘制自己的卷积神经网络结构并在同...
3D分割-基于Pytorch+3DUnet实现的3D体积语义分割算法-优质项目实战.zip
03-27
3D分割_基于Pytorch+3DUnet实现的3D体积语义分割算法_优质项目实战
Python Unet网络结构pytorch简单实现+torchsummary可视化（可以直接运行）
12-21
标题中的“Python Unet网络结构pytorch简单实现+torchsummary可视化（可以直接运行）”表明了本文将介绍如何在Python环境中，使用PyTorch框架来实现Unet网络，并结合torchsummary库进行模型可视化，且提供的代码可以...
UNet 、3D-UNet 、VNet 区别
热门推荐
qq_36484003的博客
09-29 2万+
UNet 、3D-UNet 、VNet 区别 医学图像的几个常用模型，简单总结一下。 三个model的代码在我的Github上，可以参考一下：(https://github.com/VickyLLY/unet_liver_pytorch 文章目录UNet 、3D-UNet 、VNet 区别一、UNet二、3D-UNet三、VNet 一、UNet 创新点： U型结构，下采样，上采样；短接通道（skip-connection） 二、3D-UNet 2D结构的U-Net是基本一样，唯一不同：2D操作换成了3D
如何搭建Unet-3D网络
星空下
10-12 6471
UNET模型是由卷积神经网络演变过来，一般的卷积神经网络将其任务集中在图像分类上，其中输入多是图像输出是标签，而在医学和其他学科中，需要输出是图像，输出也是图像。 UNET模型主要解决的就是这类问题，它能够定位和区分边界，并且输出的大小和输出的大小相同。 文章目录模型概况 模型概况 # 下采样部分 def build_model(input_layer, start_neurons): conv1 = Conv3D(start_neurons * 1, (3, 3), activation='relu',
[深度学习论文笔记]3D U-Net: Learning Dense Volumetric Segmentation from Sparse Annotation 从稀疏标注学习密集体分割
Slientsake的博客
05-03 3618
3D U-Net: Learning Dense Volumetric Segmentation from Sparse Annotation 3D-U-Net：从稀疏标注学习密集体分割 Published: MICCAI 2016 论文：https://arxiv.org/abs/1606.06650 代码：https://github.com/lee-zq/3DUNet-Pytorch/ 问题动机： 在生物医学数据分析中，3D数据是非常丰富的。用分割标签注释这些数据会很困难，因为只有二维切片可以在计算机
DL00198-基于3DUnet的脑肿瘤语义分割完整代码+数据集含输出结果
crasher123的博客
04-06 630
3DUNet是一种卷积神经网络（CNN），专为处理3D图像而设计。它基于U-Net架构，是一种对称的卷积网络，具有上采样和下采样的过程。PyTorch 3DUNet在U-Net的基础上添加了更多的卷积层和跳跃连接，以便更好地捕捉图像的上下文信息。它可以在训练时动态地建立记忆网络，从而有效地处理3D图像数据。
3DConvCaps：3DUNet与卷积胶囊编码器用于医学图像分割
weixin_43921949的博客
11-27 2397
利用胶囊网络的建模高级特征
3D U-Net脑胶质瘤分割BraTs + Pytorch实现
程序客栈
05-09 1万+
原论文地址: 连接 一、网络模型的分析和对比 原始2D-Unet网络模型 我的2D-Unet网络模型 1、和原来的2D-Unet网络不同的是,我输入通道为4,我这里应该改为4个通道,对应四个模态图像,而输出通道为3,我对应的是三个嵌套子区...
tensorflow卷积神经网络肿瘤识别
09-18
如果你想在Tensorflow中实现Unet结构的卷积神经网络进行脑部肿瘤识别，可以参考Tensorflow 2.6版本的实现代码。这个神经网络模型可以通过训练来提高准确率，并可以使用模型并行来加速计算。 以下是一些
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值