minhluanquach's picture
download
raw
3.54 kB
"""
Data Augmentation Transforms
==============================
Custom transforms for training data augmentation.
Applied to face images to improve model robustness.
"""
import random
from typing import Optional
import cv2
import numpy as np
import torch
from torchvision import transforms
class RandomOcclusion:
"""Randomly adds rectangular occlusion to simulate real-world scenarios.
This helps the model handle partially occluded faces.
"""
def __init__(self, p: float = 0.1, max_ratio: float = 0.15):
self.p = p
self.max_ratio = max_ratio
def __call__(self, img: torch.Tensor) -> torch.Tensor:
if random.random() > self.p:
return img
C, H, W = img.shape
occ_h = random.randint(1, int(H * self.max_ratio))
occ_w = random.randint(1, int(W * self.max_ratio))
y = random.randint(0, H - occ_h)
x = random.randint(0, W - occ_w)
# Only occlude upper half (don't occlude the lip region we're training on)
if y + occ_h > H // 2:
return img
img[:, y : y + occ_h, x : x + occ_w] = 0
return img
class RandomJPEGCompression:
"""Simulates JPEG compression artifacts.
Real-world videos often have compression artifacts.
Training with this makes the model more robust.
"""
def __init__(self, p: float = 0.2, quality_range: tuple = (50, 95)):
self.p = p
self.quality_range = quality_range
def __call__(self, img: torch.Tensor) -> torch.Tensor:
if random.random() > self.p:
return img
# Convert to numpy for JPEG compression
img_np = ((img.permute(1, 2, 0).numpy() + 1) * 127.5).astype(np.uint8)
quality = random.randint(*self.quality_range)
# Encode and decode JPEG
_, encoded = cv2.imencode(
".jpg", img_np, [cv2.IMWRITE_JPEG_QUALITY, quality]
)
decoded = cv2.imdecode(encoded, cv2.IMREAD_COLOR)
# Convert back to tensor
result = torch.from_numpy(decoded.astype(np.float32) / 127.5 - 1).permute(2, 0, 1)
return result
class RandomGaussianNoise:
"""Adds random Gaussian noise."""
def __init__(self, p: float = 0.1, std_range: tuple = (0.01, 0.05)):
self.p = p
self.std_range = std_range
def __call__(self, img: torch.Tensor) -> torch.Tensor:
if random.random() > self.p:
return img
std = random.uniform(*self.std_range)
noise = torch.randn_like(img) * std
return (img + noise).clamp(-1, 1)
def get_training_transforms(image_size: int = 256) -> transforms.Compose:
"""Get the full augmentation pipeline for training."""
return transforms.Compose([
transforms.RandomHorizontalFlip(p=0.5),
transforms.ColorJitter(
brightness=0.1, contrast=0.1, saturation=0.1, hue=0.02
),
transforms.Resize(image_size),
transforms.CenterCrop(image_size),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]),
RandomGaussianNoise(p=0.1),
])
def get_validation_transforms(image_size: int = 256) -> transforms.Compose:
"""Get transforms for validation (no augmentation)."""
return transforms.Compose([
transforms.Resize(image_size),
transforms.CenterCrop(image_size),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]),
])

Xet Storage Details

Size:
3.54 kB
·
Xet hash:
d7744490798d115643d5e5ebea8e4aacded9f11451943121cc6fc42faacd0bda

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.