pytorch之多进程与分布式

已于 2024-05-27 11:48:50 修改
阅读量1.4k 收藏 26
点赞数 20
分类专栏： pytorch 文章标签： pytorch 分布式 人工智能
于 2024-04-03 16:26:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35215756/article/details/137280271
版权
本文详细介绍了PyTorch中分布式训练的通信原语，包括point-to-point和collectivecommunication，以及All-reduce、All-gather、Broadcast等操作。此外，还阐述了初始化过程、常用启动方法（torchrun和torch.distributed.launch）以及DP和DDP的区别和实现。
摘要由CSDN通过智能技术生成

目录

通信原语

分布式训练可以分为数据并行、模型并行，流水线并行和混合并行。分布式算法又有典型的parameter server和ring all-reduce。无论是哪一种分布式技术一个核心的关键就是如何进行communication，这是实现分布式训练的基础，因此要想掌握分布式训练或当前流行的大模型训练务必对worker间的通信方式有所了解。

Pytorch的分布式训练的通信是依赖torch.distributed模块来实现的，torch.distributed提供了point-2-point communication 和collective communication两种通信方式。

  • point-2-point communication提供了send和recv语义，用于任务间的通信
    在这里插入图片描述

  • collective communication主要提供了scatter/broadcast/gather/reduce/all_reduce/all_gather 语义，不同的backend在提供的通信语义上具有一定的差异性。

    • All-reduce：所有节点上的数据都会被收集起来，然后进行某种操作（通常是求和或求平均），然后将结果广播回每个节点。这个操作在并行计算中常用于全局梯度更新。

    • All-gather： 每个节点上的数据都被广播到其他所有节点上。每个节点最终都会收到来自所有其他节点的数据集合。这个操作在并行计算中用于收集各个节点的局部数据，以进行全局聚合或分析。

    • Broadcast：一台节点上的数据被广播到其他所有节点上。通常用于将模型参数或其他全局数据分发到所有节点。

    • Reduce： 将所有节点上的数据进行某种操作（如求和、求平均、取最大值等）后，将结果发送回指定节点。这个操作常用于在并行计算中进行局部聚合。

    • Scatter： 从一个节点的数据集合中将数据分发到其他节点上。通常用于将一个较大的数据集合分割成多个部分，然后分发到不同节点上进行并行处理。

    • Gather： 将各个节点上的数据收集到一个节点上。通常用于将多个节点上的局部数据收集到一个节点上进行汇总或分析。在这里插入图片描述

使用流程

Pytorch 中分布式的基本使用流程如下：

  1. 使用 init_process_group 初始化进程组。
  2. 如果需要进行group内集体通信，用 new_group 创建子分组
  3. 创建分布式并行模型 DDP(model, device_ids=device_ids)
  4. 为数据集创建 Sampler
  5. 使用启动工具 torch.distributed.launch 或者torchrun在每个主机上执行一次脚本，开始训练
  6. 使用 destory_process_group() 销毁进程组

