Pytorch分布式编程

最新推荐文章于 2024-05-08 15:19:58 发布
最新推荐文章于 2024-05-08 15:19:58 发布
阅读量1.1k 收藏
点赞数 4
分类专栏： # Pytorch 人工智能 文章标签： 深度学习 pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzj_sxpi/article/details/115488316
版权

当我们拥有多块显卡时，可以使用并行计算来加速，Pytorch并行计算总要用DataParallel和DistributedDataParallel两种，前者主要应用于单机多卡的情况，而后者可以应用于单机多卡和多机多卡。由于作者资源有限，因此只能用单机多卡来做总结。
这里有详细的并行计算说明。
在这里插入图片描述
下面这张官方截图也详细说明了为什么DistributedDataParallel优于DataParallel。
在这里插入图片描述

一、使用DataParallel

参考文档：https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html

这种方式使用起来比较简单，只需要以下简单的几行代码即可实现。

import torch.nn as nn  #导入必需的包

net = Model() #模型初始化
net = nn.DataParallel(net)  #应用于分布式编程

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  # 查找GPU设备
net.to(device)  #在GPU中运行

全部代码

import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
class Model(nn.Module):
    def __init__(self, input_size, output_size):
        super(Model, self).__init__()
        self.fc = nn.Linear(input_size, output_size)

    def forward(self, input):
        output = self.fc(input)
        print("\tIn Model: input size", input.size(),
              "output size", output.size())

        return output

class RandomDataset(Dataset):
    def __init__(self, size, length):
        self.len = length
        self.data = torch.randn(length, size)

    def __getitem__(self, index):
        return self.data[index]

    def __len__(self):
        return self.len

input_size = 5
output_size = 2

batch_size = 30
data_size = 100
rand_loader = DataLoader(dataset=RandomDataset(input_size, data_size),
                         batch_size=batch_size, shuffle=True)
model = Model(input_size, output_size)

if torch.cuda.device_count() > 1: 
    print("Let's use", torch.cuda.device_count(), "GPUs!")

    #可以在添加第二个参数：device_ids=[0, 1, 2]，表示只在第0，1，2块上做训练
    #默认是在所有显卡上
    model = nn.DataParallel(model)

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

model.to(device)

for data in rand_loader: 
    input = data.to(device)
    output = model(input)
    print("Outside: input size", input.size(),"output_size", output.size())

运行结果
在这里插入图片描述

二、使用DistributedDataParallel

这个正如官方所说，比较复杂但是效率更高
参考文档：https://pytorch.org/docs/stable/distributed.html#
由于不同的后端通信方式的能力不同，因此这里只研究Nvidia的GPU上使用的nccl。也就是只涉及下面红框中打勾的函数。其余的遇到再进行研究。
在这里插入图片描述

初始化

torch.distributed.init_process_group()

在进行所有操作之前必须首先调用torch.distributed.init_process_group进行初始化

torch.distributed.init_process_group(backend, init_method=None, timeout=datetime.timedelta(0, 1800), world_size=-1, rank=-1, store=None, group_name=’’)

主要参数说明

  1. backend: 选择后端通信方式，这是一个str或Backend类型。根据官方文档，Nvidia推荐使用nccl，所以本博客只写有关nccl的 。
  2. init_method:指定如何初始化进程组。如果没有指定init_method或store, 这里则默认为env://。与store参数互斥。

如果在文件，它必须遵守如下格式

  • 本地文件系统, init_method=“file:///d:/tmp/some_file”
  • 共享文件系统, init_method=“file://{machine_name}/{share_folder_name}/some_file”
  1. world_size : Number of processes participating in the job. Required if store is specified.
  2. rank: Rank of the current process (it should be a number between 0 and world_size-1). Required if store is specified.
  3. store:一个键值对，用于交换连接与地址信息，与init_method互斥。

实在不知道3，4如何翻译，自我理解是world_size代表本机有几块GPU，而rank是说当前在哪块GPU上运算。

一句话可以概括的函数

