Spaces:
Runtime error
Runtime error
| import torch | |
| import torch.nn.functional as F | |
| def calculate_adaptive_weight(recon_loss, g_loss, last_layer, disc_weight_max): | |
| recon_grads = torch.autograd.grad( | |
| recon_loss, last_layer, retain_graph=True)[0] | |
| g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0] | |
| d_weight = torch.norm(recon_grads) / (torch.norm(g_grads) + 1e-4) | |
| d_weight = torch.clamp(d_weight, 0.0, disc_weight_max).detach() | |
| return d_weight | |
| def adopt_weight(weight, global_step, threshold=0, value=0.): | |
| if global_step < threshold: | |
| weight = value | |
| return weight | |
| def hinge_d_loss(logits_real, logits_fake): | |
| loss_real = torch.mean(F.relu(1. - logits_real)) | |
| loss_fake = torch.mean(F.relu(1. + logits_fake)) | |
| d_loss = 0.5 * (loss_real + loss_fake) | |
| return d_loss | |
| def DiffAugment(x, policy='', channels_first=True): | |
| if policy: | |
| if not channels_first: | |
| x = x.permute(0, 3, 1, 2) | |
| for p in policy.split(','): | |
| for f in AUGMENT_FNS[p]: | |
| x = f(x) | |
| if not channels_first: | |
| x = x.permute(0, 2, 3, 1) | |
| x = x.contiguous() | |
| return x | |
| def rand_brightness(x): | |
| x = x + ( | |
| torch.rand(x.size(0), 1, 1, 1, dtype=x.dtype, device=x.device) - 0.5) | |
| return x | |
| def rand_saturation(x): | |
| x_mean = x.mean(dim=1, keepdim=True) | |
| x = (x - x_mean) * (torch.rand( | |
| x.size(0), 1, 1, 1, dtype=x.dtype, device=x.device) * 2) + x_mean | |
| return x | |
| def rand_contrast(x): | |
| x_mean = x.mean(dim=[1, 2, 3], keepdim=True) | |
| x = (x - x_mean) * (torch.rand( | |
| x.size(0), 1, 1, 1, dtype=x.dtype, device=x.device) + 0.5) + x_mean | |
| return x | |
| def rand_translation(x, ratio=0.125): | |
| shift_x, shift_y = int(x.size(2) * ratio + | |
| 0.5), int(x.size(3) * ratio + 0.5) | |
| translation_x = torch.randint( | |
| -shift_x, shift_x + 1, size=[x.size(0), 1, 1], device=x.device) | |
| translation_y = torch.randint( | |
| -shift_y, shift_y + 1, size=[x.size(0), 1, 1], device=x.device) | |
| grid_batch, grid_x, grid_y = torch.meshgrid( | |
| torch.arange(x.size(0), dtype=torch.long, device=x.device), | |
| torch.arange(x.size(2), dtype=torch.long, device=x.device), | |
| torch.arange(x.size(3), dtype=torch.long, device=x.device), | |
| ) | |
| grid_x = torch.clamp(grid_x + translation_x + 1, 0, x.size(2) + 1) | |
| grid_y = torch.clamp(grid_y + translation_y + 1, 0, x.size(3) + 1) | |
| x_pad = F.pad(x, [1, 1, 1, 1, 0, 0, 0, 0]) | |
| x = x_pad.permute(0, 2, 3, 1).contiguous()[grid_batch, grid_x, | |
| grid_y].permute(0, 3, 1, 2) | |
| return x | |
| def rand_cutout(x, ratio=0.5): | |
| cutout_size = int(x.size(2) * ratio + 0.5), int(x.size(3) * ratio + 0.5) | |
| offset_x = torch.randint( | |
| 0, | |
| x.size(2) + (1 - cutout_size[0] % 2), | |
| size=[x.size(0), 1, 1], | |
| device=x.device) | |
| offset_y = torch.randint( | |
| 0, | |
| x.size(3) + (1 - cutout_size[1] % 2), | |
| size=[x.size(0), 1, 1], | |
| device=x.device) | |
| grid_batch, grid_x, grid_y = torch.meshgrid( | |
| torch.arange(x.size(0), dtype=torch.long, device=x.device), | |
| torch.arange(cutout_size[0], dtype=torch.long, device=x.device), | |
| torch.arange(cutout_size[1], dtype=torch.long, device=x.device), | |
| ) | |
| grid_x = torch.clamp( | |
| grid_x + offset_x - cutout_size[0] // 2, min=0, max=x.size(2) - 1) | |
| grid_y = torch.clamp( | |
| grid_y + offset_y - cutout_size[1] // 2, min=0, max=x.size(3) - 1) | |
| mask = torch.ones( | |
| x.size(0), x.size(2), x.size(3), dtype=x.dtype, device=x.device) | |
| mask[grid_batch, grid_x, grid_y] = 0 | |
| x = x * mask.unsqueeze(1) | |
| return x | |
| AUGMENT_FNS = { | |
| 'color': [rand_brightness, rand_saturation, rand_contrast], | |
| 'translation': [rand_translation], | |
| 'cutout': [rand_cutout], | |
| } | |