DataParallel basics in PyTorch - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to wrap the model for parallel GPU training using DataParallel.

PyTorch

import torch
import torch.nn as nn

model = nn.Linear(10, 2)
model = torch.nn.DataParallel([1])

Drag options to blanks, or click blank then click option'

Atorch.nn.Module()

Bnn.Linear(10, 2)

Ctorch.nn.Linear(10, 2)

Dmodel

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the class instead of the model instance.

Using an unrelated torch module.

We wrap the existing model instance with torch.nn.DataParallel to enable parallel GPU training.

2fill in blank

medium

Complete the code to move the DataParallel model to GPU device 0.

PyTorch

device = torch.device('cuda:0')
model = torch.nn.DataParallel(model)
model = model[1](device)

Drag options to blanks, or click blank then click option'

Acpu

Bcuda

Cto

Ddevice

Attempts:

3 left

💡 Hint

Common Mistakes

Using cuda() without parentheses.

Using cpu() which moves model to CPU.

The to() method moves the model to the specified device.

3fill in blank

hard

Fix the error in the code to correctly get the model's original module after DataParallel wrapping.

PyTorch

if isinstance(model, torch.nn.DataParallel):
    original_model = model[1]
else:
    original_model = model

Drag options to blanks, or click blank then click option'

Adata_parallel

Bmodule

Cmodel

Doriginal

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to access model.model which does not exist.

Using incorrect attribute names.

When using DataParallel, the original model is accessible via the module attribute.

4fill in blank

hard

Fill both blanks to create a DataParallel model and move it to all available GPUs.

PyTorch

model = nn.Linear(20, 5)
model = torch.nn.DataParallel(model, device_ids=[1])
model = model[2]('cuda')

Drag options to blanks, or click blank then click option'

A[0, 1]

B[0]

Cto

Dcuda

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a single integer instead of a list for device_ids.

Using cuda without parentheses as a method.

We specify device IDs as a list of GPU indices and use to('cuda') to move the model to GPUs.

5fill in blank

hard

Fill all three blanks to create a dictionary of losses for each GPU and sum them correctly.

PyTorch

losses = {f'gpu_{i}': output[i].mean() for i in range([1])}
total_loss = sum([3] for [3] in losses[2])

Drag options to blanks, or click blank then click option'

A2

B.values()

Closs

D.keys()

Attempts:

3 left

💡 Hint

Common Mistakes

Iterating over keys instead of values.

Using wrong range for number of GPUs.

We iterate over the values of the losses dictionary for 2 GPUs and sum the loss values.

Practice

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

easy

A. To convert a model to run only on CPU

B. To run a model on multiple GPUs by splitting input data automatically

C. To reduce the size of the model parameters

D. To change the model architecture dynamically during training

Solution

1. Step 1: Understand DataParallel's role

   DataParallel helps use multiple GPUs by splitting input data and running model copies in parallel.

2. Step 2: Compare options

   Only To run a model on multiple GPUs by splitting input data automatically describes this behavior correctly; others describe unrelated tasks.

3. Final Answer:

   To run a model on multiple GPUs by splitting input data automatically -> Option B

4. Quick Check:

   DataParallel = multi-GPU input splitting [OK]

Hint: DataParallel splits input across GPUs automatically [OK]

Common Mistakes:

• Thinking DataParallel changes model architecture
• Confusing DataParallel with CPU-only mode
• Believing it reduces model size

2. Which of the following is the correct way to wrap a PyTorch model model with DataParallel?

easy

A. model = torch.DataParallel(model)

B. model = torch.nn.parallel.DataParallel(model)

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

D. model = torch.parallel.DataParallel(model)

Solution

1. Step 1: Recall correct import path

   DataParallel is in torch.nn, so correct usage is torch.nn.DataParallel.

2. Step 2: Check options

   model = torch.nn.DataParallel(model) matches the correct usage; others are incorrect or incomplete.

3. Final Answer:

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

4. Quick Check:

   Correct import path = torch.nn.DataParallel [OK]

Hint: DataParallel is in torch.nn module [OK]

Common Mistakes:

• Using torch.DataParallel instead of torch.nn.DataParallel
• Confusing torch.nn.parallel with torch.nn
• Confusing with other torch submodules

3. Given the code below, what will be the output shape of output if input shape is (8, 3, 32, 32) and 2 GPUs are used?

import torch
import torch.nn as nn

model = nn.Linear(32*32*3, 10)
model = nn.parallel.DataParallel(model)
input = torch.randn(8, 3, 32, 32)
input = input.view(8, -1)
output = model(input)
print(output.shape)

medium

A. torch.Size([8, 10])

B. torch.Size([4, 10])

C. torch.Size([16, 10])

D. RuntimeError due to shape mismatch

Solution

1. Step 1: Understand input and model

   Input is reshaped to (8, 3072) and model outputs 10 features per input.

2. Step 2: DataParallel splits batch across 2 GPUs

   Batch of 8 splits into 2 batches of 4, processed in parallel, outputs combined back to (8, 10).

3. Final Answer:

   torch.Size([8, 10]) -> Option A

4. Quick Check:

   Output shape = batch size x output features = (8, 10) [OK]

Hint: Output batch size stays same after DataParallel [OK]

Common Mistakes:

• Thinking output batch size halves with GPUs
• Confusing input reshape with output shape
• Expecting runtime error due to DataParallel

4. What is the likely cause of this error when using DataParallel?

RuntimeError: Expected tensor for argument #1 'input' to have scalar type Float but got Double

Code snippet:

model = torch.nn.parallel.DataParallel(model)
input = torch.randn(8, 3, 32, 32, dtype=torch.double)
output = model(input)

medium

A. Input batch size is too large for GPUs

B. DataParallel requires input to be on CPU only

C. Model is not wrapped correctly with DataParallel

D. Input tensor dtype does not match model parameters dtype

Solution

1. Step 1: Analyze error message

   Error says input tensor is Double but model expects Float tensors.

2. Step 2: Check input and model dtypes

   Model parameters default to Float; input is Double, causing mismatch and error.

3. Final Answer:

   Input tensor dtype does not match model parameters dtype -> Option D

4. Quick Check:

   Dtype mismatch causes runtime error [OK]

Hint: Ensure input and model dtypes match before DataParallel [OK]

Common Mistakes:

• Assuming DataParallel only works on CPU
• Not checking tensor data types
• Thinking batch size causes dtype errors

5. You want to speed up training on 4 GPUs using DataParallel. Your model has a batch normalization layer. What should you be careful about to avoid incorrect training behavior?

hard

A. BatchNorm layers behave differently in DataParallel; use SyncBatchNorm or move to DistributedDataParallel

B. DataParallel automatically fixes BatchNorm issues, no action needed

C. Remove BatchNorm layers before using DataParallel

D. Increase batch size to avoid BatchNorm problems

Solution

1. Step 1: Understand BatchNorm behavior in DataParallel

   BatchNorm computes stats per device, which can cause inconsistent normalization across GPUs.

2. Step 2: Recommended solutions

   Use SyncBatchNorm to sync stats or switch to DistributedDataParallel for correct BatchNorm behavior.

3. Final Answer:

   BatchNorm layers behave differently in DataParallel; use SyncBatchNorm or move to DistributedDataParallel -> Option A

4. Quick Check:

   BatchNorm needs syncing or DDP for multi-GPU [OK]

Hint: BatchNorm needs syncing or DDP on multiple GPUs [OK]

Common Mistakes:

• Assuming DataParallel handles BatchNorm correctly by default
• Removing BatchNorm layers unnecessarily
• Only increasing batch size without syncing stats