Add files using upload-large-folder tool

test/transform/bf-v1-CenterCrop_22.py

@@ -0,0 +1,10 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.CenterCrop(size=32),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-CenterCrop_Pad.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.CenterCrop(size=32),
+    transforms.Pad(padding=1, fill=(170, 12, 255), padding_mode='constant'),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-Pad_CenterCrop.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.Pad(padding=5, fill=(207, 85, 18), padding_mode='symmetric'),
+    transforms.CenterCrop(size=32),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-Pad_RandomAutocontrast.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.Pad(padding=3, fill=(238, 7, 23), padding_mode='reflect'),
+    transforms.RandomAutocontrast(p=0.54),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-Pad_RandomAutocontrast_RandomPosterize.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.Pad(padding=3, fill=(70, 201, 240), padding_mode='constant'),
+    transforms.RandomAutocontrast(p=0.3),
+    transforms.RandomPosterize(bits=7, p=0.6),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-Pad_RandomHorizontalFlip_RandomAdjustSharpnes.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.Pad(padding=0, fill=(198, 7, 128), padding_mode='constant'),
+    transforms.RandomHorizontalFlip(p=0.36),
+    transforms.RandomAdjustSharpness(sharpness_factor=1.89, p=0.42),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-Pad_RandomPosterize_RandomAdjustSharpnes.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.Pad(padding=4, fill=(37, 38, 180), padding_mode='reflect'),
+    transforms.RandomPosterize(bits=6, p=0.34),
+    transforms.RandomAdjustSharpness(sharpness_factor=1.92, p=0.68),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-Pad_RandomPosterize_RandomHorizontalFlip.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.Pad(padding=4, fill=(219, 105, 67), padding_mode='reflect'),
+    transforms.RandomPosterize(bits=4, p=0.38),
+    transforms.RandomHorizontalFlip(p=0.68),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomAdjustSharpnes.py

@@ -0,0 +1,10 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomAdjustSharpness(sharpness_factor=0.6, p=0.52),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomAdjustSharpnes_29.py

@@ -0,0 +1,10 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomAdjustSharpness(sharpness_factor=1.43, p=0.23),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomAdjustSharpnes_Grayscale_3.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomAdjustSharpness(sharpness_factor=1.91, p=0.56),
+    transforms.Grayscale(num_output_channels=3),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomAdjustSharpnes_RandomAutocontrast.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomAdjustSharpness(sharpness_factor=0.99, p=0.13),
+    transforms.RandomAutocontrast(p=0.61),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomAdjustSharpnes_RandomEqualize_3.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomAdjustSharpness(sharpness_factor=0.85, p=0.26),
+    transforms.RandomEqualize(p=0.44),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomAdjustSharpnes_RandomRotation_3.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomAdjustSharpness(sharpness_factor=1.23, p=0.68),
+    transforms.RandomRotation(degrees=2),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomAdjustSharpnes_RandomSolarize_2.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomAdjustSharpness(sharpness_factor=1.45, p=0.12),
+    transforms.RandomSolarize(threshold=207, p=0.17),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomAutocontrast_75.py

