1{
2  "op": "replace",
3  "filename": "pytorch-vision/custom_augment.py",
4  "start_line": 246,
5  "end_line": 275,
6  "content": "def build_train_transform(config):\n    \"\"\"Adaptive Multi-Scale Augmentation with Structured Dropout (AMASD).\n    \n    Novel contributions:\n    1. Dataset-adaptive augmentation strength: higher magnitude for more classes (CIFAR-100)\n    2. Multi-scale processing: random choice of scale before augmentation\n    3. Structured dropout: random rectangular masks with adaptive size based on image scale\n    4. Combined photometric (RandAugment) and geometric (Affine) transforms\n    \n    Pipeline: RandomScale → RandAugment(adaptive) → RandomCrop → RandomFlip → \n              ToTensor → StructuredDropout → Normalize\n    \"\"\"\n    import torch\n    import torchvision.transforms as transforms\n    import torchvision.transforms.functional as F\n    \n    # Dataset-adaptive parameters\n    if config['dataset'] == 'cifar100':\n        # More classes, need stronger regularization\n        ra_num_ops = 3\n        ra_magnitude = 12\n        dropout_prob = 0.3\n        max_scale = 1.2\n    else:  # cifar10 or fmnist\n        ra_num_ops = 2\n        ra_magnitude = 9\n        dropout_prob = 0.2\n        max_scale = 1.1\n    \n    class RandomScale:\n        \"\"\"Randomly scale image by factor in [1.0, max_scale] before other transforms.\"\"\"\n        def __init__(self, max_scale):\n            self.max_scale = max_scale\n            \n        def __call__(self, img):\n            import random\n            scale = random.uniform(1.0, self.max_scale)\n            w, h = img.size\n            new_w, new_h = int(w * scale), int(h * scale)\n            return F.resize(img, (new_h, new_w))\n    \n    class StructuredDropout:\n        \"\"\"Random rectangular masks with size adaptive to image dimensions.\n        \n        Instead of fixed-size cutout, creates variable number of rectangular\n        masks with widths/heights proportional to image size.\n        \"\"\"\n        def __init__(self, prob=0.2):\n            self.prob = prob\n            \n        def __call__(self, img):\n            if torch.rand(1).item() > self.prob:\n                return img\n                \n            c, h, w = img.shape\n            mask = torch.ones_like(img)\n            \n            # Number of masks: 1-3\n            n_masks = torch.randint(1, 4, (1,)).item()\n            \n            for _ in range(n_masks):\n                # Mask size proportional to image dimensions\n                mask_h = torch.randint(int(h * 0.1), int(h * 0.4), (1,)).item()\n                mask_w = torch.randint(int(w * 0.1), int(w * 0.4), (1,)).item()\n                \n                # Random position\n                top = torch.randint(0, h - mask_h + 1, (1,)).item()\n                left = torch.randint(0, w - mask_w + 1, (1,)).item()\n                \n                mask[:, top:top+mask_h, left:left+mask_w] = 0\n                \n            return img * mask\n    \n    return transforms.Compose([\n        RandomScale(max_scale),\n        transforms.RandAugment(num_ops=ra_num_ops, magnitude=ra_magnitude),\n        transforms.RandomCrop(config['img_size'], padding=4),\n        transforms.RandomHorizontalFlip(),\n        transforms.ToTensor(),\n        StructuredDropout(prob=dropout_prob),\n        transforms.Normalize(config['mean'], config['std']),\n    ])"
7}

