Custom transforms in PyTorch - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a custom transform in PyTorch?

A custom transform is a user-defined operation that modifies data (like images or tensors) before feeding it into a model. It helps prepare or augment data in ways not covered by built-in transforms.

beginner

How do you create a custom transform class in PyTorch?

You create a class with a __call__ method that takes an input (like an image) and returns the transformed output. This class can then be used like a function in a transform pipeline.

intermediate

Why use custom transforms instead of built-in ones?

Custom transforms let you apply specific changes tailored to your data or experiment, such as unique augmentations or preprocessing steps that built-in transforms don’t provide.

beginner

What method must a PyTorch custom transform implement to be used in torchvision transforms?

It must implement the __call__ method, which allows the transform to be called like a function on the input data.

intermediate

How can you combine a custom transform with other transforms in PyTorch?

You can include your custom transform class inside torchvision.transforms.Compose along with other transforms to create a pipeline that applies all transformations sequentially.

What is the purpose of the __call__ method in a PyTorch custom transform?

A To save the transform to disk

B To make the transform callable like a function

C To initialize the transform parameters

D To visualize the transform effect

The __call__ method allows the transform object to be used like a function, applying the transformation to input data.

Which PyTorch module is commonly used to combine multiple transforms including custom ones?

A torch.optim.Adam

B torch.nn.Sequential

C torch.utils.data.DataLoader

D torchvision.transforms.Compose

torchvision.transforms.Compose chains multiple transforms together, including custom transforms.

Why might you write a custom transform instead of using a built-in one?

A To apply a unique data modification not available in built-in transforms

B To change the model architecture

C To increase model size

D To reduce training time

Custom transforms allow you to apply specific data changes that built-in transforms do not support.

What type of input does a PyTorch custom transform usually take?

A Model weights

B Training labels

C Data samples like images or tensors

D Optimizer parameters

Transforms operate on data samples such as images or tensors before they are fed into the model.

How do you apply a custom transform to a dataset in PyTorch?

A Pass it as the transform argument when creating the dataset

B Add it to the optimizer

C Include it in the model definition

D Use it to initialize the DataLoader

You pass the custom transform to the dataset’s transform parameter so it applies to each data sample.

Explain how to create and use a custom transform in PyTorch for image data.

Think about making a callable class and integrating it with existing transform pipelines.

Describe why custom transforms are important in machine learning workflows.

Consider how data preparation affects model performance.

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