Are you looking for an answer to the topic “distributeddataparallel“? We answer all your questions at the website https://ph.taphoamini.com in category: 152+ tips for you. You will find the answer right below.
Table of Contents
DistributedDataParallel — PyTorch master documentation
분산 데이터 기반 병렬화 구현
모듈 수준의 torch.distributed 패키지.
이 컨테이너는 다음과 같이 주어진 모듈의 적용을 시뮬레이션합니다.
일괄 처리로 청크하여 입력을 지정된 장치로 분할
크기. 모듈은 모든 기계와 장치에 복제되며,
이러한 각 복제본은 입력의 일부를 보유합니다. 뒤에 있는 동안
통과하면 각 노드의 기울기가 평균화됩니다.
배치 크기는 로컬에서 사용되는 GPU 수보다 커야 합니다.
참조: 기본 및 다중 처리 또는 nn.DataParallel 대신 nn.parallel.DistributedDataParallel 사용.
Torch.nn.DataParallel과 동일한 입력 제약 조건이 적용됩니다.
이 클래스를 생성하려면 torch.distributed가 필요합니다.
Torch.distributed.init_process_group()을 호출하여 시작되었습니다.
DistributedDataParallel은
단일 노드 다중 GPU 데이터에 대한 torch.nn.DataParallel
병렬 훈련.
사용 방법은 다음과 같습니다. N GPU가 있는 모든 호스트에서 N을 생성해야 합니다.
각 프로세스가 GPU에서 개별적으로 작동하도록 하는 동시에
0에서 N-1까지. 따라서 교육 스크립트가
다음을 호출하여 지정된 GPU에서 작동합니다.
>>> torch.cuda.set_device (i)
여기서 나는 0에서 N-1까지입니다. 각 프로세스에서 다음을 참조해야 합니다.
이 모듈을 개발할 때:
>>> torch.distributed.init_process_group (백엔드 = ‘nccl’, world_size = 4, init_method = ‘…’)
>>> 모델 = DistributedDataParallel(모델, device_s = [i], output_device = i)
노드당 여러 프로세스를 사용하려면 다음 중 하나를 사용할 수 있습니다.
torch.distributed.launch 또는 torch.multiprocessing.spawn
기억하다
nccl 백엔드는 현재 가장 빠르고
다중 프로세스 단일 GPU와 함께 사용하도록 적극 권장되는 백엔드
분산 교육 및 단일 노드 및 다중 노드 모두에 적용됩니다.
분산 교육
기억하다
이 모듈은 혼합 정밀도 분산 교육도 지원합니다.
즉, 모델에는 다음과 같은 다양한 유형의 매개변수가 있을 수 있습니다.
fp16과 fp32의 혼합물로 기울기 감소
혼합된 유형의 매개변수만 제대로 작동합니다.
또한 nccl 백엔드는 현재 가장 빠르고 최고입니다.
fp16/fp32 혼합 정밀도 훈련에 권장되는 백엔드입니다.
기억하다
모듈을 확인하는 과정에서 torch.save를 사용한다면,
이를 복구하기 위해 다른 프로세스에 torch.load
map_location은 각 프로세스에 대해 올바르게 구성됩니다. 그렇지 않은 경우
Map_location, torch.load는 장치에서 모듈을 복구합니다.
모듈이 저장되는 위치입니다.
경고
이 모듈은 gloo 및 nccl 백엔드에서만 작동합니다.
경고
빌더, 메서드 전달 및 출력 변형(또는
이 모듈의 출력 기능)은 분산 동기화입니다.
가리키다. 프로세스가 다른 경우 고려
다른 코드를 실행합니다.
경고
이 모듈은 모든 매개변수가 모델에 등록되어 있다고 가정합니다.
이번에 생성되었습니다. 나중에 매개변수를 추가하거나 제거해서는 안 됩니다.
버퍼에도 동일하게 적용됩니다.
경고
이 모듈은 모든 매개변수가 각 모델에 등록되어 있다고 가정합니다.
분산 프로세스는 동일한 순서입니다. 모듈 자체가 할 것
역순으로 gradient all-reduction을 수행한다.
등록된 모델 매개변수. 즉, 사용자가
모든 분산 프로세스가 정확히
동일한 모델이므로 정확히 동일한 매개변수 등록 순서입니다.
경고
이 모듈은 행 기본이 아닌 연속 단계가 있는 매개변수를 활성화합니다.
예를 들어 모델에 일부 매개변수가 포함될 수 있습니다.
torch.memory_format은 torch.contiguous_format입니다.
등의 형식이 torch.channels_last입니다. 하지만,
서로 다른 프로세스의 해당 매개변수가 있어야 합니다.
같은 단계.
경고
이 모듈은 torch.autograd.grad()와 함께 작동하지 않습니다.
의 .grad 속성에 그라디언트가 누적된 경우에만 작동합니다.
매개변수).
경고
이 모듈을 nccl 백엔드 또는 gloo와 함께 사용하려는 경우
백엔드(Infiniband 사용) 및 DataLoader 사용자많은 작업자분들은 멀티프로세싱을 시작하는 방식을 다음으로 변경하십시오.
forkserver(Python 3만 해당) 또는 스폰. 안타깝게도
(Infiniband를 사용하는) Gloo와 NCCL2는 포크하기에 안전하지 않습니다.
이 설정을 변경하지 않으면 교착 상태가 발생할 수 있습니다.
경고
모듈과 그 하위 모듈에 정의된 정방향 및 역방향 후크
후크가 다음으로 초기화되지 않는 한 더 이상 호출되지 않습니다.
앞으로() 메서드.
경고
래핑 후에 모델의 매개변수를 변경하려고 해서는 안 됩니다.
DistributedDataParallel을 사용하여 모델을 확장합니다. 다시 말해, 언제
의 생성자인 DistributedDataParallel로 모델을 래핑합니다.
DistributedDataParallel은 추가 그라디언트를 등록합니다.
모델 자체의 모든 매개변수에 대한 축소 기능
빌드 시간입니다. 모델 매개변수를 변경하면
DistributedDataParallel 구성에서는 지원되지 않으며
일부 매개변수의 기울기로 인해 예기치 않은 습관이 발생할 수 있습니다.
빼기 함수를 호출할 수 없습니다.
기억하다
매개변수는 프로세스 간에 브로드캐스트되지 않습니다. 모듈은
그라디언트의 모든 단계를 줄이고 변경할 수 있다고 가정합니다.
옵티마이저를 모든 프로세스에 동일한 방식으로 적용합니다. 버퍼
(예: BatchNorm 통계) 순위 지정 프로세스에 있는 모듈에서 브로드캐스트됩니다.
0, 각 반복에서 시스템의 다른 모든 복제본.
기억하다
DistributedDataParallel을 다음과 함께 사용하는 경우
분산 RPC 프레임워크, 항상 사용해야 합니다.
Torch.distributed.autograd.backward() 그라디언트를 계산하고
최적화를 위한 torch.distributed.optim.DistributedOptimizer
매개변수.
예 :: >>> Torch.distributed.autograd를 dist_autograd로 가져오기
>>> totorch.nn.parallel에서 DDP로 DistributedDataParallel 가져오기
>>> 토치 가져오기 최적화에서
>>> 토치.distributed.optim 가져오기 DistributedOptimizer에서
>>> 토치.distributed.rpc 가져오기 RRef에서
>>>
>>> t1 = 토치. 랜드((3, 3), require_grad = True)
>>> t2 = 토치. 랜드((3, 3), require_grad = True)
>>> rref = rpc.remote(“worker1”, torch.add, args = (t1, t2))
>>> ddp_model = DDP(my_model)
>>>
>>> # 설정 옵티마이저
>>> optimizer_params = [rref]
>>> ddp_model.parameters()의 param:
>>> optimizer_params.append(RRef(매개변수))
>>>
>>> dist_optim = DistributedOptimizer(
>>> 최적화.SGD,
>>> optimizer_params,
>>> lr = 0.05,
>>>)
>>>
>>> dist_autograd.context()를 context_로 사용:
>>> pred = ddp_model(rref.to_here())
>>> loss = loss_func (pred, loss)
>>> dist_autograd.backward (context_, 손실)
>>> dist_optim.step()
경고
DistributedDataParallel과 함께 사용
Shared RPC Framework는 실험적이며 변경될 수 있습니다.
매개변수
모듈(모듈) – 모듈 병렬화
device_s (python 목록: int 또는 torch.device) – CUDA 장치. 그것은해야한다
입력 모듈이 단일에 있을 때만 발행됩니다.
쿠다 장치. 단일 장치 모듈의 경우 i“th
: attr: `module` 복제본은 `device_ [i]에 배치됩니다. 을 위한
다중 장치 모듈 및 CPU 모듈, device_s는 None이어야 합니다.
또는 빈 목록이며 정방향 패스에 대한 입력 데이터여야 합니다.
올바른 장치에 배치합니다. (기본값: 모든 장치에 대한
단일 장치 모듈)
output_device(int 또는 torch.device) – 출력 장치의 위치
단일 장치 CUDA 모듈. 다중 장치 모듈 및
CPU 모듈, None이어야 하며 모듈 자체
출력 위치를 나타냅니다. (기본값: device_s [0]
단일 장치 모듈)
broadcast_buffers(bool)-동기화(브로드캐스팅) 버퍼를 허용하는 플래그
forward 함수의 시작 부분에 있는 모듈.
(기본값: 참)
process_group – 분산 데이터에 사용할 프로세스 그룹
모든 감소. None이면 기본 프로세스 그룹입니다.
`torch.distributed.init_process_group`에 의해 생성되었으며,
사용하게 될 것이다. (기본값: 없음)
bucket_cap_mb – DistributedDataParallel은 매개변수를
여러 버킷을 사용하여 각각의 그라디언트 감소
버킷은 역방향 계산에서 잠재적으로 겹칠 수 있습니다.
Bucket_cap_mb는 메가바이트(MB) 단위로 버킷 크기를 제어합니다.
(기본값: 25)
find_unused_parameters (bool) – 모든 텐서의 autograd 그래프를 트래버스합니다.
패키지의 반환 값에 포함된
모듈의 순방향 기능.
그라디언트를 허용하지 않는 매개변수
이 그래프의 일부가 미리 표시되어 있습니다.
줄일 준비가되었습니다. 그 모든 것을 기억하십시오
다음에서 파생된 순방향 출력
모듈 매개변수는 반드시 참여해야 합니다.손실 계산 및 이후 기울기
계산. 그렇지 않은 경우 이 래퍼가 수행합니다.
autograd가 그라디언트를 생성할 때까지 기다리기
해당 매개변수에 대해. 다음에서 파생된 모든 출력
그렇지 않으면 사용되지 않는 모듈 매개변수가 가능합니다.
다음을 사용하여 autograd 그래프와 분리
토치.텐서.분리. (기본값: 말리)
check_reduction – True로 설정하면 DistributedDataParallel이 활성화됩니다.
이전 반복이 있는지 자동으로 확인하려면
역 공제가 성공적으로 주어졌습니다.
각 반복의 전진 함수의 시작.
일반적으로 이 옵션을 활성화할 필요는 없습니다.
다른 순위와 같은 이상한 행동을 관찰합니다.
다른 그라디언트를 얻습니다.
DistributedDataParallel이 올바르게 사용되면 발생합니다.
(기본값: 말리)
변수
~ DistributedDataParallel.module (Module) – 병렬 처리할 모듈
예를 들어:
>>> torch.distributed.init_process_group (백엔드 = ‘nccl’, world_size = 4, init_method = ‘…’)
>>> net = torch.nn.DistributedDataParallel(모델, 페이지)
no_sync () [소스] ¶
DDP에서 그래디언트 동기화를 비활성화하는 컨텍스트 관리자
프로세스. 이 컨텍스트 내에서 그라디언트가 모듈에 누적됩니다.
나중에 컨텍스트에 표시되는 순방향 역방향 패스와 동기화되는 변수입니다.
예를 들어:
>>> ddp = torch.nn.DistributedDataParallel(모델, 페이지)
>>> ddp.no_sync() 사용:
… 입력에 대한 입력:
… ddp (input) .backward () # 동기화 없음, grads 누적
… ddp (another_input) .backward () # grads 동기화
PyTorch Gue to SageMaker’s distributed data parallel library — sagemaker 2.97.0 documentation
Modify a PyTorch training script to use SageMaker data parallel¶
다음 단계는 교육 스크립트를 PyTorch로 변환하는 방법을 보여줍니다.
SageMaker의 분산 데이터 병렬 라이브러리를 사용합니다.
분산 데이터 병렬 라이브러리 API는 PyTorch 분산 데이터에 가깝도록 설계되었습니다.
병렬(DDP) API.
병렬 데이터 라이브러리를 구현하는 방법에 대한 자세한 내용은 SageMaker 병렬 데이터에서 배포한 PyTorch 예제를 참조하십시오.
API는 PyTorch용으로 제공됩니다.
먼저 분산 데이터 병렬 라이브러리의 PyTorch 클라이언트를 가져와 시작합니다. 당신은 또한 수입
분산 교육을 위한 분산 데이터 병렬 라이브러리 모듈.
smdistributed.dataparallel.torch.distributed를 dist로 가져오기
smdistributed.dataparallel.torch.parallel.distributed에서 DDP로 DistributedDataParallel 가져오기
dist.init_process_group()
local_rank를 사용하여 각 GPU를 단일 분산 데이터 병렬 라이브러리 프로세스에 고정합니다.
주어진 노드 내에서 프로세스의 상대적 순위를 나타냅니다.
smdistributed.dataparallel.torch.get_local_rank() API 제공
당신은 로컬 장치 순위입니다. 리더 노드는 0순위가 될 것이며,
작업자 노드의 순위는 1, 2, 3 등입니다. 에 요구하고 있다
다음 코드 블록은 dist.get_local_rank()입니다.
torch.cuda.set_device(dist.get_local_rank())
그런 다음 공유 데이터 병렬 라이브러리의 DDP를 사용하여 PyTorch 모델을 래핑합니다.
모델 = …
# SageMaker의 DistributedDataParallel을 사용하여 모델을 래핑합니다.
모델 = DDP(모델)
torch.utils.data.distributed.DistributedSampler를 다음으로 변경합니다.
클러스터 정보를 포함합니다. “num_replicas“를 다음으로 설정
모든 노드에서 훈련에 참여하는 총 GPU 수
클러스터에서. 이것을 world_size라고 합니다. 당신은 그것을 얻을 것이다
세계 크기
smdistributed.dataparallel.torch.get_world_size() API. 이것은
다음 코드에서 dist.get_world_size()로 호출됩니다. 또한
다음을 사용하여 노드 순위를 지정합니다.
smdistributed.dataparallel.torch.get_rank(). 이것은
dist.get_rank().
train_sampler = DistributedSampler(train_dataset, num_replicas = dist.get_world_size(), rank = dist.get_rank())
마지막으로 체크포인트만 리더에 저장하도록 스크립트를 수정합니다.
마디. 리더 노드에는 동기화된 모델이 있습니다. 또한
작업자 노드는 체크포인트 덮어쓰기를 방지하고 가능하면
검문소 파괴.
dist.get_rank() == 0인 경우:
토치.저장(…)
다음은 모두 결합된 PyTorch 교육 스크립트의 예입니다.
분산 데이터 병렬 라이브러리를 사용하여 분산 교육을 수행하려면 다음이 필요합니다.
# 분산 데이터 병렬 라이브러리 가져오기 PyTorch API
smdistributed.dataparallel.torch.distributed를 dist로 가져오기
# 분산 데이터 병렬 라이브러리 가져오기 PyTorch DDP
smdistributed.dataparallel.torch.parallel.distributed에서 DDP로 DistributedDataParallel 가져오기
# 분산 데이터 병렬 라이브러리 시작
dist.init_process_group()
클래스 넷(nn.Module):
…
# 모델 정의
데프 트레인(…):
…
# 모델 교육
데프 테스트(…):
…
# 모델 분석
def 메인():
# 세계 크기에 따라 배치 크기 조정
batch_size // = dist.get_world_size() // 8
batch_size = 최대(배치_크기, 1)
# 데이터세트 준비
train_dataset = 토치비전.datasets.MNIST(…)
# DistributedSampler에서 num_replicas 및 순위 설정
train_sampler = torch.utils.data.distributed.DistributedSampler(
기차_데이터 세트,
num_replicas = dist.get_world_size(),
순위 = dist.get_rank())
train_loader = 토치.utils.data.DataLoader(..)
# 공유 데이터 병렬 라이브러리의 DDP를 사용하여 PyTorch 모델을 래핑합니다.
모델 = DDP(Net(). to(장치))
# 각 GPU를 단일 분산 데이터 병렬 라이브러리 프로세스에 고정합니다.
torch.cuda.set_device(local_rank)
model.cuda(local_rank)
# 트렌
옵티마이저 = optim.Adadelta(…)
스케줄러 = StepLR(…)
범위의 에포크(1, args.epochs + 1):
기차 (…)
순위 == 0인 경우:
시험 (…)
스케줄러.단계()
# 모델을 마스터 노드에 저장합니다.
dist.get_rank() == 0인 경우:
토치.저장(…)
__name__ == ‘__main__’인 경우:
기본 ()
How distributed training works in Pytorch: distributed data-parallel and mixed-precision training
이 자습서에서는 여러 GPU에서 모델을 훈련하기 위해 nn.parallel.DistributedDataParallel을 사용하는 방법을 배웁니다. 이미지 분류기를 훈련하는 약간의 예를 들어 훈련 속도를 높일 수 있는 방법을 살펴보겠습니다. import.import torchimport torchvisionimport torchvision.transforms as transformsimport torch.nn as nnimport torch.nn.functional as Fimport torch.optimimport time도 시작하겠습니다. 배치 크기가 256인 모든 실험에서 CIFAR10을 사용합니다. def create_data_loader_cifar10(): transform = transforms.Compose([transforms.RandomCrop(32), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms .Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5) )])
배치 크기 = 256
trainset = torchvision.datasets.CIFAR10(루트 = ‘./data’, 기차 = True, 다운로드 = True, 변환 = 변환) trainloader = torch.utils.data.DataLoader(trainset, batch_size = batch_size, shuffle = True, num_workers = 10, pin_memory = 참)
testset = torchvision.datasets.CIFAR10(루트 = ‘./data’, train = False, 다운로드 = True, 변환 = 변환) testloader = torch.utils.data.DataLoader(testset, batch_size = batch_size, shuffle = False, num_workers = 10) return trainloader, testloader 우리는 먼저 Nvia A100 GPU에서 1시즌 동안 모델을 훈련할 것입니다. 여기에 일반적인 pytorch 항목, 새로운 것은 없습니다. 이 자습서는 Pytorch의 docs.def train(net, trainloader): print(“훈련 시작 …”) 기준 = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr)의 공식 자습서를 기반으로 합니다. = 0.001, 운동량 = 0.9) epochs = 1 num_of_batches = len(트레인로더)
범위의 에포크(에포크):
running_loss = i의 경우 0.0, 데이터 열거(trainloader, 0):
입력, 레이블 = 데이터 이미지, 레이블 = input.cuda(), labels.cuda()
optimizer.zero_grad()
출력 = 순(이미지) 손실 = 기준(출력, 레이블) loss.backward() optimizer.step()
running_loss += loss.item ()
인쇄(f ‘[에포크 {에포크 + 1} / {에포크}] 손실: {running_loss / num_of_batches: .3f}’)
print(‘교육 완료’) 테스트 함수도 유사하게 정의됩니다. 메인 스크립트는 모든 것을 포함합니다: if __name__ == ‘__main__’: start = time.time () PATH = ‘./cifar_net.pth’ trainloader, testloader = create_data_loader_cifar10 () net = torchvision.models.resnet50 (False). cuda() start_train = time.time() train(net, trainloader) end_train = time.time() torch.save(net.state_dict(), PATH) 테스트(net, PATH, testloader)
end = time.time () seconds = (end – start) seconds_train = (end_train – start_train) print (f “총 경과 시간: {seconds: .2f}초, \ Train 1 epoch {seconds_train: .2f}초” ) 적절한 크기의 네트워크 성능을 측정하기 위해 resnet50을 사용합니다. 이제 모델을 훈련시켜 보겠습니다. $ python -m train_1gpu10000개의 테스트 이미지에서 네트워크 정확도: 27% 총 경과 시간: 69.03초, 1번 훈련 13.08초좋아, 최적화 작업을 시작할 시간입니다. 코드는 GitHub에서 사용할 수 있습니다. Pytorch에 대한 지식을 강화할 계획이라면 Manning Publications의 PyTorch를 사용한 심층 학습 및 Sebastian Raschka의 PyTorch 및 Scikit-Learn을 사용한 기계 학습을 적극 권장합니다. 모든 Manning 제품에 대해 항상 35% 할인 코드 blaisummer21을 사용할 수 있습니다.
torch.nn.DataParallel: no pain, no gain
DataParallel은 다중 스레드 프로세스이며 하나의 시스템에서만 작동합니다. 각 GPU에 대해 동일한 모델을 사용하여 순방향 패스를 수행합니다. GPU 전체에 데이터를 분산하고 각각에 대한 전달을 수행합니다. 실제로 발생하는 일은 배치 크기를 작업자 수로 나누는 것입니다. 이 경우에는 활성화해도 아무런 이점이 없습니다. 내가 사용하는 시스템에 CPU 및 하드 디스크 병목 현상이 있기 때문입니다. 디스크와 CPU가 매우 빠르지만 GPU 속도에 어려움(GPU 병목 현상)이 있는 다른 시스템은 이 기능의 이점을 누릴 수 있습니다. 실제로 코드를 변경해야 하는 경우는 다음과 같습니다. net = torchvision.models.resnet50 (False) if torch.cuda.device_count ()> 1: print (“사용해 봅시다”, torch.cuda.device_count ( ), “GPUs!”) Net = nn.DataParallel (net) nn.DataParallel을 사용할 때 배치 크기는 GPU 수로 나눌 수 있어야 합니다.nn.DataParallel은 배치를 분할하여 사용 가능한 모든 GPU와 별도로 처리합니다. . 각 정방향 패스에서 모듈은 각 GPU에 복제되며, 이는 상당한 오버헤드입니다.각 복제본은 배치(batch_size / gpus)의 일부를 보유합니다. 역방향 패스 중에 각 복제본의 그라디언트가 원본 모듈에 포함됩니다. 데이터 대 모델 병렬 처리에 대한 이전 기사에서 더 많은 정보를 얻을 수 있습니다. 여러 GPU를 사용할 때 좋은 방법은 스크립트에서 사용할 GPU를 미리 지정하는 것입니다. import os os.environ [‘CUDA_VISIBLE_DEVICES’] = “0,1” 이것은 CUDA와 관련된 다른 가져오기 전에 수행되어야 합니다. Pytorch 문서에서도 이것이 매우 어려운 접근 방식이라는 것이 분명합니다. nn을 사용하는 것이 좋습니다. 이 클래스가 아닌 DistributedDataParallel을 사용하여 노드가 하나뿐인 경우에도 다중 GPU 교육을 수행합니다. 그 이유는 DistributedDataParallel은 작업자당 하나의 프로세스(GPU)를 사용하는 반면 DataParallel은 모든 데이터 통신을 하나의 프로세스로 캡슐화하기 때문입니다. 문서에 따르면 데이터는 모델에 전달되기 전에 모든 장치에 있을 수 있습니다. 내 실험에서 DataParallel은 GPU에서 훈련하는 것보다 느렸습니다. 4개의 GPU를 사용하더라도. 작업자 수를 늘리고 시간을 단축했지만 GPU보다 나쁩니다. 나는 50K 32×32 사진에 해당하는 기간 동안 모델을 훈련하는 데 걸린 시간을 측정하고 보고했습니다. 최종 참고 사항: GPU의 성능을 비교하기 위해 배치 크기에 작업자 수를 곱했습니다. 4 GPU에 4. 그렇지 않으면 2배 이상 느립니다. 이것은 우리를 Distributed Data-Parallel의 핵심 주제로 이끕니다. 코드는 GitHub에서 사용할 수 있습니다. 소셜 미디어에서 공유하고, 기부하고, 책과 e-코스를 구매하여 항상 우리의 작업을 지원할 수 있습니다.
Pytorch Distributed Data-Parallel
분산 병렬 데이터는 다중 처리되고 단일 및 다중 기계 모두에서 작동합니다. 교육. pytorch에서 nn.parallel.DistributedDataParallel은 지정된 장치 간에 입력을 나누어 모듈을 병렬 처리합니다. 이 모듈은 다중 노드, 다중 GPU 교육에도 적합합니다. 여기서는 하나의 노드(4개의 GPU가 있는 시스템 1개)로 실험했습니다. 여기서 주요 차이점은 각 GPU가 프로세스에 의해 관리된다는 것입니다. 매개변수는 프로세스 간에 브로드캐스트되지 않으며 그라디언트만 있습니다. 모듈은 모든 시스템과 모든 장치에 복제됩니다. 정방향 패스 동안 각 작업자(GPU)는 데이터를 처리하고 자체 기울기를 로컬에서 계산합니다. 역방향 패스 동안 각 노드의 기울기가 평균화됩니다. 마지막으로 각 작업자는 매개변수 업데이트를 수행하고 계산된 매개변수 업데이트를 다른 모든 노드로 보냅니다. 이 모듈은 그라디언트에 대해 전체 축소 단계를 수행하고 옵티마이저가 모든 프로세스에서 동일한 방식으로 그라디언트를 수정할 것이라고 가정합니다. 다음은 단일 GPU 스크립트를 다중 GPU 교육으로 변환하기 위한 지침입니다.
Step 1: Initialize the distributed learning processes
def init_distributed ():
dist_url = “환경: //”
rank = int (os.environ [“RANK”]) world_size = int (os.environ [‘WORLD_SIZE’]) local_rank = int (os.environ [‘LOCAL_RANK’]) dist.init_process_group (백엔드 = “nccl”, init_method = dist_url, world_size = world_size, 순위 = 순위)
torch.cuda.set_device(local_rank)
dist.barrier() 이 초기화는 각 노드(여기서는 1)에서 torch.distributed.launch(Pytorch 1.7 및 1.8) 또는 torch.run(Pytorch 1.9 이상)을 사용하여 스크립트를 시작할 때 작동합니다.
Step 2: Wrap the model using DDP
net = torchvision.models .resnet50(거짓) .cuda()
net = nn.SyncBatchNorm.convert_sync_batchnorm(순)
local_rank = int (os.environ [‘LOCAL_RANK’]) net = nn.parallel.DistributedDataParallel (net, device_s = [local_rank]) 각 프로세스의 로컬 순위가 올바른 경우 tensor.cuda() 또는 model.cuda()는 스크립트 전체에서 올바르게 호출됩니다.
Step 3: Use a DistributedSampler in your DataLoader
import torchfrom torch.utils.data.distributed import DistributedSamplefrom torch.utils.data import DataLoaderimport torch.nn을 nn으로 가져오기
def create_data_loader_cifar10():
transform = transforms.Compose([transforms.RandomCrop(32), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
배치 크기 = 256
trainset = torchvision.datasets.CIFAR10(루트 = ‘./data’, 기차 = True, 다운로드 = True, 변환 = 변환) train_sampler = DistributedSampler(데이터세트 = trainset, 셔플 = True) trainloader = torch.utils.data.DataLoader( trainset, batch_size = batch_size, sampler = train_sampler, num_workers = 10, pin_memory = True)
testset = torchvision.datasets.CIFAR10 (루트 = ‘./data ‘, train = False, 다운로드 = True, 변환 = 변환) test_sampler = DistributedSampler (dataset = testset, shuffle = True) testloader = torch.utils.data.DataLoader ((testset, batch_size = batch_size, shuffle = False, 샘플러 = test_sampler, num_workers = 10) return trainloader, testloader 분산 모드에서 DataLoader 반복자를 만들기 전에 각 기간의 시작 부분에서 data_loader.sampler.set_epoch() 메서드를 호출하여 여러 기간에 걸친 셔플링을 수정해야 합니다. , 동일한 순서는 항상 def train (net, trainloader): print (“훈련 시작 …”) 기준 = nn.CrossEntropyLoss () optimizer = optim.SGD (net.parameters (), lr = 0.001, moment = 0.9) epochs = 1 num_of_batches = len(트레인 로더)
범위 내 에포크(에포크): trainloader.sampler.set_epoch(에포크)
보다 일반적인 형식: 범위 내 에포크(에포크): data_loader.sampler.set_epoch(에포크)
train_one_epoch (…)
Good practices for DDP
데이터를 다운로드하는 모든 메서드는 마스터 프로세스에서 격리되어야 합니다. 파일 I/O를 수행하는 모든 메서드는 마스터 process.import torch.distimport torch.distributed에서 격리되어야 합니다.
def is_dist_avail_and_initialized (): dist.is_available이 아닌 경우 (): False 반환
dist.is_initialized()가 아닌 경우: False 반환
True를 반환
def save_on_master(*args, ** kwargs):
if is_main_process(): torch.save(*args, ** kwargs)
def get_rank():
is_dist_avail_and_initialized()가 아닌 경우: 0 반환
dist.get_rank() 반환
def is_main_process():
return get_rank () == 0이 함수를 기반으로 일부 명령이 기본 프로세스에서만 실행되도록 할 수 있습니다. if is_main_process():
Torch.distributed.launch 또는 torch.run을 사용하여 스크립트를 시작합니다. $ python -m torch.distributed.launch –nproc_per_node = 4 main_script.py 오류가 발생합니다. $ kill $ (ps aux | grep main_script.py | grep -v grep | awk ‘{print $ 2}’) main_script.py를 스크립트 이름으로 바꾸십시오. 또 다른 간단한 옵션은 $ kill -9 PID입니다. 그렇지 않으면 nvia-smilsof /dev /nvia* | awk ‘{인쇄 $2}’ | xargs -I {} kill {} 이는 GPU에서 실행 중인 프로세스의 PID를 찾을 수 없는 경우를 대비한 것입니다.
Mixed-precision training in Pytorch
정밀 혼합은 부동 소수점(FP) 16과 FP 32를 서로 다른 교육 단계에서 결합합니다. FP16 훈련은 낮은 성과를 수반하는 반정밀 훈련이라고도 합니다. 자동 혼합 정밀도는 말 그대로 두 세계에서 최고입니다. FP32에 필적하는 성능으로 훈련 시간 단축. Mixed Precision Training에서 모든 계산 작업(정방향 패스, 역방향 패스, 가중치 기울기)은 FP16 캐스트 버전을 보게 됩니다. 이렇게 하려면 FP32 가중치의 복사본이 필요하며 오버플로 및 언더플로를 방지하기 위해 FP16으로 포워드 패스 후 FP32에 대한 손실을 계산해야 합니다. 가중치 기울기는 모델 가중치를 업데이트하기 위해 FP32로 반환됩니다. 또한 FP32의 손실은 FP16에서 캐스팅되어 역방향 패스를 수행하기 전에 그래디언트 언더플로를 방지하기 위해 확대됩니다. 그 대가로 FP32 가중치는 가중치 업데이트 전에 동일한 스칼라만큼 감소합니다. 다음은 기차 함수에 대한 변경 사항입니다. fp16_scaler = torch.cuda.amp.GradScaler(활성화됨 = True)
범위 내 에포크(에포크): trainloader.sampler.set_epoch(에포크) running_loss = 0.0
i의 경우 데이터를 열거합니다(trainloader, 0):
입력, 레이블 = 데이터 이미지, 레이블 = input.cuda(), labels.cuda()
optimizer.zero_grad()
Torch.cuda.amp.autocast 사용(): 출력 = 순(이미지) 손실 = 기준(출력, 레이블)
fp16_scaler.scale (loss) .backward () fp16_scaler.step (optimizer) fp16_scaler.update ()
Results and Sum up
유토피아적 병렬 세계에서 N 작업자는 속도 향상 N을 제공합니다. 여기에서 DistributedDataParallel 모드에 4개의 GPU가 필요함을 알 수 있습니다. 2배의 속도 향상을 얻습니다. 혼합 정밀 훈련은 일반적으로 엄청난 속도 향상을 제공하지만 A100 GPU 및 기타 Ampere 기반 GPU 아키텍처에는 제한된 이득이 있습니다(온라인에서 읽는 한). 아래 결과는 resnet50(배치 크기 256, NVia A100 40GB GPU 메모리)이 있는 CIFAR10에서 1 에포크에 대한 시간(초)을 보고합니다. 시간(초)단일 GPU(기준) 13.2DataParallel 4 GPUs19.1DistributedDataParallel 2 GPUs9.8DistributedDataParallel 4 GPUs6.1DistributedDataParallel 4 GPUs + Parallel Distributed 레코드는 Parallel 4 GPU에서 매우 효과적으로 사용됩니다. 4*256 = 1024이므로 모델 업데이트가 더 적습니다. 따라서 유효성 검사 정확도가 낮아진다고 생각합니다(기준선에서 27%와 비교하여 14%). 플레이하고 싶다면 GitHub에서 코드를 사용할 수 있습니다. 결과는 하드웨어에 따라 다릅니다. 내 실험에서 내가 놓친 경우가 항상 있습니다. 결함을 발견하면 Discord 서버에 알려주십시오.이 결과는 모델 교육의 확실한 시작을 제공할 것입니다. 유용하게 사용하시기 바랍니다. 소셜 미디어에 공유하고, 기부하고, 책이나 전자 코스를 구입하여 우리를 지원하십시오. 여러분의 도움은 더 많은 무료 콘텐츠와 접근 가능한 AI 콘텐츠를 제작하는 데 도움이 됩니다. 언제나처럼, 저희 블로그에 관심을 가져주셔서 감사합니다.
Deep Learning in Production Book 📖
Learn how to build, train, deploy, scale and maintain deep learning models. Understand ML infrastructure and MLOps using hands-on examples.
자세히 알아보기* 공개: 위의 링크 중 일부는 제휴 링크일 수 있으며 추가 비용 없이 다음과 같은 경우 수수료를 받습니다. 클릭 후 구매를 결정합니다.
DistributedDataParallel
모듈 수준에서 torch.distributed 패키지 기반 분산 데이터 병렬 처리를 구현합니다. 이 컨테이너는 일괄 처리 차원에서 청크로 지정된 장치 간에 입력을 분할하여 주어진 모듈의 적용을 병렬 처리합니다. 모듈은 각 기계와 각 장치에 복제되며 이러한 각 복제는 입력의 일부를 보유합니다. 역방향 패스 동안 각 노드의 기울기가 평균화됩니다. 배치 크기는 로컬에서 사용되는 GPU 수보다 커야 합니다. 참조: 기본 및 다중 처리 또는 nn.DataParallel 대신 nn.parallel.DistributedDataParallel 사용. Torch.nn.DataParallel과 동일한 입력 제약 조건이 적용됩니다. 이 클래스를 생성하려면 torch.distributed.init_process_group()을 호출하여 torch.distributed를 초기화해야 합니다. DistributedDataParallel은 단일 노드 다중 GPU 데이터 병렬 교육에 대해 torch.nn.DataParallel보다 빠른 것으로 입증되었습니다. N개의 GPU가 있는 호스트에서 DistributedDataParallel을 사용하려면 N개의 프로세스를 생성하여 각 프로세스가 0에서 N-1까지 하나의 GPU에서만 독점적으로 작동하도록 해야 합니다. 이것은 각 프로세스에 대해 CUDA_VISIBLE_DEVICES를 설정하거나 다음을 호출하여 수행할 수 있습니다. >>> torch.cuda.set_device (i)
여기서 나는 0에서 N-1까지입니다. 각 프로세스에서 이 모듈을 생성하려면 다음을 참조해야 합니다. >>> torch.distributed.init_process_group (
>>> 백엔드 = ‘nccl’, world_size = N, init_method = ‘…’
>>>)
>>> 모델 = DistributedDataParallel(모델, device_s = [i], output_device = i)
노드당 여러 프로세스를 생성하려면 torch.distributed.launch 또는 torch.multiprocessing.spawn을 사용할 수 있습니다. 참고 분산 교육과 관련된 모든 기능에 대한 간략한 소개는 PyTorch 분산 개요를 참조하십시오. nccl 백엔드는 현재 GPU를 사용할 때 가장 빠르고 강력하게 권장되는 백엔드입니다. 이는 단일 노드 및 다중 노드 분산 교육 모두에 적용됩니다. 참고 이 모듈은 혼합 정밀도 분산 교육도 지원합니다. 즉, 모델에 혼합 유형 fp16 및 fp32와 같은 다양한 유형의 매개변수가 있을 수 있으므로 이러한 혼합 유형의 매개변수로 기울기를 줄이면 잘 작동합니다. 참고 프로세스에서 torch.save를 사용하여 모듈을 확인하고 다른 프로세스에서 torch.load를 사용하여 복구하는 경우 map_location이 각 프로세스에 대해 올바르게 구성되어 있는지 확인하십시오. map_location이 없으면 torch.load는 모듈이 저장된 장치에서 모듈을 복구합니다. 참고 배치 = N인 M개의 노드에서 모델을 학습하면 배치 = M*N인 단일 노드에서 학습된 동일한 모델에 비해 기울기가 M배 더 작습니다(다른 노드 간의 기울기가 평균화되기 때문). 현지 대응 교육과 동등한 수학 프로세스 교육을 받고자 할 때 이를 고려해야 합니다. 참고 매개변수는 프로세스 간에 브로드캐스트되지 않습니다. 이 모듈은 그라디언트에 대해 전체 축소 단계를 수행하고 옵티마이저가 모든 프로세스에서 동일한 방식으로 그라디언트를 수정할 것이라고 가정합니다. 버퍼(예: BatchNorm 통계)는 순위 0 프로세스의 모듈에서 각 반복에서 시스템의 다른 모든 복제본으로 브로드캐스트됩니다. 참고 DistributedDataParallel을 Distributed RPC Framework와 함께 사용하는 경우 항상 torch.distributed.autograd.backward()를 사용하여 기울기를 계산하고 torch.distributed.optim.DistributedOptimizer를 사용하여 매개변수 최적화를 수행해야 합니다. 예: >>> Torch.distributed.autograd를 dist_autograd로 가져오기
>>> totorch.nn.parallel에서 DDP로 DistributedDataParallel 가져오기
>>> 토치 가져오기 최적화에서
>>> 토치.distributed.optim 가져오기 DistributedOptimizer에서
>>> 토치.distributed.rpc 가져오기 RRef에서
>>>
>>> t1 = 토치. 랜드((3, 3), require_grad = True)
>>> t2 = 토치. 랜드((3, 3), require_grad = True)
>>> rref = rpc.remote(“worker1”, torch.add, args = (t1, t2))
>>> ddp_model = DDP(my_model)
>>>
>>> # 설정 옵티마이저
>>> optimizer_params = [rref]
>>> ddp_model.parameters()의 param:
>>> optimizer_params.append(RRef(매개변수))
>>>
>>> dist_optim = DistributedOptimizer(
>>> 최적화.SGD,
>>> optimizer_params,
>>> lr = 0.05,
>>>)
>>>>>> dist_autograd.context()를 context_로 사용:
>>> pred = ddp_model(rref.to_here())
>>> loss = loss_func (pred, loss)
>>> dist_autograd.backward (context_, 손실)
>>> dist_optim.step()
경고 생성자, 순방향 메서드 및 출력 미분(또는 이 모듈의 출력 함수)은 동기화 지점에 배포됩니다. 다른 프로세스가 다른 코드를 실행할 수 있는 경우를 고려하십시오. 경고 이 모듈은 모델이 생성될 때 모든 매개변수가 모델에 등록되어 있다고 가정합니다. 나중에 매개변수를 추가하거나 제거해서는 안 됩니다. 둘 다 버퍼에 적용됨 경고 이 모듈은 각 분산 프로세스의 모델에 등록된 모든 매개변수가 동일한 순서라고 가정합니다. 모듈 자체는 등록된 모델 매개변수의 역순으로 기울기 allreduce를 수행합니다. 즉, 각 분산 프로세스가 정확히 동일한 모델을 가지므로 정확히 동일한 매개변수 등록 순서를 갖도록 하는 것은 사용자의 책임입니다. 경고 이 모듈은 행 메이저가 아닌 연속 단계가 있는 매개변수를 활성화합니다. 예를 들어, 모델에는 torch.memory_format이 torch.contiguous_format인 일부 매개변수와 형식이 torch.channels_last인 다른 매개변수가 포함될 수 있습니다. 그러나 다른 프로세스의 해당 매개변수는 동일한 단계를 가져야 합니다. 경고 이 모듈은 torch.autograd.grad()와 함께 작동하지 않습니다(즉, 매개변수의 .grad 속성에 그라디언트가 누적된 경우에만 작동합니다). 경고 이 모듈을 nccl 백엔드 또는 gloo 백엔드(Infiniband 사용)와 함께 여러 작업자를 사용하는 DataLoader와 함께 사용하려는 경우 다중 처리 시작 방법을 포크 서버(Python 3만 해당)로 변경하십시오. 불행히도 Gloo(Infiniband 사용) 및 NCCL2는 포크 안전하지 않으며 이 설정을 변경하지 않으면 교착 상태가 발생할 수 있습니다. 경고 후크가 forward() 메서드에서 초기화되지 않는 한 모듈과 그 하위 모듈에 정의된 정방향 및 역방향 후크는 더 이상 호출되지 않습니다. 경고 DistributedDataParallel로 모델을 래핑한 후에는 모델 매개변수를 변경하지 마십시오. DistributedDataParallel을 사용하여 모델을 래핑할 때 DistributedDataParallel 생성자는 빌드 시 모델 자체의 모든 매개변수에 추가 기울기 감소 함수를 등록하기 때문입니다. 나중에 모델 매개변수를 변경하면 기울기 감소 기능이 더 이상 올바른 매개변수 세트와 일치하지 않습니다. DistributedDataParallel을 Distributed RPC Framework와 함께 사용할 때의 경고는 실험적이며 변경될 수 있습니다. 경고 Gradient_as_bucket_view 모드는 아직 AMP(자동 혼합 정밀도)에서 작동하지 않습니다. AMP는 스케일링되지 않은 그라디언트에 사용되는 숨겨진 그라디언트를 유지합니다. gradient_as_bucket_view = True인 경우 이러한 숨겨진 그라디언트는 첫 번째 반복에서 통신 버킷을 가리킵니다. 다음 반복에서는 통신 버킷이 변경되므로 이러한 숨겨진 그라디언트도 변경되지 않을 것으로 예상되어 잘못된 결과를 초래할 수 있습니다. 매개변수
모듈(모듈) – 모듈 병렬화
device_s (python 목록: int 또는 torch.device) – CUDA 장치. 이것은 입력 모듈이 단일 CUDA 장치에 있는 경우에만 제공되어야 합니다. 단일 장치 모듈의 경우 i번째 모듈 복제본은 device_s [i]에 배치됩니다. 다중 장치 모듈 및 CPU 모듈의 경우 device_는 None 또는 빈 목록이어야 하며 정방향 전달을 위한 입력 데이터는 올바른 장치에 배치되어야 합니다. (기본값: 단일 장치 모듈에 대해 표시되는 모든 장치)
output_device(int 또는 torch.device)-단일 장치 CUDA 모듈에 대한 출력 장치의 위치입니다. 다중 장치 모듈 및 CPU 모듈의 경우 이것은 None이어야 하며 모듈 자체가 출력 위치를 지정합니다. (기본값: 단일 장치 모듈의 경우 device_s [0])
broadcast_buffers(bool)-전달 기능의 시작 부분에서 모듈 버퍼의 동기화(브로드캐스팅)를 허용하는 플래그입니다. (기본값: 참)
process_group – 분산 데이터 모두 축소에 사용할 프로세스 그룹입니다. None이면 torch.distributed.init_process_group()에 의해 생성된 기본 프로세스 그룹이 사용됩니다. (기본값: 없음)bucket_cap_mb-DistributedDataParallel은 각 버킷의 기울기 감소가 역방향 계산에서 잠재적으로 겹칠 수 있도록 여러 버킷에 매개변수를 버킷합니다. Bucket_cap_mb는 메가바이트(MB) 단위의 버킷 크기를 제어합니다. (기본값: 25)
find_unused_parameters (bool) – 패키지된 모듈의 forward 함수의 반환 값에 있는 모든 텐서의 autograd 그래프를 트래버스합니다. 이 그래프의 일부로 기울기를 허용하지 않는 매개변수는 감소할 준비가 된 것으로 미리 표시됩니다. 모듈 매개변수에서 파생된 모든 순방향 출력은 손실 계산과 나중에 기울기 계산에 참여해야 합니다. 그렇지 않은 경우 이 래퍼는 autograd가 해당 매개변수에 대한 그라디언트를 생성할 때까지 계속 대기합니다. 사용되지 않는 모듈 매개변수에서 얻은 모든 출력은 torch.Tensor.detach를 사용하여 autograd 그래프에서 분리할 수 있습니다. (기본값: 말리)
check_reduction – 이 인수는 더 이상 사용되지 않습니다.
gradient_as_bucket_view(bool) – 이것은 프로토타입 기능이며 변경될 수 있습니다. True로 설정하면 그라디언트가 모든 통신 버킷 감소의 다른 오프셋을 가리키는 뷰가 됩니다. 이렇게 하면 저장된 메모리의 크기가 그라디언트의 총 크기와 같아지는 최대 메모리 사용량을 줄일 수 있습니다. 또한 그래디언트 간의 중복 오버헤드를 방지하고 모두 통신 버킷을 줄입니다. 그래디언트가 뷰인 경우 그래디언트에서 detach_()를 호출할 수 없습니다. 이러한 오류가 발생하면 torch/optim/optimizer.py의 zero_grad() 함수를 솔루션으로 참조하여 수정하십시오. 변수
~ DistributedDataParallel.module (Module) – 병렬될 모듈. 예: >>> torch.distributed.init_process_group (backend = ‘nccl’, world_size = 4, init_method = ‘…’)
>>> net = torch.nn.DistributedDataParallel(모델, 페이지)
조인(dive_by_initial_world_size = True, 활성화 = True) [소스]
참여 프로세스에 대한 불평등한 입력으로 훈련하기 위해 torch.nn.parallel.DistributedDataParallel의 인스턴스와 함께 사용할 컨텍스트 관리자입니다. 이 컨텍스트 관리자는 집계된 DDP 프로세스를 모니터링하고 DDP의 집계되지 않은 프로세스에 의해 생성된 작업과 일치하도록 집계 통신 작업을 배치하여 순방향 및 역방향 전달을 “섀도우”합니다. 이렇게 하면 각 집합 호출에 포함된 DDP 프로세스를 통해 해당 호출이 포함되어 프로세스에 대한 입력이 같지 않은 교육 시 발생하는 중단이나 오류가 방지됩니다. 모든 DDP 프로세스가 결합되면 컨텍스트 관리자는 모든 프로세스에서 마지막 통합 프로세스에 해당하는 모델을 브로드캐스트하여 모든 프로세스에서 모델이 동일한지 확인합니다(DDP에 의해 보장됨). 이를 사용하여 프로세스에 대한 불균등한 입력으로 교육을 활성화하려면 교육 루프 주위에 컨텍스트 관리자를 래핑하기만 하면 됩니다. 더 이상의 모델 변경이나 데이터 로드가 필요하지 않습니다. 경고 이 모듈은 torch.nn.parallel.DistributedDataParallel의 다중 프로세스, 단일 장치 사용에서만 작동합니다. 즉, 하나의 프로세스가 GPU에서 작동합니다. 경고 이 모듈은 현재 SyncBatchNorm 또는 기타 사용자 지정 정의 집합 전달 전달 모델과 같은 사용자 지정 분산 집합 전달 전달 작업을 지원하지 않습니다. 매개변수
Dive_by_initial_world_size (bool) – True인 경우 그라디언트를 함께 시작한 첫 번째 world_size DDP 운동으로 나눕니다. False이면 유효 월드 크기(아직 입력을 소진하지 않은 순위의 수)가 계산되고 기울기가 allreduce 기간으로 나뉩니다. Dive_by_initial_world_size = True로 설정하면 동일하지 않은 입력과 함께 각 입력 샘플이 전역 기울기에 기여하는 정도와 관련하여 동일한 가중치를 갖습니다. 이것은 같지 않은 입력을 만나더라도 항상 초기 world_size로 그라디언트를 나눔으로써 달성됩니다. False로 설정하면 그라디언트를 나머지 노드 수로 나눕니다.이것은 같지 않은 입력이 전역 기울기에 더 도움이 됨을 의미하지만 더 작은 world_size에서 실제로 평등을 보장합니다. 일반적으로 훈련 작업의 마지막 몇 가지 입력이 고르지 않은 경우 이 값을 True로 설정하는 것이 좋습니다. 극단적인 경우 입력 수의 차이가 큰 경우 False로 설정하면 더 나은 결과를 얻을 수 있습니다.
enable (bool) – 불균일한 입력 감지를 활성화할지 여부입니다. 입력이 참여 프로세스에 있다는 것을 알고 있는 경우 비활성화하려면 활성화 = False를 전달합니다. 기본값은 True입니다. 예: >>> 토치 가져오기
>>> 토치.distributed를 dist로 가져오기
>>> 수입 OS
>>> 수입 토치. MP로 멀티프로세싱
>>> nn으로 토치.nn 가져오기
>>> # 태어난 모든 노동자에게
>>> def 작업자(순위):
>>> dist.init_process_group (“nccl”, rank = rank, world_size = 2)
>>>torch.cuda.set_device(순위)
>>> 모델 = nn.Linear(1, 1, 편향 = False) .to(순위)
>>> 모델 = torch.nn.parallel.DistributedDataParallel(
>>> 모델, device_s = [순위], output_device = 순위
>>>)
>>> # 순위 1은 순위 0이 아닌 다른 입력을 받습니다.
>>> 입력 = [torch.tensor ([1]). float () for _ in range (10 + rank)]
>>> model.join() 사용:
>>> 범위 (5)의 _:
>>> 입력 입력:
>>> 손실 = 모델(inp) .sum()
>>> loss.backward()
>>> # join() API가 없으면 아래 동기화가 중단됩니다.
>>> # 랭크 1의 차단을 완료하기 위해 모두 축소합니다.
>>> torch.cuda.synchronize (장치 = 순위)
no_sync () [출처]
DDP 프로세스에서 그래디언트 동기화를 비활성화하는 컨텍스트 관리자. 이 컨텍스트 내에서 그라디언트는 모듈 변수에 누적되며 나중에 컨텍스트에 나타나는 첫 번째 정방향-역방향 패스와 동기화됩니다. 예: >>> ddp = torch.nn.DistributedDataParallel(모델, 페이지)
>>> ddp.no_sync() 사용:
>>> 입력에 대한 입력:
>>> ddp (input) .backward () # 동기화 없음, 학점 누적
>>> ddp (another_input) .backward () # grads 동기화
Training on multiple GPUs and multi-node training with PyTorch DistributedDataParallel
See some more details on the topic distributeddataparallel here:
DistributedDataParallel — PyTorch master documentation
Implements distributed data parallelism that is based on torch.distributed package at the module level. This container parallelizes the application of the given …
Source: glaringlee.github.io
Date Published: 2/8/2021
View: 8072
A Comprehensive Tutorial to Pytorch DistributedDataParallel
DistributedDataParallel (DDP), where the latter is officially recommended. In short, DDP is faster, more flexible than DP. The fundamental thing …
Source: medium.com
Date Published: 5/22/2022
View: 6656
PyTorch Guide to SageMaker’s distributed data parallel library
First import the distributed data parallel library’s PyTorch client and initialize it. · Pin each GPU to a single distributed data parallel library process with …
Source: sagemaker.readthedocs.io
Date Published: 2/24/2022
View: 3990
DistributedDataParallel – PyTorch – W3cubDocs
Implements distributed data parallelism that is based on torch.distributed package at the module level. This container parallelizes the application of the given …
Source: docs.w3cub.com
Date Published: 2/8/2021
View: 8437
DistributedDataParallel with gpu device ID specified in PyTorch
You can set the environment variable CUDA_VISIBLE_DEVICES . Torch will read this variable and only use the GPUs specified in there.
Source: stackoverflow.com
Date Published: 5/30/2021
View: 6219
Related searches to distributeddataparallel
Information related to the topic distributeddataparallel
Here are the search results of the thread distributeddataparallel from Bing. You can read more if you want.
You have just come across an article on the topic distributeddataparallel. If you found this article useful, please share it. Thank you very much.