1{
2  "op": "replace",
3  "filename": "pytorch-vision/custom_augment.py",
4  "start_line": 246,
5  "end_line": 327,
6  "content": "def build_train_transform(config):\n    \"\"\"Curriculum-Inspired Adaptive Augmentation (CIAA).\n    \n    Novel contributions:\n    1. Dataset-specific augmentation policies: tuned for CIFAR-10, CIFAR-100, FashionMNIST\n    2. Stochastic augmentation strength: per-image random magnitude within bounds\n    3. Multi-policy selection: randomly choose between geometric and photometric emphasis\n    4. Adaptive masking: random erasing with probability based on dataset difficulty\n    \n    Pipeline: RandomChoice between two augmentation paths →\n              ToTensor → RandomErasing (adaptive) → Normalize\n    \"\"\"\n    import torch\n    import torchvision.transforms as transforms\n    import torchvision.transforms.functional as F\n    import random\n    \n    # Dataset-specific parameters\n    dataset = config['dataset']\n    if dataset == 'cifar100':\n        # More classes, stronger augmentation\n        ra_magnitude_range = (8, 14)  # random per image\n        ra_num_ops = 3\n        rotate_degree = 15\n        erase_prob = 0.3\n        scale_range = (0.9, 1.2)\n    elif dataset == 'cifar10':\n        ra_magnitude_range = (7, 12)\n        ra_num_ops = 2\n        rotate_degree = 10\n        erase_prob = 0.25\n        scale_range = (0.95, 1.15)\n    else:  # fmnist\n        # FashionMNIST: less color variation, more geometric\n        ra_magnitude_range = (5, 10)\n        ra_num_ops = 1\n        rotate_degree = 15\n        erase_prob = 0.2\n        scale_range = (0.9, 1.1)\n    \n    class RandomAugmentationPath:\n        \"\"\"Randomly selects between two augmentation strategies per image.\"\"\"\n        def __init__(self, config, ra_magnitude_range, ra_num_ops, \n                     rotate_degree, scale_range):\n            self.config = config\n            self.ra_magnitude_range = ra_magnitude_range\n            self.ra_num_ops = ra_num_ops\n            self.rotate_degree = rotate_degree\n            self.scale_range = scale_range\n            \n        def __call__(self, img):\n            # Randomly choose path A (photometric emphasis) or B (geometric emphasis)\n            if random.random() < 0.5:\n                # Path A: RandAugment + moderate geometric\n                # Random magnitude per image\n                magnitude = random.randint(*self.ra_magnitude_range)\n                img = transforms.RandAugment(\n                    num_ops=self.ra_num_ops, magnitude=magnitude\n                )(img)\n                # Basic geometric\n                if random.random() < 0.5:\n                    img = F.rotate(img, random.uniform(-self.rotate_degree/2, \n                                                       self.rotate_degree/2))\n                img = transforms.RandomCrop(self.config['img_size'], padding=4)(img)\n                img = transforms.RandomHorizontalFlip()(img)\n            else:\n                # Path B: Strong geometric + weaker photometric\n                # Random scaling\n                scale = random.uniform(*self.scale_range)\n                w, h = img.size\n                new_w, new_h = int(w * scale), int(h * scale)\n                img = F.resize(img, (new_h, new_w))\n                # Random rotation\n                img = F.rotate(img, random.uniform(-self.rotate_degree, \n                                                   self.rotate_degree))\n                # Random affine (translation, scale, shear)\n                img = transforms.RandomAffine(\n                    degrees=0, translate=(0.1, 0.1),\n                    scale=(0.9, 1.1), shear=5\n                )(img)\n                img = transforms.RandomCrop(self.config['img_size'], padding=4)(img)\n                img = transforms.RandomHorizontalFlip()(img)\n                # Mild color jitter\n                if random.random() < 0.3:\n                    img = transforms.ColorJitter(\n                        brightness=0.2, contrast=0.2, saturation=0.2\n                    )(img)\n            return img\n    \n    class AdaptiveRandomErasing:\n        \"\"\"Random erasing with probability and size adaptive to dataset.\"\"\"\n        def __init__(self, prob=0.2):\n            self.prob = prob\n            \n        def __call__(self, img):\n            if torch.rand(1).item() > self.prob:\n                return img\n                \n            c, h, w = img.shape\n            # Random number of erasures: 1-2\n            n_erasures = random.randint(1, 2)\n            \n            for _ in range(n_erasures):\n                # Erasure area between 2% and 20% of image\n                area = h * w\n                target_area = random.uniform(0.02, 0.2) * area\n                aspect_ratio = random.uniform(0.3, 1.0/0.3)\n                \n                erasure_h = int(round((target_area * aspect_ratio) ** 0.5))\n                erasure_w = int(round((target_area / aspect_ratio) ** 0.5))\n                \n                if erasure_h < h and erasure_w < w:\n                    top = random.randint(0, h - erasure_h)\n                    left = random.randint(0, w - erasure_w)\n                    img[:, top:top+erasure_h, left:left+erasure_w] = 0\n                    \n            return img\n    \n    return transforms.Compose([\n        RandomAugmentationPath(config, ra_magnitude_range, ra_num_ops,\n                               rotate_degree, scale_range),\n        transforms.ToTensor(),\n        AdaptiveRandomErasing(prob=erase_prob),\n        transforms.Normalize(config['mean'], config['std']),\n    ])"
7}

