pytorch 回归和分类

最新推荐文章于 2023-07-13 21:11:43 发布
最新推荐文章于 2023-07-13 21:11:43 发布
阅读量614 收藏 4
点赞数
分类专栏： 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43955530/article/details/103074860
版权

1 pytorch和numpy的对比

import torch
import numpy as np

np_data = np.arange(6).reshape((2,3))

torch_data = torch.from_numpy(np_data)

print(
      'numpy\n',np_data,
      '\ntorch\n',torch_data
      )

在这里插入图片描述
numpy和torch的数据类型是不一样的一个是numpy的数据类型一个是torch的数据类型

如果要讲torch转变回numpy数据类型，直接加一个.numpy()就可以了

tensor2array = torch_data.numpy()
print('\ntensor2array\n',tensor2array)

在这里插入图片描述

abs的对比

#abs
data = [-1,-2,1,2]
tensor = torch.FloatTensor(data)
print(tensor)
print(np.abs(data))
print(torch.abs(tensor))

在这里插入图片描述
可以参考
https://pytorch.org/docs/stable/torch.html#math-operations
查看torch里各种运算的使用

矩阵相乘

data = [[1,2],[3,4]]
tensor = torch.FloatTensor(data) #32-bit floating point

#print(tensor)

print('\nnumpy',np.matmul(data,data),
      '\ntorch',torch.mm(tensor,tensor))

在这里插入图片描述
mean的对比

print(np.mean(data))
print(torch.mean(tensor))

在这里插入图片描述

2 Variable变量

torch用tensor来计算，神经网络里流动的参数都是variable变量形式的，要把数据放在variable里面，让variable逐步更新神经网络

variable默认是不需要求导的，即requires_grad属性默认为False，如果某一个节点requires_grad被设置为True，那么所有依赖它的节点requires_grad都为True。

import torch
import numpy as np
from torch.autograd import Variable

tensor = torch.FloatTensor([[1,2],[3,4]])
variable = Variable(tensor,requires_grad = True)
#这里requires_grad指的是要不要把variable涉及到反向传播中去
#如果要就用True，否则用False

print(tensor)
print(variable)

在这里插入图片描述

import torch
import numpy as np

from torch.autograd import Variable

data = [[1,2],[3,4]]

tensor = torch.FloatTensor([[1,2],[3,4]])
variable = Variable(tensor,requires_grad = True)
#参数require_grad = True 表示计算梯度记录下来

print(tensor)
print(variable)

t_out = torch.mean(tensor*tensor)
v_out = torch.mean(variable*variable)
#
#
v_out.backward()#把误差反向传递
##v_out = 1/4*sum(variable*variable)
##d(v_out)/d(var) = 1/4*2*variable = variable/2
#
print(variable.grad) #打印传递后的梯度

print(variable.data) #打印variable里的tensor

#如果要把tensor转变为numpy的形式，要先.data再.numpy
print(variable.data.numpy())

在这里插入图片描述

3 激励函数

activate function是用来解决非线性问题的

线性方程y = Wx
将线性方程套上激励就变成了非线性问题y = AF（Wx）

激励函数：relu，tanh，sigmoid

仿真一下各个激励函数的样子：

import torch
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt

x = torch.linspace(-5,5,200) #在-5到5之间取200个数据点，x的数据类型是tensor的
x = Variable(x) #把tensor变成variable

#画图的时候tensor和variable都不能被matplotlib识别，所以要换成numpy类型
x_np = x.data.numpy()


#F.AF(x)就是用激励函数去处理这个x数据，x是一个variable的数据
#处理出来的也是一个variable类型的要.data换成tensor类型的再.numpy变成numpy类型的
y_relu = F.relu(x).data.numpy()
y_sigmoid = F.sigmoid(x).data.numpy()
y_tanh = F.tanh(x).data.numpy()
y_softplus = F.softplus(x).data.numpy()
#y_softmax = F.softmax(x) 是一个求概率的几率函数，对于分类问题的求解使用的


###然后画四个图来表示激励=函数的结果
plt.figure(1,figsize = (8,6))