基本概念

  • backend：设置后端网络通信的实现库，可选的为gloo、nccl和mpi；(注：mpi需要重新编译pytorch源码才能使用）；
| Backend        | ``gloo``  | ``mpi``   | ``nccl``  |
|----------------|-----|-----|-----|-----|-----|-----|
| Device         | CPU | GPU | CPU | GPU | CPU | GPU |
|----------------|-----|-----|-----|-----|-----|-----|
| send           | ✓   | ✘   | ✓   | ?   | ✘   | ✓   |
| recv           | ✓   | ✘   | ✓   | ?   | ✘   | ✓   |
| broadcast      | ✓   | ✓   | ✓   | ?   | ✘   | ✓   |
| all_reduce     | ✓   | ✓   | ✓   | ?   | ✘   | ✓   |
| reduce         | ✓   | ✘   | ✓   | ?   | ✘   | ✓   |
| all_gather     | ✓   | ✘   | ✓   | ?   | ✘   | ✓   |
| gather         | ✓   | ✘   | ✓   | ?   | ✘   | ✓   |
| scatter        | ✓   | ✘   | ✓   | ?   | ✘   | ✓   |
| reduce_scatter | ✘   | ✘   | ✘   | ✘   | ✘   | ✓  |
| all_to_all     | ✘   | ✘   | ✓   | ?   | ✘   | ✓   |
| barrier        | ✓   | ✘   | ✓   | ?   | ✘   | ✓   |
  • MASTER_PORT：机器上的空闲端口，用于承载RANK 0的进程。
  • MASTER_ADDR：驻留RANK 0的进程的机器的IP地址。gpu 数量——K.
  • WORLD_SIZE：进程的总数，以便主进程知道有多少工作进程需要等待。
  • RANK：为当前rank的index，用于标记当前是第几个rank，取值为0到work_size - 1之间的值. rank = 0 的主机为 master 节点。
  • group：即进程组。默认情况下，只有一个组，一个 job 即为一个组，也即一个 world。当需要进行更加精细的通信时，可以通过 new_group 接口，使用 word 的子集，创建新组，用于集体通信等。
  • local_rank：进程内GPU 编号，非显式参数，由 torch.distributed.launch或者torchrun 内部指定。比方说， rank = 3，local_rank = 0 表示第 3 个进程内的第 1 块 GPU。

初始化

调用任何其他方法之前，需要使用torch.distributed.init_process_group(backend=None, init_method=None, timeout=None, world_size=-1, rank=-1, store=None, group_name='', pg_options=None)或torch.distributed.device_mesh.init_device_mesh(device_type, mesh_shape, *, mesh_dim_names=None)函数初始化。两者都阻塞，直到所有进程都joined。

常规启动方法

""" python run.py """
#!/usr/bin/env python
import os
from typing import Callable

import torch
import torch.distributed as dist
import torch.multiprocessing as mp

# Initialization
def init_process(rank: int, size: int, fn: Callable[[int, int], None], backend="gloo"):
    """Initialize the distributed environment."""
    os.environ["MASTER_ADDR"] = "127.0.0.1"
    os.environ["MASTER_PORT"] = "29500"
    dist.init_process_group(backend, rank=rank, world_size=size)
    fn(rank, size)

def run_p2p(rank_id, size) -> None:
    tensor = torch.zeros(1)
    if rank_id == 0:
        tensor += 1
        # Send the tensor to process 1
        dist.send(tensor=tensor, dst=1)
        print("after send, Rank ", rank_id, " has data ", tensor[0])

        dist.recv(tensor=tensor, src=1)
        print("after recv, Rank ", rank_id, " has data ", tensor[0])
    else:
        # Receive tensor from process 0
        dist.recv(tensor=tensor, src=0)
        print("after recv, Rank ", rank_id, " has data ", tensor[0])

        tensor += 1
        dist.send(tensor=tensor, dst=0)
        print("after send, Rank ", rank_id, " has data ", tensor[0])

def run_reduce(rank_id, size) -> None:
    tensor = torch.arange(end=2, dtype=torch.int64) + 1 + 2 * rank_id
    print('before reudce',' Rank ', rank_id, ' has data ', tensor)
    dist.all_reduce(tensor=tensor, op=dist.ReduceOp.SUM)
    print('after reudce',' Rank ', rank_id, ' has data ', tensor)

if __name__ == "__main__":
    size = 2
    processes = []
    mp.set_start_method(method="spawn")
    for rank in range(size):
        # p = mp.Process(target=init_process, args=(rank, size, run_p2p))
        p = mp.Process(target=init_process, args=(rank, size, run_reduce))
        p.start()
        processes.append(p)

    for p in processes:
        p.join()

输出

python run.py
after send, Rank  0  has data  tensor(1.)
after recv, Rank  1  has data  tensor(1.)
after send, Rank  1  has data  tensor(2.)
after recv, Rank  0  has data  tensor(2.)
-----------------------------------------
python run.py
before reudce  Rank  1  has data  tensor([3, 4])
before reudce  Rank  0  has data  tensor([1, 2])
after reudce  Rank  0  has data  tensor([4, 6])
after reudce  Rank  1  has data  tensor([4, 6])

torchrun方法

在单节点分布式训练或多节点分布式训练的两种情况下，该实用程序将启动每个节点给定数量的进程(–nproc-per-node)。如果用于GPU训练，这个数字需要小于或等于当前系统(nproc_per_node)上的GPU数量，并且每个进程从GPU 0到GPU (nproc_per_node - 1)将在单个GPU上操作。

基本概念

training_script:：位置参数，单 GPU 训练脚本的完整路径，该工具将并行启动该脚本。
–nnodes：指定用来分布式训练脚本的节点数
–node_rank：多节点分布式训练时，指定当前节点的 rank。
–nproc_per_node：指定当前节点上，使用 GPU 训练的进程数。建议将该参数设置为当前节点的 GPU 数量，这样每个进程都能单独控制一个 GPU，效率最高。
–master_addr：master 节点（rank 为 0）的地址，应该为 ip 地址或者 node 0 的 hostname。对于单节点多进程训练的情况，该参数可以设置为 127.0.0.1。
–master_port：指定分布式训练中，master 节点使用的端口号，必须与其他应用的端口号不冲突。

启动方式

  • 单节点
python -m torchrun --nproc-per-node=NUM_GPUS_YOU_HAVE
           YOUR_TRAINING_SCRIPT.py (--arg1 --arg2 --arg3 and all other
           arguments of your training script)
  • 多节点
    Node 1: (IP: 192.168.1.1, and has a free port: 1234)
python -m torchrun --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)

