def test_sequential(self): f = nn.Sequential( RandomHorizontalFlip(1.0, return_transform=True), RandomHorizontalFlip(1.0, return_transform=True), ) f1 = nn.Sequential( RandomHorizontalFlip(1.0, return_transform=True), RandomHorizontalFlip(1.0), ) input = torch.tensor([[[[0., 0., 0.], [0., 0., 0.], [0., 1., 1.]]]]) # 1 x 1 x 3 x 3 expected_transform = torch.tensor([[[-1., 0., 3.], [0., 1., 0.], [0., 0., 1.]]]) # 1 x 3 x 3 expected_transform_1 = expected_transform @ expected_transform assert(f(input)[0] == input).all() assert(f(input)[1] == expected_transform_1).all() assert(f1(input)[0] == input).all() assert(f1(input)[1] == expected_transform).all()
def test_random_hflip(self): f = RandomHorizontalFlip(p=1.0, return_transform=True) f1 = RandomHorizontalFlip(p=0., return_transform=True) f2 = RandomHorizontalFlip(p=1.) f3 = RandomHorizontalFlip(p=0.) input = torch.tensor([[0., 0., 0.], [0., 0., 0.], [0., 1., 1.]]) # 3 x 3 expected = torch.tensor([[0., 0., 0.], [0., 0., 0.], [1., 1., 0.]]) # 3 x 3 expected_transform = torch.tensor([[-1., 0., 3.], [0., 1., 0.], [0., 0., 1.]]) # 3 x 3 identity = torch.tensor([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]) # 3 x 3 assert (f(input)[0] == expected).all() assert (f(input)[1] == expected_transform).all() assert (f1(input)[0] == input).all() assert (f1(input)[1] == identity).all() assert (f2(input) == expected).all() assert (f3(input) == input).all()
def test_batch_random_hflip(self): f = RandomHorizontalFlip(p=1.0, return_transform=True) f1 = RandomHorizontalFlip(p=0.0, return_transform=True) input = torch.tensor([[[[0., 0., 0.], [0., 0., 0.], [0., 1., 1.]]]]) # 1 x 1 x 3 x 3 expected = torch.tensor([[[[0., 0., 0.], [0., 0., 0.], [1., 1., 0.]]]]) # 1 x 1 x 3 x 3 expected_transform = torch.tensor([[[-1., 0., 3.], [0., 1., 0.], [0., 0., 1.]]]) # 1 x 3 x 3 identity = torch.tensor([[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]]) # 1 x 3 x 3 input = input.repeat(5, 3, 1, 1) # 5 x 3 x 3 x 3 expected = expected.repeat(5, 3, 1, 1) # 5 x 3 x 3 x 3 expected_transform = expected_transform.repeat(5, 1, 1) # 5 x 3 x 3 identity = identity.repeat(5, 1, 1) # 5 x 3 x 3 assert (f(input)[0] == expected).all() assert (f(input)[1] == expected_transform).all() assert (f1(input)[0] == input).all() assert (f1(input)[1] == identity).all()
def test_gradcheck(self): input = torch.rand((3, 3)).double() # 3 x 3 input = utils.tensor_to_gradcheck_var(input) # to var assert gradcheck(RandomHorizontalFlip(p=1.), (input, ), raise_exception=True)
def monochrome_model(gaussian_p, solarize_p): return nn.Sequential( RandomResizedCrop((image_size, image_size), interpolation="BICUBIC"), RandomHorizontalFlip(), RandomApply(GaussianBlur2d(get_kernel_size(image_size), (0.1, 2.0)), p=gaussian_p), RandomSolarize(0, 0, p=solarize_p))
def color_model(gaussian_p, solarize_p): return nn.Sequential( RandomResizedCrop((image_size, image_size), interpolation="BICUBIC"), RandomHorizontalFlip(), ColorJitter(0.4, 0.4, 0.2, 0.1, p=0.8), RandomGrayscale(p=0.2), RandomApply(GaussianBlur2d(get_kernel_size(image_size), (0.1, 2.0)), p=gaussian_p), RandomSolarize(0, 0, p=solarize_p))
def train_transforms(image_size, train_img_scale=(0.35, 1), normalize: bool = True, mean=torch.tensor([0.485, 0.456, 0.406]), std=torch.tensor([0.229, 0.224, 0.225])): """Transforms for train augmentation with Kornia.""" transforms = [ AccimageImageToTensorNN(), RandomResizedCrop((image_size, image_size), train_img_scale, keepdim=True), RandomHorizontalFlip(keepdim=True) ] if normalize: transforms.append(Normalize(mean=std, std=std, keepdim=True)) return torch.nn.Sequential(*transforms)
def __init__(self, input_shape, s=1.0, apply_transforms=None): assert len(input_shape) == 3, "input_shape should be (H, W, C)" self.input_shape = input_shape self.H, self.W, self.C = input_shape[0], input_shape[1], input_shape[2] self.s = s self.apply_transforms = apply_transforms if self.apply_transforms is None: kernel_size = int(0.1 * self.H) sigma = self._get_sigma() self.apply_transforms = KorniaCompose([ RandomResizedCrop(size=(self.H, self.W), scale=(0.08, 1.0)), RandomHorizontalFlip(p=0.5), ColorJitter(0.8 * self.s, 0.8 * self.s, 0.8 * self.s, 0.2 * self.s), RandomGrayscale(p=0.2), GaussianBlur2d(kernel_size=(kernel_size, kernel_size), sigma=(sigma, sigma)) ])
def random_flip(self, p: float = 0.5) -> TransformType: return RandomHorizontalFlip(p=p)
def smoke_test(self): f = RandomHorizontalFlip(0.5) repr = "RandomHorizontalFlip(p=0.5, return_transform=False)" assert str(f) == repr
from itertools import chain import torch import torch.nn as nn import torch.optim as optim from kornia.augmentation import RandomHorizontalFlip, RandomCrop from kornia.geometry.transform import resize from fastcore.all import * from .data_anime_heads import Datasets as AnimeHeadsDatasets, DataLoaders as AnimeHeadsDataLoaders from .data_birds import Datasets as BirdsDatasets, DataLoaders as BirdsDataLoaders from .model import RnnEncoder, CnnEncoder from .torch_utils import * # Internal Cell ce_loss = nn.CrossEntropyLoss() random_hflip = RandomHorizontalFlip().requires_grad_(False).eval() random_crop = RandomCrop((229, 229)).requires_grad_(False).eval() # Internal Cell def cosine_similarity(x1, x2, dim=1, eps=1e-8): """Returns cosine similarity between x1 and x2, computed along dim. """ w12 = torch.sum(x1 * x2, dim) w1 = torch.norm(x1, 2, dim) w2 = torch.norm(x2, 2, dim) return (w12 / (w1 * w2).clamp(min=eps)).squeeze() def func_attention(query, context, gamma1): """