函数原型英文说明试着翻译翻译
torch.distributed.is_available()Returns True if the distributed package is available返回是否支持分布式
torch.distributed.get_backend(group=None)Returns the backend of the given process group.返回给定给的后端通信名称
torch.distributed.get_rank(group=None)Returns the rank of current process group返回当前进程在哪个GPU上运行
torch.distributed.get_world_size(group=None)Returns the number of processes in the current process group返回当前可以运行的GPU总数
torch.distributed.is_initialized()Checking if the default process group has been initialized返回分布式运算是否初始化完成
torch.distributed.is_nccl_available()Checks if the NCCL backend is available.返回nccl是否可用
torch.distributed.is_mpi_available()Checks if the MPI backend is available.返回MPI是否可用

当前有三种初始化方式

  • TCP方式
    此方法指定一个rank0的IP地址，其他进行也必须手工指定rank.不支持广播地址，group_name也被废弃
import torch.distributed as dist

#Use address of one of the machines
dist.init_process_group(backend, init_method='tcp://10.1.1.20:23456',
											rank=args.rank, world_size=4)
  • 共享文件方式
    这种共享方式要求URL以file://开头并且在共享文件系统上指定一个不存在的文件（文件所在的目录存在）。这种方式将会自动创建而不会删除此文件，因此在下一次调用相同的文件时要手动清理(必须确保文件为空或者不存在，否则会出现未知错误，不支持rank自动分配，group_name也被废除）
import torch.distributed as dist