Node 2:

python -m torchrun --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)
  1. 单节点测试
import os

import torch
import torch.distributed as dist


def run(rank_id, size):
    tensor = torch.arange(2, dtype=torch.float64) + 1 + rank_id

    tensor = tensor.to(f"cuda:{rank_id}")
    print("---->before reudce", " Rank ", rank_id, " has data ", tensor, "<----")
    dist.all_reduce(tensor, op=dist.ReduceOp.SUM)
    print("---->after reudce", " Rank ", rank_id, " has data ", tensor, "<----")


def main():
    local_rank = int(os.environ["LOCAL_RANK"]) # 注意这个参数，即使代码中不使用。因为 torchrun工具默认传递该参数
    rank = int(os.environ["RANK"])
    dist.init_process_group(backend="nccl")
    run(rank, size=0)


if __name__ == "__main__":
    main()

输出：

torchrun --nproc_per_node=2 --nnode=1 --master_addr="127.0.0.1"  --master_port=29500 run.py
WARNING:torch.distributed.run:
*****************************************
Setting OMP_NUM_THREADS environment variable for each process to be 1 in default, to avoid your system being overloaded, please further tune the variable for optimal performance in your application as needed. 
*****************************************
---->before reudce  Rank  1  has data  tensor([2., 3.], device='cuda:1', dtype=torch.float64) <----
---->before reudce  Rank  0  has data  tensor([1., 2.], device='cuda:0', dtype=torch.float64) <----
---->after reudce  Rank  0  has data tensor([3., 5.], device='cuda:1',dtype=torch.float64) <----
 ---->after reudce  Rank  1  has data  tensor([3., 5.], device='cuda:0',dtype=torch.float64) <----

  1. 多节点测试（数据并行）

  2. 在 Env 方式中，在 init_process_group 中，无需指定任何参数

  3. 必须在 rank==0 的进程内保存参数。

  4. 该方式下，使用 torchrun在每台主机上，为其创建多进程，其中:nproc_per_node 参数指定为当前主机创建的进程数。一般设定为当前主机的 GPU 数

  5. nnodes 参数指定当前 job 包含多少个节点

  6. node_rank 指定当前节点的优先级

  7. master_addr 和 master_port 分别指定 master 节点的 ip:port

  8. 若没有为每个进程合理分配 GPU，则默认使用当前主机上所有的 GPU。即使一台主机上有多个进程，也会共用 GPU。

  9. 使用 torch.distributed.launch 工具时，将会为当前主机创建 nproc_per_node 个进程，每个程独立执行训练脚本。同时，它还会为每个进程分配一个 local_rank 参数，表示当前进程在当前主机上的编号。例如：rank=2, local_rank=0 表示第 3 个节点上的第 1 个进程

  10. 需要合理利用 local_rank 参数，来合理分配本地的 GPU 资源

  11. 每条命令表示一个进程。若已开启的进程未达到 word_size 的数量，则所有进程会一直等待

