深度学习的梯度消失/爆炸

最新推荐文章于 2024-09-16 16:34:53 发布
最新推荐文章于 2024-09-16 16:34:53 发布
阅读量178 收藏
点赞数
分类专栏： NG学习笔记 文章标签： 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yejing0027/article/details/104000578
版权

考虑一个L层的网络，前向计算时，对于第l层：
z l = w l a l − 1 + b l z_l = w_la_{l-1} + b_l zl​=wl​al−1​+bl​
a l = δ ( z l ) a_l = \delta (z_l) al​=δ(zl​)
反向计算时，对于第l层：
d z l = w l + 1 d z l + 1 ∗ δ ′ ( z l ) dz_l = w_{l+1}dz_{l+1} * \delta'(z_l) dzl​=wl+1​dzl+1​∗δ′(zl​)
d w l = a l − 1 d z l dw_l = a_{l-1}dz_l dwl​=al−1​dzl​
d b l = d z l db_l = dz_l dbl​=dzl​

relu activation

a l − 1 ≈ w 1 w 2 . . . w l − 1 x a_{l-1} \approx w_1w_2...w_{l-1}x al−1​≈w1​w2​...wl−1​x
d z l ≈ w L w L − 1 . . . w l + 1 d z L dz_l \approx w_Lw_{L-1}...w_{l+1}dz_L dzl​≈wL​wL−1​...wl+1​dzL​
d w l ≈ w l w 2 . . . w l − 1 w l + 1 . . . w L x d z L dw_l \approx w_lw_2...w_{l-1}w_{l+1}...w_Lxdz_L dwl​≈wl​w2​...wl−1​wl+1​...wL​xdzL​
d b l ≈ w l − 1 . . . w L d z L db_l \approx w_{l-1}...w_Ldz_L dbl​≈wl−1​...wL​dzL​
若 ∣ w j ∣ < 1 |w_j|<1 ∣wj​∣<1，随着L的增加，越靠近输入层，dz呈指数级减小，同时db也呈指数级减小；每一层dw的大小没有指数级的变化，但是随着L的增加，每一层的dw都呈指数级减小。

sigmoid activation

a l − 1 = δ ( w l − 1 ∗ . . . δ ( w 2 ∗ δ ( w 1 x + b 1 ) + b 2 ) + b l − 1 ) a_{l-1} = \delta(w_{l-1} * ...\delta(w_2 * \delta(w_1x + b_1) + b_2) + b_{l-1}) al−1​=δ(wl−1​∗...δ(w2​∗δ(w1​x+b1​)+b2​)+bl−1​)
d z l = w L δ ′ ( z L ) w L − 1 δ ′ ( z L − 1 ) . . . w l + 1 δ ′ ( z l + 1 ) d z L dz_l = w_L\delta'(z_L)w_{L-1}\delta'(z_{L-1})...w_{l+1}\delta'(z_{l+1})dz_L dzl​=wL​δ′(zL​)wL−1​δ′(zL−1​)...wl+1​δ′(zl+1​)dzL​
d w l = a l − 1 d z l dw_l = a_{l-1}dz_l dwl​=al−1​dzl​
d b l = d z l db_l = dz_l dbl​=dzl​
a l − 1 a_{l-1} al−1​在0到1之间，可以忽略不计，若 ∣ w j δ ′ ( z j ) ∣ < 1 |w_j\delta'(z_j)|<1 ∣wj​δ′(zj​)∣<1，随着L的增加，越靠近输入层，dz呈指数级减小，同时dw和db也呈指数级减小。

relu demo

假设一个10层的神经网络，每层2个节点，除了输出层是sigmoid，其他层的activator是relu

import numpy as np
from numpy.linalg import cholesky
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

def logistic(z):
    return 1 / (1 + np.exp(-z))

def logistic_gradient(z):
    a = logistic(z)
    return a * (1 - a)

def relu(z):
    return z * (z > 0)

def relu_gradient(z):
    return np.ones(z.shape) * (z > 0)

sampleNo = 10
mu = np.array([[2, 3]])
Sigma = np.array([[1, 0.5], [1.5, 3]])
R = cholesky(Sigma)
s = np.dot(np.random.randn(sampleNo, 2), R) + mu

