BiO-Net: Learning Recurrent Bi-directional Connections for Encoder-Decoder Architecture

于 2022-06-17 15:51:54 发布
阅读量668 收藏 1
点赞数
分类专栏： 论文精读 文章标签： 人工智能 深度学习 计算机视觉 cnn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45648030/article/details/125334572
版权
本文介绍了在2020年MICCAI会议上提出的BiONet模型，该模型利用递归双向连接优化编码器-解码器结构，适用于医学图像处理。网络详细地展示了预处理、编码器、中间层和解码器的设计，以及完整的代码实现。

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

MICCAI 2020 学习用于 编码器-解码器结构的递归双向连接

BiO系列项目地址

目录

MICCAI 2020 学习用于 编码器-解码器结构的递归双向连接

网络框架

系列框图​

完整网络代码

关键词：递归、双向

网络框架

​

 ​

 系列框图​

完整网络代码

import numpy as np
import torch
from torch.nn import Module, Sequential, Conv2d, BatchNorm2d, ConvTranspose2d, ReLU, MaxPool2d, Sigmoid, Parameter
from torch import tensor, cat


class BiONet(Module):

    def __init__(self,
                 num_classes: int = 3,
                 iterations: int = 2,
                 multiplier: float = 1.0,
                 num_layers: int = 4,
                 integrate: bool = False):

        super(BiONet, self).__init__()
        #  参数
        self.iterations = iterations
        self.multiplier = multiplier
        self.num_layers = num_layers
        self.integrate = integrate
        self.batch_norm_momentum = 0.01
        #  生成通道参数，此处通道是从第一个Encoder输出的量开始的，直到语义向量
        self.filters_list = [int(32 * (2 ** i) * self.multiplier) for i in range(self.num_layers + 1)]
        #  预处理卷积块，不参与循环，最终输出的是32*256*256
        self.pre_transform_conv_block = Sequential(
            # 这里看代码实现，应该永远和第一个Encoder输出的层数是一样的
            Conv2d(3, self.filters_list[0], kernel_size=(3, 3), padding=(1, 1), stride=(1, 1)),  # 生成f[1]*512*512
            ReLU(),
            BatchNorm2d(self.filters_list[0], momentum=self.batch_norm_momentum),
            Conv2d(self.filters_list[0], self.filters_list[0], kernel_size=(3, 3), padding=(1, 1), stride=(1, 1)),
            # 生成f[1]*512*512
            ReLU(),
            BatchNorm2d(self.filters_list[0], momentum=self.batch_norm_momentum),
            Conv2d(self.filters_list[0], self.filters_list[0], kernel_size=(3, 3), padding=(1, 1), stride=(1, 1)),
            # 生成f[1]*512*512
            ReLU(),
            BatchNorm2d(self.filters_list[0], momentum=self.batch_norm_momentum),
            MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=(0, 0))
        )
        self.reuse_convs = []  # encoder复用的卷积核，每个encoder对应一个元组（共3个卷积核，不包括ReLU）
        self.encoders = []  # 由encoder构成的列表。由于encoder的一部分不参与循环，因此每个encoder是一个元组(两个CONV的Sequential, DOWN)
        self.reuse_deconvs = []  # decoder复用的卷积、反卷积核，每个decoder对应一个元组（共3个卷积核，不包括ReLU）
        self.decoders = []  # 由decoder构成的列表。由于decoder的一部分不参与循环，因此每个decoder是一个元组(两个CONV的Sequential, UP)
        for iteration in range(self.iterations):
            for layer in range(self.num_layers):

                #  创建encoders的部分。虽然部分代码可以合写，但是为了看起来清晰（而且构造函数也不是很要求效率），所以分开考虑encoder和decoder
                #  和层次有关的常数
                in_channel = self.filters_list[layer] * 2  # 由于有输出部分传入的数据，因此需要翻倍输入通道
                mid_channel = self.filters_list[layer]
                out_channel = self.filters_list[layer + 1]
                #  创建encoders模型
                if iteration == 0:
                    #  创建并添加复用卷积核
                    #  只有最后一个卷积核负责升高通道
                    conv1 = Conv2d(in_channel, mid_channel, kernel_size=(3, 3), padding=(1, 1), stride=(1, 1))
                    conv2 = Conv2d(mid_channel, mid_channel, kernel_size=(3, 3), padding=(1, 1), stride=(1, 1))
                    conv3 = Conv2d(mid_channel, out_channel, kernel_size=(3, 3), padding=(1, 1), stride=(1, 1))
                    self.reuse_convs.append((conv1, conv2, conv3))
                #  创建encoder
                #  首先构造两个CONV
                convs = Sequential(
                    self.reuse_convs[layer][0],
                    ReLU(),
                    BatchNorm2d(mid_channel, momentum=self.batch_norm_momentum),
                    self.reuse_convs[layer][1],
                    ReLU(),
                    BatchNorm2d(mid_channel, momentum=self.batch_norm_momentum)
                )
                #  构建DOWN
                down = Sequential(
                    self.reuse_convs[layer][2],
                    ReLU(),
                    BatchNorm2d(out_channel, momentum=self.batch_norm_momentum),
                    MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=(0, 0))
                )
                self.add_module("iteration{0}_layer{1}_encoder_convs".format(iteration, layer), convs)
                self.add_module("iteration{0}_layer{1}_encoder_down".format(iteration, layer), down)
                self.encoders.append((convs, down))

                #  创建decoders的部分，仿照encoders
                #  和层次有关的常数，注意本部分不需要mid_channel，因为第一个卷积核就已经升高维度了
                in_channel = self.filters_list[self.num_layers - layer] + self.filters_list[self.num_layers - 1 - layer]
                out_channel = self.filters_list[self.num_layers - 1 - layer]
                #  创建decoders模型
                if iteration == 0:
                    #  创建并添加复用卷积核
                    #  从第一个卷积核就升高通道数
                    conv1 = Conv2d(in_channel, out_channel, kernel_size=(3, 3), padding=(1, 1), stride=(1, 1))
                    conv2 = Conv2d(out_channel, out_channel, kernel_size=(3, 3), padding=(1, 1), stride=(1, 1))
                    conv3 = ConvTranspose2d(out_channel, out_channel, kernel_size=(3, 3), padding=(1, 1), stride=(2, 2),
                                            output_padding=(1, 1))  # 此处和tensorflow有点区别，为了完整的形状，需要用output补一补
                    self.reuse_deconvs.append((conv1, conv2, conv3))
                #  创建encoder
                #  首先构造两个CONV
                convs = Sequential(
                    self.reuse_deconvs[layer][0],
                    ReLU(),
                    BatchNorm2d(out_channel, momentum=self.batch_norm_momentum),
                    self.reuse_deconvs[layer][1],
                    ReLU(),
                    BatchNorm2d(out_channel, momentum=self.batch_norm_momentum)
                )
                #  构造UP
                up = Sequential(
                    self.reuse_deconvs[layer][2],
                    ReLU(),
                    BatchNorm2d(out_channel, momentum=self.batch_norm_momentum)
                )
                self.add_module("iteration{0}_layer{1}_decoder_convs".format(iteration, layer), convs)
                self.add_module("iteration{0}_layer{1}_decoder_up".format(iteration, layer), up)
                self.decoders.append((convs, up))
        #  创建middle层
        self.middles = Sequential(
            Conv2d(self.filters_list[-1], self.filters_list[-1], kernel_size=(3, 3), padding=(1, 1), stride=(1, 1)),
            ReLU(),
            BatchNorm2d(self.filters_list[-1], momentum=self.batch_norm_momentum),
            Conv2d(self.filters_list[-1], self.filters_list[-1], kernel_size=(3, 3), padding=(1, 1), stride=(1, 1)),
            ReLU(),
            BatchNorm2d(self.filters_list[-1], momentum=self.batch_norm_momentum),
            ConvTranspose2d(self.filters_list[-1], self.filters_list[-1], kernel_size=(3, 3), padding=(1, 1),
                            stride=(2, 2), output_padding=(1, 1)),
            ReLU(),
            BatchNorm2d(self.filters_list[-1], momentum=self.batch_norm_momentum)
        )
        self.post_transform_conv_block = Sequential(
            Conv2d(self.filters_list[0] * self.iterations, self.filters_list[0], kernel_size=(3, 3), padding=(1, 1),
                   stride=(1, 1)) if self.integrate else Conv2d(self.filters_list[0],
                                                                self.filters_list[0], kernel_size=(3, 3),
                                                                padding=(1, 1), stride=(1, 1)),
            ReLU(),
            BatchNorm2d(self.filters_list[0], momentum=self.batch_norm_momentum),
            Conv2d(self.filters_list[0], self.filters_list[0], kernel_size=(3, 3), padding=(1, 1), stride=(1, 1)),
            ReLU(),
            BatchNorm2d(self.filters_list[0], momentum=self.batch_norm_momentum),
            Conv2d(self.filters_list[0], 1, kernel_size=(1, 1), stride=(1, 1)),
            Sigmoid(),
        )

    def forward(self, x: tensor) -> tensor:
        enc = [None for i in range(self.num_layers)]
        dec = [None for i in range(self.num_layers)]
        all_output = [None for i in range(self.iterations)]
        x = self.pre_transform_conv_block(x)
        e_i = 0
        d_i = 0
        for iteration in range(self.iterations):
            for layer in range(self.num_layers):
                if layer == 0:
                    x_in = x
                x_in = self.encoders[e_i][0](cat([x_in, x_in if dec[-1 - layer] is None else dec[-1 - layer]], dim=1))
                enc[layer] = x_in
                x_in = self.encoders[e_i][1](x_in)
                e_i = e_i + 1
            x_in = self.middles(x_in)
            for layer in range(self.num_layers):
                x_in = self.decoders[d_i][0](cat([x_in, enc[-1 - layer]], dim=1))
                dec[layer] = x_in
                x_in = self.decoders[d_i][1](x_in)
                d_i = d_i + 1
            all_output[iteration] = x_in
        if self.integrate:
            x_in = cat(all_output, dim=1)
        x_in = self.post_transform_conv_block(x_in)
        return x_in