plt.subplot(221)
plt.plot(x_np,y_relu,c = 'red',label = 'relu')
plt.ylim((-1,5))
plt.legend(loc = 'best')


plt.subplot(222)
plt.plot(x_np,y_sigmoid,c = 'red',label = 'sigmoid')
plt.ylim((-0.2,1.2))
plt.legend(loc = 'best')


plt.subplot(223)
plt.plot(x_np,y_tanh,c = 'red',label = 'tanh')
plt.ylim((-1.2,1.2))
plt.legend(loc = 'best')


plt.subplot(224)
plt.plot(x_np,y_softplus,c = 'red',label = 'softplus')
plt.ylim((-0.2,6))
plt.legend(loc = 'best')

在这里插入图片描述

4 Regression回归问题

回归是将不同属性的一个问题，最后得出一个最后的值，分析各个成分，给一些权重，得到一个评价值。

import torch
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt


xx = torch.linspace(-1,1,100)
x = torch.unsqueeze(torch.linspace(-1,1,100),dim = 1) 
#这个unsqueeze就是把一维的tensor变成二维的，在torch中只能处理二维的数据

print(xx.shape) #torch.Size([100])
print(x.shape) #torch.Size([100, 1])

y = x.pow(2) + 0.2*torch.rand(x.size())#y = x^2 + 一些噪点的影响

#要想用torch的神经网络处理，必须把tensor都变成variable
x,y = Variable(x),Variable(y)

###打印散点图
plt.scatter(x.data.numpy(),y.data.numpy())
plt.show()

在这里插入图片描述
上面构造一些数据，然后将用回归的办法来拟合一条曲线

###开始定义神经网络
class Net(torch.nn.Module): #从Module模块继承
    #定义阶段
    def __init__(self,n_feature,n_hidden,n_output):
        super(Net,self).__init__() #继承Net到模块
        self.hidden = torch.nn.Linear(n_feature,n_hidden)#隐藏层
        self.predict = torch.nn.Linear(n_hidden,n_output)#输出层
    #搭建神经网络过程
    def forward(self,x):#神经网络前向传递的过程
        x = F.relu(self.hidden(x))
        x = self.predict(x) #在输出的时候不用激励函数，因为用激励还输会截断一部分值的数据
        return x
    
net = Net(1,10,1) #feature为一维的，只有一个属性x，

print(net)

打印网络看一下

在这里插入图片描述
然后开始动态拟合曲线并表示出动态效果：

spyder不显示动态figure：参考

参考之后，窗口能独立显示

import numpy as np
import torch
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt


xx = torch.linspace(-1,1,100)
x = torch.unsqueeze(torch.linspace(-1,1,100),dim = 1) 
#这个unsqueeze就是把一维的tensor变成二维的，在torch中只能处理二维的数据

print(xx.shape) #torch.Size([100])
print(x.shape) #torch.Size([100, 1])

y = x.pow(2) + 0.2*torch.rand(x.size())#y = x^2 + 一些噪点的影响
#rand(size)表示size个0-1的随机数

#要想用torch的神经网络处理，必须把tensor都变成variable
x,y = Variable(x),Variable(y)

####打印散点图
#plt.scatter(x.data.numpy(),y.data.numpy())
#plt.show()


###开始定义神经网络
class Net(torch.nn.Module): #从Module模块继承
    #定义阶段
    def __init__(self,n_feature,n_hidden,n_output):
        super(Net,self).__init__() #继承Net到模块
        self.hidden = torch.nn.Linear(n_feature,n_hidden)#隐藏层
        self.predict = torch.nn.Linear(n_hidden,n_output)#输出层
    #搭建神经网络过程
    def forward(self,x):#神经网络前向传递的过程
        x = F.relu(self.hidden(x))
        x = self.predict(x) #在输出的时候不用激励函数，因为用激励还输会截断一部分值的数据
        return x
    
net = Net(1,10,1) #feature为一维的，只有一个属性x，

print(net)

#可视化步骤
plt.ion() #设置plt为一个动态打印的
#plt.show()


