def get_transforms(resize, crop): transforms = T.Compose([ T.Resize(resize, interpolation="bicubic"), T.CenterCrop(crop), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) return transforms
def get_transforms(resize, crop): transforms = [T.Resize(resize, interpolation="bicubic")] if crop: transforms.append(T.CenterCrop(crop)) transforms.append(T.ToTensor()) transforms.append( T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ) transforms = T.Compose(transforms) return transforms
def get_transforms(interpolation): transforms = T.Compose( [ T.Resize(256, interpolation=interpolation), T.CenterCrop(224), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ] ) return transforms
def get_dataloader(self, num_workers): dataset = paddle.vision.datasets.MNIST( mode='test', transform=transforms.Compose([ transforms.CenterCrop(20), transforms.RandomResizedCrop(14), transforms.Normalize(), transforms.ToTensor() ])) loader = paddle.io.DataLoader(dataset, batch_size=32, num_workers=num_workers, shuffle=True) return loader
def load_train_test_datasets(dataset_root): mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] resize = transforms.Resize(256) rcrop = transforms.RandomCrop((224, 224)) ccrop = transforms.CenterCrop((224, 224)) tot = transforms.ToTensor() normalize = transforms.Normalize(mean, std) train_transforms = transforms.Compose([resize, rcrop, tot, normalize]) test_transforms = transforms.Compose([resize, ccrop, tot, normalize]) train_set = DatasetFolder(osp.join(dataset_root, 'train'), transform=train_transforms) test_set = DatasetFolder(osp.join(dataset_root, 'test'), transform=test_transforms) return train_set, test_set
def __init__(self, opt=opt): super(DataGenerater, self).__init__() self.dir = opt.imgs_path self.datalist = os.listdir( self.dir) if opt.test == False else os.listdir(self.dir)[:100] self.batch_size = opt.batch_size img = Image.open(self.dir + self.datalist[0]) self.image_size = img.size img.close() self.transform = T.Compose([ T.Resize(opt.img_size), T.CenterCrop(opt.img_size), T.ToTensor(), ]) self.num_path_dict = {}
for name in names: tar.extract(name, "./") model = paddle.jit.load("./paddle_resnet50/model") ###################################################################### # Load a test image # --------------------------------------------- # A single cat dominates the examples! from PIL import Image import paddle.vision.transforms as T transforms = T.Compose([ T.Resize((256, 256)), T.CenterCrop(224), T.ToTensor(), T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) img_url = "https://github.com/dmlc/mxnet.js/blob/main/data/cat.png?raw=true" img_path = download_testdata(img_url, "cat.png", module="data") img = Image.open(img_path).resize((224, 224)) img = transforms(img) img = np.expand_dims(img, axis=0) ###################################################################### # Compile the model with relay # ---------------------------------------------
def run( self, image, need_align=False, start_lr=0.1, final_lr=0.025, latent_level=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], # for ffhq (0~17) step=100, mse_weight=1, pre_latent=None): if need_align: src_img = run_alignment(image) else: src_img = Image.open(image).convert("RGB") generator = self.generator generator.train() percept = LPIPS(net='vgg') # on PaddlePaddle, lpips's default eval mode means no gradients. percept.train() n_mean_latent = 4096 transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(256), transforms.Transpose(), transforms.Normalize([127.5, 127.5, 127.5], [127.5, 127.5, 127.5]), ]) imgs = paddle.to_tensor(transform(src_img)).unsqueeze(0) if pre_latent is None: with paddle.no_grad(): noise_sample = paddle.randn( (n_mean_latent, generator.style_dim)) latent_out = generator.style(noise_sample) latent_mean = latent_out.mean(0) latent_in = latent_mean.detach().clone().unsqueeze(0).tile( (imgs.shape[0], 1)) latent_in = latent_in.unsqueeze(1).tile( (1, generator.n_latent, 1)).detach() else: latent_in = paddle.to_tensor(np.load(pre_latent)).unsqueeze(0) var_levels = list(latent_level) const_levels = [ i for i in range(generator.n_latent) if i not in var_levels ] assert len(var_levels) > 0 if len(const_levels) > 0: latent_fix = latent_in.index_select(paddle.to_tensor(const_levels), 1).detach().clone() latent_in = latent_in.index_select(paddle.to_tensor(var_levels), 1).detach().clone() latent_in.stop_gradient = False optimizer = optim.Adam(parameters=[latent_in], learning_rate=start_lr) pbar = tqdm(range(step)) for i in pbar: t = i / step lr = get_lr(t, step, start_lr, final_lr) optimizer.set_lr(lr) if len(const_levels) > 0: latent_dict = {} for idx, idx2 in enumerate(var_levels): latent_dict[idx2] = latent_in[:, idx:idx + 1] for idx, idx2 in enumerate(const_levels): latent_dict[idx2] = (latent_fix[:, idx:idx + 1]).detach() latent_list = [] for idx in range(generator.n_latent): latent_list.append(latent_dict[idx]) latent_n = paddle.concat(latent_list, 1) else: latent_n = latent_in img_gen, _ = generator([latent_n], input_is_latent=True, randomize_noise=False) batch, channel, height, width = img_gen.shape if height > 256: factor = height // 256 img_gen = img_gen.reshape((batch, channel, height // factor, factor, width // factor, factor)) img_gen = img_gen.mean([3, 5]) p_loss = percept(img_gen, imgs).sum() mse_loss = F.mse_loss(img_gen, imgs) loss = p_loss + mse_weight * mse_loss optimizer.clear_grad() loss.backward() optimizer.step() pbar.set_description( (f"perceptual: {p_loss.numpy()[0]:.4f}; " f"mse: {mse_loss.numpy()[0]:.4f}; lr: {lr:.4f}")) img_gen, _ = generator([latent_n], input_is_latent=True, randomize_noise=False) dst_img = make_image(img_gen)[0] dst_latent = latent_n.numpy()[0] os.makedirs(self.output_path, exist_ok=True) save_src_path = os.path.join(self.output_path, 'src.fitting.png') cv2.imwrite(save_src_path, cv2.cvtColor(np.asarray(src_img), cv2.COLOR_RGB2BGR)) save_dst_path = os.path.join(self.output_path, 'dst.fitting.png') cv2.imwrite(save_dst_path, cv2.cvtColor(dst_img, cv2.COLOR_RGB2BGR)) save_npy_path = os.path.join(self.output_path, 'dst.fitting.npy') np.save(save_npy_path, dst_latent) return np.asarray(src_img), dst_img, dst_latent
def get_dataset(args, config): if config.data.random_flip is False: tran_transform = test_transform = transforms.Compose([ transforms.Resize([config.data.image_size] * 2), transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0 ]) else: tran_transform = transforms.Compose([ transforms.Resize([config.data.image_size] * 2), transforms.RandomHorizontalFlip(prob=0.5), transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0, ]) test_transform = transforms.Compose([ transforms.Resize([config.data.image_size] * 2), transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0 ]) if config.data.dataset == "CIFAR10": dataset = Cifar10( # os.path.join(args.exp, "datasets", "cifar10"), mode="train", download=True, transform=tran_transform, ) test_dataset = Cifar10( # os.path.join(args.exp, "datasets", "cifar10_test"), mode="test", download=True, transform=test_transform, ) elif config.data.dataset == "CELEBA": cx = 89 cy = 121 x1 = cy - 64 x2 = cy + 64 y1 = cx - 64 y2 = cx + 64 if config.data.random_flip: dataset = CelebA( root=os.path.join(args.exp, "datasets", "celeba"), split="train", transform=transforms.Compose([ Crop(x1, x2, y1, y2), transforms.Resize([config.data.image_size] * 2), transforms.RandomHorizontalFlip(), transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0, ]), download=True, ) else: dataset = CelebA( root=os.path.join(args.exp, "datasets", "celeba"), split="train", transform=transforms.Compose([ Crop(x1, x2, y1, y2), transforms.Resize([config.data.image_size] * 2), transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0, ]), download=True, ) test_dataset = CelebA( root=os.path.join(args.exp, "datasets", "celeba"), split="test", transform=transforms.Compose([ Crop(x1, x2, y1, y2), transforms.Resize([config.data.image_size] * 2), transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0, ]), download=True, ) elif config.data.dataset == "LSUN": train_folder = "{}_train".format(config.data.category) val_folder = "{}_val".format(config.data.category) if config.data.random_flip: dataset = LSUN( root=os.path.join(args.exp, "datasets", "lsun"), classes=[train_folder], transform=transforms.Compose([ transforms.Resize([config.data.image_size] * 2), transforms.CenterCrop((config.data.image_size, ) * 2), transforms.RandomHorizontalFlip(prob=0.5), transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0, ]), ) else: dataset = LSUN( root=os.path.join(args.exp, "datasets", "lsun"), classes=[train_folder], transform=transforms.Compose([ transforms.Resize([config.data.image_size] * 2), transforms.CenterCrop((config.data.image_size, ) * 2), transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0, ]), ) test_dataset = LSUN( root=os.path.join(args.exp, "datasets", "lsun"), classes=[val_folder], transform=transforms.Compose([ transforms.Resize([config.data.image_size] * 2), transforms.CenterCrop((config.data.image_size, ) * 2), transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0, ]), ) elif config.data.dataset == "FFHQ": if config.data.random_flip: dataset = FFHQ( path=os.path.join(args.exp, "datasets", "FFHQ"), transform=transforms.Compose([ transforms.RandomHorizontalFlip(prob=0.5), transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0 ]), resolution=config.data.image_size, ) else: dataset = FFHQ( path=os.path.join(args.exp, "datasets", "FFHQ"), transform=transforms.Compose( transforms.Transpose(), lambda x: x if x.dtype != np.uint8 else x.astype('float32') / 255.0), resolution=config.data.image_size, ) num_items = len(dataset) indices = list(range(num_items)) random_state = np.random.get_state() np.random.seed(2019) np.random.shuffle(indices) np.random.set_state(random_state) train_indices, test_indices = ( indices[:int(num_items * 0.9)], indices[int(num_items * 0.9):], ) test_dataset = Subset(dataset, test_indices) dataset = Subset(dataset, train_indices) else: dataset, test_dataset = None, None return dataset, test_dataset