@@ -0,0 +1,10 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomAutocontrast(p=0.62),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomAutocontrast_CenterCrop.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomAutocontrast(p=0.64),
+    transforms.CenterCrop(size=32),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomAutocontrast_RandomAdjustSharpnes_256.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomAutocontrast(p=0.59),
+    transforms.RandomAdjustSharpness(sharpness_factor=1.68, p=0.84),
+    transforms.Resize((256,256)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomCrop_CenterCrop_5.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomCrop(size=30),
+    transforms.CenterCrop(size=30),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomCrop_CenterCrop_RandomAutocontrast.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomCrop(size=32),
+    transforms.CenterCrop(size=28),
+    transforms.RandomAutocontrast(p=0.21),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomCrop_RandomAdjustSharpnes_6.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomCrop(size=32),
+    transforms.RandomAdjustSharpness(sharpness_factor=0.54, p=0.61),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomCrop_RandomAdjustSharpnes_RandomAutocontrast.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomCrop(size=32),
+    transforms.RandomAdjustSharpness(sharpness_factor=0.78, p=0.23),
+    transforms.RandomAutocontrast(p=0.51),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomEqualize_RandomAdjustSharpnes_2.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomEqualize(p=0.11),
+    transforms.RandomAdjustSharpness(sharpness_factor=1.06, p=0.7),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomHorizontalFlip_CenterCrop_Pad.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomHorizontalFlip(p=0.22),
+    transforms.CenterCrop(size=30),
+    transforms.Pad(padding=0, fill=(241, 60, 204), padding_mode='reflect'),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomHorizontalFlip_GaussianBlur_3.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomHorizontalFlip(p=0.79),
+    transforms.GaussianBlur(kernel_size=3, sigma=(0.4, 1.33)),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomHorizontalFlip_RandomAdjustSharpnes_RandomPerspective.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomHorizontalFlip(p=0.87),
+    transforms.RandomAdjustSharpness(sharpness_factor=1.99, p=0.73),
+    transforms.RandomPerspective(distortion_scale=0.19, p=0.19),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomHorizontalFlip_RandomAutocontrast_256.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomHorizontalFlip(p=0.39),
+    transforms.RandomAutocontrast(p=0.54),
+    transforms.Resize((256,256)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomHorizontalFlip_RandomAutocontrast_RandomAdjustSharpnes_256.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomHorizontalFlip(p=0.84),
+    transforms.RandomAutocontrast(p=0.78),
+    transforms.RandomAdjustSharpness(sharpness_factor=1.31, p=0.53),
+    transforms.Resize((256,256)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomHorizontalFlip_RandomCrop_Pad.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomHorizontalFlip(p=0.34),
+    transforms.RandomCrop(size=31),
+    transforms.Pad(padding=1, fill=(226, 100, 14), padding_mode='edge'),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomHorizontalFlip_RandomCrop_RandomPosterize.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomHorizontalFlip(p=0.49),
+    transforms.RandomCrop(size=31),
+    transforms.RandomPosterize(bits=5, p=0.54),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomHorizontalFlip_RandomPosterize_RandomAutocontrast.py

@@ -0,0 +1,12 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomHorizontalFlip(p=0.45),
+    transforms.RandomPosterize(bits=7, p=0.68),
+    transforms.RandomAutocontrast(p=0.13),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomPerspective_CenterCrop.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomPerspective(distortion_scale=0.13, p=0.35),
+    transforms.CenterCrop(size=31),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomPerspective_RandomCrop.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomPerspective(distortion_scale=0.12, p=0.53),
+    transforms.RandomCrop(size=30),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomPosterize_256.py

@@ -0,0 +1,10 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomPosterize(bits=4, p=0.83),
+    transforms.Resize((256,256)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomPosterize_RandomAutocontrast.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomPosterize(bits=4, p=0.1),
+    transforms.RandomAutocontrast(p=0.89),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomPosterize_RandomHorizontalFlip_6.py

@@ -0,0 +1,11 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomPosterize(bits=5, p=0.48),
+    transforms.RandomHorizontalFlip(p=0.88),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/bf-v1-RandomResizedCrop_65.py

@@ -0,0 +1,10 @@
+import torch
+import torchvision.transforms as transforms
+
+def transform(norm):
+    return transforms.Compose([
+    transforms.RandomResizedCrop(size=32, scale=(0.79, 0.9), ratio=(1.25, 2.99)),
+    transforms.Resize((64,64)),
+    transforms.ToTensor(),
+    transforms.Normalize(*norm)
+])

test/transform/complex_32.py

@@ -0,0 +1,42 @@
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+
+class NormalizeToFloat:
+    """ 
+    Custom transformation to normalize image data to float32 and scale to [0, 1].
+    """
+    def __call__(self, x):
+        if isinstance(x, np.ndarray):
+            x = x.astype(np.float32) / 255.0
+        elif isinstance(x, torch.Tensor):
+            x = x.float() / 255.0
+        else:
+            x = np.array(x).astype(np.float32) / 255.0
+        return x
+
+class ToComplex64:
+    """ 
+    Custom transformation to convert PyTorch tensor to torch.complex64.
+    """
+    def __call__(self, x):
+        """
+        Transform method to convert the tensor to torch.complex64.
+        :param x: Input tensor, usually a NumPy array, PIL Image, or PyTorch tensor.
+        :return: Tensor converted to torch.complex64.
+        """
+        if not isinstance(x, torch.Tensor):
+            x = torch.tensor(x)
+        x = x.type(torch.complex64)  # to torch.complex64
+        return x
+    
+def transform(norm):
+    """
+    Define the transformation to be applied to the CIFAR-10 dataset.
+    :return: A transformation pipeline using torchvision.transforms.
+    """
+    return transforms.Compose([
+        transforms.Resize((32, 32)),
+        NormalizeToFloat(),
+        transforms.ToTensor(),
+        ToComplex64()])

test/transform/complex_32_flip.py

@@ -0,0 +1,43 @@
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+
+class NormalizeToFloat:
+    """ 
+    Custom transformation to normalize image data to float32 and scale to [0, 1].
+    """
+    def __call__(self, x):
+        if isinstance(x, np.ndarray):
+            x = x.astype(np.float32) / 255.0
+        elif isinstance(x, torch.Tensor):
+            x = x.float() / 255.0
+        else:
+            x = np.array(x).astype(np.float32) / 255.0
+        return x
+
+class ToComplex64:
+    """ 
+    Custom transformation to convert PyTorch tensor to torch.complex64.
+    """
+    def __call__(self, x):
+        """
+        Transform method to convert the tensor to torch.complex64.
+        :param x: Input tensor, usually a NumPy array, PIL Image, or PyTorch tensor.
+        :return: Tensor converted to torch.complex64.
+        """
+        if not isinstance(x, torch.Tensor):
+            x = torch.tensor(x)
+        x = x.type(torch.complex64)  # to torch.complex64
+        return x
+    
+def transform(norm):
+    """
+    Define the transformation to be applied to the CIFAR-10 dataset.
+    :return: A transformation pipeline using torchvision.transforms.
+    """
+    return transforms.Compose([
+        transforms.Resize((32, 32)),
+        transforms.RandomHorizontalFlip(),
+        NormalizeToFloat(),
+        transforms.ToTensor(),
+        ToComplex64()])

test/transform/complex_64_flip.py

@@ -0,0 +1,43 @@
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+
+class NormalizeToFloat:
+    """ 
+    Custom transformation to normalize image data to float32 and scale to [0, 1].
+    """
+    def __call__(self, x):
+        if isinstance(x, np.ndarray):
+            x = x.astype(np.float32) / 255.0
+        elif isinstance(x, torch.Tensor):
+            x = x.float() / 255.0
+        else:
+            x = np.array(x).astype(np.float32) / 255.0
+        return x
+
+class ToComplex64:
+    """ 
+    Custom transformation to convert PyTorch tensor to torch.complex64.
+    """
+    def __call__(self, x):
+        """
+        Transform method to convert the tensor to torch.complex64.
+        :param x: Input tensor, usually a NumPy array, PIL Image, or PyTorch tensor.
+        :return: Tensor converted to torch.complex64.
+        """
+        if not isinstance(x, torch.Tensor):
+            x = torch.tensor(x)
+        x = x.type(torch.complex64)  # to torch.complex64
+        return x
+    
+def transform(norm):
+    """
+    Define the transformation to be applied to the CIFAR-10 dataset.
+    :return: A transformation pipeline using torchvision.transforms.
+    """
+    return transforms.Compose([
+        transforms.Resize((64, 64)),
+        transforms.RandomHorizontalFlip(),
+        NormalizeToFloat(),
+        transforms.ToTensor(),
+        ToComplex64()])

test/transform/echo.py

@@ -0,0 +1,5 @@
+import torchvision.transforms as transforms
+
+def transform(_):
+    return transforms.Compose([
+        transforms.ToTensor()])

test/transform/echo_128.py

@@ -0,0 +1,6 @@
+import torchvision.transforms as transforms
+
+def transform(_):
+    return transforms.Compose([
+        transforms.Resize((128,128)),
+        transforms.ToTensor()])

test/transform/echo_299_flip.py

@@ -0,0 +1,7 @@
+import torchvision.transforms as transforms
+
+def transform(_):
+    return transforms.Compose([
+        transforms.Resize((299,299)),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor()])

test/transform/echo_32.py

@@ -0,0 +1,6 @@
+import torchvision.transforms as transforms
+
+def transform(_):
+    return transforms.Compose([
+        transforms.Resize((32,32)),
+        transforms.ToTensor()])

test/transform/echo_512.py

@@ -0,0 +1,6 @@
+import torchvision.transforms as transforms
+
+def transform(_):
+    return transforms.Compose([
+        transforms.Resize((512,512)),
+        transforms.ToTensor()])

test/transform/echo_512_flip.py

@@ -0,0 +1,7 @@
+import torchvision.transforms as transforms
+
+def transform(_):
+    return transforms.Compose([
+        transforms.Resize((512,512)),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor()])

test/transform/echo_64_flip.py

@@ -0,0 +1,7 @@
+import torchvision.transforms as transforms
+
+def transform(_):
+    return transforms.Compose([
+        transforms.Resize((64,64)),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor()])

test/transform/git_processor.py

@@ -0,0 +1,33 @@
+"""
+GIT Processor Transform for NN Dataset Framework
+
+This transform uses appropriate preprocessing for Microsoft's GIT model
+for image captioning.
+"""
+
+from torchvision import transforms
+
+try:
+    import os
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    from transformers import GitProcessor
+    _processor = GitProcessor.from_pretrained("microsoft/git-large-coco")
+except Exception:
+    _processor = None
+
+
+def transform(norm):
+    """
+    Returns a transform function compatible with NN Dataset framework.
+    
+    For GIT, we need to:
+    1. Resize to 224x224
+    2. Normalize appropriately
+    
+    The actual GIT processor will be used in the model's forward pass.
+    """
+    return transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize(*norm)
+    ])

test/transform/norm_256.py

@@ -0,0 +1,8 @@
+import torchvision.transforms as transforms
+
+
+def transform(norm):
+    return transforms.Compose([
+        transforms.Resize((256, 256)),
+        transforms.ToTensor(),
+        transforms.Normalize(*norm)])

test/transform/norm_256_flip.py

@@ -0,0 +1,10 @@
+import torchvision.transforms as transforms
+
+
+def transform(norm):
+    return transforms.Compose([
+        transforms.Resize(256),
+        transforms.CenterCrop(256),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor(),
+        transforms.Normalize(*norm)])