#开始优化
optimizer = torch.optim.SGD(net.parameters(),lr = 0.2)
#用SGD优化器来优化，传入net的参数，学习率是0.2，越高就学习的越快，但是过快会忽略一些细节

#loss function
loss_func = torch.nn.MSELoss()#均方差

#构造一个列表存prediction和loss
prediction_list = []
loss_list = []

for t in range(1000):
    prediction = net(x)
    loss = loss_func(prediction,y)#计算prediction和y的误差
    prediction_list.append(prediction.data.numpy())
    loss_list.append(loss.data.numpy())
    
    
    #优化
    optimizer.zero_grad()#每一次反向传递初，将所有梯度归零
    loss.backward()#将loss反向传递
    optimizer.step() #优化梯度


for t in range(1000):
    if t%5 == 0: #每学习五次就打印一次学习结果
        plt.pause(0.2)
        plt.cla()
        plt.scatter(x.data.numpy(),y.data.numpy())#画散点图
        plt.plot(x.data.numpy(),prediction_list[t],'r-',lw = 5)#每一次的预测数据,用线画出来
        plt.text(-0.5,1.0,'Loss = %.4f' % loss_list[t],fontdict = {'size':20,'color':'red'})
        plt.show()  
#        
plt.ioff()

在这里插入图片描述
在这里插入图片描述每次运行的初始数据是不一样的，得到的拟合曲线也不一样，loss也不一样，以上为两次不同的运行结果

刚开始采用0.5的学习率。学习太快了，不收敛，于是，调整到0.2，并加大训练次数100到1000，使结果loss更小一点

5 Classification 分类

首先来构造数据：

import numpy as np
import torch
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt

n_data = torch.ones(100,2)
x0 = torch.normal(2*n_data,1)
y0 = torch.zeros(100) #这一堆点的标签为0
x1 = torch.normal(-2*n_data,1)
y1 = torch.ones(100) #这一堆点的标签为1
#其中x0，y0，x1，y1分别是两个点簇的坐标和标签值
x = torch.cat((x0,x1),0).type(torch.FloatTensor) #FloatTensor = 32-bit floating
y = torch.cat((y0,y1),).type(torch.LongTensor) #LongTensor = 64-bit integer


#要想用torch的神经网络处理，必须把tensor都变成variable
x,y = Variable(x),Variable(y)

###打印散点图
plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c = y.data.numpy(),s = 100,lw = 0)
plt.show()

构造两个点簇，表示不同的类，用于神经网络的训练
打印出来结果：
在这里插入图片描述
其中：torch.normal()表示返回一个张量，张量里面的随机数是从相互独立的正态分布中随机生成的

查看神经网络：

import numpy as np
import torch
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt

n_data = torch.ones(100,2)
x0 = torch.normal(2*n_data)
y0 = torch.zeros(100) #这一堆点的标签为0
x1 = torch.normal(-2*n_data)
y1 = torch.ones(100) #这一堆点的标签为1
#其中x0，y0，x1，y1分别是两个点簇的坐标和标签值
x = torch.cat((x0,x1),0).type(torch.FloatTensor) #FloatTensor = 32-bit floating
y = torch.cat((y0,y1),).type(torch.LongTensor) #LongTensor = 64-bit integer


#要想用torch的神经网络处理，必须把tensor都变成variable
x,y = Variable(x),Variable(y)

####打印散点图
#plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c = y.data.numpy(),s = 100,lw = 0)
#plt.show()


###开始定义神经网络
class Net(torch.nn.Module): #从Module模块继承
    #定义阶段
    def __init__(self,n_feature,n_hidden,n_output):
        super(Net,self).__init__() #继承Net到模块
        self.hidden = torch.nn.Linear(n_feature,n_hidden)#隐藏层
        self.predict = torch.nn.Linear(n_hidden,n_output)#输出层
    #搭建神经网络过程
    def forward(self,x):#神经网络前向传递的过程
        x = F.relu(self.hidden(x))
        x = self.predict(x) #在输出的时候不用激励函数，因为用激励还输会截断一部分值的数据
        return x
    
