超分辨率第八章-SR&transformer

超分辨率中的transformer-应用于MRI

文献一：3d Cross-Scale Feature Transformer Network for Brain Mr Image Super-Resolution：ICASSP 2022会议

文献二：Adjacent slices feature transformer network for single anisotropic 3D brain MRI image super-resolution：《Biomedical Signal Processing and Control》 期刊，2022

前置知识

1.attention

• 参考视频：Transformer中Self-Attention以及Multi-Head Attention详解

• 通过 Query (查询对象) 这个信息从 Values （被查询对象）中筛选出重要信息，简单点说，就是计算 Query 和 Values 中每个信息的相关程度。

• 通过上图，Attention 通常可以进行如下描述，表示为将 Query(Q) 和 key-value pairs（把 Values 拆分成了键值对) 映射到输出上，其中 query、每个 key、每个 value 都是向量，输出是 V （被查询对象）中所有 values 的加权，其中权重是由 Query 和每个 key 计算出来的，计算方法分为三步：

  • 第一步：Query与每一个Key计算相似性得到相似性评分s
  • 第二步：将s评分进行softmax转换成[0,1]之间的概率分布
  • 第三步：将[a1,a2,a3…an]作为权值矩阵对Value进行加权求和得到最后的Attention值
  • $$A t t e n t i o n ( Q , K , V ) = s o f t m a x ( \frac { Q K ^ { T } } { \sqrt { d _ { k } } } ) V$$

    • 

      

• 多头注意力机制

  • 首先将q、k、v序列进行均分，分为head组

    • 

    • 

  • 分别计算各head的注意力

    • 

  • 将各head的值进行拼接

    • 

  • 使用Wo进行融合

    • 

2.通道注意力机制与空间注意力机制

• 通道注意力机制
  • 通道注意力机制的代表模型是：压缩和激励网络(Squeeze-and-Excitation Networks,SENet)
  • SENet分为压缩和激励两个部分，其中压缩部分的目的是对全局空间信息进行压缩，然后在通道维度进行特征学习，形成各个通对道的重要性，最后通过激励部分对各个通道进行分配不同权重的。
  • 
  • 上图是SE模块的结构，在压缩部分，输入的元素特征图的维度是H×WxC，H、W和C分别代表高度、宽度和通道数。压缩部分的功能是将维数从H×W×C压缩至1×1×C，即把H×W压缩为1×1维，这个过程由空间维度的全局平均池化实现。
  • 在激励部分，需要将压缩部分得到的1×1×C的维度融入全连接层，预测各个通道的重要程度，然后再激励到前面特征图对应通道上进行操作。采用简单的门控机制与Sigmoid激活函数。
• 空间注意力机制
  • 
  • 首先，对一个尺寸为 H×W×C的输入特征图F进行通道维度的全局最大池化和全局平均池化，得到两个 H×W×1 的特征图（在通道维度进行池化，压缩通道大小，便于后面学习空间的特征）
  • 然后，将全局最大池化和全局平均池化的结果，按照通道拼接(concat)，得到特征图尺寸为HxWx2，
  • 最后，对拼接的结果进行卷积操作，得到特征图尺寸为 HxWx1
  • 接着通过Sigmoid激活函数 ，得到空间注意力权重矩阵

3.transformer

• 参考视频：手推transformer
  • 2017年提出，分为encoder与decoder两个部分
  • input embedding：可以将高维的离散输入数据转换为低维的连续向量表示
  • 位置编码（Positional Encoding）：由于Transformer没有内置的序列位置信息，它需要额外的位置编码来表达输入序列中单词的位置顺序。
  • 多头注意力（Multi-Head Attention）：Transformer中的自注意力机制被扩展为多个注意力头，每个头可以学习不同的注意权重，以更好地捕捉不同类型的关系。多头注意力允许模型并行处理不同的信息子空间。
  • 

4.vision transformer

• 参考视频：Vision Transformer(vit)网络详解

• 简称vit，2020年提出

