Spaces:
Sleeping
Sleeping
| import hashlib | |
| import os | |
| import requests | |
| import torch | |
| import torch.nn as nn | |
| from tqdm import tqdm | |
| URL_MAP = {"vgg_lpips": "https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1"} | |
| CKPT_MAP = {"vgg_lpips": "vgg.pth"} | |
| MD5_MAP = {"vgg_lpips": "d507d7349b931f0638a25a48a722f98a"} | |
| def download(url, local_path, chunk_size=1024): | |
| os.makedirs(os.path.split(local_path)[0], exist_ok=True) | |
| with requests.get(url, stream=True) as r: | |
| total_size = int(r.headers.get("content-length", 0)) | |
| with tqdm(total=total_size, unit="B", unit_scale=True) as pbar: | |
| with open(local_path, "wb") as f: | |
| for data in r.iter_content(chunk_size=chunk_size): | |
| if data: | |
| f.write(data) | |
| pbar.update(chunk_size) | |
| def md5_hash(path): | |
| with open(path, "rb") as f: | |
| content = f.read() | |
| return hashlib.md5(content).hexdigest() | |
| def get_ckpt_path(name, root, check=False): | |
| assert name in URL_MAP | |
| path = os.path.join(root, CKPT_MAP[name]) | |
| if not os.path.exists(path) or (check and not md5_hash(path) == MD5_MAP[name]): | |
| print("Downloading {} model from {} to {}".format(name, URL_MAP[name], path)) | |
| download(URL_MAP[name], path) | |
| md5 = md5_hash(path) | |
| assert md5 == MD5_MAP[name], md5 | |
| return path | |
| class ActNorm(nn.Module): | |
| def __init__( | |
| self, num_features, logdet=False, affine=True, allow_reverse_init=False | |
| ): | |
| assert affine | |
| super().__init__() | |
| self.logdet = logdet | |
| self.loc = nn.Parameter(torch.zeros(1, num_features, 1, 1)) | |
| self.scale = nn.Parameter(torch.ones(1, num_features, 1, 1)) | |
| self.allow_reverse_init = allow_reverse_init | |
| self.register_buffer("initialized", torch.tensor(0, dtype=torch.uint8)) | |
| def initialize(self, input): | |
| with torch.no_grad(): | |
| flatten = input.permute(1, 0, 2, 3).contiguous().view(input.shape[1], -1) | |
| mean = ( | |
| flatten.mean(1) | |
| .unsqueeze(1) | |
| .unsqueeze(2) | |
| .unsqueeze(3) | |
| .permute(1, 0, 2, 3) | |
| ) | |
| std = ( | |
| flatten.std(1) | |
| .unsqueeze(1) | |
| .unsqueeze(2) | |
| .unsqueeze(3) | |
| .permute(1, 0, 2, 3) | |
| ) | |
| self.loc.data.copy_(-mean) | |
| self.scale.data.copy_(1 / (std + 1e-6)) | |
| def forward(self, input, reverse=False): | |
| if reverse: | |
| return self.reverse(input) | |
| if len(input.shape) == 2: | |
| input = input[:, :, None, None] | |
| squeeze = True | |
| else: | |
| squeeze = False | |
| _, _, height, width = input.shape | |
| if self.training and self.initialized.item() == 0: | |
| self.initialize(input) | |
| self.initialized.fill_(1) | |
| h = self.scale * (input + self.loc) | |
| if squeeze: | |
| h = h.squeeze(-1).squeeze(-1) | |
| if self.logdet: | |
| log_abs = torch.log(torch.abs(self.scale)) | |
| logdet = height * width * torch.sum(log_abs) | |
| logdet = logdet * torch.ones(input.shape[0]).to(input) | |
| return h, logdet | |
| return h | |
| def reverse(self, output): | |
| if self.training and self.initialized.item() == 0: | |
| if not self.allow_reverse_init: | |
| raise RuntimeError( | |
| "Initializing ActNorm in reverse direction is " | |
| "disabled by default. Use allow_reverse_init=True to enable." | |
| ) | |
| else: | |
| self.initialize(output) | |
| self.initialized.fill_(1) | |
| if len(output.shape) == 2: | |
| output = output[:, :, None, None] | |
| squeeze = True | |
| else: | |
| squeeze = False | |
| h = output / self.scale - self.loc | |
| if squeeze: | |
| h = h.squeeze(-1).squeeze(-1) | |
| return h | |