From cd43aad97492fdcc3f0ee7f6cfbe64b199dd7dbc Mon Sep 17 00:00:00 2001 From: Fuou Marinas <57849916+FuouM@users.noreply.github.com> Date: Sun, 4 Aug 2024 14:28:59 +0700 Subject: [PATCH] Add articulated animation (#5) --- .gitignore | 2 + README.md | 24 +- __init__.py | 3 + articulate_inference.py | 200 +++++++++ articulate_module/avd_network.py | 90 ++++ articulate_module/batchnorm.py | 315 +++++++++++++ articulate_module/bg_motion_predictor.py | 57 +++ articulate_module/comm.py | 137 ++++++ articulate_module/config/taichi256.yaml | 104 +++++ articulate_module/config/ted-youtube384.yaml | 105 +++++ articulate_module/config/ted384.yaml | 105 +++++ articulate_module/config/vox256.yaml | 203 +++++++++ articulate_module/generator.py | 126 ++++++ articulate_module/models/.gitkeep | 0 articulate_module/pixelwise_flow_predictor.py | 137 ++++++ articulate_module/region_predictor.py | 121 +++++ articulate_module/util.py | 271 +++++++++++ articulate_module/visualizer.py | 145 ++++++ constants.py | 3 + pyproject.toml | 2 +- run.py | 69 +++ workflows/ARTICULATE.json | 423 ++++++++++++++++++ FOMM.json => workflows/FOMM.json | 0 .../FOMM_PARTSWAP.json | 0 workflow.png => workflows/workflow.png | Bin workflows/workflow_articulate.png | Bin 0 -> 254529 bytes .../workflow_fomm_partswap.png | Bin 27 files changed, 2637 insertions(+), 5 deletions(-) create mode 100644 articulate_inference.py create mode 100644 articulate_module/avd_network.py create mode 100644 articulate_module/batchnorm.py create mode 100644 articulate_module/bg_motion_predictor.py create mode 100644 articulate_module/comm.py create mode 100644 articulate_module/config/taichi256.yaml create mode 100644 articulate_module/config/ted-youtube384.yaml create mode 100644 articulate_module/config/ted384.yaml create mode 100644 articulate_module/config/vox256.yaml create mode 100644 articulate_module/generator.py create mode 100644 articulate_module/models/.gitkeep create mode 100644 articulate_module/pixelwise_flow_predictor.py create mode 100644 articulate_module/region_predictor.py create mode 100644 articulate_module/util.py create mode 100644 articulate_module/visualizer.py create mode 100644 workflows/ARTICULATE.json rename FOMM.json => workflows/FOMM.json (100%) rename FOMM_PARTSWAP.json => workflows/FOMM_PARTSWAP.json (100%) rename workflow.png => workflows/workflow.png (100%) create mode 100644 workflows/workflow_articulate.png rename workflow_fomm_partswap.png => workflows/workflow_fomm_partswap.png (100%) diff --git a/.gitignore b/.gitignore index 7e54636..f42bb28 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,7 @@ # Stuff +articulate_module/models/*.pth + checkpoints/* !checkpoints/place_checkpoints_here.txt diff --git a/README.md b/README.md index 2f8f066..7791ae2 100644 --- a/README.md +++ b/README.md @@ -7,6 +7,10 @@ Now supports Face Swapping using Motion Supervised co-part Segmentation https://github.com/AliaksandrSiarohin/motion-cosegmentation +Now also supports Motion Representations for Articulated Animation + +https://github.com/snap-research/articulated-animation + ## Workflow: @@ -15,15 +19,21 @@ https://github.com/FuouM/ComfyUI-FirstOrderMM/assets/57849916/e8adca97-b53c-48ce ### FOMM -[FOMM.json](FOMM.json) +[FOMM.json](workflows/FOMM.json) -![FOMM Workflow](workflow.png) +![FOMM Workflow](workflows/workflow.png) ### Part Swap -[FOMM_PARTSWAP.json](FOMM_PARTSWAP.json) +[FOMM_PARTSWAP.json](workflows/FOMM_PARTSWAP.json) -![Partswap Workflow](workflow_fomm_partswap.png) +![Partswap Workflow](workflows/workflow_fomm_partswap.png) + +### Articulate + +[ARTICULATE.json](workflows/ARTICULATE.json) + +![Workflow Articulate](workflows/workflow_articulate.png) ## Arguments @@ -42,6 +52,10 @@ https://github.com/FuouM/ComfyUI-FirstOrderMM/assets/57849916/e8adca97-b53c-48ce * `use_face_parser`: For Seg-based models, may help with cleaning up residual background (should only use `15seg` with this). TODO: Additional cleanup face_parser masks. Should definitely be used for FOMM models * `viz_alpha`: Opacity of the segments in the visualization +### Articulate + +Doesn't need any + ## Installation 1. Clone the repo to `ComfyUI/custom_nodes/` @@ -98,3 +112,5 @@ face_parsing_model.py resnet18-5c106cde.pth 79999_iter.pth ``` + +For **Articulate**, download the model from [Pre-trained checkpoints](https://github.com/snap-research/articulated-animation?tab=readme-ov-file#pre-trained-checkpoints) section and place it here: `articulate_module\models\vox256.pth` \ No newline at end of file diff --git a/__init__.py b/__init__.py index ccb00b0..d85937d 100644 --- a/__init__.py +++ b/__init__.py @@ -4,6 +4,7 @@ from .run import ( FOMM_Seg5Chooser, FOMM_Seg10Chooser, FOMM_Seg15Chooser, + Articulate_Runner, ) NODE_CLASS_MAPPINGS = { @@ -12,6 +13,7 @@ NODE_CLASS_MAPPINGS = { "FOMM_Seg5Chooser": FOMM_Seg5Chooser, "FOMM_Seg10Chooser": FOMM_Seg10Chooser, "FOMM_Seg15Chooser": FOMM_Seg15Chooser, + "Articulate_Runner": Articulate_Runner, } NODE_DISPLAY_NAME_MAPPINGS = { @@ -20,6 +22,7 @@ NODE_DISPLAY_NAME_MAPPINGS = { "FOMM_Seg5Chooser": "FOMM Seg5 Chooser", "FOMM_Seg10Chooser": "FOMM Seg10 Chooser", "FOMM_Seg15Chooser": "FOMM Seg15 Chooser", + "Articulate_Runner": "Articulate Runner", } diff --git a/articulate_inference.py b/articulate_inference.py new file mode 100644 index 0000000..0d2c1a4 --- /dev/null +++ b/articulate_inference.py @@ -0,0 +1,200 @@ +import numpy as np +import torch +import tqdm +import yaml +from comfy.utils import ProgressBar +from scipy.spatial import ConvexHull + +from .articulate_module.avd_network import AVDNetwork +from .articulate_module.bg_motion_predictor import BGMotionPredictor +from .articulate_module.generator import Generator +from .articulate_module.region_predictor import RegionPredictor +from .sync_batchnorm.replicate import DataParallelWithCallback + + +def articulate_inference( + source_image, + driving_video: list, + config_path: str, + checkpoint_path: str, + estimate_affine=True, + pca_based=True, +): + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + + with open(config_path) as f: + config = yaml.full_load(f) + + generator, region_predictor, bg_predictor, avd_network = init_models( + config, estimate_affine, pca_based + ) + generator = generator.to(device) + region_predictor = region_predictor.to(device) + bg_predictor = bg_predictor.to(device) + avd_network = avd_network.to(device) + + animate_params = config["animate_params"] + + load_cpk(checkpoint_path, generator, region_predictor, bg_predictor, avd_network) + + if torch.cuda.is_available(): + generator = DataParallelWithCallback(generator) + region_predictor = DataParallelWithCallback(region_predictor) + avd_network = DataParallelWithCallback(avd_network) + + generator.eval() + region_predictor.eval() + avd_network.eval() + + source_frame = source_image + driving = driving_video + predictions = [] + + num_frames = driving.shape[2] + pbar = ProgressBar(num_frames) + + with torch.no_grad(): + source_region_params = region_predictor(source_frame) + driving_region_params_initial = region_predictor(driving_video[:, :, 0]) + + for frame_idx in tqdm.tqdm(range(num_frames)): + driving_frame = driving[:, :, frame_idx] + driving_region_params = region_predictor(driving_frame) + new_region_params = get_animation_region_params( + source_region_params, + driving_region_params, + driving_region_params_initial, + mode=animate_params["mode"], + avd_network=avd_network, + ) + out = generator( + source_frame, + source_region_params=source_region_params, + driving_region_params=new_region_params, + ) + + out["driving_region_params"] = driving_region_params + out["source_region_params"] = source_region_params + out["new_region_params"] = new_region_params + + # visualization = Visualizer(**config["visualizer_params"]).visualize( + # source=source_frame, driving=driving_frame, out=out + # ) / 255.0 + + prediction = out["prediction"].data.cpu().numpy() + prediction = np.transpose(prediction, [0, 2, 3, 1]).squeeze(0) + + # visualizations.append(visualization) + predictions.append(prediction) + + pbar.update_absolute(frame_idx, num_frames) + + # print(f"{predictions[0].shape=}") + # print(f"{visualizations[0].shape=}") + + # return predictions, visualizations + return predictions + + +def init_models(config, estimate_affine, pca_based): + generator = Generator( + num_regions=config["model_params"]["num_regions"], + num_channels=config["model_params"]["num_channels"], + revert_axis_swap=config["model_params"]["revert_axis_swap"], + **config["model_params"]["generator_params"], + ) + + config["model_params"]["region_predictor_params"]["pca_based"] = pca_based + + region_predictor = RegionPredictor( + num_regions=config["model_params"]["num_regions"], + num_channels=config["model_params"]["num_channels"], + estimate_affine=estimate_affine, + **config["model_params"]["region_predictor_params"], + ) + + bg_predictor = BGMotionPredictor( + num_channels=config["model_params"]["num_channels"], + **config["model_params"]["bg_predictor_params"], + ) + + avd_network = AVDNetwork( + num_regions=config["model_params"]["num_regions"], + **config["model_params"]["avd_network_params"], + ) + + return generator, region_predictor, bg_predictor, avd_network + + +def load_cpk( + checkpoint_path, + generator=None, + region_predictor=None, + bg_predictor=None, + avd_network=None, + optimizer_reconstruction=None, + optimizer_avd=None, +): + checkpoint = torch.load(checkpoint_path) + # print(checkpoint.keys()) + if generator is not None: + generator.load_state_dict(checkpoint["generator"]) + if region_predictor is not None: + region_predictor.load_state_dict(checkpoint["region_predictor"]) + if bg_predictor is not None: + bg_predictor.load_state_dict(checkpoint["bg_predictor"]) + if avd_network is not None: + if "avd_network" in checkpoint: + avd_network.load_state_dict(checkpoint["avd_network"]) + + if optimizer_reconstruction is not None: + optimizer_reconstruction.load_state_dict(checkpoint["optimizer_reconstruction"]) + return checkpoint["epoch_reconstruction"] + + if optimizer_avd is not None: + if "optimizer_avd" in checkpoint: + optimizer_avd.load_state_dict(checkpoint["optimizer_avd"]) + return checkpoint["epoch_avd"] + return 0 + + return 0 + + +def get_animation_region_params( + source_region_params, + driving_region_params, + driving_region_params_initial, + mode="standard", + avd_network=None, + adapt_movement_scale=True, +): + assert mode in ["standard", "relative", "avd"] + new_region_params = {k: v for k, v in driving_region_params.items()} + if mode == "standard": + return new_region_params + elif mode == "relative": + source_area = ConvexHull( + source_region_params["shift"][0].data.cpu().numpy() + ).volume + driving_area = ConvexHull( + driving_region_params_initial["shift"][0].data.cpu().numpy() + ).volume + movement_scale = np.sqrt(source_area) / np.sqrt(driving_area) + + shift_diff = ( + driving_region_params["shift"] - driving_region_params_initial["shift"] + ) + shift_diff *= movement_scale + new_region_params["shift"] = shift_diff + source_region_params["shift"] + + affine_diff = torch.matmul( + driving_region_params["affine"], + torch.inverse(driving_region_params_initial["affine"]), + ) + new_region_params["affine"] = torch.matmul( + affine_diff, source_region_params["affine"] + ) + return new_region_params + elif mode == "avd": + new_region_params = avd_network(source_region_params, driving_region_params) + return new_region_params diff --git a/articulate_module/avd_network.py b/articulate_module/avd_network.py new file mode 100644 index 0000000..f1b12cb --- /dev/null +++ b/articulate_module/avd_network.py @@ -0,0 +1,90 @@ +""" +Copyright Snap Inc. 2021. This sample code is made available by Snap Inc. for informational purposes only. +No license, whether implied or otherwise, is granted in or to such code (including any rights to copy, modify, +publish, distribute and/or commercialize such code), unless you have entered into a separate agreement for such rights. +Such code is provided as-is, without warranty of any kind, express or implied, including any warranties of merchantability, +title, fitness for a particular purpose, non-infringement, or that such code is free of defects, errors or viruses. +In no event will Snap Inc. be liable for any damages or losses of any kind arising from the sample code or your use thereof. +""" +import torch +from torch import nn + + +class AVDNetwork(nn.Module): + """ + Animation via Disentanglement network + """ + + def __init__(self, num_regions, id_bottle_size=64, pose_bottle_size=64, revert_axis_swap=True): + super(AVDNetwork, self).__init__() + input_size = (2 + 4) * num_regions + self.num_regions = num_regions + self.revert_axis_swap = revert_axis_swap + + self.id_encoder = nn.Sequential( + nn.Linear(input_size, 256), + nn.BatchNorm1d(256), + nn.ReLU(inplace=True), + nn.Linear(256, 512), + nn.BatchNorm1d(512), + nn.ReLU(inplace=True), + nn.Linear(512, 1024), + nn.BatchNorm1d(1024), + nn.ReLU(inplace=True), + nn.Linear(1024, id_bottle_size) + ) + + self.pose_encoder = nn.Sequential( + nn.Linear(input_size, 256), + nn.BatchNorm1d(256), + nn.ReLU(inplace=True), + nn.Linear(256, 512), + nn.BatchNorm1d(512), + nn.ReLU(inplace=True), + nn.Linear(512, 1024), + nn.BatchNorm1d(1024), + nn.ReLU(inplace=True), + nn.Linear(1024, pose_bottle_size) + ) + + self.decoder = nn.Sequential( + nn.Linear(pose_bottle_size + id_bottle_size, 1024), + nn.BatchNorm1d(1024), + nn.ReLU(), + nn.Linear(1024, 512), + nn.BatchNorm1d(512), + nn.ReLU(), + nn.Linear(512, 256), + nn.BatchNorm1d(256), + nn.ReLU(), + nn.Linear(256, input_size) + ) + + @staticmethod + def region_params_to_emb(x): + mean = x['shift'] + jac = x['affine'] + emb = torch.cat([mean, jac.view(jac.shape[0], jac.shape[1], -1)], dim=-1) + emb = emb.view(emb.shape[0], -1) + return emb + + def emb_to_region_params(self, emb): + emb = emb.view(emb.shape[0], self.num_regions, 6) + mean = emb[:, :, :2] + jac = emb[:, :, 2:].view(emb.shape[0], emb.shape[1], 2, 2) + return {'shift': mean, 'affine': jac} + + def forward(self, x_id, x_pose, alpha=0.2): + if self.revert_axis_swap: + affine = torch.matmul(x_id['affine'], torch.inverse(x_pose['affine'])) + sign = torch.sign(affine[:, :, 0:1, 0:1]) + x_id = {'affine': x_id['affine'] * sign, 'shift': x_id['shift']} + + pose_emb = self.pose_encoder(self.region_params_to_emb(x_pose)) + id_emb = self.id_encoder(self.region_params_to_emb(x_id)) + + rec = self.decoder(torch.cat([pose_emb, id_emb], dim=1)) + + rec = self.emb_to_region_params(rec) + rec['covar'] = torch.matmul(rec['affine'], rec['affine'].permute(0, 1, 3, 2)) + return rec diff --git a/articulate_module/batchnorm.py b/articulate_module/batchnorm.py new file mode 100644 index 0000000..a5f8ff0 --- /dev/null +++ b/articulate_module/batchnorm.py @@ -0,0 +1,315 @@ +# -*- coding: utf-8 -*- +# File : batchnorm.py +# Author : Jiayuan Mao +# Email : maojiayuan@gmail.com +# Date : 27/01/2018 +# +# This file is part of Synchronized-BatchNorm-PyTorch. +# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch +# Distributed under MIT License. + +import collections + +# import torch +import torch.nn.functional as F + +from torch.nn.modules.batchnorm import _BatchNorm +from torch.nn.parallel._functions import ReduceAddCoalesced, Broadcast + +from .comm import SyncMaster + +__all__ = ['SynchronizedBatchNorm1d', 'SynchronizedBatchNorm2d', 'SynchronizedBatchNorm3d'] + + +def _sum_ft(tensor): + """sum over the first and last dimention""" + return tensor.sum(dim=0).sum(dim=-1) + + +def _unsqueeze_ft(tensor): + """add new dementions at the front and the tail""" + return tensor.unsqueeze(0).unsqueeze(-1) + + +_ChildMessage = collections.namedtuple('_ChildMessage', ['sum', 'ssum', 'sum_size']) +_MasterMessage = collections.namedtuple('_MasterMessage', ['sum', 'inv_std']) + + +class _SynchronizedBatchNorm(_BatchNorm): + def __init__(self, num_features, eps=1e-5, momentum=0.1, affine=True): + super(_SynchronizedBatchNorm, self).__init__(num_features, eps=eps, momentum=momentum, affine=affine) + + self._sync_master = SyncMaster(self._data_parallel_master) + + self._is_parallel = False + self._parallel_id = None + self._slave_pipe = None + + def forward(self, input): + # If it is not parallel computation or is in evaluation mode, use PyTorch's implementation. + if not (self._is_parallel and self.training): + return F.batch_norm( + input, self.running_mean, self.running_var, self.weight, self.bias, + self.training, self.momentum, self.eps) + + # Resize the input to (B, C, -1). + input_shape = input.size() + input = input.view(input.size(0), self.num_features, -1) + + # Compute the sum and square-sum. + sum_size = input.size(0) * input.size(2) + input_sum = _sum_ft(input) + input_ssum = _sum_ft(input ** 2) + + # Reduce-and-broadcast the statistics. + if self._parallel_id == 0: + mean, inv_std = self._sync_master.run_master(_ChildMessage(input_sum, input_ssum, sum_size)) + else: + mean, inv_std = self._slave_pipe.run_slave(_ChildMessage(input_sum, input_ssum, sum_size)) + + # Compute the output. + if self.affine: + # MJY:: Fuse the multiplication for speed. + output = (input - _unsqueeze_ft(mean)) * _unsqueeze_ft(inv_std * self.weight) + _unsqueeze_ft(self.bias) + else: + output = (input - _unsqueeze_ft(mean)) * _unsqueeze_ft(inv_std) + + # Reshape it. + return output.view(input_shape) + + def __data_parallel_replicate__(self, ctx, copy_id): + self._is_parallel = True + self._parallel_id = copy_id + + # parallel_id == 0 means master device. + if self._parallel_id == 0: + ctx.sync_master = self._sync_master + else: + self._slave_pipe = ctx.sync_master.register_slave(copy_id) + + def _data_parallel_master(self, intermediates): + """Reduce the sum and square-sum, compute the statistics, and broadcast it.""" + + # Always using same "device order" makes the ReduceAdd operation faster. + # Thanks to:: Tete Xiao (http://tetexiao.com/) + intermediates = sorted(intermediates, key=lambda i: i[1].sum.get_device()) + + to_reduce = [i[1][:2] for i in intermediates] + to_reduce = [j for i in to_reduce for j in i] # flatten + target_gpus = [i[1].sum.get_device() for i in intermediates] + + sum_size = sum([i[1].sum_size for i in intermediates]) + sum_, ssum = ReduceAddCoalesced.apply(target_gpus[0], 2, *to_reduce) + mean, inv_std = self._compute_mean_std(sum_, ssum, sum_size) + + broadcasted = Broadcast.apply(target_gpus, mean, inv_std) + + outputs = [] + for i, rec in enumerate(intermediates): + outputs.append((rec[0], _MasterMessage(*broadcasted[i*2:i*2+2]))) + + return outputs + + def _compute_mean_std(self, sum_, ssum, size): + """Compute the mean and standard-deviation with sum and square-sum. This method + also maintains the moving average on the master device.""" + assert size > 1, 'BatchNorm computes unbiased standard-deviation, which requires size > 1.' + mean = sum_ / size + sumvar = ssum - sum_ * mean + unbias_var = sumvar / (size - 1) + bias_var = sumvar / size + + self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * mean.data + self.running_var = (1 - self.momentum) * self.running_var + self.momentum * unbias_var.data + + return mean, bias_var.clamp(self.eps) ** -0.5 + + +class SynchronizedBatchNorm1d(_SynchronizedBatchNorm): + r"""Applies Synchronized Batch Normalization over a 2d or 3d input that is seen as a + mini-batch. + + .. math:: + + y = \frac{x - mean[x]}{ \sqrt{Var[x] + \epsilon}} * gamma + beta + + This module differs from the built-in PyTorch BatchNorm1d as the mean and + standard-deviation are reduced across all devices during training. + + For example, when one uses `nn.DataParallel` to wrap the network during + training, PyTorch's implementation normalize the tensor on each device using + the statistics only on that device, which accelerated the computation and + is also easy to implement, but the statistics might be inaccurate. + Instead, in this synchronized version, the statistics will be computed + over all training samples distributed on multiple devices. + + Note that, for one-GPU or CPU-only case, this module behaves exactly same + as the built-in PyTorch implementation. + + The mean and standard-deviation are calculated per-dimension over + the mini-batches and gamma and beta are learnable parameter vectors + of size C (where C is the input size). + + During training, this layer keeps a running estimate of its computed mean + and variance. The running sum is kept with a default momentum of 0.1. + + During evaluation, this running mean/variance is used for normalization. + + Because the BatchNorm is done over the `C` dimension, computing statistics + on `(N, L)` slices, it's common terminology to call this Temporal BatchNorm + + Args: + num_features: num_features from an expected input of size + `batch_size x num_features [x width]` + eps: a value added to the denominator for numerical stability. + Default: 1e-5 + momentum: the value used for the running_mean and running_var + computation. Default: 0.1 + affine: a boolean value that when set to ``True``, gives the layer learnable + affine parameters. Default: ``True`` + + Shape: + - Input: :math:`(N, C)` or :math:`(N, C, L)` + - Output: :math:`(N, C)` or :math:`(N, C, L)` (same shape as input) + + Examples: + >>> # With Learnable Parameters + >>> m = SynchronizedBatchNorm1d(100) + >>> # Without Learnable Parameters + >>> m = SynchronizedBatchNorm1d(100, affine=False) + >>> input = torch.autograd.Variable(torch.randn(20, 100)) + >>> output = m(input) + """ + + def _check_input_dim(self, input): + if input.dim() != 2 and input.dim() != 3: + raise ValueError('expected 2D or 3D input (got {}D input)' + .format(input.dim())) + super(SynchronizedBatchNorm1d, self)._check_input_dim(input) + + +class SynchronizedBatchNorm2d(_SynchronizedBatchNorm): + r"""Applies Batch Normalization over a 4d input that is seen as a mini-batch + of 3d inputs + + .. math:: + + y = \frac{x - mean[x]}{ \sqrt{Var[x] + \epsilon}} * gamma + beta + + This module differs from the built-in PyTorch BatchNorm2d as the mean and + standard-deviation are reduced across all devices during training. + + For example, when one uses `nn.DataParallel` to wrap the network during + training, PyTorch's implementation normalize the tensor on each device using + the statistics only on that device, which accelerated the computation and + is also easy to implement, but the statistics might be inaccurate. + Instead, in this synchronized version, the statistics will be computed + over all training samples distributed on multiple devices. + + Note that, for one-GPU or CPU-only case, this module behaves exactly same + as the built-in PyTorch implementation. + + The mean and standard-deviation are calculated per-dimension over + the mini-batches and gamma and beta are learnable parameter vectors + of size C (where C is the input size). + + During training, this layer keeps a running estimate of its computed mean + and variance. The running sum is kept with a default momentum of 0.1. + + During evaluation, this running mean/variance is used for normalization. + + Because the BatchNorm is done over the `C` dimension, computing statistics + on `(N, H, W)` slices, it's common terminology to call this Spatial BatchNorm + + Args: + num_features: num_features from an expected input of + size batch_size x num_features x height x width + eps: a value added to the denominator for numerical stability. + Default: 1e-5 + momentum: the value used for the running_mean and running_var + computation. Default: 0.1 + affine: a boolean value that when set to ``True``, gives the layer learnable + affine parameters. Default: ``True`` + + Shape: + - Input: :math:`(N, C, H, W)` + - Output: :math:`(N, C, H, W)` (same shape as input) + + Examples: + >>> # With Learnable Parameters + >>> m = SynchronizedBatchNorm2d(100) + >>> # Without Learnable Parameters + >>> m = SynchronizedBatchNorm2d(100, affine=False) + >>> input = torch.autograd.Variable(torch.randn(20, 100, 35, 45)) + >>> output = m(input) + """ + + def _check_input_dim(self, input): + if input.dim() != 4: + raise ValueError('expected 4D input (got {}D input)' + .format(input.dim())) + super(SynchronizedBatchNorm2d, self)._check_input_dim(input) + + +class SynchronizedBatchNorm3d(_SynchronizedBatchNorm): + r"""Applies Batch Normalization over a 5d input that is seen as a mini-batch + of 4d inputs + + .. math:: + + y = \frac{x - mean[x]}{ \sqrt{Var[x] + \epsilon}} * gamma + beta + + This module differs from the built-in PyTorch BatchNorm3d as the mean and + standard-deviation are reduced across all devices during training. + + For example, when one uses `nn.DataParallel` to wrap the network during + training, PyTorch's implementation normalize the tensor on each device using + the statistics only on that device, which accelerated the computation and + is also easy to implement, but the statistics might be inaccurate. + Instead, in this synchronized version, the statistics will be computed + over all training samples distributed on multiple devices. + + Note that, for one-GPU or CPU-only case, this module behaves exactly same + as the built-in PyTorch implementation. + + The mean and standard-deviation are calculated per-dimension over + the mini-batches and gamma and beta are learnable parameter vectors + of size C (where C is the input size). + + During training, this layer keeps a running estimate of its computed mean + and variance. The running sum is kept with a default momentum of 0.1. + + During evaluation, this running mean/variance is used for normalization. + + Because the BatchNorm is done over the `C` dimension, computing statistics + on `(N, D, H, W)` slices, it's common terminology to call this Volumetric BatchNorm + or Spatio-temporal BatchNorm + + Args: + num_features: num_features from an expected input of + size batch_size x num_features x depth x height x width + eps: a value added to the denominator for numerical stability. + Default: 1e-5 + momentum: the value used for the running_mean and running_var + computation. Default: 0.1 + affine: a boolean value that when set to ``True``, gives the layer learnable + affine parameters. Default: ``True`` + + Shape: + - Input: :math:`(N, C, D, H, W)` + - Output: :math:`(N, C, D, H, W)` (same shape as input) + + Examples: + >>> # With Learnable Parameters + >>> m = SynchronizedBatchNorm3d(100) + >>> # Without Learnable Parameters + >>> m = SynchronizedBatchNorm3d(100, affine=False) + >>> input = torch.autograd.Variable(torch.randn(20, 100, 35, 45, 10)) + >>> output = m(input) + """ + + def _check_input_dim(self, input): + if input.dim() != 5: + raise ValueError('expected 5D input (got {}D input)' + .format(input.dim())) + super(SynchronizedBatchNorm3d, self)._check_input_dim(input) diff --git a/articulate_module/bg_motion_predictor.py b/articulate_module/bg_motion_predictor.py new file mode 100644 index 0000000..af9de2d --- /dev/null +++ b/articulate_module/bg_motion_predictor.py @@ -0,0 +1,57 @@ +""" +Copyright Snap Inc. 2021. This sample code is made available by Snap Inc. for informational purposes only. +No license, whether implied or otherwise, is granted in or to such code (including any rights to copy, modify, +publish, distribute and/or commercialize such code), unless you have entered into a separate agreement for such rights. +Such code is provided as-is, without warranty of any kind, express or implied, including any warranties of merchantability, +title, fitness for a particular purpose, non-infringement, or that such code is free of defects, errors or viruses. +In no event will Snap Inc. be liable for any damages or losses of any kind arising from the sample code or your use thereof. +""" + +from torch import nn +import torch +from .util import Encoder + + +class BGMotionPredictor(nn.Module): + """ + Module for background estimation, return single transformation, parametrized as 3x3 matrix. + """ + + def __init__(self, block_expansion, num_channels, max_features, num_blocks, bg_type='zero'): + super(BGMotionPredictor, self).__init__() + assert bg_type in ['zero', 'shift', 'affine', 'perspective'] + + self.bg_type = bg_type + if self.bg_type != 'zero': + self.encoder = Encoder(block_expansion, in_features=num_channels * 2, max_features=max_features, + num_blocks=num_blocks) + in_features = min(max_features, block_expansion * (2 ** num_blocks)) + if self.bg_type == 'perspective': + self.fc = nn.Linear(in_features, 8) + self.fc.weight.data.zero_() + self.fc.bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0, 0, 0], dtype=torch.float)) + elif self.bg_type == 'affine': + self.fc = nn.Linear(in_features, 6) + self.fc.weight.data.zero_() + self.fc.bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float)) + elif self.bg_type == 'shift': + self.fc = nn.Linear(in_features, 2) + self.fc.weight.data.zero_() + self.fc.bias.data.copy_(torch.tensor([0, 0], dtype=torch.float)) + + def forward(self, source_image, driving_image): + bs = source_image.shape[0] + out = torch.eye(3).unsqueeze(0).repeat(bs, 1, 1).type(source_image.type()) + if self.bg_type != 'zero': + prediction = self.encoder(torch.cat([source_image, driving_image], dim=1)) + prediction = prediction[-1].mean(dim=(2, 3)) + prediction = self.fc(prediction) + if self.bg_type == 'shift': + out[:, :2, 2] = prediction + elif self.bg_type == 'affine': + out[:, :2, :] = prediction.view(bs, 2, 3) + elif self.bg_type == 'perspective': + out[:, :2, :] = prediction[:, :6].view(bs, 2, 3) + out[:, 2, :2] = prediction[:, 6:].view(bs, 2) + + return out diff --git a/articulate_module/comm.py b/articulate_module/comm.py new file mode 100644 index 0000000..922f8c4 --- /dev/null +++ b/articulate_module/comm.py @@ -0,0 +1,137 @@ +# -*- coding: utf-8 -*- +# File : comm.py +# Author : Jiayuan Mao +# Email : maojiayuan@gmail.com +# Date : 27/01/2018 +# +# This file is part of Synchronized-BatchNorm-PyTorch. +# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch +# Distributed under MIT License. + +import queue +import collections +import threading + +__all__ = ['FutureResult', 'SlavePipe', 'SyncMaster'] + + +class FutureResult(object): + """A thread-safe future implementation. Used only as one-to-one pipe.""" + + def __init__(self): + self._result = None + self._lock = threading.Lock() + self._cond = threading.Condition(self._lock) + + def put(self, result): + with self._lock: + assert self._result is None, 'Previous result has\'t been fetched.' + self._result = result + self._cond.notify() + + def get(self): + with self._lock: + if self._result is None: + self._cond.wait() + + res = self._result + self._result = None + return res + + +_MasterRegistry = collections.namedtuple('MasterRegistry', ['result']) +_SlavePipeBase = collections.namedtuple('_SlavePipeBase', ['identifier', 'queue', 'result']) + + +class SlavePipe(_SlavePipeBase): + """Pipe for master-slave communication.""" + + def run_slave(self, msg): + self.queue.put((self.identifier, msg)) + ret = self.result.get() + self.queue.put(True) + return ret + + +class SyncMaster(object): + """An abstract `SyncMaster` object. + + - During the replication, as the data parallel will trigger an callback of each module, all slave devices should + call `register(id)` and obtain an `SlavePipe` to communicate with the master. + - During the forward pass, master device invokes `run_master`, all messages from slave devices will be collected, + and passed to a registered callback. + - After receiving the messages, the master device should gather the information and determine to message passed + back to each slave devices. + """ + + def __init__(self, master_callback): + """ + + Args: + master_callback: a callback to be invoked after having collected messages from slave devices. + """ + self._master_callback = master_callback + self._queue = queue.Queue() + self._registry = collections.OrderedDict() + self._activated = False + + def __getstate__(self): + return {'master_callback': self._master_callback} + + def __setstate__(self, state): + self.__init__(state['master_callback']) + + def register_slave(self, identifier): + """ + Register an slave device. + + Args: + identifier: an identifier, usually is the device id. + + Returns: a `SlavePipe` object which can be used to communicate with the master device. + + """ + if self._activated: + assert self._queue.empty(), 'Queue is not clean before next initialization.' + self._activated = False + self._registry.clear() + future = FutureResult() + self._registry[identifier] = _MasterRegistry(future) + return SlavePipe(identifier, self._queue, future) + + def run_master(self, master_msg): + """ + Main entry for the master device in each forward pass. + The messages were first collected from each devices (including the master device), and then + an callback will be invoked to compute the message to be sent back to each devices + (including the master device). + + Args: + master_msg: the message that the master want to send to itself. This will be placed as the first + message when calling `master_callback`. For detailed usage, see `_SynchronizedBatchNorm` for an example. + + Returns: the message to be sent back to the master device. + + """ + self._activated = True + + intermediates = [(0, master_msg)] + for i in range(self.nr_slaves): + intermediates.append(self._queue.get()) + + results = self._master_callback(intermediates) + assert results[0][0] == 0, 'The first result should belongs to the master.' + + for i, res in results: + if i == 0: + continue + self._registry[i].result.put(res) + + for i in range(self.nr_slaves): + assert self._queue.get() is True + + return results[0][1] + + @property + def nr_slaves(self): + return len(self._registry) diff --git a/articulate_module/config/taichi256.yaml b/articulate_module/config/taichi256.yaml new file mode 100644 index 0000000..4dac9b1 --- /dev/null +++ b/articulate_module/config/taichi256.yaml @@ -0,0 +1,104 @@ +#Copyright Snap Inc. 2021. This sample code is made available by Snap Inc. for informational purposes only. +#No license, whether implied or otherwise, is granted in or to such code (including any rights to copy, modify, +#publish, distribute and/or commercialize such code), unless you have entered into a separate agreement for such rights. +#Such code is provided as-is, without warranty of any kind, express or implied, including any warranties of merchantability, +#title, fitness for a particular purpose, non-infringement, or that such code is free of defects, errors or viruses. +#In no event will Snap Inc. be liable for any damages or losses of any kind arising from the sample code or your use thereof. + + +dataset_params: + root_dir: data/taichi-png + frame_shape: null + id_sampling: True + pairs_list: null + augmentation_params: + flip_param: + horizontal_flip: True + time_flip: True + jitter_param: + brightness: 0.1 + contrast: 0.1 + saturation: 0.1 + hue: 0.1 + +model_params: + num_regions: 10 + num_channels: 3 + estimate_affine: True + revert_axis_swap: True + bg_predictor_params: + block_expansion: 32 + max_features: 1024 + num_blocks: 5 + bg_type: 'affine' + region_predictor_params: + temperature: 0.1 + block_expansion: 32 + max_features: 1024 + scale_factor: 0.25 + num_blocks: 5 + pca_based: True + pad: 0 + fast_svd: False + generator_params: + block_expansion: 64 + max_features: 512 + num_down_blocks: 2 + num_bottleneck_blocks: 6 + skips: True + pixelwise_flow_predictor_params: + block_expansion: 64 + max_features: 1024 + num_blocks: 5 + scale_factor: 0.25 + use_deformed_source: True + use_covar_heatmap: True + estimate_occlusion_map: True + avd_network_params: + id_bottle_size: 64 + pose_bottle_size: 64 + +train_params: + num_epochs: 100 + num_repeats: 150 + epoch_milestones: [60, 90] + lr: 2.0e-4 + batch_size: 14 + dataloader_workers: 6 + checkpoint_freq: 50 + scales: [1, 0.5, 0.25, 0.125] + transform_params: + sigma_affine: 0.05 + sigma_tps: 0.005 + points_tps: 5 + loss_weights: + perceptual: [10, 10, 10, 10, 10] + equivariance_shift: 10 + equivariance_affine: 10 + +train_avd_params: + num_epochs: 30 + num_repeats: 150 + batch_size: 256 + dataloader_workers: 12 + checkpoint_freq: 50 + epoch_milestones: [20, 25] + lr: 1.0e-3 + lambda_shift: 1 + lambda_affine: 1 + random_scale: 0.25 + +reconstruction_params: + num_videos: 1000 + format: '.mp4' + +animate_params: + num_pairs: 50 + format: '.mp4' + mode: 'avd' + +visualizer_params: + kp_size: 5 + draw_border: True + colormap: 'gist_rainbow' + region_bg_color: [1, 1, 1] diff --git a/articulate_module/config/ted-youtube384.yaml b/articulate_module/config/ted-youtube384.yaml new file mode 100644 index 0000000..478fc4a --- /dev/null +++ b/articulate_module/config/ted-youtube384.yaml @@ -0,0 +1,105 @@ +#Copyright Snap Inc. 2021. This sample code is made available by Snap Inc. for informational purposes only. +#No license, whether implied or otherwise, is granted in or to such code (including any rights to copy, modify, +#publish, distribute and/or commercialize such code), unless you have entered into a separate agreement for such rights. +#Such code is provided as-is, without warranty of any kind, express or implied, including any warranties of merchantability, +#title, fitness for a particular purpose, non-infringement, or that such code is free of defects, errors or viruses. +#In no event will Snap Inc. be liable for any damages or losses of any kind arising from the sample code or your use thereof. + + +dataset_params: + root_dir: data/ted-youtube-384 + frame_shape: null + id_sampling: True + pairs_list: null + augmentation_params: + flip_param: + horizontal_flip: True + time_flip: True + jitter_param: + brightness: 0.1 + contrast: 0.1 + saturation: 0.1 + hue: 0.1 + +model_params: + num_regions: 20 + num_channels: 3 + estimate_affine: True + revert_axis_swap: True + + bg_predictor_params: + block_expansion: 32 + max_features: 1024 + num_blocks: 5 + bg_type: 'affine' + region_predictor_params: + temperature: 0.1 + block_expansion: 32 + max_features: 1024 + scale_factor: 0.25 + num_blocks: 5 + pca_based: True + pad: 0 + generator_params: + block_expansion: 64 + max_features: 512 + num_down_blocks: 2 + num_bottleneck_blocks: 6 + skips: True + pixelwise_flow_predictor_params: + block_expansion: 64 + max_features: 1024 + num_blocks: 5 + scale_factor: 0.25 + use_deformed_source: True + use_covar_heatmap: True + estimate_occlusion_map: True + avd_network_params: + id_bottle_size: 64 + pose_bottle_size: 64 + +train_params: + num_epochs: 100 + num_repeats: 150 + epoch_milestones: [60, 90] + lr: 2.0e-4 + batch_size: 20 + dataloader_workers: 6 + checkpoint_freq: 50 + use_sync_bn: False + scales: [1, 0.5, 0.25, 0.125] + transform_params: + sigma_affine: 0.05 + sigma_tps: 0.005 + points_tps: 5 + loss_weights: + perceptual: [10, 10, 10, 10, 10] + equivariance_shift: 10 + equivariance_affine: 10 + +train_avd_params: + num_epochs: 30 + num_repeats: 500 + batch_size: 256 + dataloader_workers: 12 + checkpoint_freq: 50 + epoch_milestones: [20, 25] + lr: 1.0e-3 + lambda_shift: 1 + lambda_affine: 1 + random_scale: 0.25 + +reconstruction_params: + num_videos: 1000 + format: '.mp4' + +animate_params: + num_pairs: 50 + format: '.mp4' + mode: 'avd' + +visualizer_params: + kp_size: 5 + draw_border: True + colormap: 'gist_rainbow' + region_bg_color: [1, 1, 1] diff --git a/articulate_module/config/ted384.yaml b/articulate_module/config/ted384.yaml new file mode 100644 index 0000000..d076ee1 --- /dev/null +++ b/articulate_module/config/ted384.yaml @@ -0,0 +1,105 @@ +#Copyright Snap Inc. 2021. This sample code is made available by Snap Inc. for informational purposes only. +#No license, whether implied or otherwise, is granted in or to such code (including any rights to copy, modify, +#publish, distribute and/or commercialize such code), unless you have entered into a separate agreement for such rights. +#Such code is provided as-is, without warranty of any kind, express or implied, including any warranties of merchantability, +#title, fitness for a particular purpose, non-infringement, or that such code is free of defects, errors or viruses. +#In no event will Snap Inc. be liable for any damages or losses of any kind arising from the sample code or your use thereof. + + +dataset_params: + root_dir: data/TED384-v2 + frame_shape: null + id_sampling: True + pairs_list: null + augmentation_params: + flip_param: + horizontal_flip: True + time_flip: True + jitter_param: + brightness: 0.1 + contrast: 0.1 + saturation: 0.1 + hue: 0.1 + +model_params: + num_regions: 10 + num_channels: 3 + estimate_affine: True + revert_axis_swap: True + + bg_predictor_params: + block_expansion: 32 + max_features: 1024 + num_blocks: 5 + bg_type: 'affine' + region_predictor_params: + temperature: 0.1 + block_expansion: 32 + max_features: 1024 + scale_factor: 0.25 + num_blocks: 5 + pca_based: True + pad: 0 + fast_svd: False + generator_params: + block_expansion: 64 + max_features: 512 + num_down_blocks: 2 + num_bottleneck_blocks: 6 + skips: True + pixelwise_flow_predictor_params: + block_expansion: 64 + max_features: 1024 + num_blocks: 5 + scale_factor: 0.25 + use_deformed_source: True + use_covar_heatmap: True + estimate_occlusion_map: True + avd_network_params: + id_bottle_size: 64 + pose_bottle_size: 64 + +train_params: + num_epochs: 100 + num_repeats: 150 + epoch_milestones: [60, 90] + lr: 2.0e-4 + batch_size: 6 + dataloader_workers: 6 + checkpoint_freq: 50 + scales: [1, 0.5, 0.25, 0.125] + transform_params: + sigma_affine: 0.05 + sigma_tps: 0.005 + points_tps: 5 + loss_weights: + perceptual: [10, 10, 10, 10, 10] + equivariance_shift: 10 + equivariance_affine: 10 + +train_avd_params: + num_epochs: 30 + num_repeats: 150 + batch_size: 256 + dataloader_workers: 12 + checkpoint_freq: 50 + epoch_milestones: [20, 25] + lr: 1.0e-3 + lambda_shift: 1 + lambda_affine: 1 + random_scale: 0.25 + +reconstruction_params: + num_videos: 1000 + format: '.mp4' + +animate_params: + num_pairs: 50 + format: '.mp4' + mode: 'avd' + +visualizer_params: + kp_size: 5 + draw_border: True + colormap: 'gist_rainbow' + region_bg_color: [1, 1, 1] diff --git a/articulate_module/config/vox256.yaml b/articulate_module/config/vox256.yaml new file mode 100644 index 0000000..9a49924 --- /dev/null +++ b/articulate_module/config/vox256.yaml @@ -0,0 +1,203 @@ +#Copyright Snap Inc. 2021. This sample code is made available by Snap Inc. for informational purposes only. +#No license, whether implied or otherwise, is granted in or to such code (including any rights to copy, modify, +#publish, distribute and/or commercialize such code), unless you have entered into a separate agreement for such rights. +#Such code is provided as-is, without warranty of any kind, express or implied, including any warranties of merchantability, +#title, fitness for a particular purpose, non-infringement, or that such code is free of defects, errors or viruses. +#In no event will Snap Inc. be liable for any damages or losses of any kind arising from the sample code or your use thereof. + + +# Dataset parameters +# Each dataset should contain 2 folders train and test +# Each video can be represented as: +# - an image of concatenated frames +# - '.mp4' or '.gif' +# - folder with all frames from a specific video +dataset_params: + # Path to data, data can be stored in several formats: .mp4 or .gif videos, stacked .png images or folders with frames. + # Folder with frames is preferred format for training, since it is the fastest. + root_dir: data/vox-png + # Shape to resize all frames to, specify null if resizing is not needed + frame_shape: null + # In case of Vox or Taichi single video can be splitted in many chunks, or the maybe several videos for single person. + # In this case epoch can be a pass over different identities (if id_sampling=True) or over different chunks (if id_sampling=False) + # If the name of the video '12335#adsbf.mp4' the id is assumed to be 12335 + id_sampling: True + # List with pairs for animation, null for random pairs + pairs_list: null + # Augmentation parameters see augmentation.py for all possible augmentations + augmentation_params: + flip_param: + horizontal_flip: True + time_flip: True + jitter_param: + brightness: 0.1 + contrast: 0.1 + saturation: 0.1 + hue: 0.1 + +# Defines architecture of the model +model_params: + # Number of regions + num_regions: 10 + # Number of channels, for RGB image it is always 3 + num_channels: 3 + # Enable estimation of affine parameters for each region, + # set to False if only region centers (keypoints) need to be estimated + estimate_affine: True + # Svd can perform random axis swap between source and driving if singular values are close to each other + # Set to True to avoid axis swap between source and driving + revert_axis_swap: True + + # Parameters of background prediction network based on simple Unet-like encoder. + bg_predictor_params: + # Number of features multiplier + block_expansion: 32 + # Maximum allowed number of features + max_features: 1024 + # Number of block in the Encoder. + num_blocks: 5 + # Type of background movement model, select one from ['zero', 'shift', 'affine', 'perspective'] + bg_type: 'affine' + + # Parameters of the region prediction network based on Unet + region_predictor_params: + # Softmax temperature for heatmaps + temperature: 0.1 + # Number of features multiplier + block_expansion: 32 + # Maximum allowed number of features + max_features: 1024 + # Regions is predicted on smaller images for better performance, + # scale_factor=0.25 means that 256x256 image will be resized to 64x64 + scale_factor: 0.25 + # Number of block in Unet. Can be increased or decreased depending or resolution. + num_blocks: 5 + # Either to use pca_based estimation of affine parameters of regression based + pca_based: True + # Either to use fast_svd (https://github.com/KinglittleQ/torch-batch-svd) or standard pytorch svd + # Fast svd may produce not meaningful regions if used along with revert_axis_swap + fast_svd: False + + # Parameters of Generator, based on Jonson architecture + generator_params: + # Number of features multiplier + block_expansion: 64 + # Maximum allowed number of features + max_features: 512 + # Number of down-sampling blocks in Jonson architecture. + # Can be increased or decreased depending or resolution. + num_down_blocks: 2 + # Number of ResBlocks in Jonson architecture. + num_bottleneck_blocks: 6 + # To use skip connections or no. + skips: True + # Parameters of pixelwise flow predictor based on Unet + pixelwise_flow_predictor_params: + # Number of features multiplier + block_expansion: 64 + # Maximum allowed number of features + max_features: 1024 + # Number of block in Unet. Can be increased or decreased depending or resolution. + num_blocks: 5 + # Flow predictor operates on the smaller images for better performance, + # scale_factor=0.25 means that 256x256 image will be resized to 64x64 + scale_factor: 0.25 + # Set to True in order to use deformed source images using sparse flow + use_deformed_source: True + # Set to False in order to render region heatmaps with fixed covariance + # True for covariance estimate using region_predictor + use_covar_heatmap: True + # Set to False to disable occlusion mask estimation + estimate_occlusion_map: True + + # Parameter for animation-via-disentanglement (avd) network + avd_network_params: + # Bottleneck for identity branch + id_bottle_size: 64 + # Bottleneck for pose branch + pose_bottle_size: 64 + +# Parameters of training (reconstruction) +train_params: + # Number of training epochs, visualization is produced after each epoch. + num_epochs: 100 + # For better i/o performance when number of videos is small number of epochs can be multiplied by this number. + # Thus effectively with num_repeats=100 each epoch is 100 times larger. + num_repeats: 75 + # Drop learning rate 10 times after this epochs + epoch_milestones: [60, 90] + # Initial learning rate + lr: 2.0e-4 + # Batch size. (14 is batch size for one V100 gpu). + batch_size: 14 + # Either to use sync_bn or not, enabling sync_bn will significantly slow the training time + use_sync_bn: False + # Dataset preprocessing cpu workers + dataloader_workers: 6 + # Save checkpoint this frequently. If checkpoint_freq=50, checkpoint will be saved every 50 epochs. + checkpoint_freq: 50 + # Scales for perceptual pyramide loss. If scales = [1, 0.5, 0.25, 0.125] and image resolution is 256x256, + # than the loss will be computer on resolutions 256x256, 128x128, 64x64, 32x32. + scales: [1, 0.5, 0.25, 0.125] + # Parameters of transform for equivariance loss + transform_params: + sigma_affine: 0.05 + sigma_tps: 0.005 + points_tps: 5 + loss_weights: + # Weights for perceptual pyramide loss. Note that here you can only specify weight across the layer, and + # weights across the resolution will be the same. + perceptual: [10, 10, 10, 10, 10] + # Weights for equivariance loss. + equivariance_shift: 10 + equivariance_affine: 10 + +# Parameters of training (animation-via-disentanglement) +train_avd_params: + # Number of training epochs, visualization is produced after each epoch. + num_epochs: 30 + # For better i/o performance when number of videos is small number of epochs can be multiplied by this number. + # Thus effectively with num_repeats=100 each epoch is 100 times larger. + num_repeats: 2000 + # Batch size. + batch_size: 256 + # Dataset preprocessing cpu workers + dataloader_workers: 20 + # Save checkpoint this frequently. If checkpoint_freq=50, checkpoint will be saved every 50 epochs. + checkpoint_freq: 50 + # Drop learning rate 10 times after this epochs + epoch_milestones: [20, 25] + # Initial learning rate + lr: 1.0e-3 + # Maximum value for scaling augmentation, that emulate objects with different shape + random_scale: 0.25 + # Weights for equivariance loss. + lambda_shift: 1 + lambda_affine: 1 + +# Parameters of reconstruction mode +reconstruction_params: + # Maximum number of videos for reconstruction + num_videos: 1000 + # Format for visualization, note that results will be also stored in staked .png for evaluation. + format: '.mp4' + +# Parameters of animation +animate_params: + # Maximum number of pairs for animation, the pairs will be either taken from pairs_list or random. + num_pairs: 50 + # Format for visualization + format: '.mp4' + # Animation mode, select one from [avd, standard, relative] + mode: 'avd' + +# Parameters of visualization +visualizer_params: + # Size of keypoints + kp_size: 5 + # Draw border between images or not + draw_border: True + # Colormap for regions and keypoints visualization + colormap: 'gist_rainbow' + # Background color for region visualization + region_bg_color: [1, 1, 1] diff --git a/articulate_module/generator.py b/articulate_module/generator.py new file mode 100644 index 0000000..5b9dafe --- /dev/null +++ b/articulate_module/generator.py @@ -0,0 +1,126 @@ +""" +Copyright Snap Inc. 2021. This sample code is made available by Snap Inc. for informational purposes only. +No license, whether implied or otherwise, is granted in or to such code (including any rights to copy, modify, +publish, distribute and/or commercialize such code), unless you have entered into a separate agreement for such rights. +Such code is provided as-is, without warranty of any kind, express or implied, including any warranties of merchantability, +title, fitness for a particular purpose, non-infringement, or that such code is free of defects, errors or viruses. +In no event will Snap Inc. be liable for any damages or losses of any kind arising from the sample code or your use thereof. +""" + +import torch +from torch import nn +import torch.nn.functional as F +from .util import ResBlock2d, SameBlock2d, UpBlock2d, DownBlock2d +from .pixelwise_flow_predictor import PixelwiseFlowPredictor + + +class Generator(nn.Module): + """ + Generator that given source image and region parameters try to transform image according to movement trajectories + induced by region parameters. Generator follows Johnson architecture. + """ + + def __init__(self, num_channels, num_regions, block_expansion, max_features, num_down_blocks, + num_bottleneck_blocks, pixelwise_flow_predictor_params=None, skips=False, revert_axis_swap=True): + super(Generator, self).__init__() + + if pixelwise_flow_predictor_params is not None: + self.pixelwise_flow_predictor = PixelwiseFlowPredictor(num_regions=num_regions, num_channels=num_channels, + revert_axis_swap=revert_axis_swap, + **pixelwise_flow_predictor_params) + else: + self.pixelwise_flow_predictor = None + + self.first = SameBlock2d(num_channels, block_expansion, kernel_size=(7, 7), padding=(3, 3)) + + down_blocks = [] + for i in range(num_down_blocks): + in_features = min(max_features, block_expansion * (2 ** i)) + out_features = min(max_features, block_expansion * (2 ** (i + 1))) + down_blocks.append(DownBlock2d(in_features, out_features, kernel_size=(3, 3), padding=(1, 1))) + self.down_blocks = nn.ModuleList(down_blocks) + + up_blocks = [] + for i in range(num_down_blocks): + in_features = min(max_features, block_expansion * (2 ** (num_down_blocks - i))) + out_features = min(max_features, block_expansion * (2 ** (num_down_blocks - i - 1))) + up_blocks.append(UpBlock2d(in_features, out_features, kernel_size=(3, 3), padding=(1, 1))) + self.up_blocks = nn.ModuleList(up_blocks) + + self.bottleneck = torch.nn.Sequential() + in_features = min(max_features, block_expansion * (2 ** num_down_blocks)) + for i in range(num_bottleneck_blocks): + self.bottleneck.add_module('r' + str(i), ResBlock2d(in_features, kernel_size=(3, 3), padding=(1, 1))) + + self.final = nn.Conv2d(block_expansion, num_channels, kernel_size=(7, 7), padding=(3, 3)) + self.num_channels = num_channels + self.skips = skips + + @staticmethod + def deform_input(inp, optical_flow): + _, h_old, w_old, _ = optical_flow.shape + _, _, h, w = inp.shape + if h_old != h or w_old != w: + optical_flow = optical_flow.permute(0, 3, 1, 2) + optical_flow = F.interpolate(optical_flow, size=(h, w), mode='bilinear') + optical_flow = optical_flow.permute(0, 2, 3, 1) + return F.grid_sample(inp, optical_flow) + + def apply_optical(self, input_previous=None, input_skip=None, motion_params=None): + if motion_params is not None: + if 'occlusion_map' in motion_params: + occlusion_map = motion_params['occlusion_map'] + else: + occlusion_map = None + deformation = motion_params['optical_flow'] + input_skip = self.deform_input(input_skip, deformation) + + if occlusion_map is not None: + if input_skip.shape[2] != occlusion_map.shape[2] or input_skip.shape[3] != occlusion_map.shape[3]: + occlusion_map = F.interpolate(occlusion_map, size=input_skip.shape[2:], mode='bilinear') + if input_previous is not None: + input_skip = input_skip * occlusion_map + input_previous * (1 - occlusion_map) + else: + input_skip = input_skip * occlusion_map + out = input_skip + else: + out = input_previous if input_previous is not None else input_skip + return out + + def forward(self, source_image, driving_region_params, source_region_params, bg_params=None): + out = self.first(source_image) + skips = [out] + for i in range(len(self.down_blocks)): + out = self.down_blocks[i](out) + skips.append(out) + + output_dict = {} + if self.pixelwise_flow_predictor is not None: + motion_params = self.pixelwise_flow_predictor(source_image=source_image, + driving_region_params=driving_region_params, + source_region_params=source_region_params, + bg_params=bg_params) + output_dict["deformed"] = self.deform_input(source_image, motion_params['optical_flow']) + if 'occlusion_map' in motion_params: + output_dict['occlusion_map'] = motion_params['occlusion_map'] + else: + motion_params = None + + out = self.apply_optical(input_previous=None, input_skip=out, motion_params=motion_params) + + out = self.bottleneck(out) + for i in range(len(self.up_blocks)): + if self.skips: + out = self.apply_optical(input_skip=skips[-(i + 1)], input_previous=out, motion_params=motion_params) + out = self.up_blocks[i](out) + if self.skips: + out = self.apply_optical(input_skip=skips[0], input_previous=out, motion_params=motion_params) + out = self.final(out) + out = F.sigmoid(out) + + if self.skips: + out = self.apply_optical(input_skip=source_image, input_previous=out, motion_params=motion_params) + + output_dict["prediction"] = out + + return output_dict diff --git a/articulate_module/models/.gitkeep b/articulate_module/models/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/articulate_module/pixelwise_flow_predictor.py b/articulate_module/pixelwise_flow_predictor.py new file mode 100644 index 0000000..6c83cc7 --- /dev/null +++ b/articulate_module/pixelwise_flow_predictor.py @@ -0,0 +1,137 @@ +""" +Copyright Snap Inc. 2021. This sample code is made available by Snap Inc. for informational purposes only. +No license, whether implied or otherwise, is granted in or to such code (including any rights to copy, modify, +publish, distribute and/or commercialize such code), unless you have entered into a separate agreement for such rights. +Such code is provided as-is, without warranty of any kind, express or implied, including any warranties of merchantability, +title, fitness for a particular purpose, non-infringement, or that such code is free of defects, errors or viruses. +In no event will Snap Inc. be liable for any damages or losses of any kind arising from the sample code or your use thereof. +""" + +from torch import nn +import torch.nn.functional as F +import torch +from .util import Hourglass, AntiAliasInterpolation2d, make_coordinate_grid, region2gaussian +from .util import to_homogeneous, from_homogeneous + + +class PixelwiseFlowPredictor(nn.Module): + """ + Module that predicts a pixelwise flow from sparse motion representation given by + source_region_params and driving_region_params + """ + + def __init__(self, block_expansion, num_blocks, max_features, num_regions, num_channels, + estimate_occlusion_map=False, scale_factor=1, region_var=0.01, + use_covar_heatmap=False, use_deformed_source=True, revert_axis_swap=False): + super(PixelwiseFlowPredictor, self).__init__() + self.hourglass = Hourglass(block_expansion=block_expansion, + in_features=(num_regions + 1) * (num_channels * use_deformed_source + 1), + max_features=max_features, num_blocks=num_blocks) + + self.mask = nn.Conv2d(self.hourglass.out_filters, num_regions + 1, kernel_size=(7, 7), padding=(3, 3)) + + if estimate_occlusion_map: + self.occlusion = nn.Conv2d(self.hourglass.out_filters, 1, kernel_size=(7, 7), padding=(3, 3)) + else: + self.occlusion = None + + self.num_regions = num_regions + self.scale_factor = scale_factor + self.region_var = region_var + self.use_covar_heatmap = use_covar_heatmap + self.use_deformed_source = use_deformed_source + self.revert_axis_swap = revert_axis_swap + + if self.scale_factor != 1: + self.down = AntiAliasInterpolation2d(num_channels, self.scale_factor) + + def create_heatmap_representations(self, source_image, driving_region_params, source_region_params): + """ + Eq 6. in the paper H_k(z) + """ + spatial_size = source_image.shape[2:] + covar = self.region_var if not self.use_covar_heatmap else driving_region_params['covar'] + gaussian_driving = region2gaussian(driving_region_params['shift'], covar=covar, spatial_size=spatial_size) + covar = self.region_var if not self.use_covar_heatmap else source_region_params['covar'] + gaussian_source = region2gaussian(source_region_params['shift'], covar=covar, spatial_size=spatial_size) + + heatmap = gaussian_driving - gaussian_source + + # adding background feature + zeros = torch.zeros(heatmap.shape[0], 1, spatial_size[0], spatial_size[1]) + heatmap = torch.cat([zeros.type(heatmap.type()), heatmap], dim=1) + heatmap = heatmap.unsqueeze(2) + return heatmap + + def create_sparse_motions(self, source_image, driving_region_params, source_region_params, bg_params=None): + bs, _, h, w = source_image.shape + identity_grid = make_coordinate_grid((h, w), type=source_region_params['shift'].type()) + identity_grid = identity_grid.view(1, 1, h, w, 2) + coordinate_grid = identity_grid - driving_region_params['shift'].view(bs, self.num_regions, 1, 1, 2) + if 'affine' in driving_region_params: + affine = torch.matmul(source_region_params['affine'], torch.inverse(driving_region_params['affine'])) + if self.revert_axis_swap: + affine = affine * torch.sign(affine[:, :, 0:1, 0:1]) + affine = affine.unsqueeze(-3).unsqueeze(-3) + affine = affine.repeat(1, 1, h, w, 1, 1) + coordinate_grid = torch.matmul(affine, coordinate_grid.unsqueeze(-1)) + coordinate_grid = coordinate_grid.squeeze(-1) + + driving_to_source = coordinate_grid + source_region_params['shift'].view(bs, self.num_regions, 1, 1, 2) + + # adding background feature + if bg_params is None: + bg_grid = identity_grid.repeat(bs, 1, 1, 1, 1) + else: + bg_grid = identity_grid.repeat(bs, 1, 1, 1, 1) + bg_grid = to_homogeneous(bg_grid) + bg_grid = torch.matmul(bg_params.view(bs, 1, 1, 1, 3, 3), bg_grid.unsqueeze(-1)).squeeze(-1) + bg_grid = from_homogeneous(bg_grid) + + sparse_motions = torch.cat([bg_grid, driving_to_source], dim=1) + + return sparse_motions + + def create_deformed_source_image(self, source_image, sparse_motions): + bs, _, h, w = source_image.shape + source_repeat = source_image.unsqueeze(1).unsqueeze(1).repeat(1, self.num_regions + 1, 1, 1, 1, 1) + source_repeat = source_repeat.view(bs * (self.num_regions + 1), -1, h, w) + sparse_motions = sparse_motions.view((bs * (self.num_regions + 1), h, w, -1)) + sparse_deformed = F.grid_sample(source_repeat, sparse_motions) + sparse_deformed = sparse_deformed.view((bs, self.num_regions + 1, -1, h, w)) + return sparse_deformed + + def forward(self, source_image, driving_region_params, source_region_params, bg_params=None): + if self.scale_factor != 1: + source_image = self.down(source_image) + + bs, _, h, w = source_image.shape + + out_dict = dict() + heatmap_representation = self.create_heatmap_representations(source_image, driving_region_params, + source_region_params) + sparse_motion = self.create_sparse_motions(source_image, driving_region_params, + source_region_params, bg_params=bg_params) + deformed_source = self.create_deformed_source_image(source_image, sparse_motion) + if self.use_deformed_source: + predictor_input = torch.cat([heatmap_representation, deformed_source], dim=2) + else: + predictor_input = heatmap_representation + predictor_input = predictor_input.view(bs, -1, h, w) + + prediction = self.hourglass(predictor_input) + + mask = self.mask(prediction) + mask = F.softmax(mask, dim=1) + mask = mask.unsqueeze(2) + sparse_motion = sparse_motion.permute(0, 1, 4, 2, 3) + deformation = (sparse_motion * mask).sum(dim=1) + deformation = deformation.permute(0, 2, 3, 1) + + out_dict['optical_flow'] = deformation + + if self.occlusion: + occlusion_map = torch.sigmoid(self.occlusion(prediction)) + out_dict['occlusion_map'] = occlusion_map + + return out_dict diff --git a/articulate_module/region_predictor.py b/articulate_module/region_predictor.py new file mode 100644 index 0000000..c98bb58 --- /dev/null +++ b/articulate_module/region_predictor.py @@ -0,0 +1,121 @@ +""" +Copyright Snap Inc. 2021. This sample code is made available by Snap Inc. for informational purposes only. +No license, whether implied or otherwise, is granted in or to such code (including any rights to copy, modify, +publish, distribute and/or commercialize such code), unless you have entered into a separate agreement for such rights. +Such code is provided as-is, without warranty of any kind, express or implied, including any warranties of merchantability, +title, fitness for a particular purpose, non-infringement, or that such code is free of defects, errors or viruses. +In no event will Snap Inc. be liable for any damages or losses of any kind arising from the sample code or your use thereof. +""" + +from torch import nn +import torch +import torch.nn.functional as F +from .util import Hourglass, make_coordinate_grid, AntiAliasInterpolation2d +from torch.linalg import svd as svd_torch + +def svd(covar, fast=False): + # if fast: + # from torch_batch_svd import svd as fast_svd + # return fast_svd(covar) + # else: + + # u, s, v = torch.svd(covar.cpu()) + # u, s, vh = svd_torch(covar.cpu()) + u, s, vh = svd_torch(covar) + v = vh.mH + s = s.to(covar.device) + u = u.to(covar.device) + v = v.to(covar.device) + return u, s, v + + +class RegionPredictor(nn.Module): + """ + Region estimating. Estimate affine parameters of the region. + """ + + def __init__(self, block_expansion, num_regions, num_channels, max_features, + num_blocks, temperature, estimate_affine=False, scale_factor=1, + pca_based=False, fast_svd=False, pad=3): + super(RegionPredictor, self).__init__() + self.predictor = Hourglass(block_expansion, in_features=num_channels, + max_features=max_features, num_blocks=num_blocks) + + self.regions = nn.Conv2d(in_channels=self.predictor.out_filters, out_channels=num_regions, kernel_size=(7, 7), + padding=pad) + + # FOMM-like regression based representation + if estimate_affine and not pca_based: + self.jacobian = nn.Conv2d(in_channels=self.predictor.out_filters, + out_channels=4, kernel_size=(7, 7), padding=pad) + self.jacobian.weight.data.zero_() + self.jacobian.bias.data.copy_(torch.tensor([1, 0, 0, 1], dtype=torch.float)) + else: + self.jacobian = None + + self.temperature = temperature + self.scale_factor = scale_factor + self.pca_based = pca_based + self.fast_svd = fast_svd + + if self.scale_factor != 1: + self.down = AntiAliasInterpolation2d(num_channels, self.scale_factor) + + def region2affine(self, region): + shape = region.shape + region = region.unsqueeze(-1) + grid = make_coordinate_grid(shape[2:], region.type()).unsqueeze_(0).unsqueeze_(0) + mean = (region * grid).sum(dim=(2, 3)) + + region_params = {'shift': mean} + + if self.pca_based: + mean_sub = grid - mean.unsqueeze(-2).unsqueeze(-2) + covar = torch.matmul(mean_sub.unsqueeze(-1), mean_sub.unsqueeze(-2)) + covar = covar * region.unsqueeze(-1) + covar = covar.sum(dim=(2, 3)) + region_params['covar'] = covar + + return region_params + + def forward(self, x): + if self.scale_factor != 1: + x = self.down(x) + + feature_map = self.predictor(x) + prediction = self.regions(feature_map) + + final_shape = prediction.shape + region = prediction.view(final_shape[0], final_shape[1], -1) + region = F.softmax(region / self.temperature, dim=2) + region = region.view(*final_shape) + + region_params = self.region2affine(region) + region_params['heatmap'] = region + + # Regression-based estimation + if self.jacobian is not None: + jacobian_map = self.jacobian(feature_map) + jacobian_map = jacobian_map.reshape(final_shape[0], 1, 4, final_shape[2], + final_shape[3]) + region = region.unsqueeze(2) + + jacobian = region * jacobian_map + jacobian = jacobian.view(final_shape[0], final_shape[1], 4, -1) + jacobian = jacobian.sum(dim=-1) + jacobian = jacobian.view(jacobian.shape[0], jacobian.shape[1], 2, 2) + region_params['affine'] = jacobian + region_params['covar'] = torch.matmul(jacobian, jacobian.permute(0, 1, 3, 2)) + elif self.pca_based: + covar = region_params['covar'] + shape = covar.shape + covar = covar.view(-1, 2, 2) + u, s, v = svd(covar, self.fast_svd) + d = torch.diag_embed(s ** 0.5) + sqrt = torch.matmul(u, d) + sqrt = sqrt.view(*shape) + region_params['affine'] = sqrt + region_params['u'] = u + region_params['d'] = d + + return region_params diff --git a/articulate_module/util.py b/articulate_module/util.py new file mode 100644 index 0000000..4bc1fb7 --- /dev/null +++ b/articulate_module/util.py @@ -0,0 +1,271 @@ +""" +Copyright Snap Inc. 2021. This sample code is made available by Snap Inc. for informational purposes only. +No license, whether implied or otherwise, is granted in or to such code (including any rights to copy, modify, +publish, distribute and/or commercialize such code), unless you have entered into a separate agreement for such rights. +Such code is provided as-is, without warranty of any kind, express or implied, including any warranties of merchantability, +title, fitness for a particular purpose, non-infringement, or that such code is free of defects, errors or viruses. +In no event will Snap Inc. be liable for any damages or losses of any kind arising from the sample code or your use thereof. +""" + +from torch import nn + +import torch.nn.functional as F +import torch +from .batchnorm import SynchronizedBatchNorm2d as BatchNorm2d + + +def region2gaussian(center, covar, spatial_size): + """ + Transform a region parameters into gaussian like heatmap + """ + mean = center + + coordinate_grid = make_coordinate_grid(spatial_size, mean.type()) + number_of_leading_dimensions = len(mean.shape) - 1 + shape = (1,) * number_of_leading_dimensions + coordinate_grid.shape + coordinate_grid = coordinate_grid.view(*shape) + repeats = mean.shape[:number_of_leading_dimensions] + (1, 1, 1) + coordinate_grid = coordinate_grid.repeat(*repeats) + + # Preprocess kp shape + shape = mean.shape[:number_of_leading_dimensions] + (1, 1, 2) + mean = mean.view(*shape) + + mean_sub = (coordinate_grid - mean) + if type(covar) == float: + out = torch.exp(-0.5 * (mean_sub ** 2).sum(-1) / covar) + else: + shape = mean.shape[:number_of_leading_dimensions] + (1, 1, 2, 2) + covar_inverse = torch.inverse(covar).view(*shape) + under_exp = torch.matmul(torch.matmul(mean_sub.unsqueeze(-2), covar_inverse), mean_sub.unsqueeze(-1)) + out = torch.exp(-0.5 * under_exp.sum(dim=(-1, -2))) + + return out + + +def make_coordinate_grid(spatial_size, type): + """ + Create a meshgrid [-1,1] x [-1,1] of given spatial_size. + """ + h, w = spatial_size + x = torch.arange(w).type(type) + y = torch.arange(h).type(type) + + x = (2 * (x / (w - 1)) - 1) + y = (2 * (y / (h - 1)) - 1) + + yy = y.view(-1, 1).repeat(1, w) + xx = x.view(1, -1).repeat(h, 1) + + meshed = torch.cat([xx.unsqueeze_(2), yy.unsqueeze_(2)], 2) + + return meshed + + +class ResBlock2d(nn.Module): + """ + Res block, preserve spatial resolution. + """ + + def __init__(self, in_features, kernel_size, padding): + super(ResBlock2d, self).__init__() + self.conv1 = nn.Conv2d(in_channels=in_features, out_channels=in_features, kernel_size=kernel_size, + padding=padding) + self.conv2 = nn.Conv2d(in_channels=in_features, out_channels=in_features, kernel_size=kernel_size, + padding=padding) + self.norm1 = BatchNorm2d(in_features, affine=True) + self.norm2 = BatchNorm2d(in_features, affine=True) + + def forward(self, x): + out = self.norm1(x) + out = F.relu(out) + out = self.conv1(out) + out = self.norm2(out) + out = F.relu(out) + out = self.conv2(out) + out += x + return out + + +class UpBlock2d(nn.Module): + """ + Upsampling block for use in decoder. + """ + + def __init__(self, in_features, out_features, kernel_size=3, padding=1, groups=1): + super(UpBlock2d, self).__init__() + + self.conv = nn.Conv2d(in_channels=in_features, out_channels=out_features, kernel_size=kernel_size, + padding=padding, groups=groups) + self.norm = BatchNorm2d(out_features, affine=True) + + def forward(self, x): + out = F.interpolate(x, scale_factor=2) + out = self.conv(out) + out = self.norm(out) + out = F.relu(out) + return out + + +class DownBlock2d(nn.Module): + """ + Downsampling block for use in encoder. + """ + + def __init__(self, in_features, out_features, kernel_size=3, padding=1, groups=1): + super(DownBlock2d, self).__init__() + self.conv = nn.Conv2d(in_channels=in_features, out_channels=out_features, kernel_size=kernel_size, + padding=padding, groups=groups) + self.norm = BatchNorm2d(out_features, affine=True) + self.pool = nn.AvgPool2d(kernel_size=(2, 2)) + + def forward(self, x): + out = self.conv(x) + out = self.norm(out) + out = F.relu(out) + out = self.pool(out) + return out + + +class SameBlock2d(nn.Module): + """ + Simple block, preserve spatial resolution. + """ + + def __init__(self, in_features, out_features, groups=1, kernel_size=3, padding=1): + super(SameBlock2d, self).__init__() + self.conv = nn.Conv2d(in_channels=in_features, out_channels=out_features, + kernel_size=kernel_size, padding=padding, groups=groups) + self.norm = BatchNorm2d(out_features, affine=True) + + def forward(self, x): + out = self.conv(x) + out = self.norm(out) + out = F.relu(out) + return out + + +class Encoder(nn.Module): + """ + Hourglass Encoder + """ + + def __init__(self, block_expansion, in_features, num_blocks=3, max_features=256): + super(Encoder, self).__init__() + + down_blocks = [] + for i in range(num_blocks): + down_blocks.append(DownBlock2d(in_features if i == 0 else min(max_features, block_expansion * (2 ** i)), + min(max_features, block_expansion * (2 ** (i + 1))), + kernel_size=3, padding=1)) + self.down_blocks = nn.ModuleList(down_blocks) + + def forward(self, x): + outs = [x] + for down_block in self.down_blocks: + outs.append(down_block(outs[-1])) + return outs + + +class Decoder(nn.Module): + """ + Hourglass Decoder + """ + + def __init__(self, block_expansion, in_features, num_blocks=3, max_features=256): + super(Decoder, self).__init__() + + up_blocks = [] + + for i in range(num_blocks)[::-1]: + in_filters = (1 if i == num_blocks - 1 else 2) * min(max_features, block_expansion * (2 ** (i + 1))) + out_filters = min(max_features, block_expansion * (2 ** i)) + up_blocks.append(UpBlock2d(in_filters, out_filters, kernel_size=3, padding=1)) + + self.up_blocks = nn.ModuleList(up_blocks) + self.out_filters = block_expansion + in_features + + def forward(self, x): + out = x.pop() + for up_block in self.up_blocks: + out = up_block(out) + skip = x.pop() + out = torch.cat([out, skip], dim=1) + return out + + +class Hourglass(nn.Module): + """ + Hourglass architecture. + """ + + def __init__(self, block_expansion, in_features, num_blocks=3, max_features=256): + super(Hourglass, self).__init__() + self.encoder = Encoder(block_expansion, in_features, num_blocks, max_features) + self.decoder = Decoder(block_expansion, in_features, num_blocks, max_features) + self.out_filters = self.decoder.out_filters + + def forward(self, x): + return self.decoder(self.encoder(x)) + + +class AntiAliasInterpolation2d(nn.Module): + """ + Band-limited downsampling, for better preservation of the input signal. + """ + + def __init__(self, channels, scale): + super(AntiAliasInterpolation2d, self).__init__() + sigma = (1 / scale - 1) / 2 + kernel_size = 2 * round(sigma * 4) + 1 + self.ka = kernel_size // 2 + self.kb = self.ka - 1 if kernel_size % 2 == 0 else self.ka + + kernel_size = [kernel_size, kernel_size] + sigma = [sigma, sigma] + # The gaussian kernel is the product of the + # gaussian function of each dimension. + kernel = 1 + meshgrids = torch.meshgrid( + [ + torch.arange(size, dtype=torch.float32) + for size in kernel_size + ] + ) + for size, std, mgrid in zip(kernel_size, sigma, meshgrids): + mean = (size - 1) / 2 + kernel *= torch.exp(-(mgrid - mean) ** 2 / (2 * std ** 2)) + + # Make sure sum of values in gaussian kernel equals 1. + kernel = kernel / torch.sum(kernel) + # Reshape to depthwise convolutional weight + kernel = kernel.view(1, 1, *kernel.size()) + kernel = kernel.repeat(channels, *[1] * (kernel.dim() - 1)) + + self.register_buffer('weight', kernel) + self.groups = channels + self.scale = scale + inv_scale = 1 / scale + self.int_inv_scale = int(inv_scale) + + def forward(self, input): + if self.scale == 1.0: + return input + + out = F.pad(input, (self.ka, self.kb, self.ka, self.kb)) + out = F.conv2d(out, weight=self.weight, groups=self.groups) + out = out[:, :, ::self.int_inv_scale, ::self.int_inv_scale] + + return out + + +def to_homogeneous(coordinates): + ones_shape = list(coordinates.shape) + ones_shape[-1] = 1 + ones = torch.ones(ones_shape).type(coordinates.type()) + + return torch.cat([coordinates, ones], dim=-1) + + +def from_homogeneous(coordinates): + return coordinates[..., :2] / coordinates[..., 2:3] diff --git a/articulate_module/visualizer.py b/articulate_module/visualizer.py new file mode 100644 index 0000000..7406229 --- /dev/null +++ b/articulate_module/visualizer.py @@ -0,0 +1,145 @@ +import matplotlib.pyplot as plt +import numpy as np +import torch.nn.functional as F +from skimage.draw import circle_perimeter as circle + + +class Visualizer: + def __init__( + self, + kp_size=5, + draw_border=False, + colormap="gist_rainbow", + region_bg_color=(0, 0, 0), + ): + self.kp_size = kp_size + self.draw_border = draw_border + self.colormap = plt.get_cmap(colormap) + self.region_bg_color = np.array(region_bg_color) + + def draw_image_with_kp(self, image, kp_array): + image = np.copy(image) + spatial_size = np.array(image.shape[:2][::-1])[np.newaxis] + kp_array = spatial_size * (kp_array + 1) / 2 + num_regions = kp_array.shape[0] + for kp_ind, kp in enumerate(kp_array): + rr, cc = circle(int(kp[1]), int(kp[0]), self.kp_size, shape=image.shape[:2]) + image[rr, cc] = np.array(self.colormap(kp_ind / num_regions))[:3] + return image + + def create_image_column_with_kp(self, images, kp): + image_array = np.array( + [self.draw_image_with_kp(v, k) for v, k in zip(images, kp)] + ) + return self.create_image_column(image_array) + + def create_image_column(self, images): + if self.draw_border: + images = np.copy(images) + images[:, :, [0, -1]] = (1, 1, 1) + images[:, :, [0, -1]] = (1, 1, 1) + return np.concatenate(list(images), axis=0) + + def create_image_grid(self, *args): + out = [] + for arg in args: + if type(arg) == tuple: + out.append(self.create_image_column_with_kp(arg[0], arg[1])) + else: + out.append(self.create_image_column(arg)) + return np.concatenate(out, axis=1) + + def visualize(self, driving, source, out): + images = [] + + # Source image with region centers + source = source.data.cpu() + source_region_params = out["source_region_params"]["shift"].data.cpu().numpy() + source = np.transpose(source, [0, 2, 3, 1]) + images.append((source, source_region_params)) + + # Equivariance visualization + if "transformed_frame" in out: + transformed = out["transformed_frame"].data.cpu().numpy() + transformed = np.transpose(transformed, [0, 2, 3, 1]) + transformed_kp = ( + out["transformed_region_params"]["shift"].data.cpu().numpy() + ) + images.append((transformed, transformed_kp)) + + # Driving image with region centers + driving_region_params = out["driving_region_params"]["shift"].data.cpu().numpy() + driving = driving.data.cpu().numpy() + driving = np.transpose(driving, [0, 2, 3, 1]) + images.append((driving, driving_region_params)) + + # Deformed image + if "deformed" in out: + deformed = out["deformed"].data.cpu().numpy() + deformed = np.transpose(deformed, [0, 2, 3, 1]) + images.append(deformed) + + # Result + prediction = out["prediction"].data.cpu().numpy() + prediction = np.transpose(prediction, [0, 2, 3, 1]) + images.append(prediction) + + # Occlusion map + if "occlusion_map" in out: + occlusion_map = out["occlusion_map"].data.cpu().repeat(1, 3, 1, 1) + occlusion_map = F.interpolate(occlusion_map, size=source.shape[1:3]).numpy() + occlusion_map = np.transpose(occlusion_map, [0, 2, 3, 1]) + images.append(occlusion_map) + + # Heatmaps visualizations + if "heatmap" in out["driving_region_params"]: + driving_heatmap = F.interpolate( + out["driving_region_params"]["heatmap"], size=source.shape[1:3] + ) + driving_heatmap = np.transpose( + driving_heatmap.data.cpu().numpy(), [0, 2, 3, 1] + ) + images.append( + draw_colored_heatmap( + driving_heatmap, self.colormap, self.region_bg_color + ) + ) + + if "heatmap" in out["source_region_params"]: + source_heatmap = F.interpolate( + out["source_region_params"]["heatmap"], size=source.shape[1:3] + ) + source_heatmap = np.transpose( + source_heatmap.data.cpu().numpy(), [0, 2, 3, 1] + ) + images.append( + draw_colored_heatmap( + source_heatmap, self.colormap, self.region_bg_color + ) + ) + + image = self.create_image_grid(*images) + image = (255 * image).astype(np.uint8) + return image + + +def draw_colored_heatmap(heatmap, colormap, bg_color): + parts = [] + weights = [] + bg_color = np.array(bg_color).reshape((1, 1, 1, 3)) + num_regions = heatmap.shape[-1] + for i in range(num_regions): + color = np.array(colormap(i / num_regions))[:3] + color = color.reshape((1, 1, 1, 3)) + part = heatmap[:, :, :, i : (i + 1)] + part = part / np.max(part, axis=(1, 2), keepdims=True) + weights.append(part) + + color_part = part * color + parts.append(color_part) + + weight = sum(weights) + bg_weight = 1 - np.minimum(1, weight) + weight = np.maximum(1, weight) + result = sum(parts) / weight + bg_weight * bg_color + return result diff --git a/constants.py b/constants.py index 2eade3a..2b0691a 100644 --- a/constants.py +++ b/constants.py @@ -98,3 +98,6 @@ seg_model_dict = { "vox": seg10_segment_names, "vox-adv": seg10_segment_names, } + +ARTICULATE_MODEL_PATH = "articulate_module/models/vox256.pth" +ARTICULATE_CFG_PATH = "articulate_module/config/vox256.yaml" \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 1a85784..ffe24f1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,7 @@ [project] name = "comfyui-firstordermm" description = "A ComfyUI-native node to run First Order Motion Model for Image Animation. [a/https://github.com/AliaksandrSiarohin/first-order-model](https://github.com/AliaksandrSiarohin/first-order-model)" -version = "1.0.1" +version = "1.0.2" license = { file = "LICENSE" } dependencies = ["numpy", "torch", "scipy", "yaml", "matplotlib"] diff --git a/run.py b/run.py index 013f8f0..2564109 100644 --- a/run.py +++ b/run.py @@ -9,7 +9,10 @@ from pathlib import Path import torch +from .articulate_inference import articulate_inference from .constants import ( + ARTICULATE_CFG_PATH, + ARTICULATE_MODEL_PATH, config_folder, default_model_name, default_partswap_model_name, @@ -338,6 +341,72 @@ class FOMM_Partswap: ) +class Articulate_Runner: + @classmethod + def INPUT_TYPES(s): + return { + "required": { + "source_image": ("IMAGE",), + "driving_video_input": ("IMAGE",), + "frame_rate": ("FLOAT", {"default": 30.0}), + }, + "optional": {"audio": ("AUDIO",)}, + } + + RETURN_TYPES = ( + "IMAGE", + "AUDIO", + "FLOAT", + ) + RETURN_NAMES = ( + "images", + "audio", + "frame_rate", + ) + FUNCTION = "todo" + CATEGORY = "FirstOrderMM" + + def todo( + self, + source_image: torch.Tensor, + driving_video_input: torch.Tensor, + frame_rate: float, + audio=None, + ): + print(f"{source_image.shape=}") + print(f"{driving_video_input.shape=}") + print(f"{type(audio)=}") + print(base_dir) + + config_path = f"{base_dir}/{ARTICULATE_CFG_PATH}" + checkpoint_path = f"{base_dir}/{ARTICULATE_MODEL_PATH}" + + source_image = reshape_image(source_image, (256, 256)) + driving_video = reshape_image(driving_video_input, (256, 256)).unsqueeze(0) + driving_video = driving_video.permute(0, 2, 1, 3, 4) + + print("After reshaping") + print(f"{source_image.shape=}") + print(f"{driving_video.shape=}") + + params = { + "source_image": source_image, + "driving_video": driving_video, + "config_path": config_path, + "checkpoint_path": checkpoint_path, + } + + predictions = articulate_inference(**params) + + output_images = out_video(predictions) + + return ( + output_images, + audio, + frame_rate, + ) + + def serialize_integers(int_list): return "_".join(map(str, int_list)) diff --git a/workflows/ARTICULATE.json b/workflows/ARTICULATE.json new file mode 100644 index 0000000..a5f1e76 --- /dev/null +++ b/workflows/ARTICULATE.json @@ -0,0 +1,423 @@ +{ + "last_node_id": 17, + "last_link_id": 58, + "nodes": [ + { + "id": 2, + "type": "LoadImage", + "pos": [ + 242, + 94 + ], + "size": { + "0": 315, + "1": 314 + }, + "flags": {}, + "order": 0, + "mode": 0, + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 52 + ], + "shape": 3, + "slot_index": 0 + }, + { + "name": "MASK", + "type": "MASK", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": [ + "Rick1.png", + "image" + ] + }, + { + "id": 3, + "type": "VHS_LoadVideo", + "pos": [ + 323, + 465 + ], + "size": [ + 235.1999969482422, + 491.1999969482422 + ], + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [ + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null + }, + { + "name": "vae", + "type": "VAE", + "link": null + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 53 + ], + "shape": 3, + "slot_index": 0 + }, + { + "name": "frame_count", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "audio", + "type": "AUDIO", + "links": [ + 54 + ], + "shape": 3, + "slot_index": 2 + }, + { + "name": "video_info", + "type": "VHS_VIDEOINFO", + "links": [ + 3 + ], + "shape": 3, + "slot_index": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_LoadVideo" + }, + "widgets_values": { + "video": "damedane.mp4", + "force_rate": 0, + "force_size": "Disabled", + "custom_width": 512, + "custom_height": 512, + "frame_load_cap": 0, + "skip_first_frames": 0, + "select_every_nth": 1, + "choose video to upload": "image", + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "frame_load_cap": 0, + "skip_first_frames": 0, + "force_rate": 0, + "filename": "damedane.mp4", + "type": "input", + "format": "video/mp4", + "select_every_nth": 1 + } + } + } + }, + { + "id": 4, + "type": "VHS_VideoInfoLoaded", + "pos": [ + 647, + 346 + ], + "size": { + "0": 304.79998779296875, + "1": 106 + }, + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [ + { + "name": "video_info", + "type": "VHS_VIDEOINFO", + "link": 3 + } + ], + "outputs": [ + { + "name": "fps🟦", + "type": "FLOAT", + "links": [ + 55 + ], + "shape": 3, + "slot_index": 0 + }, + { + "name": "frame_count🟦", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "duration🟦", + "type": "FLOAT", + "links": null, + "shape": 3 + }, + { + "name": "width🟦", + "type": "INT", + "links": null, + "shape": 3 + }, + { + "name": "height🟦", + "type": "INT", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoInfoLoaded" + }, + "widgets_values": {} + }, + { + "id": 15, + "type": "VHS_VideoCombine", + "pos": [ + 1065, + 135 + ], + "size": [ + 315, + 615 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 56 + }, + { + "name": "audio", + "type": "AUDIO", + "link": 57 + }, + { + "name": "meta_batch", + "type": "VHS_BatchManager", + "link": null + }, + { + "name": "vae", + "type": "VAE", + "link": null + }, + { + "name": "frame_rate", + "type": "FLOAT", + "link": 58, + "widget": { + "name": "frame_rate" + } + } + ], + "outputs": [ + { + "name": "Filenames", + "type": "VHS_FILENAMES", + "links": null, + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "VHS_VideoCombine" + }, + "widgets_values": { + "frame_rate": 8, + "loop_count": 0, + "filename_prefix": "Articulate", + "format": "video/h264-mp4", + "pix_fmt": "yuv420p", + "crf": 0, + "save_metadata": true, + "pingpong": false, + "save_output": false, + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "Articulate_00001-audio.mp4", + "subfolder": "", + "type": "temp", + "format": "video/h264-mp4", + "frame_rate": 29.970029970029966 + } + } + } + }, + { + "id": 17, + "type": "Articulate_Runner", + "pos": [ + 646, + 145 + ], + "size": { + "0": 380.4000244140625, + "1": 146 + }, + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "source_image", + "type": "IMAGE", + "link": 52 + }, + { + "name": "driving_video_input", + "type": "IMAGE", + "link": 53 + }, + { + "name": "audio", + "type": "AUDIO", + "link": 54 + }, + { + "name": "frame_rate", + "type": "FLOAT", + "link": 55, + "widget": { + "name": "frame_rate" + } + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 56 + ], + "shape": 3 + }, + { + "name": "audio", + "type": "AUDIO", + "links": [ + 57 + ], + "shape": 3 + }, + { + "name": "frame_rate", + "type": "FLOAT", + "links": [ + 58 + ], + "shape": 3 + } + ], + "properties": { + "Node name for S&R": "Articulate_Runner" + }, + "widgets_values": [ + 30 + ] + } + ], + "links": [ + [ + 3, + 3, + 3, + 4, + 0, + "VHS_VIDEOINFO" + ], + [ + 52, + 2, + 0, + 17, + 0, + "IMAGE" + ], + [ + 53, + 3, + 0, + 17, + 1, + "IMAGE" + ], + [ + 54, + 3, + 2, + 17, + 2, + "AUDIO" + ], + [ + 55, + 4, + 0, + 17, + 3, + "FLOAT" + ], + [ + 56, + 17, + 0, + 15, + 0, + "IMAGE" + ], + [ + 57, + 17, + 1, + 15, + 1, + "AUDIO" + ], + [ + 58, + 17, + 2, + 15, + 4, + "FLOAT" + ] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.9090909090909091, + "offset": [ + 1.9174305033795593, + 14.883996994740842 + ] + } + }, + "version": 0.4 +} \ No newline at end of file diff --git a/FOMM.json b/workflows/FOMM.json similarity index 100% rename from FOMM.json rename to workflows/FOMM.json diff --git a/FOMM_PARTSWAP.json b/workflows/FOMM_PARTSWAP.json similarity index 100% rename from FOMM_PARTSWAP.json rename to workflows/FOMM_PARTSWAP.json diff --git a/workflow.png b/workflows/workflow.png similarity index 100% rename from workflow.png rename to workflows/workflow.png diff --git a/workflows/workflow_articulate.png b/workflows/workflow_articulate.png new file mode 100644 index 0000000000000000000000000000000000000000..da37ce7879161a5cc6b1a00260e8261406825150 GIT binary patch literal 254529 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´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

pXmiWk#SzD{A^Smr5ER^3AUAk;V+?qM=y4Os1 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 z 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