• 网络结构

  • patch embedding&Linear Projection of Flattened Patches：
    • 将输入的2维图像（3通道）分割为多个小块（patches）(若干个不重叠的 patch)，并将每个小块映射到特定维度的嵌入（embedding）向量空间中，原来的一个图像块patch（3通道）映射成特征图的一个像素点（值）
    • 将输入图片(224x224)按照16x16大小的Patch进行划分，划分后会得到$(224/16)^2=14^2=196$个Patches。接着通过线性映射将每个Patch映射到一维向量中，以ViT-B/16为例，每个Patche数据shape为[16, 16, 3]，每个 patch 最终会被映射到 768 维的向量空间
      • 输入图片<224，224，3>经过卷积核（16*16）得到<14，14，768>，再经过展平得到<196，768>
  • class token与position embedding
    • token与分类token拼接得到<197，768>，之后再与位置embedding相加得到具有分类与位置信息的token
  • encoder：12个编码器堆叠而成，进行多头自注意力计算
  • extract class token：通过编码器之后，在进入MLP head之前，需要将分类token提取出来，此时<197，768> -> <1，768>
  • MLP Head：原论文中说在训练ImageNet21K时是由Linear+tanh激活函数+Linear组成。但是迁移到ImageNet1K上或者你自己的数据上时，只用一个Linear即可。
  • 

• 流程

  • Q,K,V的生成使用全连接层模拟
  • 

• 模型参数

  • 

5.vit代码

①patch embedding块

class PatchEmbed(nn.Module):   
    def __init__(self, img_size=224, patch_size=16, in_c=3, embed_dim=768, norm_layer=None):   
        super().__init__()  
        # 将输入的img_size转换为二维元组，假设图像是正方形  
        img_size = (img_size, img_size)  
        # 将输入的patch_size转换为二维元组，表示每个patch的大小  
        patch_size = (patch_size, patch_size)   
        # 存储图像的尺寸  
        self.img_size = img_size  
        # 存储每个patch的尺寸  
        self.patch_size = patch_size  
        # 计算图像被划分成多少个patch（网格大小）  
        self.grid_size = (img_size[0] // patch_size[0], img_size[1] // patch_size[1])  
        # 计算总的patch数量  
        self.num_patches = self.grid_size[0] * self.grid_size[1]  
        # 定义一个卷积层，用于将图像划分为patch，并将每个patch映射到嵌入向量空间  
        self.proj = nn.Conv2d(in_c, embed_dim, kernel_size=patch_size, stride=patch_size)   
        # 定义一个可选的归一化层，如果norm_layer为None，则使用nn.Identity()作为占位符，不进行归一化  
        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()  
  
    def forward(self, x):  
        # 提取输入x的批次大小、通道数、高度和宽度  
        B, C, H, W = x.shape  
        # 断言输入图像的大小与模型期望的大小匹配  
        assert H == self.img_size[0] and W == self.img_size[1], \  
            f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."  
        # flatten: [B, C, H, W] -> [B, C, HW]
        # transpose: [B, C, HW] -> [B, HW, C]  
        x = self.proj(x).flatten(2).transpose(1, 2)  
        # 对嵌入向量进行归一化  
        x = self.norm(x)   
        # 返回处理后的嵌入向量  
        return x

② multi-head attention块

class Attention(nn.Module):  
    def __init__(self,  
                 dim,   # 输入token的特征维度（dim）  
                 num_heads=8,  # 多头注意力机制中头的数量  
                 qkv_bias=False,  # qkv线性变换是否使用偏置项  
                 qk_scale=None,  # q和k相乘后的缩放因子，默认为head_dim的负0.5次方  
                 attn_drop_ratio=0.,  # attention分数应用dropout的比率  
                 proj_drop_ratio=0.):  # 最终投影后应用dropout的比率  
        super(Attention, self).__init__()  
        self.num_heads = num_heads  # 存储头的数量  
        head_dim = dim // num_heads  # 每个头的特征维度  
        self.scale = qk_scale or head_dim ** -0.5  # 计算缩放因子  
        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)  # qkv的线性变换，输出是输入的3倍，对应q, k, v ,使用全连接层模拟
        self.attn_drop = nn.Dropout(attn_drop_ratio)  # attention分数的dropout  
        self.proj = nn.Linear(dim, dim)  # 最终的线性投影  
        self.proj_drop = nn.Dropout(proj_drop_ratio)  # 投影后的dropout  
  
    def forward(self, x):  
        # x的形状为[batch_size, num_patches + 1, total_embed_dim]  
        B, N, C = x.shape  # 分别获取batch大小、序列长度和特征维度  
  
        # 通过qkv线性变换，得到[batch_size, num_patches + 1, 3 * total_embed_dim]  
        #reshape操作将张量重塑为[batch_size, num_patches + 1, 3, num_heads, embed_dim_per_head]的形状，其中num_heads是多头注意力中的头数，embed_dim_per_head是每个头的特征维度（即总特征维度除以头数）。
        #permute操作则是为了调整张量的维度顺序，使其更便于后续处理。经过permute操作后，张量的形状变为[3, batch_size, num_heads,num_patches + 1, embed_dim_per_head]。   
        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)  
        #分别获取q, k, v，这里的索引操作是基于第一维进行的。由于q、k、v分别对应着这一维上的前、中、后三个部分，因此我们可以通过索引0、1、2来分别获取它们。  
        q, k, v = qkv[0], qkv[1], qkv[2]  #[batch_size, num_heads,num_patches + 1, embed_dim_per_head]
  
        # transpose: -> [batch_size, num_heads, embed_dim_per_head, num_patches + 1]
        # @: multiply -> [batch_size, num_heads, num_patches + 1, num_patches + 1] 
        # 接着乘以缩放因子，应用softmax进行归一化，最后应用dropout
        attn = (q @ k.transpose(-2, -1)) * self.scale  
        attn = attn.softmax(dim=-1)  
        attn = self.attn_drop(attn)  
  
        # 使用attention分数对v进行加权计算，得到[batch_size, num_heads, num_patches + 1, embed_dim_per_head]  
        # 然后transpose和reshape操作，将结果转换回[batch_size, num_patches + 1, total_embed_dim]  
        x = (attn @ v).transpose(1, 2).reshape(B, N, C)  
        # 对结果进行最终的线性投影  
        x = self.proj(x)  
        # 应用dropout后返回最终结果  
        x = self.proj_drop(x)  
        return x  