mu2 = np.array([[7, 6]])
t = np.dot(np.random.randn(sampleNo, 2), R) + mu2

plt.plot(s[:,0],s[:,1],'+')
plt.plot(t[:,0],t[:,1],'*')
plt.xlabel("x")
plt.ylabel("y")
plt.show()

#构造数据
x = np.concatenate((s, t)).T
y1 = np.zeros(sampleNo).reshape(1,sampleNo)
y2 = np.ones(sampleNo).reshape(1,sampleNo)
y = np.concatenate((y1, y2), axis=1)
print(x.shape, y.shape)

#初始化网络
layer = 10
#考虑一个比1稍小的w
w = {}
for i in range(1, layer):
    w_tmp = np.array([0.8, 0, 0, 0.8]).reshape(2,2)
    w[i] = w_tmp
w_out = np.ones(2).reshape(2,1)
w[layer] = w_out
#b初始化为0
b = {}
for i in range(1, layer):
    b_tmp = np.zeros(2).reshape(1,2)
    b[i] = b_tmp
b_out = np.zeros(1).reshape(1,1)
b[layer] = b_out
#activator初始化
act = {}
for i in range(1, layer):
    act[i] = relu
act[layer] = logistic

iter = 1
max_iter = 2
m = sampleNo * 2
alpha = 0.01
while iter < max_iter:
    #前向计算
    a = x
    a_dict = {}
    z_dict = {}
    a_dict[0] = a
    for i in range(1, layer+1):
        z = np.dot(w[i].T, a) + b[i].T
        a = act[i](z)
        a_dict[i] = a
        z_dict[i] = z
    #反向计算
    dz = {}
    dw = {}
    db = {}  
    for i in range(layer, 0, -1):
        if i == layer:
            dz[i] = a_dict[i] - y
        else:
            dz[i] = np.dot(w[i+1], dz[i+1]) * relu_gradient(z_dict[i])
        dw[i] = np.dot(a_dict[i - 1], dz[i].T) / m
        db[i] = np.sum(dz[i].T, axis = 0) / m
    #更新参数
    for i in range(1, layer+1):
        w[i] = w[i] - alpha * dw[i]
        b[i] = b[i] - alpha * db[i]

    iter += 1

print("反向计算")
for i in range(layer, 0, -1):
    print("第%d层" % i)
    print("dz", dz[i][:,0])
    print("dw", dw[i])
    print("db", db[i])

反向计算
第10层
dz [0.6525866]
dw [[0.00245394]
[0.07067444]]
db [0.25647431]
第9层
dz [0.6525866 0.6525866]
dw [[0.00306743 0.00306743]
[0.08834304 0.08834304]]
db [0.25647431 0.25647431]
第8层
dz [0.52206928 0.52206928]
dw [[0.00306743 0.00306743]
[0.08834304 0.08834304]]
db [0.20517945 0.20517945]
第7层
dz [0.41765542 0.41765542]
dw [[0.00306743 0.00306743]
[0.08834304 0.08834304]]
db [0.16414356 0.16414356]
第6层
dz [0.33412434 0.33412434]
dw [[0.00306743 0.00306743]
[0.08834304 0.08834304]]
db [0.13131485 0.13131485]
第5层
dz [0.26729947 0.26729947]
dw [[0.00306743 0.00306743]
[0.08834304 0.08834304]]
db [0.10505188 0.10505188]
第4层
dz [0.21383958 0.21383958]
dw [[0.00306743 0.00306743]
[0.08834304 0.08834304]]
db [0.0840415 0.0840415]
第3层
dz [0.17107166 0.17107166]
dw [[0.00306743 0.00306743]
[0.08834304 0.08834304]]
db [0.0672332 0.0672332]
第2层
dz [0.13685733 0.13685733]
dw [[0.00306743 0.00306743]
[0.08834304 0.08834304]]
db [0.05378656 0.05378656]
第1层
dz [0.10948586 0.10948586]
dw [[0.00306743 0.00306743]
[0.08834304 0.08834304]]
db [0.04302925 0.04302925]

sigmoid demo

假设一个10层的神经网络，每层2个节点，所有层都是sigmoid

