MXNet学习——初识GoogleLeNet

最新推荐文章于 2024-04-05 01:45:00 发布
最新推荐文章于 2024-04-05 01:45:00 发布
阅读量305 收藏
点赞数
分类专栏： MXNet 文章标签： GoogleLeNet Mxnet 动手学深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37738114/article/details/114682828
版权

相关理论&故事背景书上都有，不打算复述一遍，这里仅作代码记录&分享

此处非直接可用代码，由于学习过程中多次使用相同函数，故而将一些常用函数整理成了工具包，MxNet学习——自定义工具包

两者结合，方可运行代码

# -------------------------------------------------------------------------------
# Description:  GoogleLeNet 含并行连接的网络
# Reference:  
# Author: Sophia
# Date:   2021/3/11
# -------------------------------------------------------------------------------
from IPython import display
from mxnet import autograd, nd, init, gluon
from mxnet.gluon import data as gdata, loss as gloss, nn
import random, sys, time, matplotlib.pyplot as plt, mxnet as mx, os
from plt_so import *

'''
Inception 块
'''

class Inception(nn.Block):
    def __init__(self, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        # 线路1，单 1x1 卷积层
        self.p1_1 = nn.Conv2D(c1, kernel_size=1, activation='relu')
        # 线路2，1x1 卷积层 + 3x3 卷积层
        self.p2_1 = nn.Conv2D(c2[0], kernel_size=1, activation='relu')
        self.p2_2 = nn.Conv2D(c2[1], kernel_size=3, padding=1, activation='relu')
        # 线路3，1x1 卷积层 + 5x5 卷积层
        self.p3_1 = nn.Conv2D(c3[0], kernel_size=1, activation='relu')
        self.p3_2 = nn.Conv2D(c3[1], kernel_size=5, padding=2, activation='relu')
        # 线路4，3x3 最大池化层 + 1x1 卷积层
        self.p4_1 = nn.MaxPool2D(pool_size=3, strides=1, padding=1)
        self.p4_2 = nn.Conv2D(c4, kernel_size=1, activation='relu')

    def forward(self, x):
        p1 = self.p1_1(x)
        p2 = self.p2_2(self.p2_1(x))
        p3 = self.p3_2(self.p3_1(x))
        p4 = self.p4_2(self.p4_1(x))
        return nd.concat(p1, p2, p3, p4, dim=1)  # 在通道维上连结输出


'''
GoogleLeNet 模型
'''
b1 = nn.Sequential()
b1.add(nn.Conv2D(64, kernel_size=7, strides=2, padding=3, activation='relu'),
       nn.MaxPool2D(pool_size=3, strides=2, padding=1))
b2 = nn.Sequential()
b2.add(nn.Conv2D(64, kernel_size=1, activation='relu'),
       nn.Conv2D(192, kernel_size=3, padding=1),
       nn.MaxPool2D(pool_size=3, strides=2, padding=1))
b3 = nn.Sequential()
b3.add(Inception(64, (96, 128), (16, 32), 32),
       Inception(128, (128, 192), (32, 96), 64),
       nn.MaxPool2D(pool_size=3, strides=2, padding=1))
b4 = nn.Sequential()
b4.add(Inception(192, (96, 208), (16, 48), 64),
       Inception(160, (112, 224), (24, 64), 64),
       Inception(128, (128, 256), (24, 64), 64),
       Inception(112, (144, 288), (32, 64), 64),
       Inception(256, (160, 320), (32, 128), 128),
       nn.MaxPool2D(pool_size=3, strides=2, padding=1))
b5 = nn.Sequential()
b5.add(Inception(256, (160, 320), (32, 128), 128),
       Inception(384, (192, 384), (48, 128), 128),
       nn.GlobalAvgPool2D())

net = nn.Sequential()
net.add(b1, b2, b3, b4, b5, nn.Dense(10))

# X = nd.random.uniform(shape=(1, 1, 224, 224))
# net.initialize()
# print(net)
# for layer in net:
#     X = layer(X)
#     print(layer.name, 'output shape:\t', X.shape)

# 输出:
# Sequential(
#   (0): Sequential(
#     (0): Conv2D(None -> 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), Activation(relu))
#     (1): MaxPool2D(size=(3, 3), stride=(2, 2), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#   )
#   (1): Sequential(
#     (0): Conv2D(None -> 64, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#     (1): Conv2D(None -> 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
#     (2): MaxPool2D(size=(3, 3), stride=(2, 2), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#   )
#   (2): Sequential(
#     (0): Inception(
#       (p1_1): Conv2D(None -> 64, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_1): Conv2D(None -> 96, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_2): Conv2D(None -> 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))
#       (p3_1): Conv2D(None -> 16, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p3_2): Conv2D(None -> 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), Activation(relu))
#       (p4_1): MaxPool2D(size=(3, 3), stride=(1, 1), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#       (p4_2): Conv2D(None -> 32, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#     )
#     (1): Inception(
#       (p1_1): Conv2D(None -> 128, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_1): Conv2D(None -> 128, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_2): Conv2D(None -> 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))
#       (p3_1): Conv2D(None -> 32, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p3_2): Conv2D(None -> 96, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), Activation(relu))
#       (p4_1): MaxPool2D(size=(3, 3), stride=(1, 1), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#       (p4_2): Conv2D(None -> 64, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#     )
#     (2): MaxPool2D(size=(3, 3), stride=(2, 2), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#   )
#   (3): Sequential(
#     (0): Inception(
#       (p1_1): Conv2D(None -> 192, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_1): Conv2D(None -> 96, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_2): Conv2D(None -> 208, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))
#       (p3_1): Conv2D(None -> 16, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p3_2): Conv2D(None -> 48, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), Activation(relu))
#       (p4_1): MaxPool2D(size=(3, 3), stride=(1, 1), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#       (p4_2): Conv2D(None -> 64, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#     )
#     (1): Inception(
#       (p1_1): Conv2D(None -> 160, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_1): Conv2D(None -> 112, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_2): Conv2D(None -> 224, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))
#       (p3_1): Conv2D(None -> 24, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p3_2): Conv2D(None -> 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), Activation(relu))
#       (p4_1): MaxPool2D(size=(3, 3), stride=(1, 1), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#       (p4_2): Conv2D(None -> 64, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#     )
#     (2): Inception(
#       (p1_1): Conv2D(None -> 128, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_1): Conv2D(None -> 128, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_2): Conv2D(None -> 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))
#       (p3_1): Conv2D(None -> 24, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p3_2): Conv2D(None -> 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), Activation(relu))
#       (p4_1): MaxPool2D(size=(3, 3), stride=(1, 1), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#       (p4_2): Conv2D(None -> 64, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#     )
#     (3): Inception(
#       (p1_1): Conv2D(None -> 112, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_1): Conv2D(None -> 144, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_2): Conv2D(None -> 288, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))
#       (p3_1): Conv2D(None -> 32, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p3_2): Conv2D(None -> 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), Activation(relu))
#       (p4_1): MaxPool2D(size=(3, 3), stride=(1, 1), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#       (p4_2): Conv2D(None -> 64, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#     )
#     (4): Inception(
#       (p1_1): Conv2D(None -> 256, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_1): Conv2D(None -> 160, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_2): Conv2D(None -> 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))
#       (p3_1): Conv2D(None -> 32, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p3_2): Conv2D(None -> 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), Activation(relu))
#       (p4_1): MaxPool2D(size=(3, 3), stride=(1, 1), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#       (p4_2): Conv2D(None -> 128, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#     )
#     (5): MaxPool2D(size=(3, 3), stride=(2, 2), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#   )
#   (4): Sequential(
#     (0): Inception(
#       (p1_1): Conv2D(None -> 256, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_1): Conv2D(None -> 160, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_2): Conv2D(None -> 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))
#       (p3_1): Conv2D(None -> 32, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p3_2): Conv2D(None -> 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), Activation(relu))
#       (p4_1): MaxPool2D(size=(3, 3), stride=(1, 1), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#       (p4_2): Conv2D(None -> 128, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#     )
#     (1): Inception(
#       (p1_1): Conv2D(None -> 384, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_1): Conv2D(None -> 192, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p2_2): Conv2D(None -> 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), Activation(relu))
#       (p3_1): Conv2D(None -> 48, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#       (p3_2): Conv2D(None -> 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), Activation(relu))
#       (p4_1): MaxPool2D(size=(3, 3), stride=(1, 1), padding=(1, 1), ceil_mode=False, global_pool=False, pool_type=max, layout=NCHW)
#       (p4_2): Conv2D(None -> 128, kernel_size=(1, 1), stride=(1, 1), Activation(relu))
#     )
#     (2): GlobalAvgPool2D(size=(1, 1), stride=(1, 1), padding=(0, 0), ceil_mode=True, global_pool=True, pool_type=avg, layout=NCHW)
#   )
#   (5): Dense(None -> 10, linear)
# )
# sequential0 output shape:	 (1, 64, 56, 56)
# sequential1 output shape:	 (1, 192, 28, 28)
# sequential2 output shape:	 (1, 480, 14, 14)
# sequential3 output shape:	 (1, 832, 7, 7)
# sequential4 output shape:	 (1, 1024, 1, 1)
# dense0 output shape:	 (1, 10)

'''
训练模型
'''
lr, num_epochs, batch_size, ctx = 0.1, 5, 128, try_gpu()
net.initialize(force_reinit=True, ctx=ctx, init=init.Xavier())
trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr})
train_iter, test_iter = load_data_fashion_mnist_ch5(batch_size, resize=224)
train_ch5(net, train_iter, test_iter, batch_size, trainer, ctx, num_epochs)

 