③MLP块

class Mlp(nn.Module):  
    # 初始化函数，设置输入特征数、隐藏层特征数（默认为输入特征数）、输出特征数（默认为输入特征数）、激活层（默认为GELU）、丢弃率  
    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):  
        super().__init__()  # 调用父类初始化方法  
        # 如果没有指定输出特征数，则默认为输入特征数  
        out_features = out_features or in_features  
        # 如果没有指定隐藏层特征数，则默认为输入特征数  
        hidden_features = hidden_features or in_features  
        # 定义第一个全连接层，将输入特征数映射到隐藏层特征数  
        self.fc1 = nn.Linear(in_features, hidden_features)  
        # 定义激活层，默认为GELU  
        self.act = act_layer()  
        # 定义第二个全连接层，将隐藏层特征数映射到输出特征数  
        self.fc2 = nn.Linear(hidden_features, out_features)  
        # 定义丢弃层，用于防止过拟合  
        self.drop = nn.Dropout(drop)  
  
    # 前向传播函数  
    def forward(self, x):   
        x = self.fc1(x)  
        x = self.act(x)  
        x = self.drop(x)   
        x = self.fc2(x)   
        x = self.drop(x)   
        return x  
  

④encoder block块

class Block(nn.Module):  
    # 初始化函数，设置维度、头数、MLP比率、qkv偏置、qk缩放、丢弃率、注意力丢弃率、路径丢弃率、激活层、归一化层  
    def __init__(self,  
                 dim,  
                 num_heads,  
                 mlp_ratio=4.,  
                 qkv_bias=False,  
                 qk_scale=None,  
                 drop_ratio=0.,  
                 attn_drop_ratio=0.,  
                 drop_path_ratio=0.,  
                 act_layer=nn.GELU,  
                 norm_layer=nn.LayerNorm):  
        super(Block, self).__init__()  # 调用父类初始化方法  
        # 定义第一个归一化层  
        self.norm1 = norm_layer(dim)  
        # 定义注意力机制层  
        self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,  
                              attn_drop_ratio=attn_drop_ratio, proj_drop_ratio=drop_ratio)  
        # 如果路径丢弃率大于0，则定义路径丢弃层，否则使用恒等操作（即不改变输入）  
        self.drop_path = DropPath(drop_path_ratio) if drop_path_ratio > 0. else nn.Identity()  
        # 定义第二个归一化层  
        self.norm2 = norm_layer(dim)  
        # 计算MLP隐藏层维度  
        mlp_hidden_dim = int(dim * mlp_ratio)  
        # 定义MLP层  
        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop_ratio)  
  
    # 前向传播函数  
    def forward(self, x):  
        # x加上经过归一化、注意力机制、路径丢弃处理后的结果  
        x = x + self.drop_path(self.attn(self.norm1(x)))  
        # x再加上经过归一化、MLP、路径丢弃处理后的结果  
        x = x + self.drop_path(self.mlp(self.norm2(x)))  
        # 返回最终结果  
        return x

