Geometric transforms (rotate, flip, crop) in Computer Vision - ML Experiment: Train & Evaluate

Experiment - Geometric transforms (rotate, flip, crop)

Problem:You have a small image dataset for training a model. The model is not generalizing well because the dataset is too small and lacks variety.

Current Metrics:Training accuracy: 95%, Validation accuracy: 60%

Issue:The model is overfitting due to limited data variety. The validation accuracy is much lower than training accuracy.

Your Task

Use geometric transforms (rotate, flip, crop) to augment the training images and improve validation accuracy to at least 75% while keeping training accuracy below 90%.

Only apply geometric transforms: rotation, flipping, and cropping.

Do not change the model architecture or training parameters.

Use the same dataset split for fair comparison.

Hint 1

Hint 2

Hint 3

Hint 4

Solution

Computer Vision

import torch
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.optim as optim

# Define simple CNN model
class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(16 * 16 * 16, 10)  # assuming input 32x32

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = x.view(-1, 16 * 16 * 16)
        x = self.fc1(x)
        return x

# Define transforms with geometric augmentations
train_transforms = transforms.Compose([
    transforms.RandomRotation(30),  # rotate up to 30 degrees
    transforms.RandomHorizontalFlip(),  # flip horizontally
    transforms.RandomResizedCrop(32, scale=(0.8, 1.0)),  # random crop and resize
    transforms.ToTensor()
])

val_transforms = transforms.Compose([
    transforms.ToTensor()
])

# Load CIFAR10 dataset as example
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=train_transforms)
val_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=val_transforms)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)

# Initialize model, loss, optimizer
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SimpleCNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Training loop
for epoch in range(10):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item() * inputs.size(0)
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()
    train_loss = running_loss / total
    train_acc = 100 * correct / total

    model.eval()
    val_loss = 0.0
    val_correct = 0
    val_total = 0
    with torch.no_grad():
        for inputs, labels in val_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            val_loss += loss.item() * inputs.size(0)
            _, predicted = outputs.max(1)
            val_total += labels.size(0)
            val_correct += predicted.eq(labels).sum().item()
    val_loss /= val_total
    val_acc = 100 * val_correct / val_total

    print(f'Epoch {epoch+1}: Train Loss={train_loss:.4f}, Train Acc={train_acc:.2f}%, Val Loss={val_loss:.4f}, Val Acc={val_acc:.2f}%')

Added RandomRotation with max 30 degrees to augment images by rotating.

Added RandomHorizontalFlip to flip images randomly.

Added RandomResizedCrop to crop and resize images randomly.

Kept model and training parameters unchanged to isolate effect of augmentation.

Results Interpretation

Before augmentation: Training accuracy was 95%, validation accuracy was 60%. The model overfitted the training data.

After augmentation: Training accuracy dropped to 88%, validation accuracy improved to 78%. The model generalizes better to new data.

Using geometric transforms like rotation, flipping, and cropping increases data variety. This reduces overfitting and improves validation accuracy by helping the model learn more robust features.

Bonus Experiment

Try adding color jitter (brightness, contrast changes) along with geometric transforms to see if validation accuracy improves further.

💡 Hint

Use torchvision.transforms.ColorJitter with small brightness and contrast changes to augment color variations.

Practice

1. Which geometric transform flips an image horizontally, like looking in a mirror?

easy

A. Horizontal flip

B. Rotate 90 degrees

C. Crop center

D. Vertical flip

Solution

1. Step 1: Understand horizontal flip

   Horizontal flip reverses the image left to right, like a mirror reflection.

2. Step 2: Compare with other transforms

   Rotate changes orientation, crop cuts part of image, vertical flip flips top to bottom.

3. Final Answer:

   Horizontal flip -> Option A

4. Quick Check:

   Mirror image = Horizontal flip [OK]

Hint: Mirror effect means horizontal flip [OK]

Common Mistakes:

• Confusing vertical flip with horizontal flip
• Thinking rotate is flipping
• Mixing crop with flip

2. Which Python code correctly rotates an image by 90 degrees clockwise using OpenCV?

easy

A. rotated = cv2.crop(image, (0,0,100,100))

B. rotated = cv2.flip(image, 1)

