从零实现深度学习框架 给框架增加可变学习率策略

最新推荐文章于 2024-10-04 05:48:08 发布
最新推荐文章于 2024-10-04 05:48:08 发布
阅读量129 收藏
点赞数
分类专栏： 人工智能 文章标签： 深度学习 学习 人工智能
原文链接：https://aistudio.baidu.com/aistudio/projectdetail/5508536
版权

★★★ 本文源自AlStudio社区精品项目，【点击此处】查看更多精品内容 >>>

从零实现深度学习框架 给框架增加可变学习率策略

飞桨框架学习(LearnDL)是一个由Mr. Sun发起的活动，主旨在于以简单易懂的方式了解深度学习框架、构造深度学习框架乃至于改写深度学习框架。整体内容包括了入门级的名词解释乃至后续的框架实现工作，推荐新入门深度学习、对神经网络有些困惑、不知道如何给Paddle提PR、不知道如何参加黑客松、觉得平台上的交流充满“黑话”的同学一起参与学习~

本项目受启发于上述活动以及书目用Python实现深度学习框架，通过名词解释+代码的方式简要介绍深度学习/深度学习框架中的一些基础概念和一个简单的实现~

前置项目

可变学习步长

在开始之前，我也曾想过是否应该先从二元操作中跳出来，或者增加batchsize的功能，思来想去，还是先来说说优化器吧~

优化器的本质就是调节学习率。以一个“V”形状的一元函数为例，对于不在谷底的任何一点，导数值都是相同的，如果训练过程中不能逐渐降低学习率，则函数收敛到某个值后就不能很好收敛了。但实际上参数w所处的优化空间本就是一个黑盒子，为了能够在优化空间未知的情况下进行优化，一些自适应的补偿变化策略被提出来了。

本节会简单地给之前提到的框架添加一些自适应的学习率变化策略。

框架预处理

首先，在正式开始之前，对上次的代码进行少许修正，主要是针对一些变量名的书写进行规范化。

具体来说：

  • 统一了类中变量名为大写字母起头
  • 将可训练参数的指示符Flag更替为Trainable
  • 将lr更替为Learning_rate
  • 新增函数calculate，用于完成当前节点的计算部分，forward函数会依次调用父节点的forward以及本节点的calculate，提高代码重用性
  • 新增函数calculate，每个节点需要实现自身的calculate函数
  • 将错误的英文updata更新为update
  • Trainable的默认值为False
class Node(object):
    def __init__(self, Papa = None, Mama = None, Value = 0, Trainable = False, Learning_rate = 0.01):
        # 通常使用Father表示父节点，这里使用Papa和Mama纯粹因为更有趣一些
        self.Papa = Papa
        self.Mama = Mama
        self.Value = Value
        self.Trainable = Trainable
        self.Papa_grad = 0
        self.Mama_grad = 0
        self.Grad = 1
        self.Learning_rate = Learning_rate

    def update(self): # 参数更新
        if self.Trainable == True:
            self.Value = self.Value - self.Learning_rate*self.Grad

    def forward(self):
        if self.Papa != None: self.Papa.forward() # 基础节点的父节点不需要计算，但是非基础节点的父节点需要保证有值
        if self.Mama != None: self.Mama.forward()
        self.calculate()

    def calculate(self):
        self.Value = self.Value

    def backward(self):
        self.update()

# 加法节点
class AddNode(Node):
    def calculate(self):
        self.Value = self.Papa.Value + self.Mama.Value

    def backward(self):
        if self.Papa != None:
            self.Papa.Grad = self.Grad * 1
            self.Papa.backward()
        if self.Mama != None:
            self.Mama.Grad = self.Grad * 1
            self.Mama.backward()
        self.update()


# 乘法节点
class MulNode(Node):
    def calculate(self):
        self.Value = self.Papa.Value * self.Mama.Value

    def backward(self):
        if self.Papa != None:
            self.Papa.Grad = self.Grad * self.Mama.Value
            self.Papa.backward()
        if self.Mama != None:
            self.Mama.Grad = self.Grad * self.Papa.Value
            self.Mama.backward()
        self.update()