⑤vit整体结构

# 定义一个VisionTransformer类，继承自nn.Module，用于图像分类等任务  
class VisionTransformer(nn.Module):  
    # 初始化函数，设置多个参数，包括图像大小、块大小、输入通道数、类别数、嵌入维度、encoder个数、head数量、mlp缩放倍数等 
    def __init__(self, img_size=224, patch_size=16, in_c=3, num_classes=1000,  
                 embed_dim=768, depth=12, num_heads=12, mlp_ratio=4.0, qkv_bias=True,  
                 qk_scale=None, representation_size=None, distilled=False, drop_ratio=0.,  
                 attn_drop_ratio=0., drop_path_ratio=0., embed_layer=PatchEmbed, norm_layer=None,  
                 act_layer=None):  
          
        super(VisionTransformer, self).__init__()   
        # 设置类别数和嵌入维度（也作为特征数）  
        self.num_classes = num_classes  
        self.num_features = self.embed_dim = embed_dim  
        # 设置token数量，该模型设置为1  
        self.num_tokens = 2 if distilled else 1  
        # 如果没有指定归一化层，则默认为LayerNorm，并设置eps为1e-6  
        norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)  
        # 如果没有指定激活层，则默认为GELU  
        act_layer = act_layer or nn.GELU  
        # 定义图像块嵌入层，将图像分割成小块并嵌入到高维空间中  
        self.patch_embed = embed_layer(img_size=img_size, patch_size=patch_size, in_c=in_c, embed_dim=embed_dim)  
        # 获取图像块的数量  
        num_patches = self.patch_embed.num_patches  
        # 初始化类别token和蒸馏token（可忽略）  
        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))  
        self.dist_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) if distilled else None  
        # 初始化位置嵌入  
        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))  
        # 定义位置嵌入的丢弃层  
        self.pos_drop = nn.Dropout(p=drop_ratio)  
        # 根据深度生成每个Block的路径丢弃率（使用随机深度衰减规则）  
        dpr = [x.item() for x in torch.linspace(0, drop_path_ratio, depth)]   
        # 定义一系列Block，每个Block包含注意力机制和MLP  
        self.blocks = nn.Sequential(*[  
            Block(dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,  
                  drop_ratio=drop_ratio, attn_drop_ratio=attn_drop_ratio, drop_path_ratio=dpr[i],  
                  norm_layer=norm_layer, act_layer=act_layer)  
            for i in range(depth)  
        ])     
        # 定义最后的归一化层  
        self.norm = norm_layer(embed_dim)  
          
        # 如果指定了表示层的大小且不是蒸馏模型，则定义表示层 mlp head 
        if representation_size and not distilled:  
            self.has_logits = True  
            self.num_features = representation_size  
            self.pre_logits = nn.Sequential(OrderedDict([  
                ("fc", nn.Linear(embed_dim, representation_size)),  
                ("act", nn.Tanh())  
            ]))  
        else:  
            self.has_logits = False  
            self.pre_logits = nn.Identity()  
          
        # 定义分类头，如果类别数大于0则定义线性层，否则为恒等操作  
        self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()  
          
        # 如果蒸馏模型，则定义额外的分类头（可忽略）  
        self.head_dist = None  
        if distilled:  
            self.head_dist = nn.Linear(self.embed_dim, self.num_classes) if num_classes > 0 else nn.Identity()  
          
        # 初始化权重  
        nn.init.trunc_normal_(self.pos_embed, std=0.02)  
        if self.dist_token is not None:  
            nn.init.trunc_normal_(self.dist_token, std=0.02)  
        nn.init.trunc_normal_(self.cls_token, std=0.02)  
        self.apply(_init_vit_weights)  # 应用自定义的权重初始化函数  
  
    # 定义前向传播函数（特征提取部分）  
    def forward_features(self, x):  
        # 将输入图像通过图像块嵌入层  
        x = self.patch_embed(x)  
        # 扩展类别token的维度以匹配输入批次大小  
        cls_token = self.cls_token.expand(x.shape[0], -1, -1)  
        # 根据是否有蒸馏token，将类别token（和蒸馏token）与图像块嵌入拼接  
        if self.dist_token is None:  
            x = torch.cat((cls_token, x), dim=1)  
        else:  
            x = torch.cat((cls_token, self.dist_token.expand(x.shape[0], -1, -1), x), dim=1)  
          
        # 将位置嵌入加到输入上，并通过位置嵌入的丢弃层  
        x = self.pos_drop(x + self.pos_embed)  
        # 将输入通过一系列Block  
        x = self.blocks(x)  
        # 通过最后的归一化层  
        x = self.norm(x)  
        # 根据是否有蒸馏token，返回不同的输出  
        if self.dist_token is None:  
            return self.pre_logits(x[:, 0])  # 提取class token(应用此项)
        else:  
            return x[:, 0], x[:, 1]  # 返回类别token和蒸馏token对应的表示  
  
    # 定义完整的前向传播函数（包括分类头）  
    def forward(self, x):  
        # 通过前向传播函数（特征提取部分）获取表示  
        x = self.forward_features(x)    
        # 如果是蒸馏模型，则分别通过两个分类头获取预测结果  
        if self.head_dist is not None:  
            x, x_dist = self.head(x[0]), self.head_dist(x[1])  
            # 如果是训练模式且不是在使用TorchScript，则返回两个分类头的预测结果  
            # 否则，返回两个分类头预测结果的平均值（用于推理）  
            if self.training and not torch.jit.is_scripting():  
                return x, x_dist  
            else:  
                return (x + x_dist) / 2  
        else:  
            # 如果不是蒸馏模型，则只通过一个分类头获取预测结果   (应用此项)
            x = self.head(x)  
        return x