#rank should always be specified
dist.init_process_group(backend, init_method='file:///mnt/nfs/sharedfile',
                        world_size=4, rank=args.rank)
  • 环境变量方式
    从环境变量中读取，需要设置的变量至少包含:
    • MASTER_PORT：rank0上的空闲端口
    • MASTER_ADDR：rank0上的地址（rank0除外）
    • WORLD_SIZE: 可以在这里设置，也可以在初始化函数中设置
    • RANK: 可以在这里设置，也可以在初始化函数中设置
  1. 这种方式下rank0将被用来建立所有结点
  2. 这也是默认的初始化方法，意味着不必指定init_method(或者可以是env://)。

同步和异步操作集合函数

每一个集合操作函数都支持同步(Synchronous operation) 与异步(Asynchronous operation)两种操作，这依赖于async_op设置。同步操作(async_op=False)是默认的操作。
在这里插入图片描述

主要函数

函数原型
函数作用
参数
返回值
备注
torch.distributed.broadcast(tensor, src, group=None, async_op=False)将tensor广播给同组的所有成员1.tensor (Tensor) 如果src是当前的rank号，则广播出去，否则用于保存接收的数据 .
2.src (int) – Source rank.
3. group (ProcessGroup, optional) 要作用到的组.		如果async_op设置为True，则返回异步工作操作句柄，否则返回None。
torch.distributed.broadcast_object_list(object_list, src=0, group=None)广播在object_list中可picklabel的目标给整个组。1. object_list((List[Any]) 要发送的可picklable列表对象，也可以包括Python对象
2. src(int) 源		None. If rank is part of the group, object_list will contain the broadcasted objects from src rank.1. 基于NCLL的通信，Tensor在通信之前必须移动到GPU设备上。通过torch.cuda.current_device()获得当前工作在哪块GPU上，通过torch.cuda.set_device()来设置当前的rank工作的GPU。
2. 这个API是一个阻塞调用。
torch.distributed.all_reduce(tensor, op=<ReduceOp.SUM: 0>, group=None, async_op=False)减少所有设备中的Tensor数据，使所有设备都能得到最终结果。1. tensor(Tensor)-传入传出
2. op(可选)[torch.distributed.ReduceOp]()中的值。		Async work handle, if async_op is set to True. None, if not async_op or if not part of the group我的理解是计算所有设备上的数据，计算完成后清除，所以减少了 (还有待在用的过程中验证)
torch.distributed.reduce(tensor, dst, op=<ReduceOp.SUM: 0>, group=None, async_op=False)减少所有设备中的Tensor数据1. dst(int) 目标rankAsync work handle, if async_op is set to True. None, if not async_op or if not part of the group和上一行的区别是只有dst的设备能得到最终结果。
torch.distributed.all_gather(tensor_list, tensor, group=None, async_op=False)将整个组的张量收集到列表中1. tensor_list(list[Tensor]) 用于集合后Tensor的输出
2.tensor(Tensor) 在当前进程中进行广播的Tensor		Async work handle, if async_op is set to True. None, if not async_op or if not part of the group
torch.distributed.all_gather_object(object_list, obj, group=None)收集整个组的可picklable对象加入列表（也可加入Pytorch对象）1.Object_list(list[Any]) 输入list对象
2.object(Any) 从当前进程中广播的Pickable Python对象。		None. If the calling rank is part of this group, the output of the collective will be populated into the input object_list. If the calling rank is not part of the group, the passed in object_list will be unmodified.1. 基于NCLL的通信，Tensor在通信之前必须移动到GPU设备上。通过torch.cuda.current_device()获得当前工作在哪块GPU上，通过torch.cuda.set_device()来设置当前的rank工作的GPU。
2. 这个API是一个阻塞调用。
torch.distributed.gather(tensor, gather_list=None, dst=0, group=None, async_op=False)在单个进程中收集Tensor1.tensor(Tensor) 输入Tensor
2.gather_list(list[Tensor]) 用于收集数据的Tensor(必须在dst中指定目标设备)		Async work handle, if async_op is set to True. None, if not async_op or if not part of the group
torch.distributed.scatter(tensor, scatter_list=None, src=0, group=None, async_op=False)将Tensor分散到组内的所有进程，每个进程只接收一个张量1. tensor(Tensor) 输出tensor
2.scatter_list(list[Tensor]) 要分散的tensor列表
3.src(int) 源rank		Async work handle, if async_op is set to True. None, if not async_op or if not part of the group
torch.distributed.scatter_object_list(scatter_object_output_list, scatter_object_input_list, src=0, group=None)将scatter_object_output_list列表中的可picklabel对象分散到整个组（Python对象也可加入）。每一个 rank，可分散的对象将被存储在scatter_object_output_list的第一个元素。1.scatter_object_output_list(List[Any]) 非空列表，其第一个元素将存储到当前rank。
scatter_object_input_list (List[Any]) 待分散对象列表，仅src参数上的rank会被分散，其他非rank，此项可设置为None。3. src(int) Source rank from which to scatter scatter_object_input_list。		None. If rank is part of the group, scatter_object_output_list will have its first element set to the scattered object for this rank.
torch.distributed.reduce_scatter(output, input_list, op=<ReduceOp.SUM: 0>, group=None, async_op=False)Reduces, then scatters a list of tensors to all processes in a group.1. output(Tensor) 输出Tensor
2.input_list(list[Tensor]) 用来reduce和scatter的tensor列表		Async work handle, if async_op is set to True. None, if not async_op or if not part of the group.
torch.distributed.barrier(group=None, async_op=False, device_ids=None)同步所有进程device_ids ([int]) device/GPU列表Async work handle, if async_op is set to True. None, if not async_op or if not part of the group如果async_op为False，或者在wait()上调用了异步句柄，则该集合将阻塞进程，直到整个组都进入该函数。

表格太丑了，后期还得学点CSS知识调调样子

启动

单节点多设备

 python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
           YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3 and all other
           arguments of your training script)

多节点多设备

  • 节点1
python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
           --nnodes=2 --node_rank=0 --master_addr="192.168.1.1"
           --master_port=1234 YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3
           and all other arguments of your training script)
  • 节点2
python -m torch.distributed.launch --nproc_per_node=NUM_GPUS_YOU_HAVE
           --nnodes=2 --node_rank=1 --master_addr="192.168.1.1"
           --master_port=1234 YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3
           and all other arguments of your training script)

寻找帮助

python -m torch.distributed.launch --help