net = Net(2,10,2) #feature为二维的，有两个属性x，y
#输出可能是[0,1]表示分类为第一类
#输出为[1,0]表示分类为第0类


print(net)

在这里插入图片描述
这个时候loss_function需要使用CrossEntropyLoss，针对于分类问题，会得出一个概率[0.1,0.3,0.6]，概率和为1，表示这个数据被分为每一个类的概率是多少

import numpy as np
import torch
import torch.nn.functional as F
from torch.autograd import Variable
import matplotlib.pyplot as plt

n_data = torch.ones(100,2)
x0 = torch.normal(2*n_data)
y0 = torch.zeros(100) #这一堆点的标签为0
x1 = torch.normal(-2*n_data)
y1 = torch.ones(100) #这一堆点的标签为1
#其中x0，y0，x1，y1分别是两个点簇的坐标和标签值
x = torch.cat((x0,x1),0).type(torch.FloatTensor) #FloatTensor = 32-bit floating
y = torch.cat((y0,y1),).type(torch.LongTensor) #LongTensor = 64-bit integer


#要想用torch的神经网络处理，必须把tensor都变成variable
x,y = Variable(x),Variable(y)

####打印散点图
#plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c = y.data.numpy(),s = 100,lw = 0)
#plt.show()


###开始定义神经网络
class Net(torch.nn.Module): #从Module模块继承
    #定义阶段
    def __init__(self,n_feature,n_hidden,n_output):
        super(Net,self).__init__() #继承Net到模块
        self.hidden = torch.nn.Linear(n_feature,n_hidden)#隐藏层
        self.predict = torch.nn.Linear(n_hidden,n_output)#输出层
    #搭建神经网络过程
    def forward(self,x):#神经网络前向传递的过程
        x = F.relu(self.hidden(x))
        x = self.predict(x) #在输出的时候不用激励函数，因为用激励还输会截断一部分值的数据
        return x
    
net = Net(2,10,2) #feature为二维的，有两个属性x，y
#输出可能是[0,1]表示分类为第一类
#输出为[1,0]表示分类为第0类


print(net)

#可视化步骤
plt.ion() #设置plt为一个动态打印的
#plt.show()


#开始优化
optimizer = torch.optim.SGD(net.parameters(),lr = 0.02)
#用SGD优化器来优化，传入net的参数，学习率是0.02，越高就学习的越快，但是过快会忽略一些细节

#loss function
#loss_func = torch.nn.MSELoss()#均方差
loss_func = torch.nn.CrossEntropyLoss()


for t in range(100):
    out = net(x)#此时的输出可能是[-2,-12,20,18]要在后面转化为概率
    loss = loss_func(out,y)#计算prediction和y的误差

    
    #优化
    optimizer.zero_grad()#每一次反向传递初，将所有梯度归零
    loss.backward()#将loss反向传递
    optimizer.step() #优化梯度
    
    if t%2 == 0:
        plt.cla()
        prediction = torch.max(F.softmax(out),1)[1] #softmax转换成概率,并取出概率最大的一个
        pred_y = prediction.data.numpy().squeeze()
        target_y = y.data.numpy()
        plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c = pred_y,s = 100,lw = 0)
        accuracy = sum(pred_y == target_y)/200
        plt.text(1.5, -4, 'Accuracy=%.2f' % accuracy, fontdict={'size': 20, 'color':  'red'})
        plt.pause(0.1)

##        
plt.ioff()
plt.show()

在这里插入图片描述