一.文献一（CFTN）

3d Cross-Scale Feature Transformer Network for Brain Mr Image Super-Resolution（CFTN）

1.文献介绍

①先前模型的缺点

• 仅探索外部图像资源，没有挖掘内部先验，在针对特定MR图像和大规模SR重建精细纹理方面仍然存在不足。

②关于内部先验（internal priors）

先验知识：

图片处理中的先验知识是指在处理图像时使用的已知信息或假设。以下是一些常见的图片处理先验知识及其应用：

1. 平滑性先验：
   • 应用：假设图像中像素值变化较为平滑，这种假设在去噪、去模糊等任务中非常有用。通过这个先验，可以确保图像的平滑区域保持一致，而不引入伪影。
2. 稀疏性先验：
   • 应用：假设图像在某个变换域（如傅里叶变换或小波变换）中是稀疏的，即大多数变换系数接近于零。这一先验在图像压缩和重建中非常重要。
3. 边缘先验：
   • 应用：假设图像中存在明显的边缘和轮廓。边缘先验在边缘检测、图像分割和超分辨率重建中有很大作用，能够帮助模型更好地识别和恢复图像中的细节。
4. 结构先验：
   • 应用：假设图像具有某些已知的结构特性，如对称性和纹理。这些先验在图像修复、去雾等任务中可以显著提高性能。

在深度学习模型中，先验知识可以通过设计合适的损失函数、网络结构或通过预训练的方式融入模型中，从而提升模型的处理能力和泛化能力。

内部先验与外部先验：

内部先验：