#初始化网络
layer = 10
#考虑一个比1稍小的w
w = {}
for i in range(1, layer):
    w_tmp = np.array([0.8, 0, 0, 0.8]).reshape(2,2)
    w[i] = w_tmp
w_out = np.ones(2).reshape(2,1)
w[layer] = w_out
#b初始化为0
b = {}
for i in range(1, layer):
    b_tmp = np.zeros(2).reshape(1,2)
    b[i] = b_tmp
b_out = np.zeros(1).reshape(1,1)
b[layer] = b_out
#activator初始化
act = {}
for i in range(1, layer+1):
    act[i] = logistic

iter = 1
max_iter = 2
m = sampleNo * 2
alpha = 0.01
while iter < max_iter:
    #前向计算
    a = x
    a_dict = {}
    z_dict = {}
    a_dict[0] = a
    for i in range(1, layer+1):
        z = np.dot(w[i].T, a) + b[i].T
        a = act[i](z)
        a_dict[i] = a
        z_dict[i] = z
    #反向计算
    dz = {}
    dw = {}
    db = {}  
    for i in range(layer, 0, -1):
        if i == layer:
            dz[i] = a_dict[i] - y
        else:
            dz[i] = np.dot(w[i+1], dz[i+1]) * relu_gradient(z_dict[i])
        dw[i] = np.dot(a_dict[i - 1], dz[i].T) / m
        db[i] = np.sum(dz[i].T, axis = 0) / m
    #更新参数
    for i in range(1, layer+1):
        w[i] = w[i] - alpha * dw[i]
        b[i] = b[i] - alpha * db[i]

    iter += 1

print("反向计算")
for i in range(layer, 0, -1):
    print("第%d层" % i)
    print("dz", dz[i][:,0])
    print("dw", dw[i])
    print("db", db[i])

反向计算
第10层
dz [0.77621477]
dw [[0.17176994]
[0.17177003]]
db [0.27621479]
第9层
dz [0.77621477 0.77621477]
dw [[0.17176998 0.17176998]
[0.17177045 0.17177045]]
db [0.27621479 0.27621479]
第8层
dz [0.62097182 0.62097182]
dw [[0.13741614 0.13741614]
[0.13741813 0.13741813]]
db [0.22097183 0.22097183]
第7层
dz [0.49677746 0.49677746]
dw [[0.10993356 0.10993356]
[0.10994206 0.10994206]]
db [0.17677747 0.17677747]
第6层
dz [0.39742196 0.39742196]
dw [[0.08794963 0.08794963]
[0.08798579 0.08798579]]
db [0.14142197 0.14142197]
第5层
dz [0.31793757 0.31793757]
dw [[0.07037154 0.07037154]
[0.07052532 0.07052532]]
db [0.11313758 0.11313758]
第4层
dz [0.25435006 0.25435006]
dw [[0.05634747 0.05634747]
[0.05700205 0.05700205]]
db [0.09051006 0.09051006]
第3层
dz [0.20348005 0.20348005]
dw [[0.04528946 0.04528946]
[0.04808773 0.04808773]]
db [0.07240805 0.07240805]
第2层
dz [0.16278404 0.16278404]
dw [[0.0370514 0.0370514 ]
[0.04934335 0.04934335]]
db [0.05792644 0.05792644]
第1层
dz [0.13022723 0.13022723]
dw [[-0.05082364 -0.05082364]
[ 0.06565071 0.06565071]]
db [0.04634115 0.04634115]

二类分类

import numpy as np
from numpy.linalg import cholesky
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

sampleNo = 1000
mu = np.array([[2, 3]])
Sigma = np.array([[1, 0.5], [1.5, 3]])
R = cholesky(Sigma)
s = np.dot(np.random.randn(sampleNo, 2), R) + mu

mu2 = np.array([[17, 10]])
t = np.dot(np.random.randn(sampleNo, 2), R) + mu2

plt.plot(s[:,0],s[:,1],'+')
plt.plot(t[:,0],t[:,1],'*')
plt.xlabel("x")
plt.ylabel("y")
plt.show()

在这里插入图片描述

#构造数据
x = np.concatenate((s, t)).T
y1 = np.zeros(sampleNo).reshape(1,sampleNo)
y2 = np.ones(sampleNo).reshape(1,sampleNo)
y = np.concatenate((y1, y2), axis=1)