# 损失函数节点
class MSENode(Node):
    def calculate(self):
        self.Value = (self.Papa.Value - self.Mama.Value)**2

    def backward(self):
        if self.Papa != None:
            self.Papa.Grad = self.Grad * 2 * (self.Papa.Value - self.Mama.Value) * 1
            self.Papa.backward()
        if self.Mama != None:
            self.Mama.Grad = self.Grad * 2 * (self.Papa.Value - self.Mama.Value) * -1
            self.Mama.backward()
        self.update()

Momentum（冲量优化）

相对于基础的梯度更新 w n e w = w o l d − η g w_{new} = w_{old} - \eta g wnew​=wold​−ηg， g g g是当前周期的梯度，Momentum优化器的参数还需要一个衰减系数 β \beta β，具体计算为

v = η g − β v o l d v = \eta g - \beta v_{old} v=ηg−βvold​

w n e w = w o l d − v w_{new} = w_{old} - v wnew​=wold​−v。

显然，这里必须要多一个变量存储上周期的数据。方便起见可以通过重写一个node类实现这一优化策略~

class MomentumNode(Node):
    def __init__(self, Papa = None, Mama = None, Value = 0, Trainable = False, Learning_rate = 0.01):
        super().__init__(Papa = Papa, Mama = Mama, Value = Value, Trainable = Trainable, Learning_rate = Learning_rate)
        self.V = 0
        self.beta = 0.9 # 默认衰减系数为0.9

    def update(self):
        if self.Trainable == True:
            self.V = self.Learning_rate*self.Grad - self.beta*self.V
            self.Value = self.Value - self.V


x1 = Node(Value = 1.1) # 给一点小小的扰动
x2 = Node(Value = 2)
x3 = Node(Value = 3)
w1 = MomentumNode(Value = 1, Trainable=True)
w2 = Node(Value = 1, Trainable=True)
w3 = Node(Value = 1, Trainable=True)
m1 = MulNode(Papa = x1, Mama = w1)
m2 = MulNode(Papa = x2, Mama = w2)
m3 = MulNode(Papa = x3, Mama = w3)
a1 = AddNode(Papa = m1, Mama = m2)
a2 = AddNode(Papa = a1, Mama = m3)
y = Node(Value = 6) # 1+2+3 = 6, 这样MSE的结果为0
result = MSENode(Papa = a2, Mama = y, Value = 20)
print('计算前 result.value = ', result.Value)
result.forward()
print('计算后 result.value = ', result.Value)
result.backward()
print('第一次更新后 w1.value = ', w1.Value)
result.forward()
print('第一次更新后 result.value = ', result.Value)
result.backward()
print('第二次更新后 w1.value = ', w1.Value)
result.forward()
print('第二次更新后 result.value = ', result.Value)
result.backward()
print('第三次更新后 w1.value = ', w1.Value)
result.forward()
print('第三次更新后 result.value = ', result.Value)
result.backward()
print('第四次更新后 w1.value = ', w1.Value)
result.forward()
print('第四次更新后 result.value = ', result.Value)


计算前 result.value =  20
计算后 result.value =  0.009999999999999929
第一次更新后 w1.value =  0.9978
第一次更新后 result.value =  0.005123696399999996
第二次更新后 w1.value =  0.99820524
第二次更新后 result.value =  0.0028531583791212853
第三次更新后 w1.value =  0.996665394792
第三次更新后 result.value =  0.00143135432365771
第四次更新后 w1.value =  0.9972189241193136
第四次更新后 result.value =  0.0008182736317543128

框架结构更新

对比一下就会发现，虽然组网姿势完全相同，但是更新结果发生了一些微小的改变。

当然，如果我们每次都需要这么复杂地去改写Node节点似乎有点太麻烦了。

为了让框架更具有扩展性，这里对框架结构进行一些改进：

  • 增加optimizer类，用于更新节点
  • 节点调用update时，会调用自身的optimizer
class Optimizer(object):
    def __init__(self, Node):
        self.Node = Node

    def update(self):
        self.Node.Value = self.Node.Value - self.Node.Learning_rate*self.Node.Grad

