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