def logistic(z):
    return 1 / (1 + np.exp(-z))

def logistic_gradient(z):
    a = logistic(z)
    return a * (1 - a)

def relu(z):
    return z * (z > 0)

def relu_gradient(z):
    return np.ones(z.shape) * (z > 0)

#初始化网络
#考虑一个比1稍大的w
w = {}
for i in range(1, 10):
    w_tmp = np.array([1.1, 0, 0, 1.1]).reshape(2,2)
    w[i] = w_tmp
w_out = np.ones(2).reshape(2,1)
w[10] = w_out
#b初始化为0
b = {}
for i in range(1, 10):
    b_tmp = np.zeros(2).reshape(1,2)
    b[i] = b_tmp
b_out = np.zeros(1).reshape(1,1)
b[10] = b_out
#activator初始化
act = {}
for i in range(1, 10):
    act[i] = relu
act[10] = logistic

#训练
iter = 1
max_iter = 50000
m = sampleNo * 2
alpha = 0.01
while iter < max_iter:
    #前向计算
    a = x
    a_dict = {}
    z_dict = {}
    a_dict[0] = a
    for i in range(1, 11):
        z = np.dot(w[i].T, a) + b[i].T
        a = act[i](z)
        a_dict[i] = a
        z_dict[i] = z
    #反向计算
    dz = {}
    dw = {}
    db = {}  
    for i in range(10, 0, -1):
        if i == 10:
            dz[i] = a_dict[i] - y
        else:
            dz[i] = np.dot(w[i+1], dz[i+1]) * relu_gradient(z_dict[i])
        dw[i] = np.dot(a_dict[i - 1], dz[i].T) / m
        db[i] = np.sum(dz[i].T, axis = 0) / m
    #更新参数
    for i in range(1, 11):
        w[i] = w[i] - alpha * dw[i]
        b[i] = b[i] - alpha * db[i]

    iter += 1

#显示结果
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.scatter(s[:,0], s[:,1], y[y==0])
ax.scatter(t[:,0], t[:,1], y[y==1])

def predict(x):
    a = x
    for i in range(1, 11):
        z = np.dot(w[i].T, a) + b[i].T
        a = act[i](z)
    return a

x1_tmp = x2_tmp = np.linspace(-10, 30, 100)
x1_tmp, x2_tmp = np.meshgrid(x1_tmp, x2_tmp)
x_tmp = np.concatenate((x1_tmp.reshape(1, 10000), x2_tmp.reshape(1, 10000)))
y_tmp = predict(x_tmp)
y_tmp = y_tmp.reshape(100, 100)
ax.plot_surface(x1_tmp, x2_tmp, y_tmp)
ax.view_init(elev=30,azim=-120)
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.show()

在这里插入图片描述

对比只有一层的logistic regression模型，使用相同超参的训练结果如下：

在这里插入图片描述