class Node(object):
    def __init__(self, Papa = None, Mama = None, Value = 0, Trainable = False, Learning_rate = 0.01, Optimizer = Optimizer):
        # 通常使用Father表示父节点，这里使用Papa和Mama纯粹因为更有趣一些
        self.Papa = Papa
        self.Mama = Mama
        self.Value = Value
        self.Trainable = Trainable
        self.Papa_grad = 0
        self.Mama_grad = 0
        self.Grad = 1
        self.Learning_rate = Learning_rate
        if self.Trainable == True: # 暂时我们不考虑不可学习的参数转化为可学习参数的情况，对于不需要学习的参数不用生成对应的优化器
            self.Optimizer = Optimizer(self)

    def update(self): # 参数更新
        if self.Trainable == True:
            self.Optimizer.update()

    def forward(self):
        if self.Papa != None: self.Papa.forward() # 基础节点的父节点不需要计算，但是非基础节点的父节点需要保证有值
        if self.Mama != None: self.Mama.forward()
        self.calculate()

    def calculate(self):
        self.Value = self.Value

    def backward(self):
        self.update()

# 运行测试代码
x1 = Node(Value = 1.1) # 给一点小小的扰动
x2 = Node(Value = 2)
x3 = Node(Value = 3)
w1 = Node(Value = 1, Trainable=True)
w2 = Node(Value = 1, Trainable=True)
w3 = Node(Value = 1, Trainable=True)
m1 = MulNode(Papa = x1, Mama = w1)
m2 = MulNode(Papa = x2, Mama = w2)
m3 = MulNode(Papa = x3, Mama = w3)
a1 = AddNode(Papa = m1, Mama = m2)
a2 = AddNode(Papa = a1, Mama = m3)
y = Node(Value = 6) # 1+2+3 = 6, 这样MSE的结果为0
result = MSENode(Papa = a2, Mama = y, Value = 20)
print('计算前 result.value = ', result.Value)
result.forward()
print('计算后 result.value = ', result.Value)
result.backward()
print('第一次更新后 w1.value = ', w1.Value)
result.forward()
print('第一次更新后 result.value = ', result.Value)
result.backward()
print('第二次更新后 w1.value = ', w1.Value)
result.forward()
print('第二次更新后 result.value = ', result.Value)
result.backward()
print('第三次更新后 w1.value = ', w1.Value)
result.forward()
print('第三次更新后 result.value = ', result.Value)
result.backward()
print('第四次更新后 w1.value = ', w1.Value)
result.forward()
print('第四次更新后 result.value = ', result.Value)

计算前 result.value =  20
计算后 result.value =  0.009999999999999929
第一次更新后 w1.value =  0.9978
第一次更新后 result.value =  0.005123696399999996
第二次更新后 w1.value =  0.99622524
第二次更新后 result.value =  0.002625226479937307
第三次更新后 w1.value =  0.995098026792
第三次更新后 result.value =  0.00134508634644392
第四次更新后 w1.value =  0.9942911675777136
第四次更新后 result.value =  0.0006891814070964006

可以看到不指定优化器，我们的节点会自动构造随机梯度下降优化器（SGD），输出结果和从零实现深度学习框架 基础框架的构建中的示例一致。

基于Optimizer的Momentum优化器实现

class Momentum(Optimizer):
    def __init__(self, Node, Beta = 0.9):
        super().__init__(Node)
        self.Beta = Beta # 衰减系数
        self.V = 0

    def update(self):
        self.V = self.Node.Learning_rate*self.Node.Grad - self.Beta*self.V
        self.Node.Value = self.Node.Value - self.V

# 运行测试代码
x1 = Node(Value = 1.1) # 给一点小小的扰动
x2 = Node(Value = 2)
x3 = Node(Value = 3)
w1 = Node(Value = 1, Trainable=True, Optimizer= lambda Node:Momentum(Node, Beta=0.9))
w2 = Node(Value = 1, Trainable=True)
w3 = Node(Value = 1, Trainable=True)
m1 = MulNode(Papa = x1, Mama = w1)
m2 = MulNode(Papa = x2, Mama = w2)
m3 = MulNode(Papa = x3, Mama = w3)
a1 = AddNode(Papa = m1, Mama = m2)
a2 = AddNode(Papa = a1, Mama = m3)
y = Node(Value = 6) # 1+2+3 = 6, 这样MSE的结果为0
result = MSENode(Papa = a2, Mama = y, Value = 20)
print('计算前 result.value = ', result.Value)
result.forward()
print('计算后 result.value = ', result.Value)
result.backward()
print('第一次更新后 w1.value = ', w1.Value)
result.forward()
print('第一次更新后 result.value = ', result.Value)
result.backward()
print('第二次更新后 w1.value = ', w1.Value)
result.forward()
print('第二次更新后 result.value = ', result.Value)
result.backward()
print('第三次更新后 w1.value = ', w1.Value)
result.forward()
print('第三次更新后 result.value = ', result.Value)
result.backward()
print('第四次更新后 w1.value = ', w1.Value)
result.forward()
print('第四次更新后 result.value = ', result.Value)