C. rotated = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)

D. rotated = cv2.rotate(image, cv2.ROTATE_180)

Solution

1. Step 1: Identify OpenCV rotate syntax

   cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE) rotates image 90 degrees clockwise.

2. Step 2: Check other options

   Flip flips image, crop is not a cv2 function, ROTATE_180 rotates 180 degrees, not 90.

3. Final Answer:

   rotated = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE) -> Option C

4. Quick Check:

   Rotate 90 clockwise = cv2.ROTATE_90_CLOCKWISE [OK]

Hint: Use cv2.rotate with ROTATE_90_CLOCKWISE for 90° turn [OK]

Common Mistakes:

• Using flip instead of rotate
• Wrong rotate constant
• Trying crop as a cv2 function

3. What will be the shape of the image after applying this code?

import cv2
image = cv2.imread('img.jpg')
cropped = image[50:150, 30:130]

medium

A. (100, 100, 3)

B. (150, 130, 3)

C. (80, 100, 3)

D. (100, 80, 3)

Solution

1. Step 1: Calculate crop height

   Height = 150 - 50 = 100 pixels.

2. Step 2: Calculate crop width

   Width = 130 - 30 = 100 pixels.

3. Step 3: Confirm channels

   Image has 3 color channels (RGB/BGR).

4. Final Answer:

   (100, 100, 3) -> Option A

5. Quick Check:

   Crop size = (height, width, channels) = (100, 100, 3) [OK]

Hint: Subtract start from end index for height and width [OK]

Common Mistakes:

• Mixing width and height order
• Forgetting zero-based indexing
• Ignoring color channels

4. This code tries to flip an image vertically but causes an error. What is wrong?

import cv2
image = cv2.imread('img.jpg')
flipped = cv2.flip(image, 2)

medium

A. image must be grayscale for flip

B. Flip code 2 is invalid; use 0 for vertical flip

C. cv2.flip requires three arguments

D. cv2.flip does not flip images

Solution

1. Step 1: Check cv2.flip flipCode values

   flipCode=0 flips vertically, 1 flips horizontally, -1 flips both axes.

2. Step 2: Identify invalid flipCode

   flipCode=2 is invalid and causes error.

3. Final Answer:

   Flip code 2 is invalid; use 0 for vertical flip -> Option B

4. Quick Check:

   Vertical flip = flipCode 0 [OK]

Hint: Use flipCode 0 for vertical flip in cv2.flip [OK]

Common Mistakes:

• Using wrong flipCode values
• Thinking flip needs grayscale
• Assuming cv2.flip needs extra args

5. You want to rotate an image 90 degrees clockwise and then crop the central 100x100 pixels. Which code correctly does this?

hard

A. crop = img[50:150, 50:150]
rot = cv2.rotate(crop, cv2.ROTATE_90_CLOCKWISE)

B. rot = cv2.flip(img, 1)
crop = rot[rot.shape[0]//2-50:rot.shape[0]//2+50, rot.shape[1]//2-50:rot.shape[1]//2+50]

C. rot = cv2.rotate(img, cv2.ROTATE_180)
crop = rot[0:100, 0:100]

D. rot = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)
crop = rot[rot.shape[0]//2-50:rot.shape[0]//2+50, rot.shape[1]//2-50:rot.shape[1]//2+50]

Solution

1. Step 1: Rotate image 90 degrees clockwise

   Use cv2.rotate with ROTATE_90_CLOCKWISE on original image.

2. Step 2: Crop center 100x100 pixels

   Calculate center indices and slice 50 pixels before and after center in both dimensions.

3. Step 3: Verify order and correctness

   Rotation first, then crop center; other options rotate wrong angle or crop before rotate.

4. Final Answer:

   Rotate then crop center 100x100 -> Option D

5. Quick Check:

   Rotate 90° clockwise then center crop = rot = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE) crop = rot[rot.shape[0]//2-50:rot.shape[0]//2+50, rot.shape[1]//2-50:rot.shape[1]//2+50] [OK]

Hint: Rotate first, then crop center using shape indices [OK]

Common Mistakes:

• Cropping before rotating changes crop area
• Using wrong rotate angle
• Using flip instead of rotate