if __name__ == '__main__':
    Total_params = 0
    Trainable_params = 0
    NonTrainable_params = 0
    model = BiONet()
    x = torch.rand((1, 3, 512, 512))
    out = model(x)
    # 遍历model.parameters()返回的全局参数列表
    for param in model.parameters():
        mulValue = np.prod(param.size())  # 使用numpy prod接口计算参数数组所有元素之积
        Total_params += mulValue  # 总参数量
        if param.requires_grad:
            Trainable_params += mulValue  # 可训练参数量
        else:
            NonTrainable_params += mulValue  # 非可训练参数量

    print(f'Total params: {Total_params}')
    print(f'Trainable params: {Trainable_params}')
    print(f'Non-trainable params: {NonTrainable_params}')
    print(out.shape)

Bio-Net：编解码器结构的循环双向连接网络
weixin_43921949的博客
12-10 1565
网络结构使用了双向的跳跃连接
（二十七：2021.01.08）MICCAI 2020 学习（二）《BiO-Net》
Jojo论文基地
01-08 2949
MICCAI 2020 学习（二）《BiO-Net：学习用于编码器-解码器结构的递归双向连接》《BiO-Net: Learning Recurrent Bi-directional Connections for Encoder-Decoder Architecture》）讲在前面摘要论文内容1.介绍1.1 U-Net Variants（U-Net的变体总结）1.2 Recurrent Convolutional Networks（递归神经网络）2.方法2.1 递归双向跳跃连接2.2 BiO-Net结构3.
【论文翻译-2】BiO-Net: Learning Recurrent Bi-directional Connections for Encoder-Decoder Architecture
Feven_H的博客
11-23 2731
BiO-Net: Learning Recurrent Bi-directional Connections for Encoder-Decoder Architecture MICCAI：Medical Image Computing and Computer Assisted Intervention Society Abstract U-Net是深度学习解决计算机视觉任务的基本方法，可以解决例如语义分割、超分辨率、图像去噪、图像复原之类的任务。之前对于U-Net的改进主要是修改原有的模块或者是使用
BIO基础代码
weixin_41777118的博客
04-10 290
package BIO.demo1; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; public class Test1 { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(9000);
论文解读《BiX-NAS: Searching Efficient Bi-directional Architecture for Medical Image Segmentation》
weixin_37591159的博客
11-09 5107
论文解读《BiX-NAS: Searching Efficient Bi-directional Architecture for Medical Image Segmentation》 论文解读《BiX-NAS:搜索医学图像分割的高效双向架构》
BiO-Net:正式实施“BiO-Net
05-31
“BiO-Net: Learning Recurrent Bi-directional Connections for Encoder-Decoder Architecture”的官方实现，MICCAI 2020 论文： : 感谢对一些 Pytorch 代码的贡献！ 依赖关系 Python >= 3.6 PIL >= 7.0.0 ...
BiO-Net官方实现发布，PyTorch代码贡献者感谢
BiO-Net是一套正式实施的网络架构，它的核心理念是“Learning Recurrent Bi-directional Connections for Encoder-Decoder Architecture”。这一概念源于学术论文，并在著名的MICCAI 2020会议上被提出和讨论。该...
Encoder and Decoder with Attention Model
来自宇宙岛的海龟的博客
12-01 1087
#!/bin/bash # 定义变量方便修改 APP=gmall hive=/opt/module/hive/bin/hive # 如果是输入的日期按照取输入日期；如果没输入日期取当前时间的前一天 if [ -n "$1" ] ;then do_date=$1 else do_date=`date -d "-1 day" +%F` fi echo "===日志日期为 $do_...
（十八：2020.10.10）MICCAI 2020 追踪之论文纲要（译）＜上＞
Jojo论文基地
10-10 5329
讲在前面 暂时先更新PART I, 持续更新。 论文目录 PART I 《Machine Learning Methodologies 机器学习方法》 论文 概要 1.Attention, Suggestion and Annotation: A Deep Active Learning Framework for Biomedical Image Segmentation注意，建议和注释：用于生物医学图像分割的深度学习框架 2.Scribble2Label: Scribble-Sup
Bi-directional Recurrent Neural Network (BRNN)双向循环神经网络
qq_38343151的博客
10-26 1681
双向循环神经网络（BRNN）的基本思想是提出每一个训练序列向前和向后分别是两个循环神经网络（RNN），而且这两个都连接着一个输出层。这个结构提供给输出层输入序列中每一个点的完整的过去和未来的上下文信息。下图展示的是一个沿着时间展开的双向循环神经网络。六个独特的权值在每一个时步被重复的利用，六个权值分别对应：输入到向前和向后隐含层（w1, w3），隐含层到隐含层自己（w2, w5），向前和向后隐含层...
全面详解 | 深度学习中的注意力机制（二）
abcdefg90876的博客
11-12 1820
NewBeeNLP原创出品公众号专栏作者@蘑菇先生知乎|蘑菇先生学习记前情提要：全面详解 | 深度学习中的注意力机制目前深度学习中热点之一就是注意力机制（Attention ...
python学习 if is none else
weixin_52646021的博客
12-20 2991
本人功力很浅，所以有大佬的代码中是用简洁大方式写的，我需要学习一下 residual = x if self.right is None else self.right(x) 上边的这行代码等价于下面的： if self.right: residual=x else: residual=self.right(x) 相比于上面的，我更喜欢用下面的方式，虽然没有上面的简洁，但是这样可以让像我一样的人更直观的了解。学到就是赚到。 ...
深入理解CNN中的卷积和池化
gaoxueyi551的专栏
12-18 1234
对于卷积和池化是如何实现的，这个我想大部分人都明白，但是我觉得仅仅停留在这个层面还是对知识理解的不够透彻，我们还应该明白使用它们的原因是什么，它们有什么优点。因此，本着这个目的，重新审视了CNN中的卷积和池化两个关键概念。下面是后面说明将要用到的一张关于猫图像，这幅图像的尺寸是970*660。 图1. 猫咪 一、卷积的三大特性 1.1、局部感受野 如果采用全连接层来提取图片的特征，并设隐层大小为 ，则输入层和隐层之间的权值矩阵规模将是，在存储和计算效率方面都是不能忍受的。把...
第八课 RNN条件生成与Attention机制
约定的博客
03-01 854
文章目录1 RNN条件生成2 机器翻译3 Attention4 图像生成文本 1 RNN条件生成 RNN可以解决的问题有多种，根据输入输出个数不同分为： 1 一对多：图像描述 2 多对一：文本分类 3 多对多： 实时多对多：输入法、视频解说 输入完成再多对多：机器翻译 条件生成问题：P(y|x) 2 机器翻译 3 Attention 4 图像生成文本 ...
双向长短时记忆循环神经网络详解（Bi-directional LSTM RNN）
热门推荐
James Zhang's Blog
07-21 16万+
1. Recurrent Neural Network (RNN)尽管从多层感知器（MLP）到循环神经网络（RNN）的扩展看起来微不足道，但是这对于序列的学习具有深远的意义。循环神经网络（RNN）的使用是用来处理序列数据的。在传统的神经网络中模型中，层与层之间是全连接的，每层之间的节点是无连接的。但是这种普通的神经网络对于很多问题是无能为力的。比如，预测句子的下一个单词是什么，一般需要用到前面的单词
Semantic Segmentation--SegNet:A Deep Convolutional Encoder-Decoder Architecture..论文解读
DFan的NoteBook
12-27 8240
Semantic Segmentation简介在解读论文之前，先看看Semantic Segmentation这个topic是干啥的。这里引用知乎的一个提问答案：Semantic Segmentation–知乎-周博磊 图1.image classification, object detection, semantic segmentation, instance segmentatio
卷积神经网络CNN学习记录-CNN实现语义分割（Encoder-Decoder结构）
如何心安理得的在老板眼皮下摸鱼
07-22 4147
1.Encoder from keras.layers import * def Conv_Encoder( input_height=416 , input_width=416 ): Img_In = Input(shape=(input_height,input_width , 3 )) # 416,416,3 -> 208,208,64 Img_Conv = Conv2D(64, (3, 3), activation='relu', padding='same', name=
深度学习方法（八）：自然语言处理中的Encoder-Decoder模型，基本Sequence to Sequence模型...
weixin_30341735的博客
01-19 1094
欢迎转载，转载请注明：本文出自Bin的专栏blog.csdn.net/xbinworld。技术交流QQ群：433250724，欢迎对算法、技术感兴趣的同学加入。 Encoder-Decoder（编码-解码）是深度学习中非常常见的一个模型框架，比如无监督算法的auto-encoding就是用编码-解码的结构设计并训练的；比如这两年比较热的image caption的应用，就是...
变形卷积核、可分离卷积？卷积神经网络中十大拍案叫绝的操作。
mmc2015的专栏
08-31 2万+
总结的非常好，故转来，如果侵权，请告知，会及时删掉。 大家还是去看原文好，作者的文章都不错： https://zhuanlan.zhihu.com/p/28749411 https://www.zhihu.com/people/professor-ho/posts 写文章 变形卷积核、可分
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值