Inception-v4（GoogLeNet-v4）模型框架（PyTorch）

最新推荐文章于 2024-07-23 20:00:00 发布
最新推荐文章于 2024-07-23 20:00:00 发布
阅读量5.6k 收藏 56
点赞数 7
分类专栏： 常见CNN模型框架 文章标签： 深度学习 卷积神经网络 cv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41978493/article/details/107676194
版权

I. 前言

Inception-v4，又名GoogLeNet-v4，论文地址：Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning，该论文将Inception-v3与Inception-v4相比，此外还与ResNet结合，提出了Inception-ResNet-A及Inception-ResNet-B两个模型。本文只针对Inception-v4部分的模型框架进行复现。

II. 模型构架图

在这里插入图片描述

III. 各部分构架图

1. Stem


【注】标“V”即valid-padding，padding=0，否则为same-padding，需手动计算出每处所需的padding数.

2. Inception-A

在这里插入图片描述
【注】此处的Avg Pooling的kernel_size为3， padding为1， stride为1，下同.

3. Inception-B

在这里插入图片描述
【注】不对称卷积核的padding，如conv17的padding为（0,3），conv71的padding为（3,0），conv13及conv31的padding分别为（0,1）及（1,0）.

4. Inception-C

在这里插入图片描述

5. Reduction-A

在这里插入图片描述
【注】此处根据论文中的表格，k=192、l=224、m=256、n=384.

6. Reduction-B

在这里插入图片描述

IV. 代码复现

import torch
import torch.nn as nn
import torch.nn.functional as F

定义一个卷积模块（带BatchNormalization及ReLU激活函数）

class BasicConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, **kwargs):
        super(BasicConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)
        self.bn = nn.BatchNorm2d(out_channels)
        
    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        return F.relu(x)

InceptionA模块