计算前 result.value =  20
计算后 result.value =  0.009999999999999929
第一次更新后 w1.value =  0.9978
第一次更新后 result.value =  0.005123696399999996
第二次更新后 w1.value =  0.99820524
第二次更新后 result.value =  0.0028531583791212853
第三次更新后 w1.value =  0.996665394792
第三次更新后 result.value =  0.00143135432365771
第四次更新后 w1.value =  0.9972189241193136
第四次更新后 result.value =  0.0008182736317543128

alue = 0.0008182736317543128

可以看到上述代码和直接通过继承Node创建对应节点的效果是一样的。

这里使用了一个小技巧：通过lambda创建一个临时函数。

具体的语法规范如下：

函数名 = lambda 输入变量 : 表达式

则函数名是一个具有输入变量为传入参数的函数。

如果你不需要修改一些默认参数值，直接使用Optimizer = Momentum也是可以的~

以下面两个写法为例，结果是完全一致的

# case 1
Optimizer = lambda Node:Momentum(Node, Beta=0.9)
opt = Optimizer(Node)

# case 2
opt = Momentum(Node, Beta=0.9)

给OurDL增加更多优化器

在上文中，我们给自研框架OurDL进行了一些改进和框架结构调整。并且基于已有的框架，增加优化器非常的简单，只需要继承Optimizer，改写init，改写update方法即可。

以下几个实现我可能理解的有点问题，无法保证一定正确，大家仅作参考，避免被我误导

AdaGrad

更新公式如下：

s n e w = s o l d + g r a d 2 s_{new} = s_{old} + grad^2 snew​=sold​+grad2

w n e w = w o l d − η g r a d s n e w w_{new} = w_{old} - \frac{\eta grad}{\sqrt{s_{new}}} wnew​=wold​−snew​ ​ηgrad​

class AdaGrad(Optimizer):
    def __init__(self, Node, Eps = 10**-10):
        super().__init__(Node)
        self.S = 0
        self.Eps = Eps # 极小数，避免除零

    def update(self):
        self.S = self.S + self.Node.Grad**2
        self.Node.Value = self.Node.Value - self.Node.Learning_rate * self.Node.Grad / (self.S + self.Eps) ** 0.5

PMSProp

更新公式如下：

s n e w = β s o l d + ( 1 − β ) g r a d 2 s_{new} = \beta s_{old} + (1-\beta) grad^2 snew​=βsold​+(1−β)grad2

w n e w = w o l d − η g r a d s n e w w_{new} = w_{old} - \frac{\eta grad}{\sqrt{s_{new}}} wnew​=wold​−snew​ ​ηgrad​

class RMSProp(Optimizer):
    def __init__(self, Node, Beta = 0.9, Eps = 10**-10):
        super().__init__(Node)
        self.S = 0
        self.Beta = Beta
        self.Eps = Eps # 极小数，避免除零

    def update(self):
        self.S = self.Beta * self.S + (1 - self.Beta) * self.Node.Grad**2
        self.Node.Value = self.Node.Value - self.Node.Learning_rate * self.Node.Grad / (self.S + self.Eps) ** 0.5

Adam

更新公式如下：

v n e w = β 1 v o l d + ( 1 − β 1 ) g v_{new} = \beta_1 v_{old} + (1 - \beta_1)g vnew​=β1​vold​+(1−β1​)g

s n e w = β 2 s o l d + ( 1 − β 2 ) g r a d 2 s_{new} = \beta_2 s_{old} + (1-\beta_2) grad^2 snew​=β2​sold​+(1−β2​)grad2

