神经网络参数量计算-UNet3D为例

已于 2022-04-16 16:18:23 修改
阅读量2.2k 收藏 5
点赞数 1
文章标签： 深度学习
于 2022-04-15 11:27:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whunamikey/article/details/124187823
版权

目录

模型：

计算模型参数的代码：

 手算参数量结果：

 python代码计算结果：

模型：

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
import os


class UNet3D(nn.Module):
	"""
	Baseline model for pulmonary airway segmentation
	"""
	def __init__(self, in_channels=1, out_channels=1, coord=True):
		"""
		:param in_channels: input channel numbers
		:param out_channels: output channel numbers
		:param coord: boolean, True=Use coordinates as position information, False=not
		"""
		super(UNet3D, self).__init__()
		self._in_channels = in_channels
		self._out_channels = out_channels
		self._coord = coord
		self.pooling = nn.MaxPool3d(kernel_size=(2, 2, 2))
		self.upsampling = nn.Upsample(scale_factor=2)
		self.conv1 = nn.Sequential(
			nn.Conv3d(in_channels=self._in_channels, out_channels=8, kernel_size=3, stride=1, padding=1),
			nn.InstanceNorm3d(8),
			nn.ReLU(inplace=True),
			nn.Conv3d(8, 16, 3, 1, 1),
			nn.InstanceNorm3d(16),
			nn.ReLU(inplace=True))
		
		self.conv2 = nn.Sequential(
			nn.Conv3d(16, 16, kernel_size=3, stride=1, padding=1),
			nn.InstanceNorm3d(16),
			nn.ReLU(inplace=True),
			nn.Conv3d(16, 32, 3, 1, 1),
			nn.InstanceNorm3d(32),
			nn.ReLU(inplace=True))

		self.conv3 = nn.Sequential(
			nn.Conv3d(32, 32, kernel_size=3, stride=1, padding=1),
			nn.InstanceNorm3d(32),
			nn.ReLU(inplace=True),
			nn.Conv3d(32, 64, 3, 1, 1),
			nn.InstanceNorm3d(64),
			nn.ReLU(inplace=True))
	
		self.conv4 = nn.Sequential(
			nn.Conv3d(64, 64, kernel_size=3, stride=1, padding=1),
			nn.InstanceNorm3d(64),
			nn.ReLU(inplace=True),
			nn.Conv3d(64, 128, 3, 1, 1),
			nn.InstanceNorm3d(128),
			nn.ReLU(inplace=True))

		self.conv5 = nn.Sequential(
			nn.Conv3d(128, 128, kernel_size=3, stride=1, padding=1),
			nn.InstanceNorm3d(128),
			nn.ReLU(inplace=True),
			nn.Conv3d(128, 256, 3, 1, 1),
			nn.InstanceNorm3d(256),
			nn.ReLU(inplace=True))

		self.conv6 = nn.Sequential(
			nn.Conv3d(256 + 128, 128, kernel_size=3, stride=1, padding=1),
			nn.InstanceNorm3d(128),
			nn.ReLU(inplace=True),
			nn.Conv3d(128, 128, 3, 1, 1),
			nn.InstanceNorm3d(128),
			nn.ReLU(inplace=True))
		
		self.conv7 = nn.Sequential(
			nn.Conv3d(128 + 64, 64, 3, 1, 1),
			nn.InstanceNorm3d(64),
			nn.ReLU(inplace=True),
			nn.Conv3d(64, 64, 3, 1, 1),
			nn.InstanceNorm3d(64),
			nn.ReLU(inplace=True))
		
		self.conv8 = nn.Sequential(
			nn.Conv3d(64 + 32, 32, 3, 1, 1),
			nn.InstanceNorm3d(32),
			nn.ReLU(inplace=True),
			nn.Conv3d(32, 32, 3, 1, 1),
			nn.InstanceNorm3d(32),
			nn.ReLU(inplace=True))
		
		if not self._coord:
			num_channel_coord = 3
		else:
			num_channel_coord = 0
		self.conv9 = nn.Sequential(
			nn.Conv3d(32 + 16 + num_channel_coord, 16, 3, 1, 1),
			nn.InstanceNorm3d(16),
			nn.ReLU(inplace=True),
			nn.Conv3d(16, 16, 3, 1, 1),
			nn.InstanceNorm3d(16),
			nn.ReLU(inplace=True))
	
		self.sigmoid = nn.Sigmoid()
		self.conv10 = nn.Conv3d(16, self._out_channels, 1, 1, 0)

	def forward(self, input, coordmap=None):
		"""
		:param input: shape = (batch_size, num_channels, D, H, W) \
		:param coordmap: shape = (batch_size, 3, D, H, W)
		:return: output segmentation tensor, attention mapping
		"""
		conv1 = self.conv1(input)
		x = self.pooling(conv1)
		
		conv2 = self.conv2(x)
		x = self.pooling(conv2)
		
		conv3 = self.conv3(x)
		x = self.pooling(conv3)
		
		conv4 = self.conv4(x)
		x = self.pooling(conv4)

		conv5 = self.conv5(x)

		x = self.upsampling(conv5)
		x = torch.cat([x, conv4], dim=1)
		conv6 = self.conv6(x)
		
		x = self.upsampling(conv6)
		x = torch.cat([x, conv3], dim=1)
		conv7 = self.conv7(x)
		
		x = self.upsampling(conv7)
		x = torch.cat([x, conv2], dim=1)
		conv8 = self.conv8(x)
		
		x = self.upsampling(conv8)

		if self._coord and (coordmap is not None):
			x = torch.cat([x, conv1, coordmap], dim=1)
		else:
			x = torch.cat([x, conv1], dim=1)

		conv9 = self.conv9(x)
		
		x = self.conv10(conv9)

		x = self.sigmoid(x)	
		

		return x

