(即插即用模块-Attention部分) 三十六、(2023) DCA 二重交叉注意力

最新推荐文章于 2025-03-13 17:54:12 发布
最新推荐文章于 2025-03-13 17:54:12 发布
阅读量1.9k 收藏 23
点赞数 32
分类专栏： 即插即用-Attention 文章标签： 注意力机制 深度学习 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wei582636312/article/details/144892288
版权

在这里插入图片描述

文章目录

paper：Dual Cross-Attention for Medical Image Segmentation

Code：https://github.com/gorkemcanates/Dual-Cross-Attention

1、Dual Cross-Attention

U-Net 及其变体尽管在医学图像分割任务中取得了良好的性能，但仍然存在一些局限性，具体来说，卷积操作的局部性： 无法捕捉不同特征之间的长距离依赖关系。跳跃连接的语义差距： 简单地连接编码器和解码器特征会导致语义信息丢失，难以有效地融合低级特征。为了解决这些问题，这篇论文提出一种 二重交叉注意力（Dual Cross-Attention）。DCA 模块利用交叉注意力机制，有效地提取多尺度编码器特征中的通道和空间依赖关系，从而缩小编码器和解码器之间的语义差距。

DCA 的基本思想包括以下两点：通道交叉注意力（CCA）： 利用交叉注意力机制捕捉多尺度编码器特征中的通道依赖关系，提取全局通道信息。空间交叉注意力（SCA）： 利用交叉注意力机制捕捉多尺度编码器特征中的空间依赖关系，提取全局空间信息。DCA 模块通过将 CCA 和 SCA 模块串联使用，首先通过 CCA 提取全局通道信息，然后将 CCA 的输出作为 SCA 的输入，进一步提取全局空间信息。这种串联方式可以更有效地融合低级特征，并提取更精细的特征表示。

对于输入X，DCA的实现过程：

  1. 多尺度特征提取： 从编码器网络的多个阶段提取多尺度特征。
  2. Patch Embedding： 使用二维平均池化将多尺度特征转换为 tokens，并通过深度可分离卷积进行投影。
  3. CCA： 对每个 token 进行层归一化，并将其沿着通道维度拼接，形成 keys 和 values。使用深度可分离卷积进行线性投影，然后进行交叉注意力操作，提取全局通道信息。
  4. SCA： 对 CCA 的输出进行层归一化，并将其沿着通道维度拼接，形成 queries 和 keys。使用深度可分离卷积进行线性投影，并将每个 token 作为 values。进行交叉注意力操作，提取全局空间信息。
  5. 上采样和连接： 将 DCA 的输出进行层归一化和 GeLU 激活，然后进行上采样，并连接到解码器网络中。

Dual Cross-Attention 结构图：
在这里插入图片描述


DCA Block with U-Net 结构图：
在这里插入图片描述

2、代码实现

import  torch
import torch.nn as nn
import einops


class depthwise_conv_block(nn.Module):
    def __init__(self,
                 in_features,
                 out_features,
                 kernel_size=(3, 3),
                 stride=(1, 1),
                 padding=(1, 1),
                 dilation=(1, 1),
                 groups=None,
                 norm_type='bn',
                 activation=True,
                 use_bias=True,
                 pointwise=False,
                 ):
        super().__init__()
        self.pointwise = pointwise
        self.norm = norm_type
        self.act = activation
        self.depthwise = nn.Conv2d(
            in_channels=in_features,
            out_channels=in_features if pointwise else out_features,
            kernel_size=kernel_size,
            stride=stride,
            padding=padding,
            groups=groups,
            dilation=dilation,
            bias=use_bias)
        if pointwise:
            self.pointwise = nn.Conv2d(in_features,
                                       out_features,
                                       kernel_size=(1, 1),
                                       stride=(1, 1),
                                       padding=(0, 0),
                                       dilation=(1, 1),
                                       bias=use_bias)

        self.norm_type = norm_type
        self.act = activation

        if self.norm_type == 'gn':
            self.norm = nn.GroupNorm(32 if out_features >= 32 else out_features, out_features)
        if self.norm_type == 'bn':
            self.norm = nn.BatchNorm2d(out_features)
        if self.act:
            self.relu = nn.ReLU(inplace=False)

    def forward(self, x):
        x = self.depthwise(x)
        if self.pointwise:
            x = self.pointwise(x)
        if self.norm_type is not None:
            x = self.norm(x)
        if self.act:
            x = self.relu(x)
        return x