逆夏11111
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pytorch 分类和回归代码实现
weixin_42357472的博客
01-27 1410
#pytorch神经网络搭建主要就是如下步骤： a、准备数据 b、搭建层架构（input，隐藏层，output） c、loss和optimizer优化 d、反向传播更新 1.分类 import torch import torch.nn.functional as F import matplotlib.pyplot as plt # torch.manual_seed(1) # repr...
pytorch实现回归和分类
weixin_44698389的博客
03-27 1496
pytorch实现回归和分类 pytorch实现回归和分类pytorch实现回归和分类1.构建数据（1）回归数据（2）分类数据2.设置模型3.设置超参数和训练（1）回归（2）分类 在pytorch进行回归和分类时，中间模型设定部分和训练部分变化不大，主要变化的是输入输出数据的维度以及在进行loss计算时的损失函数。 首先导入必要的包 import torch import torch.nn as ...
Pytorch基础（一）- pytorch介绍，回归和分类问题
sherryhwang的博客
03-04 987
目录Pytorch发展及特点简单回归问题手写数字识别 Pytorch发展及特点 pytorch在torch7上进行开发的，2018年发布了第一个稳定的版本。 google、TensorFlow基于theano构建。Keras后端为Tensorflow FaceBook，Amazon pytorch借鉴了Chainer的API的设计规范。 自然语言处理：AllenNLP 计算机视觉：TorchVision 图卷积神经网络：Fast.ai 部署协议：onnx 通过常用的网络层，堆叠一些复杂的神经网络。
PyTorch上搭建简单神经网络实现回归和分类的示例
Quincylk的专栏
01-09 9148
原文：https://www.jb51.net/article/139098.htm 本文介绍了PyTorch上搭建简单神经网络实现回归和分类的示例，分享给大家，具体如下： 一、PyTorch入门 1. 安装方法 登录PyTorch官网，http://pytorch.org，可以看到以下界面： 按上图的选项选择后即可得到Linux下conda指令： ? 1 ...
33- PyTorch实现分类和线性回归 (PyTorch系列) (深度学习)
March_A的博客
03-06 2038
线性回归预测的是一个连续值, 逻辑回归给出的”是”和“否”的回答, 逻辑回归通过sigmoid函数把线性回归的结果规范到0到1之间.sigmoid函数是一个概率分布函数， 给定某个输入，它将输出为一个概率值.# 回归和分类之间, 区别不大, 回归后面加上一层sigmoid, 就变成分类了.(pytorch 最常见的创建模型的方式, 子类)# pytorch 最常见的创建模型的方式, 子类# 需要自定义类# 先调用父类的方法# 定义网络中会用到的东西.
PyTorch线性回归和逻辑回归实战示例
09-20
在PyTorch中实现线性回归和逻辑回归是深度学习初学者经常接触的基本任务，这两个模型也是理解机器学习基础的好入口。线性回归用于预测连续数值型数据，而逻辑回归则用于分类问题，特别是二分类问题。下面我们将详细...
Pytorch 搭建分类回归神经网络并用GPU进行加速的例子
09-18
在本教程中，我们将探讨如何使用PyTorch构建一个同时执行分类和回归任务的神经网络，并利用GPU进行加速。PyTorch是一个强大的深度学习框架，它提供了动态计算图的功能，使得构建、训练和调试神经网络变得更为灵活。 ...
PyTorch线性回归和逻辑回归实战示例.pdf
04-17
在这个实战示例中，我们探讨了如何使用 PyTorch 实现线性回归和逻辑回归。 线性回归是一种简单的统计模型，用于预测一个连续变量。在 PyTorch 中实现线性回归主要涉及以下几个步骤： 1. **设计网络架构**：线性...
PyTorch上搭建简单神经网络实现回归和分类的示例.pdf
04-17
本示例主要讲解如何在PyTorch平台上创建简单的神经网络模型，用于解决回归和分类问题。首先，我们来了解一下PyTorch的基本概念和操作。 PyTorch是一个开源的Python库，它提供了构建、训练和部署神经网络的工具。其...
Pytorch -＞ 回归与分类
xs520520wmy的博客
02-21 164
y预测 = w*x+b+eps eps ~ N (0.01，1) loss = Σ(y预测-y)^2 w’ = w-lr*▽loss/▽w（梯度/导数） 结果：w、b 回归问题 def compute_error(w,b,points): totalError = 0 # [[x,y],[x,y],...] for i in range(len(points)): x = points[i,0] y = points[i,1]
PyTorch基础（三）回归与分类
zhiguo98的博客
05-14 456
昨天终于把毕业论文的所有事情都完成了，之前学的一些深度学习知识有些又不记得了，一点点的复习，不过，复习起来还是比较容易的的，看一遍书，大致又都记起来了。学到了卷积神经网络，先利用pytorch搭建简单模型，然后再想着利用pytorch搭建别人的网络模型。 搭建模型的步骤 准备数据集 设计模型，计算y_hat，同时构造计算图 构建loss 构建优化器 训练更新 线性回归问题 import torch #准备数据集 x_data = torch.tensor([[1.0],[2.0],[3.0
PyTorch 实现 逻辑回归、多元分类
最新发布
谢TS的博客
07-13 625
线性回归 和 非线性回归 的输出都是连续的。逻辑回归 与 线性回归/非线性回归 区别在于 逻辑回归 的输出是 二元离散 的，即输出特征只有两种结果。逻辑回归是二元分类，属于多元分类的一种特殊情况。多元分类与二元分类类似，区别在于使用 softmax 函数替代 sigmoid 函数作为激活函数。如果分类的类别数为 n，则 softmax 函数接收 n 个输入，然后输出 n 个概率（概率之和为 1），概率最大的类别就是预测的类别。
torch之逻辑回归二分类
v7xyy的博客
08-14 823
使用pytorch做简单的2分类。 准备数据2fenlei.csv https://github.com/xiangkejun/machine_learning_xx/blob/master/tf2_xx/2fenlei.csv 创建 logtic_gress.py #encoding=utf-8 # 多层感知器 # 3个特征值 推出一个2分类结果 import pandas as...
PyTorch实现简单的逻辑回归
心升明月的博客
03-05 578
一、实现代码 和https://blog.csdn.net/weixin_43821559/article/details/123298468类似，代码如下： import torch import matplotlib.pyplot as plt import numpy as np import os os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE" # 1、准备数据 x_data = torch.Tensor([[1.0],[2.0],[3.0]]) y_d
PyTorch深度学习实践之用PyTorch实现线性回归
qq_62127680的博客
09-21 311
PyTorch学习摘要
pytorch 线性层_pytorch 模拟关系拟合——回归实例
weixin_39537680的博客
01-01 127
我们今天来用 pytroch 来实现一个简单的回归分析，也借此机会来熟悉 pytorch 的一些基本操作。1. 建立数据集2. 构建神经网络import torchimport torch.nn.functional as F # 激励函数都在这class Net(torch.nn.Module): # 继承 torch 的 Moduledef __init__(self, n_feat...
【PyTorch修炼】三、先做减法，具体例子带你了解torch使用的基本套路（分类和时间序列回归小例子）
AI蜗牛车
04-28 5997
一、前言 最近确实太忙了，没能很好的写这个系列的文章，但是大家不要急，好事多磨，我要保证每一篇的质量。 今天要讲的是利用torch去做实验，大体完成一个任务的写法框架思路。 因为这节之后我会大量的举例以及各种完整的代码细节讲解，大概意思就是我想利用例子把很多细节抠出来这样来说明一些知识点，这样操作可能要比直接列出来知识点更具体些，大家接受这些知识点也能更加的舒服一些。 二、做减法，思考整个流程都需...
reshape(-1,1),将数据以一列的形式呈现
weixin_39107270的博客
11-07 2348
25、pandas的reshape(1,-1)什么意思？ reshape可以用于numpy库里的ndarray和array结构以及pandas库里面的DataFrame和Series结构。 reshape函数 reshape（行，列）可以根据指定的数值将数据转换为特定的行数和列数，这个好理解，就是转换成矩阵。然而，在实际使用中，特别是在运用函数的时候，系统经常会提示是否需要对数据使用reshape...
PyTorch实战：逻辑回归与多元分类基础
在"PyTorch实现逻辑回归、多元分类-谢TS的博客.pdf"这篇文章中，作者探讨了逻辑回归和多元分类在深度学习框架PyTorch中的应用。首先，文章区分了线性回归和非线性回归，强调逻辑回归的独特性，它是一种特殊的二元...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值