if __name__ == '__main__':
	net = UNet3D(in_channels=1, out_channels=1)
	print(net)
	print('Number of network parameters:', sum(param.numel() for param in net.parameters()))
# Number of network parameters: 4118849 Baseline

计算模型参数的代码：

import torch
import torch.nn
from torchsummary import summary
from importlib import import_module

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = import_module('baseline')
config, net = model.get_model()
model = net.to(device)
summary(model, input_size=(1,64, 128, 128))

 手算参数量结果：

UNet3D(
  (pooling): MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2), padding=0, dilation=1, ceil_mode=False)
  (upsampling): Upsample(scale_factor=2.0, mode=nearest)
  (conv1): Sequential(
     ######3*3*3+8 = 224
    (0): Conv3d(1, 8, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
    ###### 0     
(1): InstanceNorm3d(8, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
     ######0
    (2): ReLU(inplace=True)
     ######3*3*3*8*16 + 16 = 3472 
    (3): Conv3d(8, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
     ######0    
(4): InstanceNorm3d(16, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
     ######0
    (5): ReLU(inplace=True)
  )
  (conv2): Sequential(
     ######3*3*3*16*16+16=6928
    (0): Conv3d(16, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
      ######0
(1): InstanceNorm3d(16, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
     #0  
(2): ReLU(inplace=True)
     ######3*3*3*16*32 + 32 = 13856  
(3): Conv3d(16, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
    ######0
(4): InstanceNorm3d(32, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
   ######0
    (5): ReLU(inplace=True)
  )
  (conv3): Sequential(
 ######3*3*3*32*32+32 = 27680
    (0): Conv3d(32, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
   ######0
    (1): InstanceNorm3d(32, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
   ######0   
 (2): ReLU(inplace=True)
   ######3*3*3*32*64+64 =55360
    (3): Conv3d(32, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0  
    (4): InstanceNorm3d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0  
    (5): ReLU(inplace=True)
  )
  (conv4): Sequential(
   ######3*3*3*64*64+64 =110656
    (0): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0  
    (1): InstanceNorm3d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0  
    (2): ReLU(inplace=True)
 ######3*3*3*64*128+128 = 221312
    (3): Conv3d(64, 128, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0
    (4): InstanceNorm3d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0
    (5): ReLU(inplace=True)
  )
  (conv5): Sequential(
######3*3*3*128*128+128 = 442496
    (0): Conv3d(128, 128, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0
    (1): InstanceNorm3d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0
    (2): ReLU(inplace=True)
######3*3*3*128*256+256 = 884992
    (3): Conv3d(128, 256, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0
    (4): InstanceNorm3d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0
    (5): ReLU(inplace=True)
  )
  (conv6): Sequential(
######3*3*3*384*128+128 = 1327232
    (0): Conv3d(384, 128, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0
    (1): InstanceNorm3d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0
    (2): ReLU(inplace=True)
######3*3*3*128*128+128 = 442496
    (3): Conv3d(128, 128, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0
    (4): InstanceNorm3d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0
    (5): ReLU(inplace=True)
  )
  (conv7): Sequential(
######3*3*3*192*64+64 = 331840
    (0): Conv3d(192, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0
    (1): InstanceNorm3d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0
    (2): ReLU(inplace=True)
#####3*3*3*64*64+64 = 110656
    (3): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0
    (4): InstanceNorm3d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0
    (5): ReLU(inplace=True)
  )
  (conv8): Sequential(
#####3*3*3*96*32+32 = 82976
    (0): Conv3d(96, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0    
(1): InstanceNorm3d(32, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0 
   (2): ReLU(inplace=True)
#####3*3*3*32*32+32 = 27680
    (3): Conv3d(32, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0 
   (4): InstanceNorm3d(32, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0  
  (5): ReLU(inplace=True)
  )
  (conv9): Sequential(
#####3*3*3*48*16+16 = 20752
    (0): Conv3d(48, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0  
  (1): InstanceNorm3d(16, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0  
  (2): ReLU(inplace=True)
#####3*3*3*16*16+16 = 2928
    (3): Conv3d(16, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))
######0  
    (4): InstanceNorm3d(16, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
######0  
    (5): ReLU(inplace=True)
  )
######0  
  (sigmoid): Sigmoid()
#####1*1*1*16*1+1 = 17
  (conv10): Conv3d(16, 1, kernel_size=(1, 1, 1), stride=(1, 1, 1))
)

 python代码计算结果：

输入大小：(1,64, 128, 128)

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv3d-1      [-1, 8, 64, 128, 128]             224
    InstanceNorm3d-2      [-1, 8, 64, 128, 128]               0
              ReLU-3      [-1, 8, 64, 128, 128]               0
            Conv3d-4     [-1, 16, 64, 128, 128]           3,472
    InstanceNorm3d-5     [-1, 16, 64, 128, 128]               0
              ReLU-6     [-1, 16, 64, 128, 128]               0
         MaxPool3d-7       [-1, 16, 32, 64, 64]               0
            Conv3d-8       [-1, 16, 32, 64, 64]           6,928
    InstanceNorm3d-9       [-1, 16, 32, 64, 64]               0
             ReLU-10       [-1, 16, 32, 64, 64]               0
           Conv3d-11       [-1, 32, 32, 64, 64]          13,856
   InstanceNorm3d-12       [-1, 32, 32, 64, 64]               0
             ReLU-13       [-1, 32, 32, 64, 64]               0
        MaxPool3d-14       [-1, 32, 16, 32, 32]               0
           Conv3d-15       [-1, 32, 16, 32, 32]          27,680
   InstanceNorm3d-16       [-1, 32, 16, 32, 32]               0
             ReLU-17       [-1, 32, 16, 32, 32]               0
           Conv3d-18       [-1, 64, 16, 32, 32]          55,360
   InstanceNorm3d-19       [-1, 64, 16, 32, 32]               0
             ReLU-20       [-1, 64, 16, 32, 32]               0
        MaxPool3d-21        [-1, 64, 8, 16, 16]               0
           Conv3d-22        [-1, 64, 8, 16, 16]         110,656
   InstanceNorm3d-23        [-1, 64, 8, 16, 16]               0
             ReLU-24        [-1, 64, 8, 16, 16]               0
           Conv3d-25       [-1, 128, 8, 16, 16]         221,312
   InstanceNorm3d-26       [-1, 128, 8, 16, 16]               0
             ReLU-27       [-1, 128, 8, 16, 16]               0
        MaxPool3d-28         [-1, 128, 4, 8, 8]               0
           Conv3d-29         [-1, 128, 4, 8, 8]         442,496
   InstanceNorm3d-30         [-1, 128, 4, 8, 8]               0
             ReLU-31         [-1, 128, 4, 8, 8]               0
           Conv3d-32         [-1, 256, 4, 8, 8]         884,992
   InstanceNorm3d-33         [-1, 256, 4, 8, 8]               0
             ReLU-34         [-1, 256, 4, 8, 8]               0
         Upsample-35       [-1, 256, 8, 16, 16]               0
           Conv3d-36       [-1, 128, 8, 16, 16]       1,327,232
   InstanceNorm3d-37       [-1, 128, 8, 16, 16]               0
             ReLU-38       [-1, 128, 8, 16, 16]               0
           Conv3d-39       [-1, 128, 8, 16, 16]         442,496
   InstanceNorm3d-40       [-1, 128, 8, 16, 16]               0
             ReLU-41       [-1, 128, 8, 16, 16]               0
         Upsample-42      [-1, 128, 16, 32, 32]               0
           Conv3d-43       [-1, 64, 16, 32, 32]         331,840
   InstanceNorm3d-44       [-1, 64, 16, 32, 32]               0
             ReLU-45       [-1, 64, 16, 32, 32]               0
           Conv3d-46       [-1, 64, 16, 32, 32]         110,656
   InstanceNorm3d-47       [-1, 64, 16, 32, 32]               0
             ReLU-48       [-1, 64, 16, 32, 32]               0
         Upsample-49       [-1, 64, 32, 64, 64]               0
           Conv3d-50       [-1, 32, 32, 64, 64]          82,976
   InstanceNorm3d-51       [-1, 32, 32, 64, 64]               0
             ReLU-52       [-1, 32, 32, 64, 64]               0
           Conv3d-53       [-1, 32, 32, 64, 64]          27,680
   InstanceNorm3d-54       [-1, 32, 32, 64, 64]               0
             ReLU-55       [-1, 32, 32, 64, 64]               0
         Upsample-56     [-1, 32, 64, 128, 128]               0
           Conv3d-57     [-1, 16, 64, 128, 128]          20,752
   InstanceNorm3d-58     [-1, 16, 64, 128, 128]               0
             ReLU-59     [-1, 16, 64, 128, 128]               0
           Conv3d-60     [-1, 16, 64, 128, 128]           6,928
   InstanceNorm3d-61     [-1, 16, 64, 128, 128]               0
             ReLU-62     [-1, 16, 64, 128, 128]               0
           Conv3d-63      [-1, 1, 64, 128, 128]              17
          Sigmoid-64      [-1, 1, 64, 128, 128]               0
================================================================

mikeyNa
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
神经网络模型的参数量和计算量
凌逆战的博客
09-08 4220
其实模型的参数量好算，但浮点运算数并不好确定，我们一般也就根据参数量直接估计计算量了。但是像卷积之类的运算，它的参数量比较小，但是运算量非常大，它是一种计算密集型的操作。反观全连接结构，它的参数量非常多，但运算量并没有显得那么大。 FLOPs(Floating-point Operations)：浮点运算次数，理解为计算量，可以用来衡量算法的复杂度。一个乘法或一个加法都是一个FLOPs FLOP...
Unet 网络的实现以及计算网络参数个数：python实现
03-13
unet
神经网络参数量的计算：以UNet为例
comeonow的博客
08-13 1594
神经网络参数量的计算：以UNet为例
转载Unet网络参数的计算
jxb727098的博客
07-19 2270
转自：https://bbs.cvmart.net/articles/1632 理论公式部分 卷积层： 其中 K 为卷积核大小，Ci为输入channel数，Co为输出的channel数(也是filter的数量)，算式第二项是偏置项的参数量 。(虽然一般不写偏置项，因为不会影响总参数量的数量级，但是我们为了准确起见，把偏置项的参数量也考虑进来） BN层： ，其中Ci为输入的channel数 （BN层有两个需要学习的参数，平移因子和缩放因子） 全连接层： ，Ti为输入向量的长度，To为输出向量的长度，其中第
参数量仅有50KB的超轻量级unet变种网络egeunet【参数和计算量降低494和160倍】医疗图像分割实践
Together_CZ的博客
07-31 1896
参数量仅有50KB的超轻量级unet变种网络egeunet【参数和计算量降低494和160倍】医疗图像分割实践
SmaAt-UNet:论文“ SmaAt-UNet的PyTorch代码
05-09
SmaAt-UNet 论文代码“ SmaAt-UNet：使用小型体系结构进行降水临近预报” ， 建议的SmaAt-UNet可以在下的模型文件夹中。 在本文中，我们使用了模块（PL），该模块简化了培训过程，并允许轻松添加记录器和创建检查...
3D分割-使用3D-UNet实现前列腺结构分割算法-附项目源码-优质项目实战.zip
05-06
本项目通过采用3D-UNet架构，旨在提供一个高质量的实战案例，帮助研究者和开发者深入理解并应用3D卷积神经网络（CNN）在医学图像分割中的潜力。 3D-UNet是一种在三维数据上扩展了传统2D UNet结构的深度学习模型。2D...
3D-Unet:用于大脑分割的3D Unet的Chainer实现
04-27
3D网络 用于大脑分割的3D Unet的Chainer实现。 培训配置位于configs / base.yml。 由于GPU内存的限制，我们使用了基于补丁的方法。 要求 SimpleITK 连连看v4 yaml 网络架构 3D Unet架构 用法 训练训练3D unet。 ...
脑肿瘤分割-基于3D-UNet+3D-VNet+2D-UNet实现的脑肿瘤分割算法-并进行生存预测-附项目源码-优质项目实战
最新发布
05-06
脑肿瘤分割_基于3D-UNet+3D-VNet+2D-UNet实现的脑肿瘤分割算法_并进行生存预测_附项目源码_优质项目实战
损失函数matlab代码-3D-UNet-PyTorch-Implementation:使用PyTorch实现3D-UNet
06-08
损失函数matlab代码3D-UNet-PyTorch-实现 这是Özgün Çiçek等人提出的3D UNet的实现，详情请参考：。 使用的数据集：，我使用的数据集已经被其他人处理过，由于某些原因我不能在这里分享它。 如果您想在工作中...
nnunet参数
fanre的专栏
08-13 792
MS-Model【1】：nnU-Net
BUPTer
10-02 1872
本文提出的nnU-net（），是在 2D & 3D 经典 U-net 的基础上， 稳健而又自适应的框架。nnU-net移去了冗余的部分，着重于剩下的对模型表现和泛化能力起作用的部分U-Net凭借其直接和成功的架构，迅速发展成为医学图像分割领域的一个常用基准。然而，U-Net对新问题的适应性包括关于确切的架构、预处理、训练和推理的几个自由度。这些选择并不是相互独立的，而是对整体性能有很大影响。本文介绍了nnU-Net（no-new-Net），它是指在二维和三维虚构U-Net。
【深度学习】医学图像分割的集成与后处理
李响
06-18 1654
【深度学习】医学图像分割的集成与后处理 文章目录 1 如何通过组合多个神经网络提高模型性能 1.1 使用融合模型减少模型的方差 2 tensorflow keras 实现模型平均 2.1 训练多种模型 2.2 融合模型 3 神经网络训练之交叉验证 4 训练和后处理 5 介绍一些免费/开源的医学影像后处理工具 1 如何通过组合多个神经网络提高模型性能 深度神经网络是非线性的。它们提供了更大的灵活性，并且理论上随着数据集的增多，其性能表现会越好。其缺点是通过随机训练算法进行学习，这意味着神经网络对训练
[深度学习论文笔记]UNETR: Transformers for 3D Medical Image Segmentation
热门推荐
Slientsake的博客
03-30 1万+
解码器的选择：在表3中，通过比较UNETR和其他解码器架构在两个MRI和CT模式的代表性分割任务上的性能来评估解码器的有效性。虽然这种基于FCN的方法具有强大的表示学习能力，但它们在远程依赖学习中的表现，仅限于它们的局部接受域。同样，将三维输入体积 ，分辨率(H,W,D)和C输入通道划分为平坦的均匀非重叠斑块 ，创建一个一维序列，其中(P, P, P)表示每个patch的分辨率， 为序列的长度。此外，在小器官的分割中，在胆囊和肾上腺的Dice评分方面，方法显著优于第二最佳基线的6.382%和6.772%。
nnUNet 详细解读（一）论文技术要点归纳
qq128252的博客
11-01 6467
提出了一种基于2D和3D UNet的自适应框架nnUNet，无需手动调参，平均DICE最高。总共10个数据集，7个用于训练阶段，3个用于评估阶段，且不能手动调参。预处理：resampling和normalization训练：loss，optimizer设置、数据增广推理：patch-based策略、test-time-augmentations集成和模型集成等后处理：增强单连通域等。
【图像分割】Unet系列深度讲解（FCN、UNET、UNET++）
Danger的博客
03-20 5790
【图像分割】Unet系列深度讲解（FCN、UNET、UNET++）
归一化方法在医学图像实战中的理解
supernova121的博客
01-08 871
总所周知在数据载入机器学习模型训练之前都需要进行归一化以保证数据在统一尺度有利于训练得到统一的特征，同样的对应特征而言在神经网络训练的时候不同深度卷积产生的特征尺度也会发生偏移和变化，为了统一特征学习，归一化概念被引入神经网络。
Pytorch实现姿态识别（二）——视频分析C3D的网络架构
wa1tzy的博客
07-21 2406
C3D网络架构与结构图： 3D卷积与2D卷积的区别：其中多了一个时间维度 三维卷积与三维池化的理解： ① nn.Conv3d(3, 64, kernel_size=(3, 3, 3), padding=(1, 1, 1)) kernel_size=(3, 3, 3)： 第一个3：一共16帧，当前处理3帧； 第二、三个3：H,W的大小； padding=(1, 1, 1)：三维、高、宽都填充1 ② nn.MaxPool3d(kernel_size=(1, 2, 2), stride=(1, 2, 2))
U-Net、3D-Unet、ResU-Net、Attention U-Net等4种U-Net神经网络结构和算法原理
04-17
U-Net、3D-Unet、ResU-Net和Attention U-Net是四种常用的U-Net神经网络结构，它们在医学图像分割等领域具有广泛的应用。下面我将为你介绍它们的算法原理。 1. U-Net[^1]： U-Net是一种用于图像分割的卷积神经网络结构。它由一个编码器和一个解码器组成，编码器用于提取图像的特征，解码器用于生成分割结果。U-Net的特点是将编码器和解码器之间的特征图进行跳跃连接，这样可以保留更多的低级和高级特征信息，提高分割的准确性。 2. 3D-Unet[^2]： 3D-Unet是U-Net的扩展版本，用于处理三维体积数据的分割任务。它在U-Net的基础上引入了3D卷积操作，以处理体积数据的空间信息。3D-Unet的编码器和解码器结构与U-Net类似，但在卷积操作中使用了3D卷积核。 3. ResU-Net[^3]： ResU-Net是在U-Net的基础上引入了残差连接的改进版本。残差连接可以帮助网络更好地传递梯度和特征信息，减轻了梯度消失的问题。ResU-Net的编码器和解码器结构与U-Net类似，但在跳跃连接中使用了残差连接。 4. Attention U-Net[^4]： Attention U-Net是在U-Net的基础上引入了注意力机制的改进版本。注意力机制可以帮助网络更好地关注重要的特征区域，提高分割的准确性。Attention U-Net的编码器和解码器结构与U-Net类似，但在跳跃连接中使用了注意力机制。 这些U-Net神经网络结构在医学图像分割等领域具有广泛的应用，它们通过不同的改进方式提高了分割的准确性和性能。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值