提示

  • 只有使用NCCL后端才能到达最佳性能
  • 必须通过命令行参数传递--local_rank=LOCAL_PROCESS_RANK，如果用GPU训练，还要确保代码仅仅运行在LOCAL_PROCESS_RANK的GPU上，可以通过以下两种方式实现

首先解析local_rank参数

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--local_rank", type=int)
args = parser.parse_args()

然后设置在当前rank上运行

方式一：在代码运行之前调用
torch.cuda.set_device(args.local_rank) 

方式二：用with封装
 with torch.cuda.device(args.local_rank):
	 #运行代码
  • 应该在开始时调用以下函数来启动分布式后端。 确保init_method使用env://，这是唯一支持的初始化方法。
torch.distributed.init_process_group(backend='YOUR BACKEND',
                                     init_method='env://')

model = torch.nn.parallel.DistributedDataParallel(model,
                                                  device_ids=[args.local_rank],
                                                  output_device=args.local_rank)
  • 亦可以通过环境变量LOCAL_RANK将local_rank传递给子进程，这必须在启动脚本时使用--use_env=True来激活这种方式，这时要调整示例流程，用os.environ['LOCAL_RANK']替换args.local_rank。此时将不会传递--local_rank变量。

local_rank并不是全局唯一的，它仅在设备的每个进程上是唯一的。 因此，不能使用它来决定是否应写入网络文件系统。 如果未正确执行操作，可能会出现问题（https://github.com/pytorch/pytorch/issues/12042)。

代码示例

下周再写