# sample.py
import torch.distributed as dist
import torch.utils.data.distributed

# ......
import argparse
parser = argparse.ArgumentParser()
# 注意这个参数，必须要以这种形式指定，即使代码中不使用。因为 launch 工具默认传递该参数
parser.add_argument("--local_rank", type=int)
args = parser.parse_args()

# ......
dist.init_process_group(backend='nccl', init_method='env://')

# ......
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=download, transform=transform)
train_sampler = torch.utils.data.distributed.DistributedSampler(trainset)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, sampler=train_sampler)

# ......
# 根据 local_rank，配置当前进程使用的 GPU
net = Net()
device = torch.device('cuda', args.local_rank)
net = net.to(device)
net = torch.nn.parallel.DistributedDataParallel(net, 
												device_ids=[args.local_rank], 
												output_device=args.local_rank)

执行方式

torchrun --nproc_per_node=2 --nnodes=3 --node_rank=0 --master_addr="192.168.1.201" --master_port=23456 sample.py

torchrun  --nproc_per_node=2 --nnodes=3 --node_rank=1 --master_addr="192.168.1.201" --master_port=23456 sample.py

torchrun  --nproc_per_node=2 --nnodes=3 --node_rank=2 --master_addr="192.168.1.201" --master_port=23456 sample.py

DPvsDDP实现

pytorch训练之DP和DDP

参考

  1. https://pytorch.org/tutorials/intermediate/dist_tuto.html
  2. https://krishansubudhi.github.io/deeplearning/2019/10/15/PyTorch-Distributed.html
  3. https://pytorch.org/docs/stable/distributed.html
  4. https://zhuanlan.zhihu.com/p/478953028
  5. https://pytorch.org/tutorials/beginner/dist_overview.html
  6. https://pytorch.org/docs/stable/distributed.html#multi-gpu-collective-functions
  7. https://blog.roboflow.com/collective-communication-distributed-systems-pytorch/
  8. https://zhuanlan.zhihu.com/p/76638962