class InceptionA(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(InceptionA, self).__init__()
        #branch1: avgpool --> conv1*1(96)
        self.b1_1 = nn.AvgPool2d(kernel_size=3, padding=1, stride=1)
        self.b1_2 = BasicConv2d(in_channels, 96, kernel_size=1)
        
        #branch2: conv1*1(96)
        self.b2 = BasicConv2d(in_channels, 96, kernel_size=1)
        
        #branch3: conv1*1(64) --> conv3*3(96)
        self.b3_1 = BasicConv2d(in_channels, 64, kernel_size=1)
        self.b3_2 = BasicConv2d(64, 96, kernel_size=3, padding=1)
        
        #branch4: conv1*1(64) --> conv3*3(96) --> conv3*3(96)
        self.b4_1 = BasicConv2d(in_channels, 64, kernel_size=1)
        self.b4_2 = BasicConv2d(64, 96, kernel_size=3, padding=1)
        self.b4_3 = BasicConv2d(96, 96, kernel_size=3, padding=1)
        
    def forward(self, x):
        y1 = self.b1_2(self.b1_1(x))
        y2 = self.b2(x)
        y3 = self.b3_2(self.b3_1(x))
        y4 = self.b4_3(self.b4_2(self.b4_1(x)))
        
        outputsA = [y1, y2, y3, y4]
        return torch.cat(outputsA, 1)

InceptionB模块

class InceptionB(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(InceptionB, self).__init__()
        #branch1: avgpool --> conv1*1(128)
        self.b1_1 = nn.AvgPool2d(kernel_size=3, padding=1, stride=1)
        self.b1_2 = BasicConv2d(in_channels, 128, kernel_size=1)
        
        #branch2: conv1*1(384)
        self.b2 = BasicConv2d(in_channels, 384, kernel_size=1)
        
        #branch3: conv1*1(192) --> conv1*7(224) --> conv1*7(256)
        self.b3_1 = BasicConv2d(in_channels, 192, kernel_size=1)
        self.b3_2 = BasicConv2d(192, 224, kernel_size=(1,7), padding=(0,3))
        self.b3_3 = BasicConv2d(224, 256, kernel_size=(1,7), padding=(0,3))
        
        #branch4: conv1*1(192) --> conv1*7(192) --> conv7*1(224) --> conv1*7(224) --> conv7*1(256)
        self.b4_1 = BasicConv2d(in_channels, 192, kernel_size=1, stride=1)
        self.b4_2 = BasicConv2d(192, 192, kernel_size=(1,7), padding=(0,3))
        self.b4_3 = BasicConv2d(192, 224, kernel_size=(7,1), padding=(3,0))
        self.b4_4 = BasicConv2d(224, 224, kernel_size=(1,7), padding=(0,3))
        self.b4_5 = BasicConv2d(224, 256, kernel_size=(7,1), padding=(3,0))
        
    def forward(self, x):
        y1 = self.b1_2(self.b1_1(x))
        y2 = self.b2(x)
        y3 = self.b3_3(self.b3_2(self.b3_1(x)))
        y4 = self.b4_5(self.b4_4(self.b4_3(self.b4_2(self.b4_1(x)))))
        
        outputsB = [y1, y2, y3, y4]
        return torch.cat(outputsB, 1)

InceptionC模块

class InceptionC(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(InceptionC, self).__init__()
        #branch1: avgpool --> conv1*1(256)
        self.b1_1 = nn.AvgPool2d(kernel_size=3, padding=1, stride=1)
        self.b1_2 = BasicConv2d(in_channels, 256, kernel_size=1)
        
        #branch2: conv1*1(256)
        self.b2 = BasicConv2d(in_channels, 256, kernel_size=1)
        
        #branch3: conv1*1(384) --> conv1*3(256) & conv3*1(256)
        self.b3_1 = BasicConv2d(in_channels, 384, kernel_size=1)
        self.b3_2_1 = BasicConv2d(384, 256, kernel_size=(1,3), padding=(0,1))
        self.b3_2_2 = BasicConv2d(384, 256, kernel_size=(3,1), padding=(1,0))
        
        #branch4: conv1*1(384) --> conv1*3(448) --> conv3*1(512) --> conv3*1(256) & conv7*1(256)
        self.b4_1 = BasicConv2d(in_channels, 384, kernel_size=1, stride=1)
        self.b4_2 = BasicConv2d(384, 448, kernel_size=(1,3), padding=(0,1))
        self.b4_3 = BasicConv2d(448, 512, kernel_size=(3,1), padding=(1,0))
        self.b4_4_1 = BasicConv2d(512, 256, kernel_size=(3,1), padding=(1,0))
        self.b4_4_2 = BasicConv2d(512, 256, kernel_size=(1,3), padding=(0,1))
        
    def forward(self, x):
        y1 = self.b1_2(self.b1_1(x))
        y2 = self.b2(x)
        y3_1 = self.b3_2_1(self.b3_1(x))
        y3_2 = self.b3_2_2(self.b3_1(x))
        y4_1 = self.b4_4_1(self.b4_3(self.b4_2(self.b4_1(x))))
        y4_2 = self.b4_4_2(self.b4_3(self.b4_2(self.b4_1(x))))
        
        outputsC = [y1, y2, y3_1, y3_2, y4_1, y4_2]
        return torch.cat(outputsC, 1)

ReductionA模块

class ReductionA(nn.Module):
    def __init__(self, in_channels, out_channels, k, l, m, n):
        super(ReductionA, self).__init__()
        #branch1: maxpool3*3(stride2 valid)
        self.b1 = nn.MaxPool2d(kernel_size=3, stride=2)
        
        #branch2: conv3*3(n stride2 valid)
        self.b2 = BasicConv2d(in_channels, n, kernel_size=3, stride=2)
        
        #branch3: conv1*1(k) --> conv3*3(l) --> conv3*3(m stride2 valid)
        self.b3_1 = BasicConv2d(in_channels, k, kernel_size=1)
        self.b3_2 = BasicConv2d(k, l, kernel_size=3, padding=1)
        self.b3_3 = BasicConv2d(l, m, kernel_size=3, stride=2)
        
    def forward(self, x):
        y1 = self.b1(x)
        y2 = self.b2(x)
        y3 = self.b3_3(self.b3_2(self.b3_1(x)))
        
        outputsRedA = [y1, y2, y3]
        return torch.cat(outputsRedA, 1)

ReductionB模块

class ReductionB(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(ReductionB, self).__init__()
        #branch1: maxpool3*3(stride2 valid)
        self.b1 = nn.MaxPool2d(kernel_size=3, stride=2)
        
        #branch2: conv1*1(192) --> conv3*3(192 stride2 valid)
        self.b2_1 = BasicConv2d(in_channels, 192, kernel_size=1)
        self.b2_2 = BasicConv2d(192, 192, kernel_size=3, stride=2)
        
        #branch3: conv1*1(256) --> conv1*7(256) --> conv7*1(320) --> conv3*3(320 stride2 valid)
        self.b3_1 = BasicConv2d(in_channels, 256, kernel_size=1)
        self.b3_2 = BasicConv2d(256, 256, kernel_size=(1,7), padding=(0,3))
        self.b3_3 = BasicConv2d(256, 320, kernel_size=(7,1), padding=(3,0))
        self.b3_4 = BasicConv2d(320, 320, kernel_size=3, stride=2)
        
    def forward(self, x):
        y1 = self.b1(x)
        y2 = self.b2_2(self.b2_1((x)))
        y3 = self.b3_4(self.b3_3(self.b3_2(self.b3_1(x))))
        
        outputsRedB = [y1, y2, y3]
        return torch.cat(outputsRedB, 1)

Stem模块

class Stem(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(Stem, self).__init__()
        #conv3*3(32 stride2 valid)
        self.conv1 = BasicConv2d(in_channels, 32, kernel_size=3, stride=2)
        #conv3*3(32 valid)
        self.conv2 = BasicConv2d(32, 32, kernel_size=3)
        #conv3*3(64)
        self.conv3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
        #maxpool3*3(stride2 valid) & conv3*3(96 stride2 valid)
        self.maxpool4 = nn.MaxPool2d(kernel_size=3, stride=2)
        self.conv4 = BasicConv2d(64, 96, kernel_size=3, stride=2)
        
        #conv1*1(64) --> conv3*3(96 valid)
        self.conv5_1_1 = BasicConv2d(160, 64, kernel_size=1)
        self.conv5_1_2 = BasicConv2d(64, 96, kernel_size=3)
        #conv1*1(64) --> conv7*1(64) --> conv1*7(64) --> conv3*3(96 valid)
        self.conv5_2_1 = BasicConv2d(160, 64, kernel_size=1)
        self.conv5_2_2 = BasicConv2d(64, 64, kernel_size=(7,1), padding=(3,0))
        self.conv5_2_3 = BasicConv2d(64, 64, kernel_size=(1,7), padding=(0,3))
        self.conv5_2_4 = BasicConv2d(64, 96, kernel_size=3)
        
        #conv3*3(192 valid)
        self.conv6 = BasicConv2d(192, 192, kernel_size=3, stride=2)
        #maxpool3*3(stride2 valid)
        self.maxpool6 = nn.MaxPool2d(kernel_size=3, stride=2)
        
    def forward(self, x):
        y1_1 = self.maxpool4(self.conv3(self.conv2(self.conv1(x))))
        y1_2 = self.conv4(self.conv3(self.conv2(self.conv1(x))))
        y1 = torch.cat([y1_1, y1_2], 1)
        
        y2_1 = self.conv5_1_2(self.conv5_1_1(y1))
        y2_2 = self.conv5_2_4(self.conv5_2_3(self.conv5_2_2(self.conv5_2_1(y1))))
        y2 = torch.cat([y2_1, y2_2], 1)
        
        y3_1 = self.conv6(y2)
        y3_2 = self.maxpool6(y2)
        y3 = torch.cat([y3_1, y3_2], 1)
        
        return y3

定义网络模型，将上述模块按构架图组装一起

class Googlenetv4(nn.Module):
    def __init__(self):
        super(Googlenetv4, self).__init__()
        self.stem = Stem(3, 384)
        self.icpA = InceptionA(384, 384)
        self.redA = ReductionA(384, 1024, 192, 224, 256, 384)
        self.icpB = InceptionB(1024, 1024)
        self.redB = ReductionB(1024, 1536)
        self.icpC = InceptionC(1536, 1536)
        self.avgpool = nn.AvgPool2d(kernel_size=8)
        self.dropout = nn.Dropout(p=0.8)
        self.linear = nn.Linear(1536, 1000)
        
    def forward(self, x):
        #Stem Module
        out = self.stem(x)
        #InceptionA Module * 4
        out = self.icpA(self.icpA(self.icpA(self.icpA(out))))
        #ReductionA Module
        out = self.redA(out)
        #InceptionB Module * 7
        out = self.icpB(self.icpB(self.icpB(self.icpB(self.icpB(self.icpB(self.icpB(out)))))))
        #ReductionB Module
        out = self.redB(out)
        #InceptionC Module * 3
        out = self.icpC(self.icpC(self.icpC(out)))
        #Average Pooling
        out = self.avgpool(out)
        out = out.view(out.size(0), -1)
        #Dropout
        out = self.dropout(out)
        #Linear(Softmax)
        out = self.linear(out)
        
        return out

V. 测试部分及结果

def test():
    x = torch.randn(1, 3, 299, 299)
    net = Googlenetv4()
    y = net(x)
    print(y.size())
test()

torch.Size([1, 1000])
Leung WaiHo
关注
  • 7
    点赞
  • 踩
  • 56
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
探索深度学习之美：Inception-v4 项目解析与应用
gitblog_00083的博客
04-26 434
探索深度学习之美：Inception-v4 项目解析与应用 项目地址:https://gitcode.com/titu1994/Inception-v4 项目简介 Inception-v4 是一个由titu1994在GitCode上开源的深度学习模型实现，它是Google Brain团队于2016年提出的Inception系列网络架构的第四代版本。该项目旨在提供一个高效、强大的图像分类框架，同时也...
【深度学习基础】基于PyTorch实现Inception-v4, Inception-ResNet-v1, Inception-ResNet-v2亲身实践
Cai Yichao的博客
09-11 6371
这篇博客主要介绍了几种新的Inception block结构，以及论文如何结合Residual block的思想优化网络，并基于PyTorch实现了Inception-v4，Inception-ResNet的网络结构。
Inception-V4, Inception-ResNet and the Impact of Residual Connections on Learning
just
02-24 550
深层卷积网络近年来图像识别性能最大进步的核心；Inception结构也被证明是一个计算成本低、性能好的网络架构；最何恺明团队提出残差架构，在2015ILSVRC挑战中，取得最好的成绩；ResNet性能与最新一代Inception-v3网络相似；这就提出一个问题：将Inception架构与残差连接架构综合起来，是否可以提升性能？本文用实验说明，残差结构可以显著的加快网络的训练，并且有残差模块的网络比没有残差模块的网络性能稍高；
Inception-ResNet模型框架（PyTorch）
weixin_41978493的博客
07-31 2713
I. 前言 在Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning一文中，除了提出Inception Network的v4版本，还与ResNet进行结合，提出了Inception-ResNet-v1及Inception-ResNet-v2两个模型. II. 模型构架图 【注】Inception-ResNet-v1及Inception-ResNet-v2的总体构架一致，但各部分的结构不尽相同，现予以
CNN卷积神经网络之Inception-v4,Inception-ResNet
qq_41917697的博客
02-21 1873
CNN卷积神经网络之Inception-v4（Inception-ResNet）前言pandas是什么？二1.引入库总结 未经本人同意，禁止任何形式的转载！ 前言 《Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning》 论文地址：https://arxiv.org/abs/1602.07261. 在15年ResNet 提出后，2016年Inception汲取ResNet 的优势，推出了Incep
实验1：inception - v4模型的实现
liupc的学习笔记
08-22 885
本来做的实验是：inception-v4模型实现，并且用它来进行推理，但是推理的部分实在是没必要做笔记。就是《inference汇总》稍微改了一点点而已。这里就只把inception-v4模型的实现列出来了。完整的inference的代码见：D:\pythonCodes\深度学习实验\4.1_经典分类网络\7：GoogLeNet v4\inference_inceptionV4 在torchvision中，是没有inception-v4的实现的。这里找的是：https://github.com/Cad
从代码解释GoogleNet Inception-v4
qq_63610379的博客
08-02 186
注：本文为笔者查阅资料自行注释，仅供参考😁可以说是图像分类中很好的素材了，我们可以直接通过模块来调用Google 开源的很多预构建模型，也可以直接看代码，前者更利于实践应用，而后者则更加利于我们理解这个模型。
Inception-Resnet-v1、Inception-Resnet-v2学习笔记（附Pytorch代码）
你好，明天，，的博客
02-14 4190
介绍Inception-Resnet-v1和IInception-Resnet-v2网络结构，并基于pytorch实现这两种网络结构。nception-V4在Inception-V3的基础上进一步改进了Inception模块，提升了模型性能和计算效率，但没有使用残差模块， Inception-ResNet将Inception模块和深度残差网络ResNet结合，提出了三种包含残差连接的Inception模块，残差连接显著加快了训练收敛速度。
PyTorch实现的Inception-v4
mingo_敏
08-09 26
PyTorch实现的Inception-v4 PyTorch: https://github.com/shanglianlm0525/ClassicNetwork PyTorch代码:
GoogLeNet(V1-V4)Pytorch复现.zip
06-13
【图像分类】一文彻底搞明白GoogLeNet https://blog.csdn.net/hhhhhhhhhhwwwwwwwwww/article/details/117776589?spm=1001.2014.3001.5502
GoogLeNet-classification 采用GoogLeNet网络在pytorch框架下实现图像分类，拿走即用
03-29
GoogLeNet是google推出的基于Inception模块的深度神经网络模型，在2014年的ImageNet竞赛中夺得了冠军，在随后的两年中一直在改进，形成了Inception V2、Inception V3、Inception V4等版本。GoogLeNet采用了模块化的...
GoogLeNet_v4 pytorch代码
04-12
总的来说，GoogLeNet_v4的PyTorch实现是理解深度学习网络结构和训练过程的好例子，同时也能帮助开发者在自己的项目中应用和改进这一强大的模型。对于想要深入学习深度学习、尤其是卷积神经网络的初学者来说，这是一...
tensorflow-model-zoo.torch：用于Torch7和PyTorch的InceptionV3，InceptionV4，Inception-Resnet预训练模型
02-06
适用于Torch7和PyTorch的Tensorflow模型动物园（已淘汰） ：请使用新的repo ，其中包含带有更好API的inceptionv4和inceptionresnetv2。 这是和制作的张量流预训练模型的移植。 特别感谢MoustaphaCissé。 所有型号...
Inceptionv1v2v3v4的pytorch实现
08-05
Inception模型最初由Szegedy等人在2014年提出，命名为Inception-v1，也称为GoogLeNet。该模型的主要创新在于引入了“多分支”架构，允许在网络的不同层并行执行不同大小的卷积，以捕获不同尺度的特征。这种设计减少...
探索深度学习在图像识别领域的创新应用
SWZ156的博客
07-23 897
本文深入探讨了深度学习在图像识别领域的最新进展和创新应用。通过对卷积神经网络（CNN）等模型的研究，分析了其在人脸识别、物体检测和场景理解等方面的卓越表现，并展望了未来深度学习技术在图像识别领域的发展趋势。
Mindspore框架循环神经网络RNN模型实现情感分类|（二）词向量
人工智能视觉分析算法学习实践和经验分享。
07-23 1107
Mindspore框架循环神经网络RNN模型实现情感分类|（三）预训练词向量Mindspore框架循环神经网络RNN模型实现情感分类|（四）损失函数与优化器Mindspore框架循环神经网络RNN模型实现情感分类|（五）模型训练与推理。
学习在测试时学习（Learning at Test Time）: 具有表达性隐藏状态的循环神经网络（RNNs）
最新发布
AI浩
07-23 955
https://arxiv.org/pdf/2407.04620 自注意力机制在长文本语境中表现良好，但其复杂度为二次方。现有的循环神经网络（RNN）层具有线性复杂度，但其在长文本语境中的性能受到隐藏状态表达能力的限制。我们提出了一种新的序列建模层类，该类具有线性复杂度和高表达能力的隐藏状态。核心思想是将隐藏状态本身视为一个机器学习模型，而其更新规则则是自监督学习的一个步骤。由于隐藏状态甚至在测试序列上通过训练进行更新，因此我们的层被称为测试时训练（Test-Time Training，TTT）层。我们考虑
inception-v4 官网下载
09-07
### 回答1： Inception-v4是一种深度学习模型，由Google团队开发。如果想要在官网下载Inception-v4，可以采取以下步骤： 首先，访问Google Brain官方网站，找到他们的Github页面。在这个页面上，可以找到Inception-v4的代码和详细说明文档。需要注意的是，Inception-v4是一个开源的项目，所以可以直接在GitHub页面上下载它。 其次，如果想要在本地计算机上运行Inception-v4，需要确保具备适当的硬件和软件环境。例如，需要安装CUDA、cuDNN等深度学习框架和库。此外，在运行Inception-v4之前，最好先阅读文档，了解如何配置和运行模型。 最后，在下载和使用Inception-v4的过程中，需要遵循相关的法律和规定。尤其是在涉及敏感数据或人类隐私的情况下，需要格外谨慎。在使用Inception-v4时，需要注意保护个人隐私和数据安全。 ### 回答2： 为了下载inception-v4模型，可以通过官方网站进行获取。首先，使用浏览器打开谷歌（Google）的官方网站（https://www.tensorflow.org/），该网站提供了TensorFlow深度学习框架的文档和资源。 在页面的顶部菜单栏中，可以找到一个名为“Get Started（入门）”的标签。鼠标悬停在该标签上后，会显示一个下拉菜单，其中包含了各种资源和工具。点击下拉菜单中的“Models”选项。 在Models页面中，会列出所有可用的模型和数据集。浏览页面，找到inception模型的部分。点击inception栏目下的链接进入inception模型的详情页。 在inception模型的详情页中，可以找到相关的说明和下载链接。查看下载链接，点击相应的下载按钮以下载inception-v4模型的压缩文件。下载完成后，可以解压缩文件，并按照官方提供的说明进行模型的使用和应用。 总体而言，只需要按照上述步骤在TensorFlow官网中找到inception-v4的模型页面，并通过官方下载链接下载相关文件即可。注意要遵循官方说明进行正确的下载和使用，以获得最佳的结果。 ### 回答3： Inception-v4是一个深度学习模型在计算机视觉任务上具有出色性能的架构。但是，没有从官方网站下载Inception-v4。 Inception-v4最初是由Google Brain团队开发的，并在2016年的一篇论文中被提出。该模型是Inception-v3的改进版本，采用了一些新的技术和架构设计来提高准确性和计算效率。 然而，Inception-v4并没有官方的单独下载网站。相反，我们可以在一些开源机器学习库中找到实现了Inception-v4模型的代码。 例如，TensorFlow和PyTorch等流行的深度学习框架都有相关的代码和实现。可以通过官方的GitHub页面或官方文档来获取这些代码。从这些代码中, 我们可以找到Inception-v4的实现，并下载源代码或通过命令行工具进行安装。 另外，一些机器学习社区也可能有Inception-v4的开源实现代码可供下载。这些社区网站（如GitHub、GitLab等）通常会有用户贡献的模型实现代码。我们可以在这些网站上搜索"Inception-v4"关键字，找到最适合自己需求的实现代码进行下载和使用。 总结而言，要下载Inception-v4，我们应该查看TensorFlow、PyTorch等深度学习框架的官方库，或者搜索并浏览开源机器学习社区的代码仓库。这些途径会提供有关该模型的实现代码和相关信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值