w n e w = w o l d − η v n e w s n e w w_{new} = w_{old} - \frac{\eta v_{new}}{\sqrt{s_{new}}} wnew​=wold​−snew​ ​ηvnew​​

class Adam(Optimizer):
    def __init__(self, Node, Beta1 = 0.9, Beta2 = 0.99, Eps = 10**-10):
        super().__init__(Node)
        self.S = 0
        self.V = 0
        self.Beta1 = Beta1
        self.Beta2 = Beta2
        self.Eps = Eps # 极小数，避免除零

    def update(self):
        self.V = self.Beta1 * self.V + (1 - self.Beta1) * self.Node.Grad
        self.S = self.Beta2 * self.S + (1 - self.Beta2) * self.Node.Grad**2
        self.Node.Value = self.Node.Value - self.Node.Learning_rate * self.V / (self.S + self.Eps) ** 0.5

结语

本项目延续之前的工作内容，给自研框架OurDL进行了一些结构化的改进，并且让这个框架支持不同的优化器~关于各个优化器对应的结果可以自行修改示例代码观察，可以看到更替了优化器之后收敛速度明显提高。

最后，把上面的代码复制粘贴到OurDL.py文件里就可以快乐通过import的方式使用了~

Fork本项目，即可看到最新的OurDL.py文件~

请点击此处查看本环境基本用法.

Please click here for more detailed instructions.

AI Studio
关注
专栏目录
深度学习知识点全面总结
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
01-05 26万+
本文详细介绍深度学习概念及原理，参考网上相关资料汇总，内容包含众多章节，包括神经网络基础及常见深度学习网络结构介绍，用于个人学习总结，适合深度学习初学者学习。同时介绍机器学习常见的分类算法：SVM、神经网络、随机森林、逻辑回归、KNN、贝叶斯。常见的监督学习算法：感知机、SVM、人工神经网络、决策树、逻辑回归.........
从零实现深度学习框架——神经元与常见激活函数
日积月累，天道酬勤
02-03 2129
本文来学习深度学习中神经网络的基础构建——神经元，以及常见的激活函数。
可变学习率
weixin_34289454的博客
07-04 184
2019独角兽企业重金招聘Python工程师标准>>> ...
深度学习中的学习率调整策略（1）
qq_41387508的博客
07-24 4044
学习率(LearningRate, LR/lr)是深度学习中很重要的一个超参数了。其公式： 也就是说它是在训练过程中更新网络权重的一个调整因子，为什么说其重要呢？简单说： 学习率太大，梯度容易爆炸，loss的振幅较大，模型难以收敛；学习率太小，容易过拟合，也容易陷入“局部最优”点； 因此选择一个合适的学习率是非常重要的。 对于新手来说，一般可能是看网上的经验或者开源代码选择一个差不多的lr（比如0.1-0.001之间）。 但是，真正用自己的数据来进行模型调试的时候就会发现，学习率也是一个非常重要的超参.
深度学习总结(三)——学习率设置
码农王小呆的博客
12-06 3万+
1. 学习率对训练的影响为了能够使得梯度下降法有较好的性能，我们需要把学习率的值设定在合适的范围内。太大的学习速率导致学习的不稳定，太小值又导致极长的训练时间。自适应学习速率通过保证稳定训练的前提下，达到了合理的高速率，可以减少训练时间。2. 学习率的设置固定学习率的设置： 经验选择：一般情况下倾向于选取较小的学习速率以保证系统的稳定性，学习速率的选取范围在0.01~0.8之间。 对于不同大小的数据
【深度学习】学习率 (learning rate)
热门推荐
JNing
02-02 10万+
【深度学习】学习率 (learning rate)
深度学习（五）学习率的调节
QuinnHanz的博客
05-31 4万+
学习率对于深度学习是一个重要的超参数，它控制着基于损失梯度调整神经网络权值的速度，大多数优化算法（SGD、RMSprop、Adam）对其都有所涉及。学习率越小，损失梯度下降的速度越慢，收敛的时间更长，如公式所示：new_weight= existing_weight — learning_rate * gradient(新权值 = 当前权值 – 学习率 × 梯度) 如果学习...
从零实现深度学习框架——理解正则化(一)
日积月累，天道酬勤
03-24 2926
本文介绍解决过拟合与欠拟合的方法——正则化，主要介绍L1和L2正则化。
基于不同深度学习框架实现中文文本分类.zip
03-28
在本项目"基于不同深度学习框架实现中文文本分类"中，我们主要关注的是如何利用深度学习技术处理中文文本数据，进行有效的分类。这涉及到多个重要知识点，包括深度学习的基础概念、常用的深度学习框架以及中文文本...
初级深度学习框架的说明文档
05-08
此外，深度学习框架还集成了多种优化算法，如随机梯度下降（SGD）、Adam、RMSprop等，这些优化器用于调整学习率和其他超参数，以找到模型的最佳权重。同时，它们还提供了各种正则化技术，如L1、L2正则化，以及...
一个分布式深度学习框架联合大医学图像分析
07-23
### 分布式深度学习框架与大规模医学图像分析 #### 引言 随着信息技术的发展和大数据时代的到来，医学图像分析在临床诊断、疾病预测等方面发挥着越来越重要的作用。特别是在COVID-19疫情爆发后，对医学图像分析的...
深度学习如何设置学习率
mao_feng的博客
10-23 4万+
学习率是深度学习中的一个重要的超参，如何调整学习率是训练出好模型的关键要素之一。在通过SGD求解问题的极小值时，梯度不能太大，也不能太小。太大容易出现超调现象，即在极值点两端不断发散，或是剧烈震荡，总之随着迭代次数增大loss没有减小的趋势；太小会导致无法快速地找到好的下降的方向，随着迭代次数增大loss基本不变。 学习率调整方法基本上有两种 1. 基于经验的手动调整。 通过尝
深度学习: 学习率 (learning rate)
黎国溥
11-02 3万+
                                     深度学习: 学习率 (learning rate)    作者：liulina603        致敬 原文：https://blog.csdn.net/liulina603/article/details/80604385   深度学习: 学习率 (learning rate) Introduction 学习...
