MobileNetV2: Inverted Residuals and Linear Bottlenecks

最新推荐文章于 2025-02-12 07:00:00 发布
最新推荐文章于 2025-02-12 07:00:00 发布
阅读量625 收藏
点赞数
分类专栏： deep learning pytorch paper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/seamanj/article/details/90676734
版权
博客提及数值转换，如从16到96再到24，指出中间值96由t确定，这里t为6，通过16乘以6得到96。

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

在这里插入图片描述
推荐阅读:https://blog.youkuaiyun.com/kangdi7547/article/details/81431572

16->96->24, 为什么中间有96怎么确定, 由t来确定, 这里t为6, 所以16*6 =96

MobileNetV2(
  (features): Sequential(
    (0): ConvBNReLU(
      (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU6(inplace)
    )
    (1): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False)
          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): Conv2d(32, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (2): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(16, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(96, 96, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=96, bias=False)
          (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(96, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (3): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(24, 144, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(144, 144, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=144, bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(144, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (4): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(24, 144, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(144, 144, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=144, bias=False)
          (1): BatchNorm2d(144, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(144, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (5): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (6): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (7): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(32, 192, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(192, 192, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=192, bias=False)
          (1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (8): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (9): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (10): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(384, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (11): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(64, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=384, bias=False)
          (1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(384, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (12): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (13): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (14): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(576, 576, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=576, bias=False)
          (1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(576, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (15): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(960, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (16): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(960, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (17): InvertedResidual(
      (conv): Sequential(
        (0): ConvBNReLU(
          (0): Conv2d(160, 960, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (1): ConvBNReLU(
          (0): Conv2d(960, 960, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=960, bias=False)
          (1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU6(inplace)
        )
        (2): Conv2d(960, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (3): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (18): ConvBNReLU(
      (0): Conv2d(320, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (1): BatchNorm2d(1280, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (2): ReLU6(inplace)
    )
  )
  (classifier): Sequential(
    (0): Dropout(p=0.2)
    (1): Linear(in_features=1280, out_features=1000, bias=True)
  )
)

Process finished with exit code 0
论文笔记：MobileNetV2: Inverted Residuals and Linear Bottlenecks
jinshuihe~_~
09-17 3459
MobileNetV2: Inverted Residuals and Linear Bottlenecks MobileNet V2是MobileNet V1的改进版。 MobileNet V1引入depthwise separable convolution代替standard convolution，减少运算量。 MobileNet V2主要的改进有两点： Linear Bottl...
论文阅读：MobileNetV2: Inverted Residuals and Linear Bottlenecks（MobileNetV2）
漩涡小林的博客
03-12 683
文章目录1 摘要2 存在问题3 亮点3.1 Linear Bottlenecks3.2 Inverted residual block3.4 总的结构体4 部分结果4.1 部分数据对比4.2 部分效果对比5 结论5.1 优势5.2 不足6 参考资料 1 摘要 本文基于MobileNetV1（戳这可以先了解一下MobileNetV1）的缺陷提出了MobileNetV2结构，并且详尽地分析介绍了...
《MobileNetV2: Inverted Residuals and Linear Bottlenecks》
胖胖大海的博客
07-18 2021
标准残差块： 1、使用1x1卷积减少通道数 2、使用NxN卷积提取特征 3、使用1x1卷积提升通道数，提升后与输入通道数相等 4、将残差块的输入与输出相加，形成short-cut连接 备注：标准残差块的通道数两头大，中间小 反向残差块（inverted residual）： 1、使用1x1卷积提升通道数 2、使用深度可分离卷积提取特征 3、使用1x1卷积减少通道数，减少后与输入通道数相等 4、将残差块的输入与输出相加，形成short-cut连接 备注：翻转残差块的通道数两头小，中间
MobileNetV2（2018 CVPR）
最新发布
朴实无华的研究生活
02-12 1094
本文介绍了MobileNetV2，一种新的移动架构，改进了多个任务和基准上的移动模型性能。MobileNetV2采用倒残差结构，其中捷径连接位于薄瓶颈层之间。中间扩展层使用轻量深度卷积来过滤特征。实验表明，去除瓶颈层中的非线性可以提高性能。MobileNetV2在ImageNet分类、COCO目标检测和PASCAL VOC图像分割任务上进行了评估，并展示了其在准确性和计算复杂度之间的权衡。该网络还。
【轻量级网络】MobileNetV2_ Inverted Residuals and Linear Bottlenecks
筱
08-16 365
paper：MobileNetV2 code：caffe pytorch 文章目录1、Preliminaries, discussion and intuition1.1、Depthwise Separable Convolutions1.2、Linear Bottlenecks Mobilenetv2核心模块是：inverted residual structure. 1、Prelimin...
论文阅读——MobileNetV2: Inverted Residuals and Linear Bottlenecks
qq_37151108的博客
05-19 1610
继续MobileNetv2. 改进：Inverted Residual connections & Linear Bottleneck 摘要： 在轻量级的MobileNetv1提出后，本文又将轻量级的思想应用于分割网络，精简了DeepLabv3用于分割。 
主要创新点在inverted residuals和linear bottleneck的提出。在网络瓶颈部分增加inverted residuals连接以及移除网络瓶颈部分的非线性，保证该部分的信息表达能力。最终在ImageNet分类、COCO物体
MobileNetV2:Inverted Residuals and Linear BottleNecks
abrams90的专栏
07-09 3135
摘要： 本文我们描述了一种新的mobile结构称为MobileNetV2，改进了模型在多个tasks与benchmarks以及不同大小模型的SOTA。我们还描述了一个将这些mobile模型应用在目标检测中的新框架，称为SSDLite。此外，我们还介绍了如何通过改进DeepLabv3构建我们称为DeepLabv3的mobile语义分割模型。网络基于反转残差结构，shortcut位于thin ...
mobilenetv2: inverted residuals and linear bottlenecks
06-06
MobileNetV2是一种轻量级的神经网络模型，其中使用了“倒置残差”和“线性瓶颈”的技术。倒置残差是指在每个卷积层之前添加一个轻量级的残差块，以减少计算量和参数数量。线性瓶颈是指在每个残差块中使用一个线性...
MobileNetV2：Inverted Residuals and Linear Bottlenecks
just
12-13 2208
①本文提出了一种新的移动端架构MobileNet V2，在当前移动端模型中最优；
MobileNetV2: Inverted Residuals and Linear Bottlenecks--M Sandler
xu.hyj
09-01 1292
本文描述了一种新的用于移动和嵌入式设备的架构MobileNetV2，该架构提高了多个任务和基准数据集上以及不同模型尺寸内的最佳性能。MobileNetV2基于倒置的残差结构，残差链接位于窄的瓶颈之间。中间层使用深度可分离卷积进行滤波（提取）特征。此外作者发现去除窄层的非线性对于保持表征能力非常重要然后在ImageNet分类、COCO对象检测、VOC图像分割上进行了性能测试。我们评估了精度和通过乘法加法(MAdd)度量的操作数量，以及实际延迟和参数数量之间的权衡。好!
轻量级网络——MobileNetV2
热门推荐
Clichong
05-16 4万+
1.MobileNetV2的介绍 MobileNet v2网络是由google团队在2018年提出的，相比MobileNet V1网络，准确率更高，模型更小。 网络中的亮点 ： Inverted Residuals （倒残差结构 ） Linear Bottlenecks（结构的最后一层采用线性层） 2.MobileNetV2的结构 1）Inverted Residuals 在之前的ResNet残差结构是先用1x1的卷积降维，再升维的操作。而在MobileNetV2中，是先升维，在降维的操作。 所以对于
MobileNetV2: Inverted Residuals and Linear Bottlenecks(MobileNetV2)-论文阅读笔记
weixin_43749999的博客
05-09 2596
MobileNetV2: Inverted Residuals and Linear Bottlenecks MobileNetV2论文阅读笔记 //2022.5.8下午12:35开始阅读 论文地址 MobileNetV2: Inverted Residuals and Linear Bottlenecks | IEEE Conference Publication | IEEE Xplore 论文目的 提出了一种新的移动端的网络架构模型，MobileNetV2网络。然后，作者还描述
MobileNetV2 ：Inverted Residuals and Linear Bottlenecks
女王の专属领地
04-22 9115
论文链接 | https://arxiv.org/abs/1704.04861论文源码 | https://github.com/Randl/MobileNet2-pytorch/摘要：介绍了一种新的移动端架构——MobileNetV2，其在多任务和基准以及不同模型大小的范围上进一步刷新了移动端模型的当前最佳性能。介绍了如何通过全新框架 SSDLite 将这些模型高效应用于目标检测。展示了通过简化...
轻量化网络（二）MobileNetV2: Inverted Residuals and Linear Bottlenecks
shentu7的博客
04-12 566
论文链接 Pytorch实现 Tensorflow实现 Mobilenet V2是谷歌在Mobilenet V1上的进一步改进，第一版参考文章，是Mobilenet系列的第二篇。该文章以深度可分离卷积(Depthwise Separable Convolutions)为基础提出了Inverted Residuals and Linear Bottlenecks，深度可分离卷积在许多神经网络中有很大...
MobileNetV2
qq_67654130的博客
11-21 1710
是一种轻量级的卷积神经网络架构，旨在提高移动设备和嵌入式设备上的深度学习模型的效率，尤其是在资源有限的环境下（如计算能力、内存和存储空间）。： 由于采用了轻量化的设计，MobileNetV2 在许多设备上可以实现快速的推理时间，尤其在没有强大硬件支持的情况下（如手机或物联网设备）。MobileNetV2 的设计目标是优化计算效率，使得它能够在移动设备上运行而不会牺牲太多的精度。这种结构能够在较低的计算成本下，提取高效的图像特征，非常适合用于移动设备等计算资源有限的场景。，它和传统的残差模块有所不同。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值