我有明珠一颗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
GoogLeNet模型
慕云
10-26 257
GoogLeNet模型 1、Inception块 GoogLeNet中的基础卷积块叫做Inception块。 import d2lzh.d2lzh as d2l from mxnet import gluon,init,nd from mxnet.gluon import nn class Inception(nn.Block): #c1-c4为每条线路里的层的输出通道数 def __init__(self,c1,c2,c3,c4,**kwargs): super(Inc
并行连接的网络（GoogleLeNet）
AlanxZhang的博客
09-28 1071
Inception块 在GoogLeNet中，基本的卷积块被称为Inception块 Inception块由四条并行路径组成。 前三条路径使用窗口大小为1×1、3×3 和5×5的卷积层，从不同空间大小中提取信息。 中间的两条路径在输入上执行1×1 卷积，以减少通道数，从而降低模型的复杂性。 第四条路径使用3× 最大汇聚层，然后使用1×1 卷积层来改变通道数。 这四条路径都使用合适的填充来使输入与输出的高和宽一致，最后我们将每条线路的输出在通道维度上连结，并构成I...
GoogLeNet详解
tt丫的博客
01-07 1万+
​ 目录 一、GoogLeNet网络的背景 二、GooLeNet网络结构 三、GooLeNet的亮点 四、GooLeNet代码实现 一、GoogLeNet网络的背景 想要更好的预测效果，就要从网络深度和网络宽度两个角度出发增加网络的复杂度。 但这个思路有两个较为明显的问题： 首先，更复杂的网络意味着更多的参数，也很容易过拟合； 其次，更复杂的网络会消耗更多的计算资源，而且卷积核个数设计不合理，导致了卷积核中参数没有被完全利用(多数权重都趋近0)时，会造成大量计算资源的浪费
GoogleLeNet-含并行连接的网络
qq_41286360的博客
04-05 720
GoogleLeNet（Inception v1）是一个创新的深度卷积神经网络模型，它通过引入“Inception模块”和多尺度特征提取的策略，显著提高了模型的参数效率、计算效率和分类准确率。GoogleLeNet的成功不仅证明了深度学习在计算机视觉领域的强大潜力，而且也为后续更深、更复杂的卷积神经网络模型（如Inception v2、Inception v3、Inception v4等）的研究和应用提供了有益的启示。
【深度学习】经典的卷积神经网络模型介绍（LeNet、AlexNet、VGGNet、GoogLeNet、ResNet和MobileNet）
点赞的都能无bug通过！
03-17 4万+
经典的卷积神经网络模型介绍卷积神经网络简介一、LeNet1、INPUT层-输入层2、C1层-卷积层3、S2层-池化层（下采样层）4、C3层-卷积层5、S4层-池化层（下采样层）6、C5层-卷积层7、F6层-全连接层二、AlexNet1、AlexNet特点2、ReLu作为激活函数3、数据增强4、层叠池化5、局部相应归一化6、Dropout7、Alex网络结构8、AlexNet参数数量三、VGG net1、VGG的特点2、VGG网络结构3、VGG优缺点四、GoogLeNet1、GoogLeNet Incepet
论文精读之--GoogLeNet
weixin_43584866的博客
01-12 1449
GoogLeNet是2014年Google团队提出的，其中L为大写，目的是为了致敬LeNet。论文的多处命名来自于电影盗梦空间。GoogLeNet主要的模型是Inception（中文翻译为盗梦空间）。论文题目为《Going deeper with convolutions》，来自于该图片：GoogLNet当年取得了ILSVRC 2014年分类冠军，检测冠军以及定位亚军。开启了多尺度，1*1卷积时代，以及衍生了GooLeNet v2 v3 v4系列。
pytorch实现InceptionV1模型（小白学习，详细讲解）
m0_50127633的博客
05-21 1299
Incepti## InceptionV1的模型 首先我们需要把流程图和表中数据对应起来，后续我们实现InceptionV1的时候，需要用到表中的数据。 代码实现 import torch import torch.nn as nn import torch.nn.functional as F class GlobalAvgPool2d(nn.Module): def __init__(self): super(GlobalAvgPool2d, self).__init__()
用Mxnet实现图像分类——比较LR & MLP & CNN区别.zip
04-17
1.用Mxnet实现图像分类——比较LR & MLP & CNN区别 2.图像数据包括43种交通指示牌图像，每种图像数量200多，总图像数量为10000+ 3.主要代码为ipynb格式，内含判分模块 4.Mxnet网上教程非常少，此资源可作为学习Mxnet...
通过 MXNet / Gluon 来动手学习深度学习　在线
07-21
[通过 MXNet / Gluon 来动手学习深度学习　在线 引言 预备知识 深度学习基础 深度学习计算 卷积神经网络 循环神经网络 优化算法 计算性能 计算机视觉 自然语言处理 附录
MXNet中文学习笔记
02-28
MXNet中文学习笔记
googlenet模型和参数
12-23
训练好的googlenet模型，里面包含模型文件和参数，可以直接用来测试不需训练
CNN模型简单介绍(LeNet,AlexNet,VGG,GoogLeNet,ResNet,GAN,R-CNN)
01-16
CNN模型简单介绍,按照提出时间依次介绍LeNet,AlexNet,VGG,GoogLeNet,ResNet,GAN,R-CNN。十几页的ppt，主要介绍各个模型的核心思想、贡献，希望能为大家提供一条清晰的CNN发展脉络。具体的算法实现等需要阅读文章代码。相关文章会作为另一个资源提供免费打包下载。
完美可运行Google net
09-09
深度学习 图像处理 可运行 Google net卷积神经网络CNN代码解析，深度学习 图像处理 可运行 Google net卷积神经网络CNN代码解析，对MATLAB-deep learning master工具箱的例子进行了说明。
动手学深度学习第二版，MXNet 和 PyTorch
最新发布
05-25
《动手学深度学习第二版》是一本专注于深度学习实践的权威教材，涵盖了MXNet和PyTorch两大深度学习框架的详细教程。这本书旨在帮助读者深入理解深度学习的基本原理，并通过实际操作来提升技能。 首先，MXNet是...
【跟李沐学AI】week6a | NiN GoogleLeNet
davidyang_980的博客
01-28 356
26 网络中的网络 NiN 背景问题： 卷积层需要较少的参数，但是卷积层后面的第一个全连接层往往需要较多的参数，VGG达到了102M个。过量的参数很容易造成过拟合，以及把训练时间都花在了访问内存上。所以NiN的思想就是完全不要全连接层，用卷积层来替代。 NiN块 （之后的网络多是提出局部的一个块架构） 使用1×1的卷积来起到全连接层的作用，输出形状和卷积层输出一样。 NiN架构 无全连接层 交替使用NiN块和步幅为2的最大池化层（逐步减少高宽和增大通道数） 最后使用全局平均池化层得到输出（输出通道数就是
学了就忘系列——记录网络1（LeNet、Vgg、Alex、Google）
博客标题不能为空
02-24 135
【代码】学了就忘系列——记录网络1（LeNet、Vgg、Alex、Google）
【图像分类】GoogLeNet详解
m0_61796189的博客
06-04 1284
在2014年的图像识别比赛中，由Google团体提出的GooLeNet网络结构大放异彩，字母的大写L为了纪念LeNet，GooLeNet吸收了NiN中串联的思想，其论文重点是解决了什么样大的卷积核最合适的问题。在GooLeNet中，基本的卷积块被称为 InceptionInceptionInception 块，这可能来源电《盗梦空间》（InceptionInceptionInception ）中的一句电影台词"We need to go deeper"（我们需要走得更深）。下图为为GooLeNet的框架图
GoogLeNet系列解读
热门推荐
shuzfan的专栏
02-25 15万+
本文介绍的是著名的网络结构GoogLeNet及其延伸版本，目的是试图领会其中的思想而不是单纯关注结构。GoogLeNet Incepetion V1 Motivation Architectural Details GoogLeNet Conclusion GoogLeNet Inception V2 Introduction General Design Principles Factorizi
GoogleLeNet(Inception-V1)论文及代码解析
stesha_chen的博客
08-13 6324
目录 GoogleLeNet论文 tensorflow代码分析 小结 GoogleLeNet论文        GoogleLeNet是2014年ImageNet中ILSVRC14竞赛的冠军，和VGG网络是同一届，VGG网络是当年竞赛的亚军。但是实际上两个网络的TOP-5错误率相差并不多，GoogleLeNet的网络结构相对VGG复杂一些，是一个22层的网络，并且提...
gluon_中文教程1
08-03
"该资源是一个关于MXNet和Gluon的中文教程，涵盖了深度学习的基础知识和实践应用。教程旨在帮助读者通过MXNet/Gluon动手学习深度学习，包括在AWS上运行教程的指导。内容涉及监督学习、Gluon基础、卷积神经网络、循环...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我有明珠一颗

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

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

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

打赏作者

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

抵扣说明：

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

余额充值