深度学习------学习率的调整（自学使用）
weixin_48983346的博客
07-12 1322
学习率
基于深度学习的不遗忘训练
weixin_42605076的博客
10-02 735
基于深度学习的不遗忘训练（也称为抗遗忘训练或持久性学习）是针对模型在学习新任务时可能会忘记已学习内容的一种解决方案。该方法旨在使深度学习模型在不断接收新信息的同时，保持对旧知识的记忆。
深度学习·wandb
2301_80132162的博客
10-01 401
一个好用的可视化训练过程和调参工具，建议在深度学习中使用，语法来说更加方便。
安全帽头盔检测数据集 3类 12000张 安全帽数据集 voc yolo
最新发布
阿利同学的博客
10-04 758
安全帽头盔检测数据集 3类 12000张 安全帽数据集 voc yolo
AI学习指南深度学习篇-批标准化（Batch Normalization）简介
俞兆鹏的博客
09-28 889
批标准化是深度学习领域不可或缺的重要技术之一，极大地提高了训练速度和模型性能。它通过标准化中间层的输出，减轻了内部协变量偏移的影响，有效解决了训练过程中常见的问题。从传统的深度网络到现代复杂模型，批标准化为深度学习的快速发展做出了重要贡献。在实际应用中，理解并有效利用批标准化的特性，可以帮助我们构建更高效、准确的深度学习模型。继续深入研究和探索批标准化在其他网络构架中的应用，将进一步推动深度学习的发展与多样性。
深度学习：DCGAN
Landy_Jay的博客
10-01 457
CDGAN（Deep Convolutional Generative Adversarial Networks），是GAN（Generative Adversarial Networks）的一种变体，它特别使用了卷积神经网络（CNNs）作为生成器和判别器的构建模块。DCGAN使用全卷积网络结构代替传统的池化层和全连接层。在生成器中采用转置卷积（也称为分数步长卷积或反卷积）来逐步增加图像的空间维度。在判别器中使用卷积层来逐步减少空间维度并提取特征。
ColossalAI深度学习框架介绍与应用
"尤洋老师在2021年12月26日的亚马逊云科技开发者社区（User Group）北京活动中分享了ColossalAI，这是一款用于深度学习的高性能并行计算框架。ColossalAI的目标是解决日益增长的神经网络规模带来的计算挑战，其设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值