import torch import torch.nn as nn from torch import Tensor import numpy as np import cv2 from .ffc import FFC_BN_ACT def get_activation(kind='tanh'): if kind == 'tanh': return nn.Tanh() if kind == 'sigmoid': return nn.Sigmoid() if kind is False: return nn.Identity() raise ValueError(f'Unknown activation kind {kind}') class FFCResnetBlock(nn.Module): def __init__(self, dim, padding_type, norm_layer, activation_layer=nn.ReLU, dilation=1, inline=False, **conv_kwargs): super().__init__() self.conv1 = FFC_BN_ACT(dim, dim, kernel_size=3, padding=dilation, dilation=dilation, norm_layer=norm_layer, activation_layer=activation_layer, padding_type=padding_type, **conv_kwargs) self.conv2 = FFC_BN_ACT(dim, dim, kernel_size=3, padding=dilation, dilation=dilation, norm_layer=norm_layer, activation_layer=activation_layer, padding_type=padding_type, **conv_kwargs) self.inline = inline def forward(self, x): if self.inline: x_l, x_g = x[:, :-self.conv1.ffc.global_in_num], x[:, -self.conv1.ffc.global_in_num:] else: x_l, x_g = x if type(x) is tuple else (x, 0) id_l, id_g = x_l, x_g x_l, x_g = self.conv1((x_l, x_g)) x_l, x_g = self.conv2((x_l, x_g)) x_l, x_g = id_l + x_l, id_g + x_g out = x_l, x_g if self.inline: out = torch.cat(out, dim=1) return out class ConcatTupleLayer(nn.Module): def forward(self, x): assert isinstance(x, tuple) x_l, x_g = x assert torch.is_tensor(x_l) or torch.is_tensor(x_g) if not torch.is_tensor(x_g): return x_l return torch.cat(x, dim=1) class FFCResNetGenerator(nn.Module): def __init__(self, input_nc=4, output_nc=3, ngf=64, n_downsampling=3, n_blocks=9, norm_layer=nn.BatchNorm2d, padding_type='reflect', activation_layer=nn.ReLU, up_norm_layer=nn.BatchNorm2d, up_activation=nn.ReLU(True), init_conv_kwargs={}, downsample_conv_kwargs={}, resnet_conv_kwargs={}, spatial_transform_kwargs={}, add_out_act=True, max_features=1024, out_ffc=False, out_ffc_kwargs={}): assert (n_blocks >= 0) super().__init__() model = [nn.ReflectionPad2d(3), FFC_BN_ACT(input_nc, ngf, kernel_size=7, padding=0, norm_layer=norm_layer, activation_layer=activation_layer, **init_conv_kwargs)] ### downsample for i in range(n_downsampling): mult = 2 ** i if i == n_downsampling - 1: cur_conv_kwargs = dict(downsample_conv_kwargs) cur_conv_kwargs['ratio_gout'] = resnet_conv_kwargs.get('ratio_gin', 0) else: cur_conv_kwargs = downsample_conv_kwargs model += [FFC_BN_ACT(min(max_features, ngf * mult), min(max_features, ngf * mult * 2), kernel_size=3, stride=2, padding=1, norm_layer=norm_layer, activation_layer=activation_layer, **cur_conv_kwargs)] mult = 2 ** n_downsampling feats_num_bottleneck = min(max_features, ngf * mult) ### resnet blocks for i in range(n_blocks): cur_resblock = FFCResnetBlock(feats_num_bottleneck, padding_type=padding_type, activation_layer=activation_layer, norm_layer=norm_layer, **resnet_conv_kwargs) model += [cur_resblock] model += [ConcatTupleLayer()] ### upsample for i in range(n_downsampling): mult = 2 ** (n_downsampling - i) model += [nn.ConvTranspose2d(min(max_features, ngf * mult), min(max_features, int(ngf * mult / 2)), kernel_size=3, stride=2, padding=1, output_padding=1), up_norm_layer(min(max_features, int(ngf * mult / 2))), up_activation] if out_ffc: model += [FFCResnetBlock(ngf, padding_type=padding_type, activation_layer=activation_layer, norm_layer=norm_layer, inline=True, **out_ffc_kwargs)] model += [nn.ReflectionPad2d(3), nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)] if add_out_act: model.append(get_activation('tanh' if add_out_act is True else add_out_act)) self.model = nn.Sequential(*model) def forward(self, img, mask, rel_pos=None, direct=None) -> Tensor: masked_img = torch.cat([img * (1 - mask), mask], dim=1) if rel_pos is None: return self.model(masked_img) else: x_l, x_g = self.model[:2](masked_img) x_l = x_l.to(torch.float32) x_l += rel_pos x_l += direct return self.model[2:]((x_l, x_g)) class NLayerDiscriminator(nn.Module): def __init__(self, input_nc=3, ndf=64, n_layers=4, norm_layer=nn.BatchNorm2d,): super().__init__() self.n_layers = n_layers kw = 4 padw = int(np.ceil((kw-1.0)/2)) sequence = [[nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, True)]] nf = ndf for n in range(1, n_layers): nf_prev = nf nf = min(nf * 2, 512) cur_model = [] cur_model += [ nn.Conv2d(nf_prev, nf, kernel_size=kw, stride=2, padding=padw), norm_layer(nf), nn.LeakyReLU(0.2, True) ] sequence.append(cur_model) nf_prev = nf nf = min(nf * 2, 512) cur_model = [] cur_model += [ nn.Conv2d(nf_prev, nf, kernel_size=kw, stride=1, padding=padw), norm_layer(nf), nn.LeakyReLU(0.2, True) ] sequence.append(cur_model) sequence += [[nn.Conv2d(nf, 1, kernel_size=kw, stride=1, padding=padw)]] for n in range(len(sequence)): setattr(self, 'model'+str(n), nn.Sequential(*sequence[n])) def get_all_activations(self, x): res = [x] for n in range(self.n_layers + 2): model = getattr(self, 'model' + str(n)) res.append(model(res[-1])) return res[1:] def forward(self, x): act = self.get_all_activations(x) return act[-1], act[:-1] def set_requires_grad(module, value): for param in module.parameters(): param.requires_grad = value class MaskedSinusoidalPositionalEmbedding(nn.Embedding): """This module produces sinusoidal positional embeddings of any length.""" def __init__(self, num_embeddings: int, embedding_dim: int): super().__init__(num_embeddings, embedding_dim) self.weight = self._init_weight(self.weight) @staticmethod def _init_weight(out: nn.Parameter): """ Identical to the XLM create_sinusoidal_embeddings except features are not interleaved. The cos features are in the 2nd half of the vector. [dim // 2:] """ n_pos, dim = out.shape position_enc = np.array( [[pos / np.power(10000, 2 * (j // 2) / dim) for j in range(dim)] for pos in range(n_pos)] ) out.requires_grad = False # set early to avoid an error in pytorch-1.8+ sentinel = dim // 2 if dim % 2 == 0 else (dim // 2) + 1 out[:, 0:sentinel] = torch.FloatTensor(np.sin(position_enc[:, 0::2])) out[:, sentinel:] = torch.FloatTensor(np.cos(position_enc[:, 1::2])) out.detach_() return out @torch.no_grad() def forward(self, input_ids): """`input_ids` is expected to be [bsz x seqlen].""" return super().forward(input_ids) class MultiLabelEmbedding(nn.Module): def __init__(self, num_positions: int, embedding_dim: int): super().__init__() self.weight = nn.Parameter(torch.Tensor(num_positions, embedding_dim)) self.reset_parameters() def reset_parameters(self): nn.init.normal_(self.weight) def forward(self, input_ids): # input_ids:[B,HW,4](onehot) out = torch.matmul(input_ids, self.weight) # [B,HW,dim] return out class MPE(nn.Module): def __init__(self): super().__init__() self.rel_pos_emb = MaskedSinusoidalPositionalEmbedding(num_embeddings=128, embedding_dim=64) self.direct_emb = MultiLabelEmbedding(num_positions=4, embedding_dim=64) self.alpha5 = nn.Parameter(torch.tensor(0, dtype=torch.float32), requires_grad=True) self.alpha6 = nn.Parameter(torch.tensor(0, dtype=torch.float32), requires_grad=True) def forward(self, rel_pos=None, direct=None): b, h, w = rel_pos.shape rel_pos = rel_pos.reshape(b, h * w) rel_pos_emb = self.rel_pos_emb(rel_pos).reshape(b, h, w, -1).permute(0, 3, 1, 2) * self.alpha5 direct = direct.reshape(b, h * w, 4).to(torch.float32) direct_emb = self.direct_emb(direct).reshape(b, h, w, -1).permute(0, 3, 1, 2) * self.alpha6 return rel_pos_emb, direct_emb class LamaFourier: def __init__(self, build_discriminator=True, use_mpe=False, large_arch: bool = False) -> None: # super().__init__() n_blocks = 9 if large_arch: n_blocks = 18 self.generator = FFCResNetGenerator(4, 3, add_out_act='sigmoid', n_blocks = n_blocks, init_conv_kwargs={ 'ratio_gin': 0, 'ratio_gout': 0, 'enable_lfu': False }, downsample_conv_kwargs={ 'ratio_gin': 0, 'ratio_gout': 0, 'enable_lfu': False }, resnet_conv_kwargs={ 'ratio_gin': 0.75, 'ratio_gout': 0.75, 'enable_lfu': False }, ) self.discriminator = NLayerDiscriminator() if build_discriminator else None self.inpaint_only = False if use_mpe: self.mpe = MPE() else: self.mpe = None def train_generator(self): self.inpaint_only = False self.forward_generator = True self.forward_discriminator = False self.generator.train() self.discriminator.eval() set_requires_grad(self.discriminator, False) set_requires_grad(self.generator, True) if self.mpe is not None: set_requires_grad(self.mpe, True) def train_discriminator(self): self.inpaint_only = False self.forward_generator = False self.forward_discriminator = True self.discriminator.train() self.generator.eval() set_requires_grad(self.discriminator, True) set_requires_grad(self.generator, False) if self.mpe is not None: set_requires_grad(self.mpe, False) def to(self, device): self.generator.to(device) if self.discriminator is not None: self.discriminator.to(device) if self.mpe is not None: self.mpe.to(device) def eval(self): self.inpaint_only = True self.generator.eval() if self.mpe is not None: self.mpe.eval() return self def __call__(self, img: Tensor, mask: Tensor, rel_pos=None, direct=None): if self.mpe is not None: rel_pos, direct = self.mpe(rel_pos, direct) else: rel_pos, direct = None, None predicted_img = self.generator(img, mask, rel_pos, direct) if self.inpaint_only: return predicted_img * mask + (1 - mask) * img if self.forward_discriminator: predicted_img = predicted_img.detach() img.requires_grad = True discr_real_pred, discr_real_features = self.discriminator(img) discr_fake_pred, discr_fake_features = self.discriminator(predicted_img) # fp = discr_fake_pred.detach().mean() if self.forward_discriminator: return { 'predicted_img': predicted_img, 'discr_real_pred': discr_real_pred, 'discr_fake_pred':discr_fake_pred } else: return { 'predicted_img': predicted_img, 'discr_real_features': discr_real_features, 'discr_fake_features': discr_fake_features, 'discr_fake_pred': discr_fake_pred } def load_masked_position_encoding(self, mask): mask = (mask * 255).astype(np.uint8) ones_filter = np.ones((3, 3), dtype=np.float32) d_filter1 = np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]], dtype=np.float32) d_filter2 = np.array([[0, 0, 0], [1, 1, 0], [1, 1, 0]], dtype=np.float32) d_filter3 = np.array([[0, 1, 1], [0, 1, 1], [0, 0, 0]], dtype=np.float32) d_filter4 = np.array([[0, 0, 0], [0, 1, 1], [0, 1, 1]], dtype=np.float32) str_size = 256 pos_num = 128 ori_mask = mask.copy() ori_h, ori_w = ori_mask.shape[0:2] ori_mask = ori_mask / 255 mask = cv2.resize(mask, (str_size, str_size), interpolation=cv2.INTER_AREA) mask[mask > 0] = 255 h, w = mask.shape[0:2] mask3 = mask.copy() mask3 = 1. - (mask3 / 255.0) pos = np.zeros((h, w), dtype=np.int32) direct = np.zeros((h, w, 4), dtype=np.int32) i = 0 if mask3.max() > 0: # otherwise it will cause infinity loop while np.sum(1 - mask3) > 0: i += 1 mask3_ = cv2.filter2D(mask3, -1, ones_filter) mask3_[mask3_ > 0] = 1 sub_mask = mask3_ - mask3 pos[sub_mask == 1] = i m = cv2.filter2D(mask3, -1, d_filter1) m[m > 0] = 1 m = m - mask3 direct[m == 1, 0] = 1 m = cv2.filter2D(mask3, -1, d_filter2) m[m > 0] = 1 m = m - mask3 direct[m == 1, 1] = 1 m = cv2.filter2D(mask3, -1, d_filter3) m[m > 0] = 1 m = m - mask3 direct[m == 1, 2] = 1 m = cv2.filter2D(mask3, -1, d_filter4) m[m > 0] = 1 m = m - mask3 direct[m == 1, 3] = 1 mask3 = mask3_ abs_pos = pos.copy() rel_pos = pos / (str_size / 2) # to 0~1 maybe larger than 1 rel_pos = (rel_pos * pos_num).astype(np.int32) rel_pos = np.clip(rel_pos, 0, pos_num - 1) if ori_w != w or ori_h != h: rel_pos = cv2.resize(rel_pos, (ori_w, ori_h), interpolation=cv2.INTER_NEAREST) rel_pos[ori_mask == 0] = 0 direct = cv2.resize(direct, (ori_w, ori_h), interpolation=cv2.INTER_NEAREST) direct[ori_mask == 0, :] = 0 return rel_pos, abs_pos, direct def load_lama_mpe(model_path, device, use_mpe=True, large_arch: bool = False) -> LamaFourier: model = LamaFourier(build_discriminator=False, use_mpe=use_mpe, large_arch=large_arch) sd = torch.load(model_path, map_location = 'cpu') model.generator.load_state_dict(sd['gen_state_dict']) if use_mpe: model.mpe.load_state_dict(sd['str_state_dict']) model.eval().to(device) return model