class conv_block(nn.Module):
    def __init__(self,
                 in_features,
                 out_features,
                 kernel_size=(3, 3),
                 stride=(1, 1),
                 padding=(1, 1),
                 dilation=(1, 1),
                 norm_type='bn',
                 activation=True,
                 use_bias=True,
                 ):
        super().__init__()
        self.conv = nn.Conv2d(in_channels=in_features,
                              out_channels=out_features,
                              kernel_size=kernel_size,
                              stride=stride,
                              padding=padding,
                              dilation=dilation,
                              bias=use_bias)

        self.norm_type = norm_type
        self.act = activation

        if self.norm_type == 'gn':
            self.norm = nn.GroupNorm(32 if out_features >= 32 else out_features, out_features)
        if self.norm_type == 'bn':
            self.norm = nn.BatchNorm2d(out_features)
        if self.act:
            self.relu = nn.ReLU(inplace=False)

    def forward(self, x):
        x = self.conv(x)
        if self.norm_type is not None:
            x = self.norm(x)
        if self.act:
            x = self.relu(x)
        return x


class ScaleDotProduct(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.softmax = nn.Softmax(dim=-1)

    def forward(self, x1, x2, x3, scale):
        x2 = x2.transpose(-2, -1)
        x12 = torch.einsum('bhcw, bhwk -> bhck', x1, x2) * scale
        att = self.softmax(x12)
        x123 = torch.einsum('bhcw, bhwk -> bhck', att, x3)
        return x123


class PoolEmbedding(nn.Module):
    def __init__(self,
                 pooling,
                 patch,
                 ) -> None:
        super().__init__()
        self.projection = pooling(output_size=(patch, patch))

    def forward(self, x):
        x = self.projection(x)
        x = einops.rearrange(x, 'B C H W -> B (H W) C')
        return x


class depthwise_projection(nn.Module):
    def __init__(self,
                 in_features,
                 out_features,
                 groups,
                 kernel_size=(1, 1),
                 padding=(0, 0),
                 norm_type=None,
                 activation=False,
                 pointwise=False) -> None:
        super().__init__()

        self.proj = depthwise_conv_block(in_features=in_features,
                                         out_features=out_features,
                                         kernel_size=kernel_size,
                                         padding=padding,
                                         groups=groups,
                                         pointwise=pointwise,
                                         norm_type=norm_type,
                                         activation=activation)

    def forward(self, x):
        P = int(x.shape[1] ** 0.5)
        x = einops.rearrange(x, 'B (H W) C-> B C H W', H=P)
        x = self.proj(x)
        x = einops.rearrange(x, 'B C H W -> B (H W) C')
        return x


class UpsampleConv(nn.Module):
    def __init__(self,
                 in_features,
                 out_features,
                 kernel_size=(3, 3),
                 padding=(1, 1),
                 norm_type=None,
                 activation=False,
                 scale=(2, 2),
                 conv='conv') -> None:
        super().__init__()
        self.up = nn.Upsample(scale_factor=scale,
                              mode='bilinear',
                              align_corners=True)
        if conv == 'conv':
            self.conv = conv_block(in_features=in_features,
                                   out_features=out_features,
                                   kernel_size=(1, 1),
                                   padding=(0, 0),
                                   norm_type=norm_type,
                                   activation=activation)
        elif conv == 'depthwise':
            self.conv = depthwise_conv_block(in_features=in_features,
                                             out_features=out_features,
                                             kernel_size=kernel_size,
                                             padding=padding,
                                             norm_type=norm_type,
                                             activation=activation)

    def forward(self, x):
        x = self.up(x)
        x = self.conv(x)
        return x


class ChannelAttention(nn.Module):
    def __init__(self, in_features, out_features, n_heads=1) -> None:
        super().__init__()
        self.n_heads = n_heads
        self.q_map = depthwise_projection(in_features=out_features,
                                          out_features=out_features,
                                          groups=out_features)
        self.k_map = depthwise_projection(in_features=in_features,
                                          out_features=in_features,
                                          groups=in_features)
        self.v_map = depthwise_projection(in_features=in_features,
                                          out_features=in_features,
                                          groups=in_features)

        self.projection = depthwise_projection(in_features=out_features,
                                               out_features=out_features,
                                               groups=out_features)
        self.sdp = ScaleDotProduct()

    def forward(self, x):
        q, k, v = x[0], x[1], x[2]
        q = self.q_map(q)
        k = self.k_map(k)
        v = self.v_map(v)
        b, hw, c_q = q.shape
        c = k.shape[2]
        scale = c ** -0.5
        q = q.reshape(b, hw, self.n_heads, c_q // self.n_heads).permute(0, 2, 1, 3).transpose(2, 3)
        k = k.reshape(b, hw, self.n_heads, c // self.n_heads).permute(0, 2, 1, 3).transpose(2, 3)
        v = v.reshape(b, hw, self.n_heads, c // self.n_heads).permute(0, 2, 1, 3).transpose(2, 3)
        att = self.sdp(q, k, v, scale).permute(0, 3, 1, 2).flatten(2)
        att = self.projection(att)
        return att


class SpatialAttention(nn.Module):
    def __init__(self, in_features, out_features, n_heads=4) -> None:
        super().__init__()
        self.n_heads = n_heads

        self.q_map = depthwise_projection(in_features=in_features,
                                          out_features=in_features,
                                          groups=in_features)
        self.k_map = depthwise_projection(in_features=in_features,
                                          out_features=in_features,
                                          groups=in_features)
        self.v_map = depthwise_projection(in_features=out_features,
                                          out_features=out_features,
                                          groups=out_features)

        self.projection = depthwise_projection(in_features=out_features,
                                               out_features=out_features,
                                               groups=out_features)
        self.sdp = ScaleDotProduct()

    def forward(self, x):
        q, k, v = x[0], x[1], x[2]
        q = self.q_map(q)
        k = self.k_map(k)
        v = self.v_map(v)
        b, hw, c = q.shape
        c_v = v.shape[2]
        scale = (c // self.n_heads) ** -0.5
        q = q.reshape(b, hw, self.n_heads, c // self.n_heads).permute(0, 2, 1, 3)
        k = k.reshape(b, hw, self.n_heads, c // self.n_heads).permute(0, 2, 1, 3)
        v = v.reshape(b, hw, self.n_heads, c_v // self.n_heads).permute(0, 2, 1, 3)
        att = self.sdp(q, k, v, scale).transpose(1, 2).flatten(2)
        x = self.projection(att)
        return x


class CCSABlock(nn.Module):
    def __init__(self,
                 features,
                 channel_head,
                 spatial_head,
                 spatial_att=True,
                 channel_att=True) -> None:
        super().__init__()
        self.channel_att = channel_att
        self.spatial_att = spatial_att
        if self.channel_att:
            self.channel_norm = nn.ModuleList([nn.LayerNorm(in_features,
                                                            eps=1e-6)
                                               for in_features in features])

            self.c_attention = nn.ModuleList([ChannelAttention(
                in_features=sum(features),
                out_features=feature,
                n_heads=head,
            ) for feature, head in zip(features, channel_head)])
        if self.spatial_att:
            self.spatial_norm = nn.ModuleList([nn.LayerNorm(in_features,
                                                            eps=1e-6)
                                               for in_features in features])

            self.s_attention = nn.ModuleList([SpatialAttention(
                in_features=sum(features),
                out_features=feature,
                n_heads=head,
            )
                for feature, head in zip(features, spatial_head)])

    def forward(self, x):
        if self.channel_att:
            x_ca = self.channel_attention(x)
            x = self.m_sum(x, x_ca)
        if self.spatial_att:
            x_sa = self.spatial_attention(x)
            x = self.m_sum(x, x_sa)
        return x

    def channel_attention(self, x):
        x_c = self.m_apply(x, self.channel_norm)
        x_cin = self.cat(*x_c)
        x_in = [[q, x_cin, x_cin] for q in x_c]
        x_att = self.m_apply(x_in, self.c_attention)
        return x_att

    def spatial_attention(self, x):
        x_c = self.m_apply(x, self.spatial_norm)
        x_cin = self.cat(*x_c)
        x_in = [[x_cin, x_cin, v] for v in x_c]
        x_att = self.m_apply(x_in, self.s_attention)
        return x_att

    def m_apply(self, x, module):
        return [module[i](j) for i, j in enumerate(x)]

    def m_sum(self, x, y):
        return [xi + xj for xi, xj in zip(x, y)]

    def cat(self, *args):
        return torch.cat((args), dim=2)


class DCA(nn.Module):
    def __init__(self,
                 features,
                 strides=[8,4,2,1],
                 patch=28,
                 channel_att=True,
                 spatial_att=True,
                 n=1,
                 channel_head=[1, 1, 1, 1],
                 spatial_head=[4, 4, 4, 4],
                 ):
        super().__init__()
        self.n = n
        self.features = features
        self.spatial_head = spatial_head
        self.channel_head = channel_head
        self.channel_att = channel_att
        self.spatial_att = spatial_att
        self.patch = patch
        self.patch_avg = nn.ModuleList([PoolEmbedding(
            pooling=nn.AdaptiveAvgPool2d,
            patch=patch,
        )
            for _ in features])
        self.avg_map = nn.ModuleList([depthwise_projection(in_features=feature,
                                                           out_features=feature,
                                                           kernel_size=(1, 1),
                                                           padding=(0, 0),
                                                           groups=feature
                                                           )
                                      for feature in features])

        self.attention = nn.ModuleList([
            CCSABlock(features=features,
                      channel_head=channel_head,
                      spatial_head=spatial_head,
                      channel_att=channel_att,
                      spatial_att=spatial_att)
            for _ in range(n)])

        self.upconvs = nn.ModuleList([UpsampleConv(in_features=feature,
                                                   out_features=feature,
                                                   kernel_size=(1, 1),
                                                   padding=(0, 0),
                                                   norm_type=None,
                                                   activation=False,
                                                   scale=stride,
                                                   conv='conv')
                                      for feature, stride in zip(features, strides)])
        self.bn_relu = nn.ModuleList([nn.Sequential(
            nn.BatchNorm2d(feature),
            nn.ReLU()
        )
            for feature in features])

    def forward(self, raw):
        x = self.m_apply(raw, self.patch_avg)
        x = self.m_apply(x, self.avg_map)
        for block in self.attention:
            x = block(x)
        x = [self.reshape(i) for i in x]
        x = self.m_apply(x, self.upconvs)
        x_out = self.m_sum(x, raw)
        x_out = self.m_apply(x_out, self.bn_relu)
        return (*x_out,)

    def m_apply(self, x, module):
        return [module[i](j) for i, j in enumerate(x)]

    def m_sum(self, x, y):
        return [xi + xj for xi, xj in zip(x, y)]

    def reshape(self, x):
        return einops.rearrange(x, 'B (H W) C-> B C H W', H=self.patch)


if __name__ == '__main__':
    x = torch.randn(4, 32, 224, 224)
    y = torch.randn(4, 64, 112, 112)
    z = torch.randn(4, 128, 56, 56)
    v = torch.randn(4, 256, 28, 28)
    model = DCA([32,64,128,256])
    output1, output2, output3, output4 = model((x,y,z,v))
    print(output1.shape)
    print(output2.shape)
    print(output3.shape)
    print(output4.shape)
Unet 改进：添加双交叉注意力模块（DCA）
Henry的博客
02-05 422
交叉注意力允许一个序列中的元素关注另一个序列中的元素，常用于处理多模态数据（如图像和文本）。DCA包含两个交叉注意力模块，分别处理两个不同方向的信息交互，确保双向的信息流动和融合。使用模态B的特征作为查询，模态A的特征作为键和值，再次计算注意力权重并加权求和。反过来，图像特征作为查询，文本特征作为键和值，生成与图像相关的文本特征表示。使用模态A的特征作为查询，模态B的特征作为键和值，计算注意力权重并加权求和。例如，文本特征作为查询，图像特征作为键和值，生成与文本相关的图像特征表示。：适用于多种多模态任务。
[论文笔记] DCA（Dual Chunk Attention）
心宝的博客
07-23 2083
DCA 通过分块处理和分步注意力计算，巧妙地解决了长文本处理中的计算和内存瓶颈问题，使得模型在处理长文本时既高效又有效。
Unet 改进添加双交叉注意力模块（DCA）
02-04
Unet 改进添加双交叉注意力模块（DCA），可以直接替换主干网络
U-Net结构改进：双交叉注意力模块（DCA）——图像分割的新突破
2401_82355416的博客
03-13 1139
本文提出了一种新颖的双交叉注意力模块（DCA），并将其成功应用于U-Net架构中。实验结果表明，DCA模块能够有效捕捉长距离依赖关系和多尺度特征，显著提升图像分割的性能。未来，我们将从以下几个方面进一步探索DCA模块的潜力：1. 扩展到其他网络结构：将DCA模块应用于其他图像分割网络（如DeepLab、PSPNet等），验证其通用性。2. 应用于其他视觉任务：探索DCA模块在目标检测、图像生成等任务中的应用。3. 优化计算效率：进一步优化DCA模块的计算复杂度，使其更适合实际应用场景。
推荐文章：双交叉注意力在医学影像分割中的突破 - DCA框架解析
gitblog_00188的博客
09-12 675
推荐文章：双交叉注意力在医学影像分割中的突破 - DCA框架解析 项目地址:https://gitcode.com/gh_mirrors/du/Dual-Cross-Attention 项目介绍 在医疗领域，准确的影像分割是临床诊断和治疗计划制定的关键。近年来，基于深度学习的方法，特别是U-Net及其变种，在这一任务上取得了显著进展。然而，如何高效融合编码器与解码器间的多尺度特征信息，一直是提升模...
【Attention】用于医学图像分割的双重交叉注意力
qq_43583311的博客
11-20 1166
提出了一种简单而有效的注意力模块--DCA，以改进基于 U-Net 架构的跳转连接方案，这种方案在编码器和解码器特征之间引入了语义鸿沟，限制了分割性能。交叉关注机制使模型能够捕捉不同尺度的依赖关系，从而获得更好的特征表征。
U-Net结构改进：双交叉注意力模块（DCA）
热门推荐
记录
05-07 2万+
本文由迈阿密大学的研究团队于2023年3月30日发表，提出了双交叉注意力模块（Dual Cross-Attention , DCA），其目标是在轻微的参数和复杂性增加的情况下改进U-Net及其变体，能够简单而有效地增强u-net结构中的跳跃连接（skip-connection）。
Dual Cross-Attention Learning for Fine-Grained Visual Categorization and Object Re-Identification
Howie_123的博客
11-14 1787
自我注意力机制能够捕获序列特征和全局信息，被广泛应用于各种NLP和CV任务中，并提高了其性能。本工作致力于研究若何将自我注意力机制进行扩展以更好地在识别细粒度物体（如不同种类的鸟或人的身份识别）时更好地对微妙的嵌入特征进行学习。为此，我们提出了与自我注意力学习相配合的双交叉注意力学习（DCAL）算法。首先，我们提出了全局-局部交叉注意力来促进全局图像和局部高响应图像区域之间的信息交互，这有助于加强空间上的识别线索。其次，我们提出了逐对交叉注意力（PWCA）来建立图像对之间的交互。
双交叉注意学习用于细粒度视觉分类和目标重新识别
qq_45745941的博客
04-09 1408
探索了如何扩展自注意模块，以更好地学习识别细粒度对象的微妙特征嵌入，例如，不同的鸟类物种或人的身份。方法提出了一种双交叉注意学习(DCAL)算法来协调自注意学习。首先，提出了全局-局部交叉注意(GLCA)来增强全局图像与局部高响应区域之间的相互作用，这有助于增强识别的空间识别线索。其次，提出了成对交叉注意(PWCA)来建立图像对之间的相互作用。PWCA可以通过将另一幅图像作为干扰物来规范图像的注意力学习，并在推理过程中被移除。
长语句语音合成--Dynamic Convolution Attention (DCA)
zephyr_wang的博客
11-21 642
1 简介 本文根据2020年《LOCATION-RELATIVE ATTENTION MECHANISMS FOR ROBUST LONG-FORM SPEECH SYNTHESIS》翻译总结的。 基于注意力的端到端的text-to-speech (TTS) 系统尽管有能力在域内产生人类水平的语音合成，但在域外文本处理上容易出现文本对齐失败的情况。这些失败很可能是因为采用了简单的location-relative 注意力机制，其废除了基于内容的query/key比较。我们比较了两种注意力机制：locatio
DCANet:深度连接注意力网络
04-24
深度连接注意力网络（DCANet） 插图 图1. DCANet的示意图。 我们使用Grad-CAM可视化中间特征激活。 Vanilla SE-ResNet50在不同阶段的关注点发生了巨大变化。 相比之下，我们的DCA逐步增强了SE-ResNet50的递归调整焦点，并密切关注目标对象。 方法 图2.深度连接注意力网络概述。 我们将先前关注块中的转换模块的输出连接到当前关注块中的提取模块的输出。 在多个关注维度的上下文中，我们将关注沿着每个维度连接起来。 在这里，我们展示了一个具有两个注意维度的示例。 可以扩展到更大的尺寸。 执行 在此存储库中，所有模型都由实现。 我们在使用标准的数据扩充策略。 要复制我们的DCANet作品，请参考 。 训练有素的模型 :smiling_face_with_smiling_eyes: All trained models and training log files are submitted to an an
交叉注意力一脚踹进医学图像分割！新成果精度、效率表现SOTA
学姐带你玩AI的博客
06-21 2347
为解决传统方法的局限性，研究者们提出了交叉注意力机制能更有效地整合来自不同模态/尺度的特征，让模型同时捕捉全局和局部信息，加速学习并减少干扰。因此这种策略成为了目前医学图像领域的重要研究方向，为我们实现更高的综合性能提供了新的解决思路。本次分享，开源代码已附，论文创新点做了简单提炼，供大家参考学习寻找灵感。论文原文以及开源代码需要的同学看文末。
双交叉注意力模块（DCA）
最新发布
03-16
### 双交叉注意力模块（DCA）概述 双交叉注意力模块（Dual Cross Attention, DCA）是一种旨在提升模型对复杂场景理解能力的技术方案。其核心理念在于通过引入双向注意力机制，增强特征表示的能力并改善目标检测或...
基于双重交叉注意的医学图像分割
qq_45745941的博客
04-06 3747
提出了双交叉注意(Dual Cross-Attention, DCA)，能够增强u - net架构下医学图像分割的跳过连接。DCA通过连续捕获跨多尺度编码器特征的通道和空间依赖关系来解决编码器和解码器特征之间的语义差距。
【注意力机制】《DCANet： Learning Connected Attentions for Convolutional Neural Networks》
猫猫与橙子的博客
09-03 2608
文章链接：https://arxiv.org/abs/2007.05099 作者团队：北德克萨斯州大学 目录 1.Abstract 2.Deep Connected Attention 2.1Revisiting Self-Attention Blocks 2.2 Attention Connection 2.3 Size Matching 2.4 Multi-dimensional attention connection 4.Experiments 4.1 Classificatio
注意力机制代码_增强注意力！DCANet：学习卷积神经网络的连接注意力
weixin_39929465的博客
12-09 447
DCANet: Learning Connected Attentions for Convolutional Neural Networks论文下载链接：https://arxiv.org/abs/2007.05099注：如果上述链接无法访问或者下载速度过慢，可以看文末，已上传至百度云，方便下载本文深入探索自注意力机制，并提出即插即用的DCA模块，增强你的注意力模型，提高网络性能！如DCA-CB...
论文笔记Dual Cross-Attention for Medical Image Segmentation
Stark_Z的博客
04-18 1651
用于医学图像分割的双交叉注意力
探索深度连接注意力网络：DCANet 的魅力与潜力
gitblog_00033的博客
06-23 460
探索深度连接注意力网络：DCANet 的魅力与潜力 去发现同类优质开源项目:https://gitcode.com/ 在人工智能领域，尤其是在计算机视觉中，深度学习模型的性能和效率始终是核心关注点。今天，我们向您推荐一个创新的开源项目——Deep Connected Attention Networks（DCANet），它以独特的方式改进了现有的卷积神经网络结构，使其能更有效地聚焦于关键信息。 项...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

御宇w

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

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

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

打赏作者

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

抵扣说明：

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

余额充值