Custom transforms in PyTorch

Introduction

Custom transforms let you change your data in your own way before training. This helps your model learn better by seeing different versions of the data.

You want to flip or rotate images in a special way not covered by built-in tools.

You need to add noise or change colors in a unique style to make your model stronger.

Your data is not images but text or numbers, and you want to prepare it before training.

You want to combine several small changes into one easy step.

You want to fix or clean your data in a way no standard tool does.

Syntax

PyTorch

class MyTransform:
    def __init__(self, param):
        self.param = param

    def __call__(self, sample):
        # change sample using self.param
        transformed_sample = sample  # example placeholder
        return transformed_sample

The class must have a __call__ method to work like a function.

You can add parameters in __init__ to control how the transform works.

Examples

This transform adds random noise to a tensor sample.

PyTorch

import torch

class AddNoise:
    def __init__(self, noise_level):
        self.noise_level = noise_level

    def __call__(self, sample):
        return sample + self.noise_level * torch.randn_like(sample)

This transform converts a color image tensor to grayscale by averaging color channels.

PyTorch

class ToGray:
    def __call__(self, image):
        return image.mean(dim=0, keepdim=True)

Sample Model

This example shows a simple custom transform that doubles the input tensor values.

PyTorch

import torch
from torchvision import transforms

class MultiplyByTwo:
    def __call__(self, x):
        return x * 2

# Create a tensor sample
sample = torch.tensor([1.0, 2.0, 3.0])

# Create transform instance
transform = MultiplyByTwo()

# Apply transform
transformed_sample = transform(sample)

print('Original:', sample)
print('Transformed:', transformed_sample)

Important Notes

Custom transforms can be combined with built-in transforms using transforms.Compose.

Make sure your transform works with the data type you use (e.g., PIL images or tensors).

Test your transform separately to avoid bugs in your training pipeline.

Summary

Custom transforms let you change data your own way before training.

They are classes with a __call__ method that changes the input.

Use them to add new data changes not in standard libraries.

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