Custom transforms in PyTorch - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a custom transform class that converts an image to grayscale.

PyTorch

import torchvision.transforms as transforms

class ToGrayScale:
    def __call__(self, img):
        return img.[1]('L')

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

Ato_grayscale

Bconvert

Cgrayscale

Dconvert_grayscale

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-existent method like 'to_grayscale' causes errors.

Forgetting to specify the number of output channels.

The convert method is used to change the image mode, and 'L' mode means single channel grayscale.

2fill in blank

medium

Complete the code to apply the custom transform to an image.

PyTorch

from PIL import Image

img = Image.open('sample.jpg')
transform = ToGrayScale()
gray_img = transform.[1](img)

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

A__call__

B__call

Ctransform

Dapply

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to call a non-existent method like 'apply'.

Using incorrect method names like '__call' without trailing underscores.

The __call__ method allows the instance to be called like a function. Using transform(img) calls __call__ internally.

3fill in blank

hard

Fix the error in the custom transform that should normalize a tensor image.

PyTorch

import torch

class NormalizeTensor:
    def __init__(self, mean, std):
        self.mean = mean
        self.std = std
    def __call__(self, tensor):
        return (tensor - self.mean) / [1]

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

Aself.mean

Bmean

Cstd

Dself.std

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'mean' or 'self.mean' in the denominator causes wrong normalization.

Forgetting to use 'self.' prefix for instance variables.

Normalization subtracts the mean and divides by the standard deviation stored in self.std.

4fill in blank

hard

Fill both blanks to complete a custom transform that randomly flips an image horizontally with 50% chance.

PyTorch

import random
from PIL import Image

class RandomHorizontalFlip:
    def __call__(self, img):
        if random.random() [1] 0.5:
            return img.[2](Image.FLIP_LEFT_RIGHT)
        return img

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

A>

B<

Ctranspose

Dflip

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' changes the flip probability.

Using a non-existent method like 'flip()' causes errors.

The condition checks if a random number is greater than 0.5 to flip. The transpose() method with Image.FLIP_LEFT_RIGHT flips the image horizontally.

5fill in blank

hard

Fill all three blanks to create a custom transform that converts an image to tensor and normalizes it.

PyTorch

import torchvision.transforms.functional as F

class ToTensorNormalize:
    def __init__(self, mean, std):
        self.mean = mean
        self.std = std
    def __call__(self, img):
        tensor = F.[1](img)
        tensor = F.[2](tensor, self.mean, [3])
        return tensor

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

Ato_tensor

Bnormalize

Cself.std

Dto_tensor_normalize

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-existent function like 'to_tensor_normalize'.

Passing mean or std incorrectly without 'self.'.

to_tensor converts the image to a tensor. normalize applies normalization using mean and standard deviation. The standard deviation is passed as self.std.

Practice

1. What is the main purpose of creating a custom transform in PyTorch?

easy

A. To speed up model training by changing the optimizer

B. To save the model after training

C. To define a new neural network layer

D. To apply a specific data change not available in standard transforms

Solution

1. Step 1: Understand what transforms do

   Transforms change input data before training to help the model learn better.

2. Step 2: Identify the role of custom transforms

   Custom transforms let you add new ways to change data that standard tools don't have.

3. Final Answer:

   To apply a specific data change not available in standard transforms -> Option D

4. Quick Check:

   Custom transform = new data change [OK]

Hint: Custom transforms change data uniquely before training [OK]

Common Mistakes:

• Confusing transforms with model layers
• Thinking transforms speed up training directly
• Mixing transforms with saving models

2. Which of the following is the correct way to define a custom transform class in PyTorch?

easy

A. class MyTransform: def transform(self, x): return x * 2

B. class MyTransform: def __call__(self, x): return x * 2

C. def MyTransform(x): return x * 2

D. def MyTransform: return x * 2

Solution

1. Step 1: Recall custom transform structure

   Custom transforms are classes with a __call__ method to make them callable.

2. Step 2: Check each option

   class MyTransform: def __call__(self, x): return x * 2 defines a class with __call__, correct syntax. Others miss class or __call__ or have wrong syntax.

3. Final Answer:

   class MyTransform: def __call__(self, x): return x * 2 -> Option B

4. Quick Check:

   Custom transform = class + __call__ method [OK]

Hint: Custom transform must be a class with __call__ method [OK]

Common Mistakes:

• Defining transform as a function only
• Using wrong method name like transform instead of __call__
• Missing class keyword

3. Given this custom transform code, what will be the output of transform(3)?

class AddFive:
    def __call__(self, x):
        return x + 5

transform = AddFive()

medium

A. 8

B. 15

C. 3

D. Error

Solution

1. Step 1: Understand the transform class behavior

   The __call__ method adds 5 to the input x.

2. Step 2: Calculate transform(3)

   Input 3 plus 5 equals 8.

3. Final Answer:

   8 -> Option A

4. Quick Check:

   3 + 5 = 8 [OK]

Hint: Call __call__ method adds 5 to input [OK]

Common Mistakes:

• Confusing addition with multiplication
• Expecting the original input unchanged
• Thinking transform is not callable

4. Identify the error in this custom transform code:

class Multiply:
    def call(self, x):
        return x * 3

transform = Multiply()
print(transform(4))

medium

A. Method should be named __call__, not call

B. Class should inherit from nn.Module

C. Missing return statement in method

D. transform(4) is invalid syntax

Solution

1. Step 1: Check method name for callable class

   To make an instance callable, method must be __call__, not call.

2. Step 2: Verify other parts

   Class inheritance is optional for transforms; return is present; calling instance is valid.

3. Final Answer:

   Method should be named __call__, not call -> Option A

4. Quick Check:

   Callable class needs __call__ method [OK]

Hint: Callable classes need __call__, not call method [OK]

Common Mistakes:

• Using call instead of __call__
• Thinking inheritance from nn.Module is required
• Missing return statement

5. You want to create a custom transform that normalizes a tensor by subtracting its mean and dividing by its standard deviation. Which code correctly implements this?

hard

A. class Normalize:
def __call__(self, x):
return x + x.mean() + x.std()

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

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

D. class Normalize:
def __call__(self, x):
return x * x.mean() / x.std()

Solution

1. Step 1: Recall normalization formula

   Normalization means subtract mean and divide by standard deviation.

2. Step 2: Check each option's formula

   class Normalize: def __call__(self, x): return (x - x.mean()) / x.std() matches formula: (x - mean) / std. Others do incorrect math.

3. Final Answer:

   class Normalize: def __call__(self, x): return (x - x.mean()) / x.std() -> Option C

4. Quick Check:

   Normalize = (x - mean) / std [OK]

Hint: Normalize = subtract mean, then divide by std [OK]

Common Mistakes:

• Dividing before subtracting mean
• Adding mean and std instead of subtract/divide
• Multiplying by mean/std incorrectly