Custom transforms in PyTorch - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a custom PyTorch transform on a tensor

Given the following custom transform class and input tensor, what is the output tensor after applying the transform?

PyTorch

import torch
class AddScalar:
    def __init__(self, scalar):
        self.scalar = scalar
    def __call__(self, x):
        return x + self.scalar

transform = AddScalar(3)
tensor = torch.tensor([1, 2, 3])
output = transform(tensor)
print(output)

A tensor([4, 5, 6])

B tensor([3, 3, 3])

C tensor([1, 2, 3])

D tensor([6, 7, 8])

💡 Hint

Remember the transform adds the scalar 3 to each element of the tensor.

The transform adds 3 to each element of the input tensor [1, 2, 3], resulting in [4, 5, 6].

❓ Model Choice

intermediate

Choosing the correct custom transform for image normalization

You want to create a custom PyTorch transform that normalizes an image tensor by subtracting the mean and dividing by the standard deviation. Which class correctly implements this?

A

class Normalize:
    def __init__(self, mean, std):
        self.mean = mean
        self.std = std
    def __call__(self, x):
        return (x - self.mean) / self.std

B

class Normalize:
    def __init__(self, mean, std):
        self.mean = mean
        self.std = std
    def __call__(self, x):
        return x + self.mean - self.std

C

class Normalize:
    def __init__(self, mean, std):
        self.mean = mean
        self.std = std
    def __call__(self, x):
        return x * self.std + self.mean

D

class Normalize:
    def __init__(self, mean, std):
        self.mean = mean
        self.std = std
    def __call__(self, x):
        return (x + self.mean) / self.std

💡 Hint

Normalization means subtracting mean and dividing by std deviation.

Option A correctly subtracts the mean and divides by the std deviation, which is the standard normalization formula.

❓ Hyperparameter

advanced

Effect of changing scalar in a custom transform

You have a custom transform that multiplies input tensors by a scalar value. If you increase the scalar from 2 to 5, what is the expected effect on the model training when using this transform on input data?

A The input values become negative, causing the model to fail training.

B The input values become smaller, which slows down training and reduces model accuracy.

C The input values remain unchanged, so training is unaffected.

D The input values become larger, which may cause the model to learn faster but risk numerical instability.

💡 Hint

Multiplying inputs by a larger scalar increases their magnitude.

Increasing the scalar increases input magnitude, which can speed learning but may cause instability if too large.

🔧 Debug

advanced

Identify the error in this custom transform code

What error will this custom transform code raise when applied to a tensor?

PyTorch

import torch
class Multiply:
    def __init__(self, factor):
        self.factor = factor
    def __call__(self, x):
        return x * self.factor

transform = Multiply(4)
tensor = torch.tensor([1, 2, 3])
output = transform(tensor)
print(output)

A No error, output is tensor([4, 8, 12])

B NameError: name 'factor' is not defined

C AttributeError: 'Multiply' object has no attribute 'factor'

D TypeError: unsupported operand type(s) for *: 'int' and 'Multiply'

💡 Hint

Check variable usage inside the __call__ method.

Inside __call__, 'factor' is used without 'self.', causing a NameError.

🧠 Conceptual

expert

Why use custom transforms instead of built-in ones?

Which of the following is the best reason to create a custom transform in PyTorch instead of using built-in transforms?

A To avoid using PyTorch's DataLoader class.

B Because built-in transforms are slower and less efficient.

C To implement a unique data preprocessing step not available in built-in transforms.

D Because custom transforms automatically improve model accuracy.

💡 Hint

Think about when you need something special that built-in tools don't offer.

Custom transforms allow you to add unique preprocessing steps tailored to your data or task.