cpp简单实现一下RNN神经网络

最新推荐文章于 2023-09-17 16:50:13 发布
最新推荐文章于 2023-09-17 16:50:13 发布
阅读量728 收藏 8
点赞数
文章标签： 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40708167/article/details/113781324
版权

RNN的结构

在这里插入图片描述
用之前的输出和当前的输入作为新的输入输入带神经网络

t a n h ( x ) = e x − e − x e x + e − x tanh(x)=\frac{e^x-e^{-x}}{e^x+e^{-x}} tanh(x)=ex+e−xex−e−x​
S o f t m a x ( X ) = e X ∑ i e x i Softmax(X)=\frac{e^X}{\sum_i{e^{x_i}}} Softmax(X)=∑i​exi​eX​
t a n h ( x ) tanh(x) tanh(x)是非线性函数，使用非线性函数增强神经网络表达力，(｡･∀･)ﾉﾞ
S o f t m a x ( x ) Softmax(x) Softmax(x)来处理最后的处理结果，计算每种结果的概率，在反向传播时的效果比最小二乘法更好┗|｀O′|┛

前向传播

X i = t a n h ( U i X i − 1 + V i H i + B i ) X_i=tanh\left( U_i X_{i-1} + V_i H_i + B_i \right) Xi​=tanh(Ui​Xi−1​+Vi​Hi​+Bi​)
H i = X i H_i=X_i Hi​=Xi​

  • X i X_i Xi​ 是第i层的输出向量
  • H i H_i Hi​ 是第i层的上个时刻输出向量
  • U i , V i U_i,V_i Ui​,Vi​分别是对输入数据处理的权重矩阵
  • B i B_i Bi​是偏置
  • 每层神经网络按照这个公式递推就可以了
  • 用Softmax对最后一层处理

反向传播

对于每次的计算，求取其梯度，然后用梯度更新参数
∂ ε ( t ) ∂ U i = ∂ ε ( t ) ∂ X n ( t ) ∏ k = i + 1 n ∂ X k ( t ) ∂ X k − 1 ( t ) ( ∑ k = 1 t + 1 ( ∂ X k − 1 ∂ U i ∏ T = k t ∂ X i ( T ) ∂ X i ( T − 1 ) ) ) \frac{\partial \varepsilon\left(t\right)}{\partial U_i}=\frac{\partial \varepsilon\left(t\right)}{\partial X_n\left(t\right)} \prod_{k=i+1}^{n}\frac{\partial X_{k}\left(t\right)}{\partial X_{k-1}\left(t\right)} \left( \sum_{k=1}^{t+1} \left( \frac{\partial X_{k-1}}{\partial U_i} \prod_{T=k}^{t}\frac{\partial X_i\left(T\right)}{\partial X_i\left(T-1\right)}\right) \right) ∂Ui​∂ε(t)​=∂Xn​(t)∂ε(t)​k=i+1∏n​∂Xk−1​(t)∂Xk​(t)​(k=1∑t+1​(∂Ui​∂Xk−1​​T=k∏t​∂Xi​(T−1)∂Xi​(T)​))
∂ ε ( t ) ∂ U i = ∂ ε ( t ) ∂ X n ( t ) ∏ k = i + 1 n ∂ X k ( t ) ∂ X k − 1 ( t ) ( ∑ k = 1 t + 1 ( ∂ X k − 1 ∂ V i ∏ T = k t ∂ X i ( T ) ∂ X i ( T − 1 ) ) ) \frac{\partial \varepsilon\left(t\right)}{\partial U_i}=\frac{\partial \varepsilon\left(t\right)}{\partial X_n\left(t\right)} \prod_{k=i+1}^{n}\frac{\partial X_{k}\left(t\right)}{\partial X_{k-1}\left(t\right)} \left( \sum_{k=1}^{t+1} \left( \frac{\partial X_{k-1}}{\partial V_i} \prod_{T=k}^{t}\frac{\partial X_i\left(T\right)}{\partial X_i\left(T-1\right)} \right) \right) ∂Ui​∂ε(t)​=∂Xn​(t)∂ε(t)​k=i+1∏n​∂Xk−1​(t)∂Xk​(t)​(k=1∑t+1​(∂Vi​∂Xk−1​​T=k∏t​∂Xi​(T−1)∂Xi​(T)​))
∂ ε ( t ) ∂ U i = ∂ ε ( t ) ∂ X n ( t ) ∏ k = i + 1 n ∂ X k ( t ) ∂ X k − 1 ( t ) ( ∑ k = 1 t + 1 ( ∂ X k − 1 ∂ B i ∏ T = k t ∂ X i ( T ) ∂ X i ( T − 1 ) ) ) \frac{\partial \varepsilon\left(t\right)}{\partial U_i}=\frac{\partial \varepsilon\left(t\right)}{\partial X_n\left(t\right)} \prod_{k=i+1}^{n}\frac{\partial X_{k}\left(t\right)}{\partial X_{k-1}\left(t\right)} \left( \sum_{k=1}^{t+1} \left( \frac{\partial X_{k-1}}{\partial B_i} \prod_{T=k}^{t}\frac{\partial X_i\left(T\right)}{\partial X_i\left(T-1\right)} \right) \right) ∂Ui​∂ε(t)​=∂Xn​(t)∂ε(t)​k=i+1∏n​∂Xk−1​(t)∂Xk​(t)​(k=1∑t+1​(∂Bi​∂Xk−1​​T=k∏t​∂Xi​(T−1)∂Xi​(T)​))
求其梯度的式子很长，需要追溯到上层神经网络的输出和其他时刻的时候神经网络的输出，所也要用递推的方法求梯度