贱贱的剑
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
pytorch 分布式训练
qq_29981283的博客
11-06 1932
pytorch 分布式训练 参考文献 https://pytorch.org/tutorials/intermediate/dist_tuto.html demo import os import torch import torch.distributed as dist from torch.multiprocessing import Process def run(rank, size)...
Pytorch 分布式模式介绍
weixin_36670529的博客
05-19 1万+
一 分布式训练策略 数据较多或者模型较大时，为提高机器学习模型训练效率，一般采用多GPU的分布式训练。 按照并行方式，分布式训练一般分为数据并行和模型并行两种， 模型并行：分布式系统中的不同GPU负责网络模型的不同部分。例如，神经网络模型的不同网络层被分配到不同的GPU，或者同一层内部的不同参数被分配到不同GPU； 数据并行：不同的GPU有同一个模型的多个副本，每个GPU分配到不同的数据，...
pytorch 多卡分布式训练 调用all_gather_object 出现阻塞等待死锁的问题
ReadyShowShow的博客
09-12 511
torch._C._distributed_c10d中的函数all_gather_object 出现阻塞等待死锁的问题。解决办法就是 在进程通信之前调用torch.cuda.set_device(local_rank)pytorch 多卡分布式训练。
distributed_pytorch:使用Dask和PyTorch课程进行并行化和分布式计算
05-19
使用Dask和PyTorch课程进行并行化和分布式计算 数据科学为商业，学术界和其他部门带来不可否认的价值。 随着我们开始意识到这一点，企业和组织已经在收集和存储比以往任何时候都更多的数据。 因此，数据科学从业者所面临的挑战不是复杂的机器学习方法，而是我们处理大量数据的能力。 将并行化和分布式计算应用于机器学习用例（例如计算机视觉任务）可以提高速度和生产率，从而使我们能够充分利用海量数据和复杂方法。 利用分布式计算并将标准Python转换为优化的并行代码可能是具有挑战性的。 学完本课程后，学生将掌握使用分布式计算和并行化以扩大其机器学习所需的基础知识。 本课程将包括一个案例研究示例，演示使用PyTorch进行图像分类的这些策略，PyTorch是可以受益于并行化的多种机器学习方法之一。 学习目标 学完本课程后，学生将能够： 描述什么是分布式计算，并了解如何访问云中的机器集群并与之交互 解
【Pytorch API笔记9】用torch.distributed.barrier()进行同步操作
最新发布
hjxu2016的博客
05-08 231
当一个进程调用 torch.distributed.barrier()时，这个进程将会被阻塞，知道所有进程都调用了。torch.distributed.barrier()是一个同步操作，通常用在分布式训练中，同步不同进程的操作。torch.distributed.barrier()，然后会同时解除所有阻塞，几乎执行后续的操作。
torch.distributed
热门推荐
weixin_36670529的博客
05-19 1万+
Backends torch.distributed supports three backends, each with different capabilities. The table below shows which functions are available for use with CPU / CUDA tensors. MPI supports CUDA only if th...
torch.cudn.is_available()返回false解决方案
qq_41776136的博客
03-01 271
环境 系统：ubuntu18.04 显卡：gtx1070 之前，一直用pytorch用的好好的，今天突然不能调用gpu了，很奇怪，在网上好一通找。大部分都是说什么pytorch和cuda的版本对应不正确，我寻思不对啊之前都用的好好的怎么会突然版本不对呢？ 赶紧查查cuda版本： nvcc –V 或者 cat /usr/local/cuda/version.txt 显示是没变化的。难道是pytorch版本不小心升级了？ 再去anaconda中新建一个环境，安装pytorch对应版本： 可以在官网找到合.
PyTorch 1.0 正式版已经发布了
09-19
社区的创新项目不断拓展PyTorch的应用边界，如Horovod，这是一个分布式训练框架，简化了多GPU训练；PyTorch Geometry，提供了几何计算机视觉的模块；TensorBoardX则使得PyTorch模型可以与TensorBoard兼容，利用可视...
人工智能最火编程语言 Python大战Java!.pdf
04-17
Scala由于与Apache Spark的紧密关系，近年来在数据处理和分布式计算中崭露头角，增长趋势显著。其结合了面向对象和函数式编程的特点，适合处理大规模数据流。而Julia则是一种新兴的高性能计算语言，尽管目前市场份额...
计算机python编程试题,机器学习,深度学习试题及答案.pdf
11-16
- 深度学习框架：B选项Hadoop是一个分布式计算框架，不是深度学习开发平台；而Caffe、TensorFlow和PyTorch都是常见的深度学习框架。 - 无监督学习：KMeans是一种无监督学习算法，用于聚类；LR（逻辑回归）和SVM...
分布式并行计算：SJTU CS433分布式并行计算课程
02-20
CS433分布式并行计算课程 此仓库包含一些有关 OpenMP的 卡达 我们的最终项目-优化Caffe 前两个作业很幼稚，但是它们给了我们并行编程的基本感觉，特别是使用CUDA编写内核函数。 正如我们的老师所说，编写高性能CUDA...
送给研一入学的你们—炼丹师入门手册1
08-03
* Jupyter：Jupyter 是一个基于 Web 的 IDE，提供了交互式编程和数据可视化等功能。 工具和资源 我们还将介绍一些常用的工具和资源，包括 CodeRunner、Git、GitHub 等。 * CodeRunner：CodeRunner 是一个轻量级的...
torch.distributed.broadcast 解释&示例
BlackZhou013的博客
03-20 3826
是PyTorch分布式框架中的一个函数，它的作用是在分布式环境中将一个张量从指定的进程广播到所有其他进程。具体地说，当一个进程调用函数并指定一个张量作为输入，该函数会将这个张量广播给所有其他进程，这些进程也可以通过调用该函数来接收这个张量。在广播过程中，每个进程都会从指定进程接收张量，并将其写入自己的内存中。这样，所有进程都能够获得相同的张量副本，从而可以在分布式训练或其他任务中进行协同计算。其中，tensor是要广播的张量，src是指定的源进程，它会将张量广播给其他进程。group。
pytorch框架下的DDP应用(附完整的训练代码)
01-25 2793
1. 简介 DDP（DistributedDataParallel）和DP（DataParallel）均为并行的pytorch训练的加速方法。两种方法使用场景有些许差别： DP模式 主要是应用到单机多卡的情况下，对代码的改动比较少，主要是对model进行封装，不需要对数据集和通信等方面进行修改。一般初始化如下： import torch import torchvision model = torchvision.models.resnet101(num_classes=10) model = t
pytorch---基础篇（常用函数）
hei_hei_hei_的博客
03-28 3939
目录 1.张量 2. 3. 4. 5. 6. 7. 8. 9. 10. 1. 张量 torch.numel(input)->int：返回张量中元素的个数 x = torch.arange(11) x.numel() # 11 torch.numel(x) # 11 2. 创建操作 torch.eye(n, m=None, out=None)：返回一个m∗nm*nm∗n张量，对角线位置全1，其它位置全0。如果m没指定，则默认为n∗nn*nn∗n >>> torch.e
Pytorch报错解决——（亲测有效）RuntimeError: Distributed package doesn‘t have NCCL built in
m0_61787307的博客
03-18 1万+
亲测这个报错就没了，然而接下来还有好多别的报错…我继续去解决了，解决完再分享别的~若要解释原因就是windows系统不支持NCCL，只能换用GLOO。上网搜寻一番后，发现了解决方法。这一行中的nccl换成gloo。
Pytorch DistributedDataParallel 详细说明/教程/手把手
yihang___的博客
03-12 2390
转载自https://medium.com/codex/a-comprehensive-tutorial-to-pytorch-distributeddataparallel-1f4b42bb1b51 The limited computation resource at school discourages distibuted training across multiple gpus. I started to learn it for the first time when I joined M.
pytorch分布式：all_gather, all_reduce
Hello Word!
04-29 5445
all_gather: 把一个tensor广播到一个list，返回tensor list .chunk: 把一个tensor切分成几块 # 把 features.data广播到list中的元素上，list中的内容是total_features切分成的几个块，最后返回这个list.相当于把features拷贝成了好几份 dist.all_gather(list(total_features.chunk(self.world_size, dim=0)), features.data) htt
“最全“PyTorch分布式训练教程来了！
刘钊的博客
10-21 4270
前言 本文对使用pytorch进行分布式训练（单机多卡）的过程进行了详细的介绍，附加实际代码，希望可以给正在看的你提供帮助。本文分三个部分展开，分别是: 先验知识 使用过程框架 代码解析 若想学习分布式的部署，看完本文就足够了，但为了读者能了解更多细节，我在第一部分的每个模块都加了对应的官方文档的链接。 同时，我正在进行PyTorch官方文档的翻译工作，除了对其进行便于理解的翻译，还添加了我的解释。项目地址：https://github.com/liuzhaoo/Pytorch-API-and-Tuto
pytorch编程工具
05-10
PyTorch是一种基于Python的科学计算框架，专门用于自然语言处理、计算机视觉等领域。PyTorch的设计特点是动态计算图，这使得它比其他框架更加灵活、可扩展。PyTorch为用户提供了简单易用的API，包括张量、矩阵操作和神经网络建模等功能。此外，PyTorch还具有分布式训练、自动求梯度、动态调试等一系列先进的特性。 PyTorch的优点是什么？首先，PyTorch是一个开源的软件，且跨平台。这意味着开发者可以在不同的平台上使用PyTorch工具进行编程，无需更多的代码修改。其次，PyTorch支持GPU加速，可大大提高训练速度。此外，PyTorch为团队协作提供了方便，它可以轻松地与其他编程语言、库集成。 PyTorch也有缺点。由于动态计算图的设计，PyTorch的计算速度比较慢。另外，PyTorch对于内存利用不够高效，会有很多中间步骤和变量会自动保存在内存中，这会占用大量内存空间，加大了内存压力。最后，PyTorch的文档相对其他库来说还比较少，所以在使用的过程中需要自行解决问题。 总的来说，PyTorch是一个非常强大的编程工具，它提供了丰富的功能，方便了自然语言处理、计算机视觉、深度学习等领域的编程工作。如果你需要在深度学习领域进行研究或开发，PyTorch可以说是一个不错的选择。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

贱贱的剑

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

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

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

打赏作者

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

抵扣说明：

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

余额充值