AIVoyager
关注
  • 20
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于pytorch的单机多卡分布式训练源码
09-06
在PyTorch中，单机多卡分布式训练是一种优化深度学习模型训练效率的方法，它能够充分利用多GPU资源，加速模型的收敛过程。本教程将详细解释如何使用PyTorch实现单机多卡分布式训练，主要参考提供的源码文件`pytorch_...
horovod：用于TensorFlow，Keras，PyTorch和Apache MXNet的分布式培训框架
02-03
Horovod能够与Keras整合，让用户在Keras的简洁API之上享受到分布式训练的便利。 4. **PyTorch**：PyTorch是Facebook开源的深度学习框架，以其动态计算图和易用性受到欢迎。Horovod同样支持PyTorch，使得用户可以...
讲解torch 多进程卡死
牛肉胡辣汤
12-10 661
在使用torch进行多进程训练时，卡死问题可能会让我们很头疼。通过检查数据加载过程，正确处理数据共享，合理分配系统资源以及添加详细的日志和调试信息，我们可以及时发现问题并解决。希望本文提供的解决方案能够帮助你解决torch多进程卡死问题，并顺利完成训练任务。当使用PyTorch进行多进程训练时，在实际应用场景中，我们可以使用torch的DataLoader来加载训练数据，并使用将模型在多个GPU上进行并行加速。# 定义图像分类模型return x# 数据预处理])# 加载训练数据集。
PyTorch多进程模型推理
dzw0120的博客
02-19 7901
Python多进程，PyTorch多进程加速模型推理
Pytorch多进程睡死的大坑
kelxLZ的博客
03-09 7068
Author：ZERO-A-ONE Date：2021-03-09 最近在使用Pytorch编写一些多进程程序，遇到了一个大坑，就是Python常用的多进程库multiprocessing 在实现多进程的模式不同，对Pytorch程序的影响 一、起步 首先我写了如下的一段代码，使用了multiprocessing 的进程池的方法，想实现多进程的训练 import argparse import time import multiprocessing as mp import CartPole impor.
python之pytorch多进程
T20151470的博客
10-31 724
使用torch.multiprocessing模块，你可以创建多个进程，每个进程都可以有自己的PyTorch张量和模型参数。这样，你可以将数据分发到不同的进程中，让它们并行地执行训练过程。多进程是计算机科学中的一个术语，它是指同时运行多个进程，这些进程可以同时执行不同的任务。在计算机操作系统中，进程是分配资源的基本单位，每个进程都有自己独立的内存空间和系统资源，互不干扰。多进程技术可以用于实现并行计算和分布式计算，其中每个进程可以独立地执行不同的任务，从而可以同时处理多个任务，提高计算机的处理效率。
如何在单机上搭建分布式深度学习环境？以Pytorch+cuda+mpi on LXC为例
sinat_22510827的博客
11-06 1130
环境：Manjaro - arch linux 框架：pytorch 1.0-cuda-10.0 Nividia driver：410 cuda：10.0 前言 为了在单机上跑起分布式实验的环境，我选择了lxc作为容器（可以类似的看作为docker，docker就是基于LXC的），来在一台PC上跑起多个实验环境。使用lxc，可以方便的进行容器的管理，也能方便的克隆镜像。 同时，LXC支持，多个虚拟化的环境中共享使用一个GPU，只需要将显卡设备对应的文件挂载到 LXC 容器中就能解决这个问题。在安装前，请
分布式入门，怎样用PyTorch实现多GPU分布式训练
calvinpaean的博客
12-08 926
这篇文章旨在阐述训练大规模深度学习模型时的分布式计算思想。 具体来讲，本文首先介绍了分布式计算的基本概念，以及分布式计算如何用于深度学习。然后，列举了配置处理分布式应用的环境的标准需求（硬件和软件）。最后，为了提供亲身实践的经验，本文从理论角度和实现的角度演示了一个用于训练深度学习模型的分布式算法（同步随机梯度下降，Synchronous SGD）。 何为分布式计算 分布式计算指的是一种编写程序的方式，它利用网络中多个连接的不同组件。通常，大规模计算通过以这种方式布置计算机来实现，这些计算机能够并行地处理高
pytorch使用horovod多gpu训练的实现
12-17
以上步骤概括了使用Horovod进行PyTorch多GPU训练的主要流程。在实际应用中，你可能还需要考虑其他因素，比如设置学习率策略、添加检查点保存、调整日志和超参数等。注意，为了充分利用Horovod的优势，你的系统需要...
多节点训练-Pytorch单机多GPU训练方法示例与教程-附详细教程说明-超优质项目分享.zip
02-19
# 启动多进程，每台机器上运行的代码相同 if __name__ == "__main__": torch.distributed.init_process_group(backend='nccl') # 使用NCCL作为通信后端 # 分别在每个进程中创建模型和优化器 model = MyModel()...
「分布式训练」+ DDP单机多卡并行指南
07-20
分布式训练的目标是将训练任务分解到多个计算资源上，每个资源处理一部分工作负载，然后同步结果以保持模型的一致性。PyTorch中的DDP是实现这一目标的一种策略，它在每块GPU上复制整个模型，并对数据进行分片，使得...
Pytorch 分布式DPP 基本概念
REstrat的博客
10-06 955
（强烈推荐）
Pytorch - 分布式通信原语（附源码）
qq_29462849的博客
06-28 1211
作者丨颜挺帅@知乎（已授权）来源丨https://zhuanlan.zhihu.com/p/478953028编辑丨极市平台导读本文用通过pytorch中的分布式原语库来介绍每个通信原语的行为表现，主要对point-2-point communication 和collective communication两种通信方式进行介绍，并附有相关代码。前言由于工作需要，最近在...
PyTorch多机多GPU并行训练方法及问题整理
qq_44289607的博客
03-07 1万+
在单机多gpu可以满足的情况下, 绝对不建议使用多机多gpu进行训练, 多台机器之间传输数据的时间非常慢, 如果机器只是千兆网卡, 再加上别的一些损耗, 网络的传输速度跟不上, 会导致训练速度实际很慢。 1 初始化 初始化操作一般在程序刚开始的时候进行。 在进行多机多gpu运行训练的时候，需要先使用 torch.distributed.init_process_group()进行初始化。 torch.distributed.init_process_group...
pytorch多卡训练nn.DataParallel和nn.DistributedDataParallel比较
weixin_38076506的博客
04-17 3155
本文来源于：Pytorch Distributed - 知乎 Pytorch Distributed 现在的模型越来越大，并行显得越来越重要，而众所周知，pytorch 的并行文档写的非常不清楚，不仅影响使用，甚至我们都不知道他的工作原理。一次偶然的机会，我发现了几篇在这方面写的很好的文章，因此也准备参考别人的（参考的文章在Reference部分列出）再结合自己的使用经验总结一下。 nn.DataParallel Pytorch的数据并行方式，是经常使用的单机多卡的并行方式。 工作原理 这种方式
pytorch 中的数据集与多进程并发
yichudu
06-20 1465
需要 Dataset + collate_fn + Sampler + DataLoader 联用, 才等价于 tf 的 dataset.
[深度学习] 分布式Pytorch介绍（三）
热门推荐
摩登都市天空---专栏
04-20 2万+
[深度学习] 分布式模式介绍（一） [深度学习] 分布式Tensorflow介绍（二） [深度学习] 分布式Pytorch 1.0介绍（三） [深度学习] 分布式Horovod介绍（四） Pytorch 分布式简介 https://pytorch.org/docs/stable/distributed.html torch.distributed 包支持 Pytorch 中通过...
PyTorch深度学习——框架简介
最新发布
just do it
04-02 1469
在静态图的计算中，构建前向的计算操作的同时也会构建一个反向传播的梯度计算，这样前向的计算图构建完毕伴随着反向计算图的构建完毕，有了损失函数之后，就可以从损失函数所在的张量的边开始逐渐沿着反向计算图获取对应的梯度与静态图的构建相比，动态图在构建前向计算图的时候则是给每个输出张量绑定一个反向传播的梯度计算函数，当计算图达到最终的损失函数的张量的时候，直接调用该张量对应的反向传播函数，并不大根据前向计算图进行递归的反向传播函数的调用，最后到达输入张量，即可求得每个权重张量对应的梯度张量。
PyTorch多进程分布式训练最简单最好用的实施办法
我的博客有点东西
12-03 1万+
PyTorch的distributed训练已经逐渐代替nn.Dataparallel的方式，因为官方对其有更好的支持，并且训练速度更快。大家可能知道一种启动方法，就是用torch.launch启动。但有没有被冗长的代码段惹的不开心呢。今天阿杰为大家带来一种更简单的启动方式，那就是torch.multiprocessing Note： torch.multiprocessing的启动和用torch.launch本质是一样的，就是单纯的代码量少。 使用方法 使用头文件 import torch.multipro
pytorch分布式
09-13
PyTorch提供了多种方式来进行分布式训练。根据引用，可以使用torch.distributed.init_process_group函数来初始化分布式训练环境。该函数有两个参数，backend用于指定后端引擎，常用的是'nccl'；init_method用于指定初始化方法，通常使用'env://'来从环境变量中获取初始化信息。 另外，根据引用，PyTorch还提供了一个启动实用程序torch.distributed.launch，它可以用于在每个训练节点上启动多个分布式训练进程。这个工具可以简化分布式训练的启动过程。 此外，引用中介绍了PyTorch Elastic这个分布式训练框架。PyTorch Elastic可以以容错和弹性的方式启动分布式PyTorch作业。它基于TorchElastic库，并要求Python3和torchelastic库的使用。 综上所述，PyTorch提供了多种方式来进行分布式训练，包括使用torch.distributed.init_process_group函数和torch.distributed.launch工具，以及使用PyTorch Elastic框架实现容错和弹性启动。具体使用哪种方式取决于您的需求和环境配置。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值