代码实现

#include<bits/stdc++.h>
struct Matrix
{
    int rows,colums;
    float **val;
    void init(int _rows,int _colums)
    {
        rows=_rows,colums=_colums;
        val=new float*[rows];
        for(int i=0; i<rows; i++)
        {
            val[i]=new float[colums];
            for(int j=0; j<colums; j++)
                val[i][j]=(rand()%200-100)/100.0;
        }
    }
};
float tanh(float x){
    x=exp(x);x=x*x;
    return  (x-1)/(x+1);
}
struct NerualNetwork
{
    int layoutNum;
    float factor=0.02;
    Matrix *X,*U,*V,*H,*B;
    Matrix *D,*dU,*dV,*dB,*TU,*TV,*TB;
    Matrix Softmax;
    std::vector<int>layout;
    void addLayout(int number)
    {
        layout.push_back(number);
        layoutNum++;
    }
    void bulid(){
        X=new Matrix[layoutNum];
        H=new Matrix[layoutNum];
        D=new Matrix[layoutNum];


        U =new Matrix[layoutNum];
        dU=new Matrix[layoutNum];
        TU=new Matrix[layoutNum];
        V =new Matrix[layoutNum];
        dV=new Matrix[layoutNum];
        TV=new Matrix[layoutNum];
        B =new Matrix[layoutNum];
        dB=new Matrix[layoutNum];
        TB=new Matrix[layoutNum];

        srand(time(NULL));
        X[0].init(layout[0],1);
        D[0].init(layout[0],1);
        for(int i=1;i<layoutNum;i++){
            X[i].init(layout[i],1);
            H[i].init(layout[i],1);
            D[i].init(layout[i],1);

             U[i].init(layout[i],layout[i-1]);
            dU[i].init(layout[i],layout[i-1]);
            TU[i].init(layout[i],layout[i-1]);
             V[i].init(layout[i],layout[i]);
            dV[i].init(layout[i],layout[i]);
            TV[i].init(layout[i],layout[i]);
             B[i].init(layout[i],1);
            dB[i].init(layout[i],1);
            TB[i].init(layout[i],1);
        }
        Softmax.init(layout[layoutNum-1],1);
    }
    void clearMenory(){
        for(int k=1;k<layoutNum;k++)
            for(int i=0;i<H[k].rows;i++)
                X[k].val[i][0]=0;
    }
    void InitTrainMenory(){
        for(int k=1;k<layoutNum;k++){
            for(int i=0;i<B[k].rows;i++)dB[k].val[i][0]=TB[k].val[i][0]=0;
            for(int i=0;i<U[k].rows;i++){
                memset(dU[k].val[i],0,dU[k].colums*4);
                memset(TU[k].val[i],0,TU[k].colums*4);
            }
            for(int i=0;i<V[k].rows;i++){
                memset(dV[k].val[i],0,dV[k].colums*4);
                memset(TV[k].val[i],0,TV[k].colums*4);
            }
        }
    }
    int updateSoftmax(){
        float sum=0;
        Matrix M=X[layoutNum-1];
        for(int i=0;i<M.rows;i++){
            Softmax.val[i][0]=exp(M.val[i][0]);
            sum+=Softmax.val[i][0];
        }
        int k=0;
        for(int i=0;i<M.rows;i++){
            Softmax.val[i][0]/=sum;
            if(Softmax.val[i][0]>Softmax.val[k][0])k=i;
        }
        return k;
    }
    Matrix run(int input){
        for(int i=0;i<X[0].rows;i++)X[0].val[i][0]=0;
        X[0].val[input][0]=1;
        for(int k=1;k<layoutNum;k++)
        {
            for(int i=0;i<H[k].rows;i++)H[k].val[i][0]=X[k].val[i][0];
            for(int i=0;i<X[k].rows;i++){
                X[k].val[i][0]=B[k].val[i][0];
                for(int j=0;j<U[k].colums;j++)
                    X[k].val[i][0]+=U[k].val[i][j]*X[k-1].val[j][0];

                for(int j=0;j<X[k].rows;j++)
                    X[k].val[i][0]+=V[k].val[i][j]*H[k].val[j][0];
                X[k].val[i][0]=tanh(X[k].val[i][0]);
            }
        }
        return X[layoutNum-1];
    }
    void Partial(int label){
        if(label==-1){
            for(int i=0;i<D[layoutNum-1].rows;i++)
                D[layoutNum-1].val[i][0]=0;
        }else{
            updateSoftmax();
            for(int i=0;i<D[layoutNum-1].rows;i++)
                D[layoutNum-1].val[i][0]=Softmax.val[i][0];
            D[layoutNum-1].val[label][0]-=1;
        }
        for(int k=layoutNum-1;k>0;k--){

            for(int i=0;i<V[k].colums;i++){
                float sum=0;
                for(int j=0;j<V[k].rows;j++)sum+=V[k].val[j][i];
                for(int j=0;j<TU[k].colums;j++)TU[k].val[i][j]*=sum;
                for(int j=0;j<TV[k].colums;j++)TV[k].val[i][j]*=sum;
                TB[k].val[i][0]*=sum;
            }
            for(int i=0;i<TU[k].rows;i++)
            for(int j=0;j<TU[k].colums;j++){
                TU[k].val[i][j]=(TU[k].val[i][j]+X[k-1].val[j][0])*(1-X[k].val[i][0]*X[k].val[i][0]);
                dU[k].val[i][j]+=TU[k].val[i][j]*D[k].val[i][0];
            }

            for(int i=0;i<TV[k].rows;i++)
            for(int j=0;j<TV[k].colums;j++){
                TV[k].val[i][j]=(TV[k].val[i][j]+H[k].val[j][0])*(1-X[k].val[i][0]*X[k].val[i][0]);
                dV[k].val[i][j]+=TV[k].val[i][j]*D[k].val[i][0];
            }
            for(int i=0;i<TB[k].rows;i++){
                TB[k].val[i][0]=(TB[k].val[i][0]+1)*(1-X[k].val[i][0]*X[k].val[i][0]);
                dB[k].val[i][0]+=TB[k].val[i][0]*D[k].val[i][0];
            }
            for(int i=0;i<U[k].colums;i++){
                D[k-1].val[i][0]=0;
                for(int j=0;j<U[k].rows;j++)
                    D[k-1].val[i][0]+=U[k].val[j][i]*(1-X[k].val[j][0]*X[k].val[j][0])*D[k].val[j][0];
            }
        }
    }
    void UpdateTrain(){
        for(int k=1;k<layoutNum;k++){
            for(int i=0;i<B[k].rows;i++)B[k].val[i][0]-=dB[k].val[i][0]*factor;
            for(int i=0;i<U[k].rows;i++)
                for(int j=0;j<U[k].colums;j++)
                    U[k].val[i][j]-=dU[k].val[i][j]*factor;
            for(int i=0;i<V[k].rows;i++)
                for(int j=0;j<V[k].colums;j++){
                    V[k].val[i][j]-=dV[k].val[i][j]*factor;

                }
        }
    }
}RNN;
int main()
{
    RNN.addLayout(5);
    RNN.addLayout(5);
    RNN.addLayout(5);
    RNN.bulid();
    for(int i=0;i<10000;i++){
        for(int j=0;j<5;j++)
        {
            RNN.InitTrainMenory();
            RNN.clearMenory();
            for(int k=0;k<4;k++){
                RNN.run((k+j)%5);
                if(k==3)RNN.Partial((4+j)%5);
                else RNN.Partial(-1);
            }
            RNN.UpdateTrain();
        }
    }
    for(int j=0;j<5;j++)
    {
        RNN.clearMenory();
        for(int k=0;k<4;k++)RNN.run((k+j)%5),printf("%c ",'a'+(k+j)%5);
        int ans=RNN.updateSoftmax();
        printf(" -->%c\n",'a'+(ans));
    }

    return 0;
}