• 定义：基于输入图像本身的特性和信息的先验知识。
• 例子：图像的平滑性、边缘特性、局部一致性等。在图像去噪中，假设图像的某些部分应该是平滑的或者连贯的，这就是一种内部先验。
• 应用：例如图像增强、去噪、去模糊等任务，通过分析和利用图像自身的统计特性和结构信息来提升处理效果。

外部先验：

• 定义：来自于输入图像之外的额外知识或数据的先验信息。
• 例子：预训练模型的权重、从大型数据集中学习到的统计规律等。在图像分类任务中，使用从大量标注数据中学到的特征，可以作为一种强有力的外部先验。
• 应用：例如图像识别、语义分割等任务，通过利用大规模数据训练的模型来提供外部先验，增强模型的泛化能力和准确性。

超分辨率中：

内部先验：

• 定义：利用图像自身的特性和结构信息来提高重建质量。
• 应用：在超分辨率任务中，内部先验可以帮助模型保留和强化图像的细节和纹理。例如，通过分析低分辨率图像中的边缘和纹理信息，可以生成更清晰、更细致的高分辨率图像。此外，内部先验还可以帮助模型减少噪声和伪影，使得重建结果更加自然。

外部先验：

• 定义：依靠外部数据或预训练模型的知识来辅助图像重建。
• 应用：在超分辨率任务中，外部先验通常通过预训练模型来实现。这些模型在大量高分辨率和低分辨率图像对上进行了训练，学到了如何从低分辨率图像中恢复出高分辨率细节。例如，GAN（生成对抗网络）和VDSR（超深卷积神经网络）等方法都依赖于外部先验，通过使用大规模数据集进行训练，模型能够捕捉到更丰富的细节和结构信息，从而生成质量更高的高分辨率图像。

③文章贡献

• CFTN自适应地将MRI特征的全局跨尺度自相似先验集成到深度网络中。
  • 全局跨尺度自相似性先验（the global cross-scale self-similarity priors）
    • “全局跨尺度自相似先验 (global cross-scale self-similarity priors)”是指在不同尺度（大小）上存在的全局图像特征的相似性。这些先验知识用于指导深度网络在图像处理任务中更好地重建和保留图像细节。
    • 在图像超分辨率等任务中，图像的局部区域可能在不同的尺度上显示出相似的模式。例如，一个物体的纹理或边缘在不同分辨率下可能看起来相似。利用这些自相似性先验，模型可以更有效地填补低分辨率图像中的细节，从而生成高质量的高分辨率图像。
• mutual-projection feature enhancement module（MFEM）
  • CFTN对整个MR特征内的跨尺度相关性进行建模，可以捕捉MR特征内的跨尺度自相似性先验。
• spatial attention fusion module（SAFM）
  • 通过空间注意力融合模块削弱无用的跨尺度特征并增强重要的信息区域。
  • 可以自适应地调整和融合目标尺度特征和上采样特征

2.网络结构（CFTN）

①residual channel attention block (RCAB)

• 作为主干网络的基本单元，该模块来自”RCAN”
• 

②mutual-projection feature enhancement module (MFEM)

• 原理：对于超分辨率等任务，在不同尺度上的特征有更丰富的细节和纹理。

• 结构:

  • 融合低尺度特征权重的$Y_m$与原始图片上采样残差连接后，组合为 $Y^{‘}_m$ 。输出带有 HR 细节的目标尺度特征 $Y^{‘}_m$ 和相应的下采样特征 $X^{‘}_m$
  • $X^{‘}_m$作为$RCAB_{m+1}$的输入，使网络探索更多跨尺度的信息。
  • 