echoye12
关注
专栏目录
梯度消失/梯度爆炸
qq_41413211的博客
04-04 99
梯度是损失函数在某点的导数，它表示损失函数在该点的变化率。负梯度方向是损失函数值下降最快的方向。反向传播是一种计算神经网络中每个权重损失函数梯度的方法。通过计算损失函数关于每个权重的梯度，我们可以知道如何调整权重以使损失函数最小化。(30条消息) 神经网络训练过程_坠金的博客-CSDN博客。
梯度消失、梯度爆炸
weixin_40522801的博客
05-18 479
反向传播算法(即BP算法)是从输出层反向传到输入层，逐层传递误差梯度，进而进行权重的更新。训练很深的神经网络时，随着层数的增加，导数会出现指数级的下降，则导致梯度消失。或者指数级的增加，导致梯度爆炸；本质是梯度传递的链式法则所导致的矩阵高次幂（反向传播会逐层对函数求偏导相乘）。 1 梯度消失 1.1 原因 在深层网络中，如果激活函数的导数小于1，根据链式求导法则，靠近输入层的参数的梯度因为乘了很多的小于1的数而越来越小，最终就会趋近于0，例如函数，其导数为的值域为，极易发生这种情况。所以梯度消失出现.
深度学习（三）：梯度消失与梯度爆炸及其解决办法
weixin_42892235的博客
08-17 2488
在深度学习中梯度消失和梯度爆炸一直是要解决的核心问题，就用这篇文章来总结一下相关的概念。本文分为三部分，第一部分主要直观的介绍深度学习中为什么使用梯度更新，第二部分主要介绍深度学习中梯度消失及爆炸的原因，第三部分对提出梯度消失及爆炸的解决方案。有基础的同鞋可以跳着阅读。 其中，梯度消失爆炸的解决方案主要包括以下几个部分。 预训练加微调- 梯度剪切、权重正则（针对梯度爆炸） 使用不同的激活函数 使用batchnorm 使用残差结构 使用LSTM网络 1.什么是梯度更新，为什么要用它 什么是梯度：是张量运算
一点关于梯度消失/爆炸、过拟合、梯度检验的随记
探索数据奥秘的博客
01-23 1266
Andrew Ng在优化深度神经网络的3周课程中，第一周就讲了深度神经网络最常有的3个问题，分别是梯度消失/爆炸，过拟合，梯度检验。并分别给出了解决办法，合理的网络参数初始化可以预防梯度消失/爆炸问题出现；而当网络的预测结果出现过拟合现象时，则考虑用正则化手段调试网络；梯度检验则是因为要向别人证明自己的梯度下降所求的每个梯度是正确的，因为正向求成本函数是可以完全看到正确的，刚好借正向的结果以及导数...
机器学习总结（二）：梯度消失和梯度爆炸
热门推荐
以梦为马，不负韶华
04-05 3万+
神经网络的训练过程通常分为两个阶段：前向传播和反向传播。 前向传播如下图所示，原理比较简单 上一层的神经元与本层的神经元有连接，那么本层的神经元的激活等于上一层神经元对应的权值进行加权和运算，最后通过一个非线性函数（激活函数）如ReLu，sigmoid等函数，最后得到的结果就是本层神经元的输出。逐层逐神经元通过该操作向前传播，最终得到输出层的结果。 反向传播由最后一层开始，逐层向前传播进行
深度学习中梯度消失的理解
h_l_dou的博客
09-24 907
深度学习中梯度消失的理解
动手学深度学习：梯度消失、梯度爆炸
01-06
动手学深度学习：梯度消失、梯度爆炸 内容摘自伯禹人工智能AI公益课程 目录： 梯度消失和梯度爆炸的基本概念 考虑到环境因素的其他问题 Kaggle房价预测# 梯度消失、梯度爆炸以及Kaggle房价预测 1、梯度消失和梯度...
也来谈谈RNN的梯度消失/爆炸问题
Paper weekly
11-30 872
©PaperWeekly 原创 ·作者｜苏剑林单位｜追一科技研究方向｜NLP、神经网络尽管 Transformer 类的模型已经攻占了 NLP 的多数领域，但诸如 LSTM、GRU之...
神经网络优化算法：Dropout、梯度消失/爆炸、Adam优化算法，一篇就够了！
mantch
08-19 3803
1. 训练误差和泛化误差 机器学习模型在训练数据集和测试数据集上的表现。如果你改变过实验中的模型结构或者超参数，你也许发现了：当模型在训练数据集上更准确时，它在测试数据集上却不⼀定更准确。这是为什么呢？ 因为存在着训练误差和泛化误差： **训练误差：**模型在训练数据集上表现出的误差。 **泛化误差：**模型在任意⼀个测试数据样本上表现出的误差的期望，并常常通过测试数据集上的误差来近似。 训练...
深度学习——梯度消失、梯度爆炸
GWENGJING的博客
09-11 911
梯度消失和梯度爆炸的根源：深度神经网络结构、反向传播算法
深度学习中的梯度消失与梯度爆炸及解决方案
bitcarmanlee的博客
02-23 4199
1.梯度消失与梯度爆炸 反向传播算法在神经网络中非常常见，可以说是整个深度学习的基石。在反向传播中，经常会出现梯度消失与梯度爆炸的问题。梯度消失产生的原因一般有两种情况：一是结构较深的网络，二是采用了不太合适的激活函数。而梯度爆炸一般也有两种情况：一是结构较深的网络，二是初始化权重不合适，权重值太大。 从网上找了一张深度网络示例图，简单说明一下梯度消失或者爆炸的问题。 其中σ′(z4)\sigma'(z_4)σ′(z4​)表示激活层的导数，w4w_4w4​是该层的权重。σ′(z4)w4\sigma'(z_
梯度爆炸的解决办法：clip gradient
u010814042的博客
07-26 3万+
1.梯度爆炸的影响在一个只有一个隐藏节点的网络中，损失函数和权值w偏置b构成error surface，其中有一堵墙，如下所示   损失函数每次迭代都是每次一小步，但是当遇到这堵墙时，在墙上的某点计算梯度，梯度会瞬间增大，指向某处不理想的位置。如果我们使用缩放，可以把误导控制在可接受范围内，如虚线箭头所示2.解决梯度爆炸问题的方法通常会使用一种叫”clip gradients “的方法. 它能
logistic regression 以及梯度下降
mysql403的专栏
04-28 4074
先说下线性回归(直接上图) 如上图所示，根据肿瘤尺寸数据进行判断。设hypothesis函数为根据上图可以看出线性h(x)能够将上述数据进行有效分类，当h(x)>0.5,则为肿瘤患者，当h(x) 此时通过调整线性模型的参数后最终得到的线性模型为蓝色的直线，此时就会发现最右侧的红色叉号被预测成了正常，这显然是不合理的，并且后果是严重的（人家有病，你预测正常，影响治疗.....），
【放假第9天】TensorFlow总结2 简单线性回归案例以及梯度爆炸/梯度消失
qq_40647378的博客
12-23 284
随着梯度下降而下降 #里面的值都是初始化的值 注意二维表达 0.7和1,1 def myregression(): #1.准备数据，x特征值，y目标值 x=tf.random_normal([100,1],mean=1.4,stddev=0.5,name="x_data") #矩阵相乘必须是二维的 y_true=tf.matmul(x,[[0...
梯度消失 & 梯度爆炸
soullines的博客
07-01 7834
神经网络(DNN)其实就是人工神经网络(ANN)的多层实现,一个ANN有2个或者2个以上的隐藏层,则被称为深度神经网络(DNN),下面的内容我们会针对神经网络反向微分过程中产生的梯度爆炸和梯度消失,以及当前有效的缓和方法做一些具体的论述; **当然有兴趣的同学建议自己去推导神经网络反向传播BP算法的推导 ** 1.神经网络 2.梯度消失 & 梯度爆炸 3.缓和梯度消失 &...
地球物理中的深度学习理论（DNN的架构、反向传播、梯度消失、梯度爆炸）
hhhhhhhhhhyyyyyy的博客
10-06 1361
1、DL 已被证明具有准确预测复杂系统并缓解大型地球物理应用中的“维数灾难”的潜力。 2、DL的应用 3、DL的发展方向
机器学习经典算法(2)-逻辑回归
UCASer
03-22 348
逻辑回归模型：假设数据服从伯努利分布，通过极大化似然函数的方法，运用梯度下降来对参数进行优化，最后通过sigmoid函数将其转化为概率形式，并通过设定阈值实现二分类。
梯度下降 Gradient Descent 详解、梯度消失和爆炸
止鱼
12-26 5457
1、什么是梯度 在微积分中，对多元函数的参数求∂偏导，把求得的各个参数的偏导数以向量形式写出来即为梯度。 例如对于函数f(x,y)，分别对x,y求偏导，求得的梯度向量就是 (∂f/∂x, ∂f/∂y)^T，简称 grad f(x,y)，或者▽f(x,y)。相对于的，在点（x_0,y_0）处的梯度就是 (∂f/∂x_0, ∂f/∂y_0)^T, 或者记做 ▽f(x_0,y_0)。 2、梯度的意义 ...
RNN股票预测(Pytorch版)
最新发布
qq_52237775的博客
09-16 678
记录RNN实战
RNN如何避免梯度消失/爆炸问题？
07-15
循环神经网络（RNN）中的梯度消失/爆炸问题是由于反向传播过程中链式法则导致的，当网络深度增加时，激活函数的导数可能非常小（如sigmoid），使得浅层单元的权重更新极其微弱（梯度消失），而如果导数很大（如ReLU...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值