用 a b c d e 训练RNN

输入四个字母 预测第五个字母是啥
在这里插入图片描述

开心苏苏
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现RNN的前向推理——实现手写数字识别
qq_45430594的博客
04-11 2170
目录1.循环神经网络2.循环神经网络计算过程3.C语言实现 1.循环神经网络   循环神经网络的单个神经元模型如下图所示，与以往的神经元相比它包含了一个反馈输入，如果将其按照时间变化展开可以看到循环神经网络单个神经元类似一系列权值共享前馈神经元的依次连接，连接后同传统神经元相同随着时间的变化输入和输出会发生变化，但不同的是循环神经网络上一时刻神经元的“历史信息”会通过权值与下一时刻的神经元相连接，这样循环神经网络在 t 时刻的输入完成与输出的映射且参考了 t 之前所有输入数据对网络的影响，形成了反馈网络结构
循环神经网络（RNN）
CSTGYinZong的博客
07-29 1124
它能挖掘数据中的以及。利用了RNN的这种能力，使深度学习模型在解决语音识别、语言模型、机器翻译以及时序分析等NLP领域的问题时有所突破。
C++元编程——单向深度RNN实现
Dr_Jack的博客
12-07 657
书接上文，话说两端。通过节点建立RNN有点麻烦，现在又搞了一个深度RNN。就是把单个RNN堆叠起来。废话不多，直接搞代码： 最后运算结果显示，这个多层的RNN也是有学习能力的。由于没有足够多的有关联数据（也比较懒，不想搞），所以就没正经试验过。有兴趣的小朋友们可以用自己的数据试一试。
RNN递归神经网络的详细推导及C++实现
热门推荐
新博客：https://aping-dev.com/
10-11 1万+
//让程序自己学会是否需要进位，从而学会加法#include "iostream" #include "math.h" #include "stdlib.h" #include "time.h" #include "vector" #include "assert.h" using namespace std;#define innode 2 //输入结点数，将输入2个加数 #defi
C++实现的神经网络
09-14
虽然用C++实现神经网络会比较麻烦，不过如果注意到以下下的trick, 在用C++实现神经网络时会舒服很多，代码也会非常简明，核心代码在百行左右也不是问题。 C++没有内置的向量,矩阵库，可以自己先轮几个Vector, Matrix类以及各种数学运算操作，最好搞成链式操作。 不要用index form来推导和实现BP算法，个人比较喜欢matrix form, 公式会非常紧凑，实现起来也不太容易出错 顶层框架设计，比如先设计几个基类Model类，数据库类，定义几个通用的接口。实现具体的算法时，只要实现特定接口即可。 我最近实现了一把基本的神经网络，包括LR和多层NN模型, 使用C++11， Visual Studio 2017开发
基于C++的 RNN/lstm神经网络算法（不调用外源库）
最新发布
修行之路
09-17 745
基于C++的 RNN/lstm神经网络算法（不调用外源库）
C语言实现RNN项目时遇到的一些问题
liuxiangxxl的博客
08-23 768
#include&lt;stdio.h&gt; void main() {     FILE *fw=fopen("D:\\data.txt","r");     int i,j,a[4][5];     for(i=0;i&lt;4;i++)         {         for(j=0;j&lt;5;j++)         {             fscanf(fw,"%d",&a...
BP神经网络 c++完整实现代码
01-08
**BP神经网络** BP（Backpropagation）神经网络是一种基于梯度下降的监督学习算法，广泛应用于模式识别、...同时，也可以将其作为基础，扩展为更复杂的神经网络结构，如卷积神经网络（CNN）或循环神经网络（RNN）。
cpp-OpenNN开放神经网络库
08-16
1. **神经网络结构**：支持多种类型的神经网络结构，如前馈神经网络、多层感知器、卷积神经网络（CNN）和递归神经网络（RNN），用户可以根据具体任务选择合适的网络架构。 2. **训练算法**：包括随机梯度下降、动量...
BP_C.zip_BP神经网络
09-19
在这个BP神经网络的C语言实现中，`BP_C.cpp`很可能是包含网络结构定义、训练算法以及前向传播和反向传播计算的核心代码文件。 BP神经网络通常包括输入层、隐藏层和输出层。输入层接收原始数据，隐藏层处理这些数据...
simple-rnn:具有Boost的C ++中的递归神经网络
05-21
简单 具有Boost的C ++中的递归神经元网络 这是Alex Graves令人难以置信的多维rnnlib的部分简化版本。 它使用较小的功能集，并降低了复杂性，可以再次使用一维数据。 有关其实现的更多详细信息，请参见 ，此项工作的全部著作归Alex Graves所有。 该库的作者没有任何财产，但会尽其所能维护该库。 原始项目是根据GPLv3许可证发布的，此处同样适用。 简单的RNN自述文件 RNNLIB用C ++编写，并且可以在任何平台上进行编译。 但是，仅在VS2012上进行了重新设计和测试。 构建它需要满足以下条件： 现代C ++编译器（例如gcc 3.0或更高版本） Boost C ++库1.36版或更高版本（仅标头，无需编译）
RNN实现源码
04-29
RNN的实现源码
frnn:C ++快速递归神经网络库
05-16
快速神经网络 概述 frnn是一个用c ++编写的快速循环神经网络库，它使用CUDA和OpenMP进行并行化。 它支持RNN的所有可能的配置。 将为CPU-GPU和纯CPU系统提供支持，并将根据其功能确定用于每个功能的设备。 文献资料 该代码有充分的文档记录，并为所有类，结构，函数和变量提供了说明。 另外，将在上提供更多的文档，但是，这样做会很慢，因为主要的重点是首先在代码中提供带有文档的功能，然后再进行彻底的文档编写。 编译并运行 事先要求 CUDA（当前为GPU和CPU所必需） 您将需要安装CUDA SDK，因为代码中的很大一部分使用CUDA。 当前，用于GPU和CPU版本的makefile中没有单独的组件，如果没有GPU，编译器将选择功能的CPU实现，因此两个版本都需要CUDA SDK（我意识到这是一个问题，并且将对其进行纠正）。 此外，Makefile假定CUDA安装为/u
RNN
03-18
RNN
cpp-DyNet动态神经网络库
08-16
这意味着开发者可以在运行时根据数据或算法需求动态地添加、删除或更改操作节点，这在某些需要灵活结构的模型中非常有用，例如递归神经网络（RNN）和注意力机制。 **2. C++和Python接口** DyNet提供了C++和Python两...
cpp-persistentrnn百度开源的递归神经网络库
08-16
**cpp-persistentrnn百度开源的递归神经网络库** 递归神经网络（Recursive Neural Network，简称RNN）是一种能够处理序列数据的深度学习模型，它具有记忆单元，可以捕捉序列中的长期依赖关系。在自然语言处理（NLP...
C++元编程——计算链和RNN
Dr_Jack的博客
12-06 566
反向传播时候有个计算链，误差传播时也是反向走过各个计算链，所以这个计算链的概念很重要。下面是这个计算链的实现cal_chain.hpp： 下面看一看用这个计算链实现RNN： 这个用法当然不是RNN的常规用法。真正的RNN训练应该用一段固定长度的序列进行计算。最好有层内正反向两个传播节点。
C++元编程——双向RNN
Dr_Jack的博客
12-08 170
可以看到，训练只要训练6000次结果就稳定了，但是问题在于出来的结果和期望结果有一定的差距。可以看出输出结果是各个输入数据的均值，这个就非常尴尬了。我觉得这和我的训练方式不当可能有关系，下次可以试验每个输入都进行多次训练，直到结果稳定再进行下一个输入的训练。这个试验代码定义了一个3层的DRNN，输入输出分别是3->8->16->2。第二层输入是8*1矩阵；一层包含两个方向的横向节点，最终输出是根据两个节点的输出加权得到。搞了一个双向的RNN，按照网上介绍的双向RNN实现出来的，但是试验结果确非常奇葩。
RNN神经网络
DRAmonster的博客
10-21 3191
RNN神经网络 RNN网络是一种基础的多层反馈神经网络，该神经网络的节点定向连接成环。相比于前馈神经网络，该网络内部具有很强的记忆性，它可以利用内部的记忆来处理任意时序的输入序列。 循环网络的概念 循环网络是一种对序列数据有较强的处理能力的网络。在网络模型中不同部分进行权值共享使得模型可以扩展到不同样式的样本，比如CNN网络中一个确定好的卷积核模板，几乎可以处理任何大小的图片。将图片中分成多个区域，使用同样的卷积核对每一个区域进行处理，最后可以获得非常好的处理结果。 同样的，循环网络使用类似的模块（形式上相
python实现RNN神经网络
03-28
以下是一个简单的Python代码示例，用于实现基本的循环神经网络(RNN)： ``` import numpy as np # 定义sigmoid函数 def sigmoid(x): return 1 / (1 + np.exp(-x)) # 定义RNN类 class RNN: def __init__(self, input_size, hidden_size, output_size): # 初始化权重矩阵 self.Wxh = np.random.randn(hidden_size, input_size) * 0.01 self.Whh = np.random.randn(hidden_size, hidden_size) * 0.01 self.Why = np.random.randn(output_size, hidden_size) * 0.01 # 初始化偏置向量 self.bh = np.zeros((hidden_size, 1)) self.by = np.zeros((output_size, 1)) def forward(self, x): # 初始化隐藏状态和输出 h = np.zeros((self.Whh.shape[0], 1)) y = np.zeros((self.Why.shape[0], 1)) # 循环计算 for i in range(len(x)): # 更新隐藏状态 h = sigmoid(np.dot(self.Wxh, x[i]) + np.dot(self.Whh, h) + self.bh) # 更新输出 y = np.dot(self.Why, h) + self.by return y # 测试 x = [np.array([[0], [1]]), np.array([[1], [0]]), np.array([[1], [1]]), np.array([[0], [0]])] y = [np.array([[1]]), np.array([[1]]), np.array([[0]]), np.array([[0]])] model = RNN(2, 16, 1) for i in range(1000): for j in range(len(x)): y_pred = model.forward(x[j]) loss = np.sum((y_pred - y[j])**2) # 反向传播 dL_dy = 2 * (y_pred - y[j]) dWhy = np.dot(dL_dy, model.h.T) dL_dh = np.dot(model.Why.T, dL_dy) + model.dh_next dh_raw = model.h * (1 - model.h) dh = dL_dh * dh_raw dbh = dh dWxh = np.dot(dh, x[j].T) dWhh = np.dot(dh, model.h.T) # 更新参数 model.Wxh -= 0.1 * dWxh model.Whh -= 0.1 * dWhh model.Why -= 0.1 * dWhy model.bh -= 0.1 * dbh model.by -= 0.1 * dL_dy model.dh_next = np.dot(model.Whh.T, dh) if i % 100 == 0: print("Epoch: {}, Loss: {}".format(i, loss)) ``` 这个代码示例实现了一个简单的RNN，用于二进制加法。它有2个输入神经元，16个隐藏神经元和1个输出神经元。它使用sigmoid作为激活函数，并使用反向传播算法进行训练。在训练过程中，它将输入序列通过RNN，计算输出并计算损失。然后，它使用反向传播算法计算梯度，并使用梯度下降算法更新权重矩阵和偏置向量。在每个epoch结束时，它会打印出损失值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值