• Cross-scale Transformer（CST）

  • 结构（通过transform结构可以学习到低尺度-高尺度对的相似性，可生成对应的权重）
    • 将输入的$x_m$降维得到$z_m$
    • embedding（1*1*1）：将高维的离散数据映射到低维的连续向量空间中，使得相似的数据点在向量空间中距离更近，分别展开形成V,Q,K
    • Q：高尺度图片序列，K：低尺度图片序列，通过size=p、stride=g，将序列展开为各p个块$q_i$ and $k_j$，即：
      • $$i \in \left[ 1 , \frac { H } { g } \times \frac { W } { g } \times \frac { L } { g } \right]$$
      • $$j \in \left[ 1 , \frac { H } { r g } \times \frac { W } { r g } \times \frac { L } { r g } \right]$$
    • 之后将两个特征矩阵进行点乘，并经过softmax层进行归一化，生成高-低对尺度图片的特征相似度的权重。
      • $$s _ { i , j } = \langle q _ { i } , k _ { j } \rangle$$
      • $$\omega _ { i , j } = \frac { e x p ( s _ { i , j } ) } { \sum _ { j } e x p ( s _ { i , j } ) }$$
    • 再将该权重与vi（高尺度，上升r倍）序列逐元素相乘得到具有跨尺度特征的$Y_m$
      • $$y _ { j } = \sum _ { j } \omega _ { i , j } \otimes v _ { j }$$
    • 最后通过转置卷积将$yj$序列折叠为高维的$y_m$
    • 

③spatial attention fusion module (SAFM)

• 上采样特征 Y 和 HR 特征 $Y^′_m$经过此模块产生准确的 HR 融合特征 $Y_f$
• 考虑到MFEM输出的目标尺度特征Y’m可能包含一些无用的重复信息，为了将Y’m更有意义的部分集成到主干网络中，利用空间注意力来自适应调整和融合特征。
• 参考前部分空间注意力机制
• 

二.文献二（ASFT）

• Adjacent slices feature transformer network for single anisotropic 3D brain MRI image super-resolution

1.文献介绍

主要贡献：

• 构建了 ASFT 网络，将脑 MRI 图像 SR 问题视为在各向异性脑 MRI 图像的相邻平面内切片中插入附加切片的任务。
• 多分支特征转换和提取（MFTE）块利用相邻平面内切片的相似性，变换相邻 HR 参考切片的特征，以丰富目标切片的细节。
• 使用SA方法来自适应细化空间特征，增强参考切片中有意义的特征区域并过滤掉无用的特征区域。此外，使用 CA 来学习多级特征的权重，以保留有助于提高 SR 性能的重要特征。
• 设计了一个内容和梯度混合损失函数来监督SR网络学习几何失真较少的精细纹理和上下文。内容和梯度项可以分别保持保真度并约束与相邻像素的关系。
• 创新性地将其转换为向高分辨率层面插入额外切片的问题，利用各向异性 3D MRI 图像的 3D 空间连续性与相邻切片的相似性，从高分辨率层面中自适应地学习与挖掘有利于提高目标切片分辨率的信息，从 2D 角度解决 3D MRI 图像的超分辨率问题。在此基础上，进一步提出基于图像梯度与内容的联合优化函数，保留 MRI 图像原有结构信息的同时,提升 3D MRI 图像的分辨率。

2.网络结构

• 

①initial feature extraction (IFE) operation

• ASFT由给定的LR脑部MRI图像$I _ { L R } \in R ^ { W \times H \times D }$以尺度因子s生成HR脑部MRI图像$I _ { S R } \in R ^ { W \times H \times s D }$

• $ x _ { I n } , x _ { I n } ^ { U } , x _ { I n } ^ { N } f r o m I _ { L R } ^ {\uparrow} , I _ { R e f } ^ { U } I _ { R e f } ^ { N }$，

  • 分为三个分支，$ X _ { I n } = \left\{ x _ { I n } ^ { U } , x _ { I n } , x _ { I n } ^ { N } \right\} .$
  • 上标 U 和 N 分别表示目标切片的前一个与后一个相邻的高分辨率切片

• 后分别通过卷积层初步提取特征得到$X _ { 1 } = \left\{ x _ { 1 } ^ { U } , x _ { 1 } , x _ { 1 } ^ { N } \right\}$

②feature mapping sub-network (FMNet)

• Multi-branch Features Transformation and Extraction
  • 主分支被用于提取多层次特征，上、下两个分支用于从相邻的高分辨率切片中提取特征并进行特征的转换，即对与目标切片不相关的特征信息进行抑制，相关的特征信息进行增强
  • 上下相近切片的两个分支将通过SA，之后采用沿通道方向的均值操作来融合所有分支的特征。
  • 

③reconstruction sub-network (RecNet)

• 通过SA增强较强特征，之后再进行一次融合并与原始图片残差连接得到最终输出