Buckets:
| """ | |
| 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.