Multi-GPU training in PyTorch - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Multi-GPU training in PyTorch?

Multi-GPU training means using more than one graphics card to train a model faster by splitting the work across GPUs.

beginner

What PyTorch class helps to easily use multiple GPUs for training?

The <code>torch.nn.DataParallel</code> class wraps a model to run it on multiple GPUs by splitting input data automatically.

beginner

Why do we need to move the model and data to GPUs in PyTorch multi-GPU training?

Because GPUs do the heavy math work, the model and data must be on GPUs to speed up training. PyTorch needs explicit commands to move them.

intermediate

What is a common challenge when using multiple GPUs for training?

Synchronizing gradients and combining results from all GPUs can be tricky, but PyTorch handles this automatically with DataParallel.

intermediate

How does DataParallel split the input data across GPUs?

It splits the input batch into smaller chunks, sends each chunk to a different GPU, runs the model on each chunk, then combines the outputs.

Which PyTorch class is commonly used for simple multi-GPU training?

A torch.optim.Adam

B torch.nn.DataParallel

C torch.utils.data.DataLoader

D torch.nn.Sequential

torch.nn.DataParallel is designed to wrap models for multi-GPU training.

Before training on GPUs, what must you do with your model in PyTorch?

A Call <code>model.to('cuda')</code> to move it to GPU

B Call <code>model.train()</code> only

C Call <code>model.eval()</code>

D Nothing, PyTorch moves it automatically

You must move the model to GPU explicitly using model.to('cuda').

How does DataParallel handle the outputs from multiple GPUs?

A It discards outputs from all but one GPU

B It leaves outputs on each GPU separately

C It combines outputs back on the main GPU

D It sends outputs to CPU automatically

DataParallel gathers outputs from all GPUs and combines them on the main GPU.

What is a benefit of using multiple GPUs for training?

A Less memory usage on each GPU

B No need to move data to GPU

C Simpler code without changes

D Faster training by parallelizing work

Multiple GPUs speed up training by sharing the workload.

Which of these is NOT true about DataParallel?

A It requires manual gradient synchronization

B It wraps the model for multi-GPU use

C It combines outputs on the main GPU

D It automatically splits input batches

DataParallel automatically synchronizes gradients; manual sync is not needed.

Explain how PyTorch's DataParallel helps in multi-GPU training.

Think about how input and output are handled across GPUs.

Describe the steps to prepare a PyTorch model and data for multi-GPU training.

Consider what needs to be on GPU and how to enable multi-GPU.

Practice

1. What is the main purpose of using torch.nn.DataParallel in PyTorch?

easy

A. To reduce the model size by pruning layers

B. To convert the model to a CPU-only version

C. To split the model and data across multiple GPUs for faster training

D. To visualize the model architecture

Solution

1. Step 1: Understand the role of DataParallel

   torch.nn.DataParallel is designed to distribute the model and input data across multiple GPUs to speed up training.

2. Step 2: Compare options

   Reducing the model size by pruning layers, converting the model to a CPU-only version, and visualizing the model architecture do not relate to multi-GPU training. Only splitting the model and data across multiple GPUs for faster training correctly describes the purpose.

3. Final Answer:

   To split the model and data across multiple GPUs for faster training -> Option C

4. Quick Check:

   Multi-GPU training = DataParallel usage [OK]

Hint: DataParallel splits model and data across GPUs for speed [OK]

Common Mistakes:

• Thinking DataParallel reduces model size
• Confusing DataParallel with CPU conversion
• Assuming DataParallel is for visualization

2. Which of the following is the correct way to wrap a PyTorch model for multi-GPU training?

easy

A. model = torch.nn.DataParallel(model)

B. model = torch.nn.Sequential(model)

C. model = torch.nn.ModuleList(model)

D. model = torch.nn.Parameter(model)

Solution

1. Step 1: Identify the correct wrapper for multi-GPU

   To enable multi-GPU training, PyTorch provides torch.nn.DataParallel which wraps the model.

2. Step 2: Check other options

   Sequential chains layers, ModuleList stores layers, and Parameter is for tensors, none enable multi-GPU.

3. Final Answer:

   model = torch.nn.DataParallel(model) -> Option A

4. Quick Check:

   Wrap model with DataParallel for multi-GPU [OK]

Hint: Use DataParallel(model) to enable multi-GPU training [OK]

Common Mistakes:

• Using Sequential or ModuleList instead of DataParallel
• Trying to wrap model with Parameter
• Forgetting to wrap the model at all

3. Consider this code snippet for multi-GPU training:

import torch
model = MyModel()
model = torch.nn.DataParallel(model)
model.cuda()
inputs = inputs.cuda()
outputs = model(inputs)
print(outputs.device)

What will be printed if multiple GPUs are available?

medium

A. cuda:0

B. cpu

C. cuda:1

D. cuda:all

Solution

1. Step 1: Understand DataParallel device behavior

   When using DataParallel, the model replicates on all GPUs but the output is gathered on the default device, usually cuda:0.

2. Step 2: Analyze the print statement

   The outputs.device will show the device of the gathered output tensor, which is cuda:0, not all GPUs or CPU.

3. Final Answer:

   cuda:0 -> Option A

4. Quick Check:

   DataParallel output device = cuda:0 [OK]

Hint: DataParallel gathers output on cuda:0 device [OK]

Common Mistakes:

• Expecting output on all GPUs simultaneously
• Thinking output is on CPU
• Assuming output device is cuda:1 or others

4. You wrote this code for multi-GPU training but get an error:

model = MyModel()
model = torch.nn.DataParallel(model)
inputs = inputs.cuda()
outputs = model(inputs)

The error says: 'Expected all tensors to be on the same device'. What is the likely cause?

medium

A. Model should be wrapped with Sequential instead

B. Model is not moved to GPU before wrapping with DataParallel

C. DataParallel requires inputs on CPU

D. Inputs are not on CPU

Solution

1. Step 1: Check model and input device placement

   The model must be moved to GPU (e.g., model.cuda()) before wrapping with DataParallel to ensure all parts are on the same device.

2. Step 2: Analyze error cause

   If the model is on CPU but inputs are on GPU, the error about device mismatch occurs.

3. Final Answer:

   Model is not moved to GPU before wrapping with DataParallel -> Option B

4. Quick Check:

   Model and inputs must be on same device [OK]

Hint: Move model to GPU before DataParallel wrap [OK]

Common Mistakes:

• Wrapping model before moving to GPU
• Assuming inputs must be on CPU
• Using wrong wrapper like Sequential

5. You want to train a model on 4 GPUs using PyTorch. Which of these steps is NOT necessary for correct multi-GPU training?

hard

A. Move input data to GPU before passing to the model

B. Move the model to GPU before wrapping

C. Wrap the model with torch.nn.DataParallel

D. Manually split input batches and send each to a different GPU

Solution

1. Step 1: Review multi-GPU training steps

   Using DataParallel automatically splits input batches and sends them to multiple GPUs, so manual splitting is not needed.

2. Step 2: Confirm necessary steps

   Wrapping the model, moving it to GPU, and moving inputs to GPU are all required for proper multi-GPU training.

3. Final Answer:

   Manually split input batches and send each to a different GPU -> Option D

4. Quick Check:

   DataParallel handles input splitting automatically [OK]

Hint: DataParallel auto-splits inputs; manual split not needed [OK]

Common Mistakes:

• Trying to manually split inputs across GPUs
• Forgetting to move model to GPU
• Not wrapping model with DataParallel