1{
2  "op": "replace",
3  "filename": "pytorch-vision/custom_augment.py",
4  "start_line": 246,
5  "end_line": 370,
6  "content": "def build_train_transform(config):\n    \"\"\"Augmentation Pyramid with Stochastic Depth (APSD).\n    \n    Novel contributions:\n    1. Pyramid of augmentations: apply transforms at multiple scales sequentially\n    2. Stochastic depth: randomly skip some augmentation blocks to create varied difficulty\n    3. Channel-wise perturbations: simulate depth effects via per-channel adjustments\n    4. Adaptive policy mixing: blend between conservative and aggressive augmentation\n    \n    Pipeline: RandomScale → RandomAugmentationBlock (with stochastic depth) →\n              ToTensor → ChannelWiseMask → Normalize\n    \"\"\"\n    import torch\n    import torchvision.transforms as transforms\n    import torchvision.transforms.functional as F\n    import random\n    import numpy as np\n    \n    dataset = config['dataset']\n    \n    # Dataset-specific hyperparameters\n    if dataset == 'cifar100':\n        scale_range = (0.8, 1.2)\n        ra_magnitude = (9, 14)\n        ra_num_ops = 3\n        block_drop_prob = 0.2  # stochastic depth probability\n        channel_mask_prob = 0.3\n        perspective_distortion = 0.2\n    elif dataset == 'cifar10':\n        scale_range = (0.85, 1.15)\n        ra_magnitude = (8, 12)\n        ra_num_ops = 2\n        block_drop_prob = 0.15\n        channel_mask_prob = 0.25\n        perspective_distortion = 0.15\n    else:  # fmnist\n        scale_range = (0.9, 1.1)\n        ra_magnitude = (5, 9)\n        ra_num_ops = 1\n        block_drop_prob = 0.1\n        channel_mask_prob = 0.2\n        perspective_distortion = 0.1\n    \n    class RandomScale:\n        def __init__(self, scale_range):\n            self.scale_range = scale_range\n        def __call__(self, img):\n            scale = random.uniform(*self.scale_range)\n            w, h = img.size\n            new_w, new_h = int(w * scale), int(h * scale)\n            return F.resize(img, (new_h, new_w))\n    \n    class AugmentationBlock:\n        \"\"\"Applies a sequence of transforms with stochastic depth.\"\"\"\n        def __init__(self, config, ra_num_ops, ra_magnitude, \n                     block_drop_prob, perspective_distortion):\n            self.config = config\n            self.ra_num_ops = ra_num_ops\n            self.ra_magnitude = ra_magnitude\n            self.block_drop_prob = block_drop_prob\n            self.perspective_distortion = perspective_distortion\n            \n            # Pre-instantiate transforms for efficiency\n            self.randaugment = transforms.RandAugment(\n                num_ops=ra_num_ops, \n                magnitude=random.randint(*ra_magnitude)\n            )\n            self.random_crop = transforms.RandomCrop(\n                config['img_size'], padding=4\n            )\n            self.random_hflip = transforms.RandomHorizontalFlip(p=0.5)\n            self.color_jitter = transforms.ColorJitter(\n                brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1\n            )\n            self.random_rotate = transforms.RandomRotation(degrees=15)\n            self.random_perspective = transforms.RandomPerspective(\n                distortion_scale=perspective_distortion, p=0.5\n            )\n            self.random_affine = transforms.RandomAffine(\n                degrees=0, translate=(0.1, 0.1), scale=(0.9, 1.1), shear=5\n            )\n            self.random_grayscale = transforms.RandomGrayscale(p=0.1)\n            \n        def __call__(self, img):\n            # Stochastic depth: skip entire block with probability\n            if random.random() < self.block_drop_prob:\n                return img\n                \n            # Randomly select augmentation intensity\n            intensity = random.random()\n            \n            # Always apply basic geometric\n            img = self.random_crop(img)\n            img = self.random_hflip(img)\n            \n            # Apply photometric transforms based on intensity\n            if intensity < 0.3:\n                # Mild: only color jitter\n                img = self.color_jitter(img)\n            elif intensity < 0.7:\n                # Moderate: RandAugment + color jitter\n                img = self.randaugment(img)\n                img = self.color_jitter(img)\n            else:\n                # Strong: multiple transforms\n                img = self.randaugment(img)\n                img = self.color_jitter(img)\n                img = self.random_grayscale(img)\n            \n            # Apply geometric transforms based on intensity\n            if intensity > 0.5:\n                # Add rotation\n                img = self.random_rotate(img)\n            if intensity > 0.7:\n                # Add perspective distortion\n                img = self.random_perspective(img)\n            if intensity > 0.8:\n                # Add affine transformation\n                img = self.random_affine(img)\n                \n            return img\n    \n    class ChannelWiseMask:\n        \"\"\"Apply random masks per channel to simulate depth effects.\"\"\"\n        def __init__(self, prob=0.2):\n            self.prob = prob\n            \n        def __call__(self, img):\n            if torch.rand(1).item() > self.prob:\n                return img\n                \n            c, h, w = img.shape\n            mask = torch.ones_like(img)\n            \n            # Different mask for each channel\n            for ch in range(c):\n                if random.random() < 0.5:\n                    # Rectangular mask\n                    mask_h = random.randint(int(h * 0.05), int(h * 0.3))\n                    mask_w = random.randint(int(w * 0.05), int(w * 0.3))\n                    top = random.randint(0, h - mask_h)\n                    left = random.randint(0, w - mask_w)\n                    mask[ch, top:top+mask_h, left:left+mask_w] = 0\n                else:\n                    # Gaussian-like smooth mask\n                    center_h = random.randint(0, h-1)\n                    center_w = random.randint(0, w-1)\n                    radius = random.randint(int(min(h,w)*0.05), int(min(h,w)*0.2))\n                    y, x = torch.meshgrid(torch.arange(h), torch.arange(w), indexing='ij')\n                    dist = ((y - center_h)**2 + (x - center_w)**2).float().sqrt()\n                    channel_mask = torch.where(dist < radius, 0.0, 1.0)\n                    mask[ch] *= channel_mask\n                    \n            return img * mask\n    \n    return transforms.Compose([\n        RandomScale(scale_range),\n        AugmentationBlock(config, ra_num_ops, ra_magnitude,\n                          block_drop_prob, perspective_distortion),\n        transforms.ToTensor(),\n        ChannelWiseMask(prob=channel_mask_prob),\n        transforms.Normalize(config['mean'], config['std']),\n    ])"
7}

1{
2  "n": 2
3}