Upload folder using huggingface_hub

.gitattributes

@@ -53,3 +53,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+DEMO/AdamKinzinger2_3.mp4 filter=lfs diff=lfs merge=lfs -text
+DEMO/BobCorker_0.mp4 filter=lfs diff=lfs merge=lfs -text
+DEMO/kohli.mp4 filter=lfs diff=lfs merge=lfs -text
+upsampler/data/390.mp4 filter=lfs diff=lfs merge=lfs -text
+upsampler/data/684.mp4 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+checkpoints/mix-train.pth.tar
+results_hq.mp4

DEMO/AdamKinzinger2_3.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36d57156a133df0384ac8fb0e68ec26f46f4f11e35dde6f51feee1b549fd2430
+size 2357112

DEMO/BobCorker_0.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba7cda063d4b56b57da8af68412a705f27da2a66d81e572edb673400cbb6a4fd
+size 7693563

DEMO/kohli.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d53528539cdc2332468ebd10234d7e6831be176fe7e93505f6beec2420e4c22e
+size 1678730

README.md

@@ -0,0 +1,77 @@
+# Adaptive Super Resolution For One-Shot Talking-Head Generation
+The repository for ICASSP2024 Adaptive Super Resolution For One-Shot Talking-Head Generation (AdaSR TalkingHead)
+
+## Abstract
+The one-shot talking-head generation learns to synthesize a talking-head video with one source portrait image under the driving of same or different identity video. Usually these methods require plane-based pixel transformations via Jacobin matrices or facial image warps for novel poses generation. The constraints of using a single image source and pixel displacements often compromise the clarity of the synthesized images. Some methods try to improve the quality of synthesized videos by introducing additional super-resolution modules, but this will undoubtedly increase computational consumption and destroy the original data distribution. In this work, we propose an adaptive high-quality talking-head video generation method, which synthesizes high-resolution video without additional pre-trained modules. Specifically, inspired by existing super-resolution methods, we down-sample the one-shot source image, and then adaptively reconstruct high-frequency details via an encoder-decoder module, resulting in enhanced video clarity. Our method consistently improves the quality of generated videos through a straightforward yet effective strategy, substantiated by quantitative and qualitative evaluations. The code and demo video are available on: https://github.com/Songluchuan/AdaSR-TalkingHead/
+
+## Updates
+
+- [03/2024] Inference code and pretrained model are released.
+- [03/2024] Arxiv Link: https://arxiv.org/abs/2403.15944.
+- [COMING] Super-resolution model (based on StyleGANEX and ESRGAN).
+- [COMING] Train code and processed datasets.
+
+
+## Installation
+
+**Clone this repo:**
+```bash
+git clone git@github.com:Songluchuan/AdaSR-TalkingHead.git
+cd AdaSR-TalkingHead
+```
+**Dependencies:**
+
+We have tested on:
+- CUDA 11.3-11.6
+- PyTorch 1.10.1
+- Matplotlib 3.4.3; Matplotlib 3.4.2; opencv-python 4.7.0; scikit-learn 1.0; tqdm 4.62.3
+
+## Inference Code 
+
+
+1. Download the pretrained model on google drive: https://drive.google.com/file/d/1g58uuAyZFdny9_twvbv0AHxB9-03koko/view?usp=sharing (it is trained on the HDTF dataset), and put it under checkpoints/<br>
+
+
+2. The demo video and reference image are under ```DEMO/```
+
+   
+3. The inference code is in the ```run_demo.sh```, please run it with 
+
+```
+bash run_demo.sh
+```
+
+4. You can set different demo image and driven video in the ```run_demo.sh```
+```
+--source_image DEMO/demo_img_3.jpg
+```
+ and 
+```
+--driving_video DEMO/demo_video_1.mp4
+```
+
+
+## Video
+<div align="center">
+  <a href="https://www.youtube.com/watch?v=B_-3F51QmKE" target="_blank">
+    <img src="media/Teaser_video.png" alt="AdaSR Talking-Head" width="1120" style="height: auto;" />
+  </a>
+</div>
+
+
+
+## Citation
+
+```bibtex
+@inproceedings{song2024adaptive,
+  title={Adaptive Super Resolution for One-Shot Talking Head Generation},
+  author={Song, Luchuan and Liu, Pinxin and Yin, Guojun and Xu, Chenliang},
+  year={2024},
+  organization={IEEE International Conference on Acoustics, Speech, and Signal Processing}
+}
+```
+
+## Acknowledgments
+
+The code is mainly developed based on [styleGANEX](https://github.com/williamyang1991/StyleGANEX), [ESRGAN](https://github.com/xinntao/ESRGAN) and [unofficial face2vid](https://github.com/zhanglonghao1992/One-Shot_Free-View_Neural_Talking_Head_Synthesis). Thanks to the authors contribution.
+

animate.py

@@ -0,0 +1,34 @@
+import os
+from tqdm import tqdm
+
+import torch
+from torch.utils.data import DataLoader
+
+from logger import Logger, Visualizer
+import imageio
+from scipy.spatial import ConvexHull
+import numpy as np
+
+from sync_batchnorm import DataParallelWithCallback
+
+def normalize_kp(kp_source, kp_driving, kp_driving_initial, adapt_movement_scale=False,
+                 use_relative_movement=False, use_relative_jacobian=False):
+    if adapt_movement_scale:
+        source_area = ConvexHull(kp_source['value'][0].data.cpu().numpy()).volume
+        driving_area = ConvexHull(kp_driving_initial['value'][0].data.cpu().numpy()).volume
+        adapt_movement_scale = np.sqrt(source_area) / np.sqrt(driving_area)
+    else:
+        adapt_movement_scale = 1
+
+    kp_new = {k: v for k, v in kp_driving.items()}
+
+    if use_relative_movement:
+        kp_value_diff = (kp_driving['value'] - kp_driving_initial['value'])
+        kp_value_diff *= adapt_movement_scale
+        kp_new['value'] = kp_value_diff + kp_source['value']
+
+        if use_relative_jacobian:
+            jacobian_diff = torch.matmul(kp_driving['jacobian'], torch.inverse(kp_driving_initial['jacobian']))
+            kp_new['jacobian'] = torch.matmul(jacobian_diff, kp_source['jacobian'])
+
+    return kp_new

augmentation.py

@@ -0,0 +1,345 @@
+"""
+Code from https://github.com/hassony2/torch_videovision
+"""
+
+import numbers
+
+import random
+import numpy as np
+import PIL
+
+from skimage.transform import resize, rotate
+from skimage.util import pad
+import torchvision
+
+import warnings
+
+from skimage import img_as_ubyte, img_as_float
+
+
+def crop_clip(clip, min_h, min_w, h, w):
+    if isinstance(clip[0], np.ndarray):
+        cropped = [img[min_h:min_h + h, min_w:min_w + w, :] for img in clip]
+
+    elif isinstance(clip[0], PIL.Image.Image):
+        cropped = [
+            img.crop((min_w, min_h, min_w + w, min_h + h)) for img in clip
+            ]
+    else:
+        raise TypeError('Expected numpy.ndarray or PIL.Image' +
+                        'but got list of {0}'.format(type(clip[0])))
+    return cropped
+
+
+def pad_clip(clip, h, w):
+    im_h, im_w = clip[0].shape[:2]
+    pad_h = (0, 0) if h < im_h else ((h - im_h) // 2, (h - im_h + 1) // 2)
+    pad_w = (0, 0) if w < im_w else ((w - im_w) // 2, (w - im_w + 1) // 2)
+
+    return pad(clip, ((0, 0), pad_h, pad_w, (0, 0)), mode='edge')
+
+
+def resize_clip(clip, size, interpolation='bilinear'):
+    if isinstance(clip[0], np.ndarray):
+        if isinstance(size, numbers.Number):
+            im_h, im_w, im_c = clip[0].shape
+            # Min spatial dim already matches minimal size
+            if (im_w <= im_h and im_w == size) or (im_h <= im_w
+                                                   and im_h == size):
+                return clip
+            new_h, new_w = get_resize_sizes(im_h, im_w, size)
+            size = (new_w, new_h)
+        else:
+            size = size[1], size[0]
+
+        scaled = [
+            resize(img, size, order=1 if interpolation == 'bilinear' else 0, preserve_range=True,
+                   mode='constant', anti_aliasing=True) for img in clip
+            ]
+    elif isinstance(clip[0], PIL.Image.Image):
+        if isinstance(size, numbers.Number):
+            im_w, im_h = clip[0].size
+            # Min spatial dim already matches minimal size
+            if (im_w <= im_h and im_w == size) or (im_h <= im_w
+                                                   and im_h == size):
+                return clip
+            new_h, new_w = get_resize_sizes(im_h, im_w, size)
+            size = (new_w, new_h)
+        else:
+            size = size[1], size[0]
+        if interpolation == 'bilinear':
+            pil_inter = PIL.Image.NEAREST
+        else:
+            pil_inter = PIL.Image.BILINEAR
+        scaled = [img.resize(size, pil_inter) for img in clip]
+    else:
+        raise TypeError('Expected numpy.ndarray or PIL.Image' +
+                        'but got list of {0}'.format(type(clip[0])))
+    return scaled
+
+
+def get_resize_sizes(im_h, im_w, size):
+    if im_w < im_h:
+        ow = size
+        oh = int(size * im_h / im_w)
+    else:
+        oh = size
+        ow = int(size * im_w / im_h)
+    return oh, ow
+
+
+class RandomFlip(object):
+    def __init__(self, time_flip=False, horizontal_flip=False):
+        self.time_flip = time_flip
+        self.horizontal_flip = horizontal_flip
+
+    def __call__(self, clip):
+        if random.random() < 0.5 and self.time_flip:
+            return clip[::-1]
+        if random.random() < 0.5 and self.horizontal_flip:
+            return [np.fliplr(img) for img in clip]
+
+        return clip
+
+
+class RandomResize(object):
+    """Resizes a list of (H x W x C) numpy.ndarray to the final size
+    The larger the original image is, the more times it takes to
+    interpolate
+    Args:
+    interpolation (str): Can be one of 'nearest', 'bilinear'
+    defaults to nearest
+    size (tuple): (widht, height)
+    """
+
+    def __init__(self, ratio=(3. / 4., 4. / 3.), interpolation='nearest'):
+        self.ratio = ratio
+        self.interpolation = interpolation
+
+    def __call__(self, clip):
+        scaling_factor = random.uniform(self.ratio[0], self.ratio[1])
+
+        if isinstance(clip[0], np.ndarray):
+            im_h, im_w, im_c = clip[0].shape
+        elif isinstance(clip[0], PIL.Image.Image):
+            im_w, im_h = clip[0].size
+
+        new_w = int(im_w * scaling_factor)
+        new_h = int(im_h * scaling_factor)
+        new_size = (new_w, new_h)
+        resized = resize_clip(
+            clip, new_size, interpolation=self.interpolation)
+
+        return resized
+
+
+class RandomCrop(object):
+    """Extract random crop at the same location for a list of videos
+    Args:
+    size (sequence or int): Desired output size for the
+    crop in format (h, w)
+    """
+
+    def __init__(self, size):
+        if isinstance(size, numbers.Number):
+            size = (size, size)
+
+        self.size = size
+
+    def __call__(self, clip):
+        """
+        Args:
+        img (PIL.Image or numpy.ndarray): List of videos to be cropped
+        in format (h, w, c) in numpy.ndarray
+        Returns:
+        PIL.Image or numpy.ndarray: Cropped list of videos
+        """
+        h, w = self.size
+        if isinstance(clip[0], np.ndarray):
+            im_h, im_w, im_c = clip[0].shape
+        elif isinstance(clip[0], PIL.Image.Image):
+            im_w, im_h = clip[0].size
+        else:
+            raise TypeError('Expected numpy.ndarray or PIL.Image' +
+                            'but got list of {0}'.format(type(clip[0])))
+
+        clip = pad_clip(clip, h, w)
+        im_h, im_w = clip.shape[1:3]
+        x1 = 0 if h == im_h else random.randint(0, im_w - w)
+        y1 = 0 if w == im_w else random.randint(0, im_h - h)
+        cropped = crop_clip(clip, y1, x1, h, w)
+
+        return cropped
+
+
+class RandomRotation(object):
+    """Rotate entire clip randomly by a random angle within
+    given bounds
+    Args:
+    degrees (sequence or int): Range of degrees to select from
+    If degrees is a number instead of sequence like (min, max),
+    the range of degrees, will be (-degrees, +degrees).
+    """
+
+    def __init__(self, degrees):
+        if isinstance(degrees, numbers.Number):
+            if degrees < 0:
+                raise ValueError('If degrees is a single number,'
+                                 'must be positive')
+            degrees = (-degrees, degrees)
+        else:
+            if len(degrees) != 2:
+                raise ValueError('If degrees is a sequence,'
+                                 'it must be of len 2.')
+
+        self.degrees = degrees
+
+    def __call__(self, clip):
+        """
+        Args:
+        img (PIL.Image or numpy.ndarray): List of videos to be cropped
+        in format (h, w, c) in numpy.ndarray
+        Returns:
+        PIL.Image or numpy.ndarray: Cropped list of videos
+        """
+        angle = random.uniform(self.degrees[0], self.degrees[1])
+        if isinstance(clip[0], np.ndarray):
+            rotated = [rotate(image=img, angle=angle, preserve_range=True) for img in clip]
+        elif isinstance(clip[0], PIL.Image.Image):
+            rotated = [img.rotate(angle) for img in clip]
+        else:
+            raise TypeError('Expected numpy.ndarray or PIL.Image' +
+                            'but got list of {0}'.format(type(clip[0])))
+
+        return rotated
+
+
+class ColorJitter(object):
+    """Randomly change the brightness, contrast and saturation and hue of the clip
+    Args:
+    brightness (float): How much to jitter brightness. brightness_factor
+    is chosen uniformly from [max(0, 1 - brightness), 1 + brightness].
+    contrast (float): How much to jitter contrast. contrast_factor
+    is chosen uniformly from [max(0, 1 - contrast), 1 + contrast].
+    saturation (float): How much to jitter saturation. saturation_factor
+    is chosen uniformly from [max(0, 1 - saturation), 1 + saturation].
+    hue(float): How much to jitter hue. hue_factor is chosen uniformly from
+    [-hue, hue]. Should be >=0 and <= 0.5.
+    """
+
+    def __init__(self, brightness=0, contrast=0, saturation=0, hue=0):
+        self.brightness = brightness
+        self.contrast = contrast
+        self.saturation = saturation
+        self.hue = hue
+
+    def get_params(self, brightness, contrast, saturation, hue):
+        if brightness > 0:
+            brightness_factor = random.uniform(
+                max(0, 1 - brightness), 1 + brightness)
+        else:
+            brightness_factor = None
+
+        if contrast > 0:
+            contrast_factor = random.uniform(
+                max(0, 1 - contrast), 1 + contrast)
+        else:
+            contrast_factor = None
+
+        if saturation > 0:
+            saturation_factor = random.uniform(
+                max(0, 1 - saturation), 1 + saturation)
+        else:
+            saturation_factor = None
+
+        if hue > 0:
+            hue_factor = random.uniform(-hue, hue)
+        else:
+            hue_factor = None
+        return brightness_factor, contrast_factor, saturation_factor, hue_factor
+
+    def __call__(self, clip):
+        """
+        Args:
+        clip (list): list of PIL.Image
+        Returns:
+        list PIL.Image : list of transformed PIL.Image
+        """
+        if isinstance(clip[0], np.ndarray):
+            brightness, contrast, saturation, hue = self.get_params(
+                self.brightness, self.contrast, self.saturation, self.hue)
+
+            # Create img transform function sequence
+            img_transforms = []
+            if brightness is not None:
+                img_transforms.append(lambda img: torchvision.transforms.functional.adjust_brightness(img, brightness))
+            if saturation is not None:
+                img_transforms.append(lambda img: torchvision.transforms.functional.adjust_saturation(img, saturation))
+            if hue is not None:
+                img_transforms.append(lambda img: torchvision.transforms.functional.adjust_hue(img, hue))
+            if contrast is not None:
+                img_transforms.append(lambda img: torchvision.transforms.functional.adjust_contrast(img, contrast))
+            random.shuffle(img_transforms)
+            img_transforms = [img_as_ubyte, torchvision.transforms.ToPILImage()] + img_transforms + [np.array,
+                                                                                                     img_as_float]
+
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                jittered_clip = []
+                for img in clip:
+                    jittered_img = img
+                    for func in img_transforms:
+                        jittered_img = func(jittered_img)
+                    jittered_clip.append(jittered_img.astype('float32'))
+        elif isinstance(clip[0], PIL.Image.Image):
+            brightness, contrast, saturation, hue = self.get_params(
+                self.brightness, self.contrast, self.saturation, self.hue)
+
+            # Create img transform function sequence
+            img_transforms = []
+            if brightness is not None:
+                img_transforms.append(lambda img: torchvision.transforms.functional.adjust_brightness(img, brightness))
+            if saturation is not None:
+                img_transforms.append(lambda img: torchvision.transforms.functional.adjust_saturation(img, saturation))
+            if hue is not None:
+                img_transforms.append(lambda img: torchvision.transforms.functional.adjust_hue(img, hue))
+            if contrast is not None:
+                img_transforms.append(lambda img: torchvision.transforms.functional.adjust_contrast(img, contrast))
+            random.shuffle(img_transforms)
+
+            # Apply to all videos
+            jittered_clip = []
+            for img in clip:
+                for func in img_transforms:
+                    jittered_img = func(img)
+                jittered_clip.append(jittered_img)
+
+        else:
+            raise TypeError('Expected numpy.ndarray or PIL.Image' +
+                            'but got list of {0}'.format(type(clip[0])))
+        return jittered_clip
+
+
+class AllAugmentationTransform:
+    def __init__(self, resize_param=None, rotation_param=None, flip_param=None, crop_param=None, jitter_param=None):
+        self.transforms = []
+
+        if flip_param is not None:
+            self.transforms.append(RandomFlip(**flip_param))
+
+        if rotation_param is not None:
+            self.transforms.append(RandomRotation(**rotation_param))
+
+        if resize_param is not None:
+            self.transforms.append(RandomResize(**resize_param))
+
+        if crop_param is not None:
+            self.transforms.append(RandomCrop(**crop_param))
+
+        if jitter_param is not None:
+            self.transforms.append(ColorJitter(**jitter_param))
+
+    def __call__(self, clip):
+        for t in self.transforms:
+            clip = t(clip)
+        return clip

config/mix-resolution.yml

@@ -0,0 +1,89 @@
+dataset_params:
+  root_dir: ../../../train/cropped_clips_512_vid/
+  frame_shape: [512, 512, 3]
+  id_sampling: True
+  pairs_list: None
+  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:
+  common_params:
+    num_kp: 15 
+    image_channel: 3                    
+    feature_channel: 32
+    estimate_jacobian: False
+  kp_detector_params:
+     temperature: 0.1
+     block_expansion: 32            
+     max_features: 1024
+     scale_factor: 0.25
+     num_blocks: 5
+     reshape_channel: 16384  # 16384 = 1024 * 16
+     reshape_depth: 16
+  he_estimator_params:
+     block_expansion: 64            
+     max_features: 2048
+     num_bins: 66
+  generator_params:
+    block_expansion: 64
+    max_features: 512
+    num_down_blocks: 2
+    reshape_channel: 32
+    reshape_depth: 16         # 512 = 32 * 16
+    num_resblocks: 6
+    estimate_occlusion_map: True
+    dense_motion_params:
+      block_expansion: 32
+      max_features: 1024
+      num_blocks: 5
+      # reshape_channel: 32
+      reshape_depth: 16
+      compress: 4
+  discriminator_params:
+    scales: [1]
+    block_expansion: 32                 
+    max_features: 512
+    num_blocks: 4
+    sn: True
+
+train_params:
+  num_epochs: 200
+  num_repeats: 5
+  num_worker: 8
+  epoch_milestones: [16,]
+  lr_generator: 2.0e-4
+  lr_discriminator: 2.0e-4
+  lr_kp_detector: 2.0e-4
+  lr_he_estimator: 2.0e-4
+  gan_mode: 'hinge'    # hinge or ls
+  batch_size: 4
+  scales: [1, 0.5, 0.25, 0.125]
+  checkpoint_freq: 1
+  hopenet_snapshot: './checkpoints/hopenet_robust_alpha1.pkl'
+  transform_params:
+    sigma_affine: 0.05
+    sigma_tps: 0.005
+    points_tps: 5
+  loss_weights:
+    generator_gan: 1                  
+    discriminator_gan: 1
+    feature_matching: [10, 10, 10, 10]
+    perceptual: [10, 10, 10, 10, 10]
+    equivariance_value: 10
+    equivariance_jacobian: 0
+    keypoint: 10
+    headpose: 20
+    expression: 5
+
+visualizer_params:
+  kp_size: 5
+  draw_border: True
+  colormap: 'gist_rainbow'

crop_portrait.py

@@ -0,0 +1,145 @@
+# """
+# Crop upper boddy in every video frame, square bounding box is averaged among all frames and fixed.
+# """
+
+# import os
+# import cv2
+# import argparse
+# from tqdm import tqdm
+# import face_recognition
+# import torch
+# import util
+# import numpy as np
+# import face_detection
+
+# def crop_per_image(data_dir, dest_size, crop_level):
+#     fa = face_detection.FaceAlignment(face_detection.LandmarksType._2D, flip_input=False, device='cuda')
+
+#     image_list = util.get_file_list(os.path.join(data_dir, 'full'))
+#     batch_size = 5
+#     frames = []
+
+#     for i in tqdm(range(len(image_list))):
+#         frame = face_recognition.load_image_file(image_list[i])
+#         frames.append(frame)
+
+#     H, W, _ = frames[0].shape
+
+#     batches = [frames[i:i + batch_size] for i in range(0, len(frames), batch_size)]
+
+#     for idx in tqdm(range(len(batches))):
+#         fb = batches[idx]
+#         preds = fa.get_detections_for_batch(np.asarray(fb))
+
+#         for j, f in enumerate(preds):
+#             if f is None:
+#                 print('no face in image {}'.format(idx * batch_size + j))
+#             else:
+#                 left, top, right, bottom = f
+
+            
+#             height = bottom - top
+#             width = right - left
+#             crop_size = int(height * crop_level)
+
+#             horizontal_delta = (crop_size - width) // 2
+#             vertical_delta = (crop_size - height) // 2
+
+#             left = max(left - horizontal_delta, 0)
+#             right = min(right + horizontal_delta, W)
+#             top = max(top - int(vertical_delta * 0.5), 0)
+#             bottom = min(bottom + int(vertical_delta * 1.5), H)
+            
+#             crop_f = cv2.imread(image_list[idx * batch_size + j])
+#             crop_f = crop_f[top:bottom, left:right]
+#             crop_f = cv2.resize(crop_f, (dest_size, dest_size), interpolation=cv2.INTER_AREA)
+#             cv2.imwrite(os.path.join(data_dir, 'crop', os.path.basename(image_list[idx * batch_size + j])), crop_f)
+
+
+# if __name__ == '__main__':
+#     parser = argparse.ArgumentParser(description='Process some integers.')
+#     parser.add_argument('--data_dir', type=str, default=None)
+#     parser.add_argument('--dest_size', type=int, default=256)
+#     parser.add_argument('--crop_level', type=float, default=1.0, help='Adjust crop image size.')
+#     parser.add_argument('--vertical_adjust', type=float, default=0.3, help='Adjust vertical location of portrait in image.')
+#     args = parser.parse_args()
+#     util.create_dir(os.path.join(args.data_dir,'crop'))
+#     util.create_dir(os.path.join(args.data_dir, 'crop_region'))
+#     crop_per_image(args.data_dir, dest_size=args.dest_size, crop_level=args.crop_level)
+
+
+import os
+import cv2
+import argparse
+from tqdm import tqdm
+import face_recognition
+import numpy as np
+import face_detection
+import util
+
+def crop_per_frame_and_make_video(data_dir, dest_size, crop_level, video_out_path, fps=30):
+    # Initialize face alignment
+    fa = face_detection.FaceAlignment(face_detection.LandmarksType._2D, flip_input=False, device='cuda')
+
+    # Get list of images (frames)
+    image_list = util.get_file_list(os.path.join(data_dir, 'full'))
+    batch_size = 5
+    frames = []
+
+    # Load frames
+    for image_path in tqdm(image_list, desc='Loading images'):
+        frame = cv2.imread(image_path)
+        frames.append(frame)
+
+    H, W, _ = frames[0].shape
+    batches = [frames[i:i + batch_size] for i in range(0, len(frames), batch_size)]
+    cropped_frames = []
+
+    for idx, fb in enumerate(tqdm(batches, desc='Processing batches')):
+        preds = fa.get_detections_for_batch(np.asarray(fb))
+
+        for j, f in enumerate(preds):
+            if f is None:
+                print(f'No face in image {idx * batch_size + j}')
+                continue  # Skip frames with no detected face
+            
+            left, top, right, bottom = f
+            height = bottom - top
+            width = right - left
+            crop_size = int(height * crop_level)
+
+            horizontal_delta = (crop_size - width) // 2
+            vertical_delta = (crop_size - height) // 2
+
+            left = max(left - horizontal_delta, 0)
+            right = min(right + horizontal_delta, W)
+            top = max(top - int(vertical_delta * 0.5), 0)
+            bottom = min(bottom + int(vertical_delta * 1.5), H)
+            
+            crop_f = fb[j][top:bottom, left:right]
+            crop_f = cv2.resize(crop_f, (dest_size, dest_size), interpolation=cv2.INTER_AREA)
+            cropped_frames.append(crop_f)
+
+    # Define the codec and create VideoWriter object
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(video_out_path, fourcc, fps, (dest_size, dest_size))
+
+    # Write frames to video
+    for frame in tqdm(cropped_frames, desc='Compiling video'):
+        out.write(frame)
+
+    # Release everything when job is finished
+    out.release()
+    cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Crop video frames and compile into a video.')
+    parser.add_argument('--data_dir', type=str, required=True, help='Directory with video frames to process.')
+    parser.add_argument('--dest_size', type=int, default=256, help='Destination size of cropped images.')
+    parser.add_argument('--crop_level', type=float, default=1.0, help='Adjust crop size relative to face detection.')
+    parser.add_argument('--video_out_path', type=str, required=True, help='Output path for the resulting video.')
+    parser.add_argument('--fps', type=int, default=30, help='Frames per second for the output video.')
+    args = parser.parse_args()
+
+    util.create_dir(os.path.join(args.data_dir, 'crop'))
+    crop_per_frame_and_make_video(args.data_dir, dest_size=args.dest_size, crop_level=args.crop_level, video_out_path=args.video_out_path, fps=args.fps)

demo.py

@@ -0,0 +1,313 @@
+# python demo.py --config config/vox-256-spade.yml --checkpoint checkpoints/00000189-checkpoint.pth.tar --source_image  /home/cxu-serve/p61/rzhu14/lsong11_workspace/Thin-Plate-Spline-Motion-Model/assets/test.png --driving_video  /home/cxu-serve/p61/rzhu14/lsong11_workspace/Thin-Plate-Spline-Motion-Model/assets/driving.mp4 --relative --adapt_scale --find_best_frame --gen spade
+import matplotlib
+matplotlib.use('Agg')
+import os, sys
+import yaml
+from argparse import ArgumentParser
+from tqdm import tqdm
+
+import imageio
+import numpy as np
+from skimage.transform import resize
+from skimage import img_as_ubyte
+import torch
+import torch.nn.functional as F
+from sync_batchnorm import DataParallelWithCallback
+
+from modules.generator import OcclusionAwareGenerator, OcclusionAwareSPADEGenerator
+from modules.keypoint_detector import KPDetector, HEEstimator
+from animate import normalize_kp
+from scipy.spatial import ConvexHull
+import warnings
+warnings.filterwarnings("ignore")
+
+
+if sys.version_info[0] < 3:
+    raise Exception("You must use Python 3 or higher. Recommended version is Python 3.7")
+
+def load_checkpoints(config_path, checkpoint_path, gen, cpu=False):
+
+    with open(config_path) as f:
+        config = yaml.load(f)
+
+    if gen == 'original':
+        generator = OcclusionAwareGenerator(**config['model_params']['generator_params'],
+                                            **config['model_params']['common_params'])
+    elif gen == 'spade':
+        generator = OcclusionAwareSPADEGenerator(**config['model_params']['generator_params'],
+                                                 **config['model_params']['common_params'])
+
+    if not cpu:
+        generator.cuda()
+
+    kp_detector = KPDetector(**config['model_params']['kp_detector_params'],
+                             **config['model_params']['common_params'])
+    if not cpu:
+        kp_detector.cuda()
+
+    he_estimator = HEEstimator(**config['model_params']['he_estimator_params'],
+                               **config['model_params']['common_params'])
+    if not cpu:
+        he_estimator.cuda()
+    
+    if cpu:
+        checkpoint = torch.load(checkpoint_path, map_location=torch.device('cpu'))
+    else:
+        checkpoint = torch.load(checkpoint_path)
+ 
+    generator.load_state_dict(checkpoint['generator'])
+    kp_detector.load_state_dict(checkpoint['kp_detector'])
+    he_estimator.load_state_dict(checkpoint['he_estimator'])
+    
+    if not cpu:
+        generator = DataParallelWithCallback(generator)
+        kp_detector = DataParallelWithCallback(kp_detector)
+        he_estimator = DataParallelWithCallback(he_estimator)
+
+    generator.eval()
+    kp_detector.eval()
+    he_estimator.eval()
+    
+    return generator, kp_detector, he_estimator
+
+
+def headpose_pred_to_degree(pred):
+    device = pred.device
+    idx_tensor = [idx for idx in range(66)]
+    idx_tensor = torch.FloatTensor(idx_tensor).to(device)
+    pred = F.softmax(pred)
+    degree = torch.sum(pred*idx_tensor, axis=1) * 3 - 99
+
+    return degree
+
+'''
+# beta version
+def get_rotation_matrix(yaw, pitch, roll):
+    yaw = yaw / 180 * 3.14
+    pitch = pitch / 180 * 3.14
+    roll = roll / 180 * 3.14
+
+    roll = roll.unsqueeze(1)
+    pitch = pitch.unsqueeze(1)
+    yaw = yaw.unsqueeze(1)
+
+    roll_mat = torch.cat([torch.ones_like(roll), torch.zeros_like(roll), torch.zeros_like(roll), 
+                          torch.zeros_like(roll), torch.cos(roll), -torch.sin(roll),
+                          torch.zeros_like(roll), torch.sin(roll), torch.cos(roll)], dim=1)
+    roll_mat = roll_mat.view(roll_mat.shape[0], 3, 3)
+
+    pitch_mat = torch.cat([torch.cos(pitch), torch.zeros_like(pitch), torch.sin(pitch), 
+                           torch.zeros_like(pitch), torch.ones_like(pitch), torch.zeros_like(pitch),
+                           -torch.sin(pitch), torch.zeros_like(pitch), torch.cos(pitch)], dim=1)
+    pitch_mat = pitch_mat.view(pitch_mat.shape[0], 3, 3)
+
+    yaw_mat = torch.cat([torch.cos(yaw), -torch.sin(yaw), torch.zeros_like(yaw),  
+                         torch.sin(yaw), torch.cos(yaw), torch.zeros_like(yaw),
+                         torch.zeros_like(yaw), torch.zeros_like(yaw), torch.ones_like(yaw)], dim=1)
+    yaw_mat = yaw_mat.view(yaw_mat.shape[0], 3, 3)
+
+    rot_mat = torch.einsum('bij,bjk,bkm->bim', roll_mat, pitch_mat, yaw_mat)
+
+    return rot_mat
+
+'''
+def get_rotation_matrix(yaw, pitch, roll):
+    yaw = yaw / 180 * 3.14
+    pitch = pitch / 180 * 3.14
+    roll = roll / 180 * 3.14
+
+    roll = roll.unsqueeze(1)
+    pitch = pitch.unsqueeze(1)
+    yaw = yaw.unsqueeze(1)
+
+    pitch_mat = torch.cat([torch.ones_like(pitch), torch.zeros_like(pitch), torch.zeros_like(pitch), 
+                          torch.zeros_like(pitch), torch.cos(pitch), -torch.sin(pitch),
+                          torch.zeros_like(pitch), torch.sin(pitch), torch.cos(pitch)], dim=1)
+    pitch_mat = pitch_mat.view(pitch_mat.shape[0], 3, 3)
+
+    yaw_mat = torch.cat([torch.cos(yaw), torch.zeros_like(yaw), torch.sin(yaw), 
+                           torch.zeros_like(yaw), torch.ones_like(yaw), torch.zeros_like(yaw),
+                           -torch.sin(yaw), torch.zeros_like(yaw), torch.cos(yaw)], dim=1)
+    yaw_mat = yaw_mat.view(yaw_mat.shape[0], 3, 3)
+
+    roll_mat = torch.cat([torch.cos(roll), -torch.sin(roll), torch.zeros_like(roll),  
+                         torch.sin(roll), torch.cos(roll), torch.zeros_like(roll),
+                         torch.zeros_like(roll), torch.zeros_like(roll), torch.ones_like(roll)], dim=1)
+    roll_mat = roll_mat.view(roll_mat.shape[0], 3, 3)
+
+    rot_mat = torch.einsum('bij,bjk,bkm->bim', pitch_mat, yaw_mat, roll_mat)
+
+    return rot_mat
+
+def keypoint_transformation(kp_canonical, he, estimate_jacobian=True, free_view=False, yaw=0, pitch=0, roll=0):
+    kp = kp_canonical['value']
+    if not free_view:
+        yaw, pitch, roll = he['yaw'], he['pitch'], he['roll']
+        yaw = headpose_pred_to_degree(yaw)
+        pitch = headpose_pred_to_degree(pitch)
+        roll = headpose_pred_to_degree(roll)
+    else:
+        if yaw is not None:
+            yaw = torch.tensor([yaw]).cuda()
+        else:
+            yaw = he['yaw']
+            yaw = headpose_pred_to_degree(yaw)
+        if pitch is not None:
+            pitch = torch.tensor([pitch]).cuda()
+        else:
+            pitch = he['pitch']
+            pitch = headpose_pred_to_degree(pitch)
+        if roll is not None:
+            roll = torch.tensor([roll]).cuda()
+        else:
+            roll = he['roll']
+            roll = headpose_pred_to_degree(roll)
+
+    t, exp = he['t'], he['exp']
+
+    rot_mat = get_rotation_matrix(yaw, pitch, roll)
+    
+    # keypoint rotation
+    kp_rotated = torch.einsum('bmp,bkp->bkm', rot_mat, kp)
+
+    # keypoint translation
+    t = t.unsqueeze_(1).repeat(1, kp.shape[1], 1)
+    kp_t = kp_rotated + t
+
+    # add expression deviation 
+    exp = exp.view(exp.shape[0], -1, 3)
+    kp_transformed = kp_t + exp
+
+    if estimate_jacobian:
+        jacobian = kp_canonical['jacobian']
+        jacobian_transformed = torch.einsum('bmp,bkps->bkms', rot_mat, jacobian)
+    else:
+        jacobian_transformed = None
+
+    return {'value': kp_transformed, 'jacobian': jacobian_transformed}
+
+def make_animation(source_image, driving_video, generator, kp_detector, he_estimator, relative=True, adapt_movement_scale=True, estimate_jacobian=True, cpu=False, free_view=False, yaw=0, pitch=0, roll=0):
+    with torch.no_grad():
+        predictions = []
+        source = torch.tensor(source_image[np.newaxis].astype(np.float32)).permute(0, 3, 1, 2)
+        if not cpu:
+            source = source.cuda()
+        driving = torch.tensor(np.array(driving_video)[np.newaxis].astype(np.float32)).permute(0, 4, 1, 2, 3)
+        kp_canonical = kp_detector(source)
+        he_source = he_estimator(source)
+        he_driving_initial = he_estimator(driving[:, :, 0])
+
+        kp_source = keypoint_transformation(kp_canonical, he_source, estimate_jacobian)
+        kp_driving_initial = keypoint_transformation(kp_canonical, he_driving_initial, estimate_jacobian)
+        # kp_driving_initial = keypoint_transformation(kp_canonical, he_driving_initial, free_view=free_view, yaw=yaw, pitch=pitch, roll=roll)
+
+        for frame_idx in tqdm(range(driving.shape[2])):
+            driving_frame = driving[:, :, frame_idx]
+            if not cpu:
+                driving_frame = driving_frame.cuda()
+            he_driving = he_estimator(driving_frame)
+            kp_driving = keypoint_transformation(kp_canonical, he_driving, estimate_jacobian, free_view=free_view, yaw=yaw, pitch=pitch, roll=roll)
+
+            # np.save('all_kps/%05d.npy'%frame_idx, kp_driving['value'].cpu().detach().numpy())
+            # import pdb; pdb.set_trace()
+            kp_norm = normalize_kp(kp_source=kp_source, kp_driving=kp_driving,
+                                   kp_driving_initial=kp_driving_initial, use_relative_movement=relative,
+                                   use_relative_jacobian=estimate_jacobian, adapt_movement_scale=adapt_movement_scale)
+            out = generator(source, frame_idx, kp_source=kp_source, kp_driving=kp_norm)
+
+            predictions.append(np.transpose(out['prediction'].data.cpu().numpy(), [0, 2, 3, 1])[0])
+    return predictions
+
+def find_best_frame(source, driving, cpu=False):
+    import face_alignment
+
+    def normalize_kp(kp):
+        kp = kp - kp.mean(axis=0, keepdims=True)
+        area = ConvexHull(kp[:, :2]).volume
+        area = np.sqrt(area)
+        kp[:, :2] = kp[:, :2] / area
+        return kp
+
+    # fa = face_alignment.FaceAlignment(face_alignment.LandmarksType._2D, flip_input=True,
+    #                                   device='cpu' if cpu else 'cuda')
+
+    fa = face_alignment.FaceAlignment(face_alignment.LandmarksType.TWO_D, flip_input=True,
+                                      device='cpu' if cpu else 'cuda')
+    kp_source = fa.get_landmarks(255 * source)[0]
+    kp_source = normalize_kp(kp_source)
+    norm  = float('inf')
+    frame_num = 0
+    for i, image in tqdm(enumerate(driving)):
+        kp_driving = fa.get_landmarks(255 * image)[0]
+        kp_driving = normalize_kp(kp_driving)
+        new_norm = (np.abs(kp_source - kp_driving) ** 2).sum()
+        if new_norm < norm:
+            norm = new_norm
+            frame_num = i
+    return frame_num
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument("--config", default='config/vox-256.yaml', help="path to config")
+    parser.add_argument("--checkpoint", default='', help="path to checkpoint to restore")
+
+    parser.add_argument("--source_image", default='', help="path to source image")
+    parser.add_argument("--driving_video", default='', help="path to driving video")
+    parser.add_argument("--result_video", default='./results_hq.mp4', help="path to output")
+
+    parser.add_argument("--gen", default="spade", choices=["original", "spade"])
+ 
+    parser.add_argument("--relative", dest="relative", action="store_true", help="use relative or absolute keypoint coordinates")
+    parser.add_argument("--adapt_scale", dest="adapt_scale", action="store_true", help="adapt movement scale based on convex hull of keypoints")
+
+    parser.add_argument("--find_best_frame", dest="find_best_frame", action="store_true", 
+                        help="Generate from the frame that is the most alligned with source. (Only for faces, requires face_aligment lib)")
+
+    parser.add_argument("--best_frame", dest="best_frame", type=int, default=None,  
+                        help="Set frame to start from.")
+ 
+    parser.add_argument("--cpu", dest="cpu", action="store_true", help="cpu mode.")
+
+    parser.add_argument("--free_view", dest="free_view", action="store_true", help="control head pose")
+    parser.add_argument("--yaw", dest="yaw", type=int, default=None, help="yaw")
+    parser.add_argument("--pitch", dest="pitch", type=int, default=None, help="pitch")
+    parser.add_argument("--roll", dest="roll", type=int, default=None, help="roll")
+ 
+
+    parser.set_defaults(relative=False)
+    parser.set_defaults(adapt_scale=False)
+    parser.set_defaults(free_view=False)
+
+    opt = parser.parse_args()
+
+    source_image = imageio.imread(opt.source_image)
+    reader = imageio.get_reader(opt.driving_video)
+    fps = reader.get_meta_data()['fps']
+    driving_video = []
+    try:
+        for im in reader:
+            driving_video.append(im)
+    except RuntimeError:
+        pass
+    reader.close()
+
+    source_image = resize(source_image, (512, 512))[..., :3]
+    driving_video = [resize(frame, (512, 512))[..., :3] for frame in driving_video]
+    generator, kp_detector, he_estimator = load_checkpoints(config_path=opt.config, checkpoint_path=opt.checkpoint, gen=opt.gen, cpu=opt.cpu)
+
+    with open(opt.config) as f:
+        config = yaml.load(f)
+    estimate_jacobian = config['model_params']['common_params']['estimate_jacobian']
+    print(f'estimate jacobian: {estimate_jacobian}')
+
+    if opt.find_best_frame or opt.best_frame is not None:
+        i = opt.best_frame if opt.best_frame is not None else find_best_frame(source_image, driving_video, cpu=opt.cpu)
+        print ("Best frame: " + str(i))
+        driving_forward = driving_video[i:]
+        driving_backward = driving_video[:(i+1)][::-1]
+        predictions_forward = make_animation(source_image, driving_forward, generator, kp_detector, he_estimator, relative=opt.relative, adapt_movement_scale=opt.adapt_scale, estimate_jacobian=estimate_jacobian, cpu=opt.cpu, free_view=opt.free_view, yaw=opt.yaw, pitch=opt.pitch, roll=opt.roll)
+        predictions_backward = make_animation(source_image, driving_backward, generator, kp_detector, he_estimator, relative=opt.relative, adapt_movement_scale=opt.adapt_scale, estimate_jacobian=estimate_jacobian, cpu=opt.cpu, free_view=opt.free_view, yaw=opt.yaw, pitch=opt.pitch, roll=opt.roll)
+        predictions = predictions_backward[::-1] + predictions_forward[1:]
+    else:
+        predictions = make_animation(source_image, driving_video, generator, kp_detector, he_estimator, relative=opt.relative, adapt_movement_scale=opt.adapt_scale, estimate_jacobian=estimate_jacobian, cpu=opt.cpu, free_view=opt.free_view, yaw=opt.yaw, pitch=opt.pitch, roll=opt.roll)
+    imageio.mimsave(opt.result_video, [img_as_ubyte(frame) for frame in predictions], fps=fps)

environment.yaml

@@ -0,0 +1,106 @@
+name: mesh-video
+channels:
+  - pytorch
+  - conda-forge
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - blas=1.0=mkl
+  - bzip2=1.0.8=h7b6447c_0
+  - ca-certificates=2023.01.10=h06a4308_0
+  - certifi=2022.12.7=py38h06a4308_0
+  - cudatoolkit=11.3.1=h9edb442_10
+  - flit-core=3.8.0=py38h06a4308_0
+  - freetype=2.12.1=h4a9f257_0
+  - giflib=5.2.1=h5eee18b_3
+  - gmp=6.2.1=h295c915_3
+  - gnutls=3.6.15=he1e5248_0
+  - intel-openmp=2021.4.0=h06a4308_3561
+  - jpeg=9e=h5eee18b_1
+  - lame=3.100=h7b6447c_0
+  - lcms2=2.12=h3be6417_0
+  - lerc=3.0=h295c915_0
+  - libdeflate=1.17=h5eee18b_0
+  - libedit=3.1.20221030=h5eee18b_0
+  - libffi=3.2.1=hf484d3e_1007
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libidn2=2.3.2=h7f8727e_0
+  - libopus=1.3.1=h7b6447c_0
+  - libpng=1.6.39=h5eee18b_0
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - libtasn1=4.19.0=h5eee18b_0
+  - libtiff=4.5.0=h6a678d5_2
+  - libunistring=0.9.10=h27cfd23_0
+  - libuv=1.44.2=h5eee18b_0
+  - libvpx=1.7.0=h439df22_0
+  - libwebp=1.2.4=h11a3e52_1
+  - libwebp-base=1.2.4=h5eee18b_1
+  - lz4-c=1.9.4=h6a678d5_0
+  - mkl=2021.4.0=h06a4308_640
+  - mkl-service=2.4.0=py38h7f8727e_0
+  - mkl_fft=1.3.1=py38hd3c417c_0
+  - mkl_random=1.2.2=py38h51133e4_0
+  - ncurses=6.4=h6a678d5_0
+  - nettle=3.7.3=hbbd107a_1
+  - numpy-base=1.23.5=py38h31eccc5_0
+  - openh264=2.1.1=h4ff587b_0
+  - openssl=1.1.1t=h7f8727e_0
+  - pillow=9.4.0=py38h6a678d5_0
+  - pip=23.0.1=py38h06a4308_0
+  - python=3.8.0=h0371630_2
+  - pytorch=1.10.1=py3.8_cuda11.3_cudnn8.2.0_0
+  - pytorch-mutex=1.0=cuda
+  - readline=7.0=h7b6447c_5
+  - setuptools=65.6.3=py38h06a4308_0
+  - six=1.16.0=pyhd3eb1b0_1
+  - sqlite=3.33.0=h62c20be_0
+  - tk=8.6.12=h1ccaba5_0
+  - torchaudio=0.10.1=py38_cu113
+  - torchvision=0.11.2=py38_cu113
+  - typing_extensions=4.4.0=py38h06a4308_0
+  - wheel=0.38.4=py38h06a4308_0
+  - x264=1!157.20191217=h7b6447c_0
+  - xz=5.2.10=h5eee18b_1
+  - zlib=1.2.13=h5eee18b_0
+  - zstd=1.5.4=hc292b87_0
+  - pip:
+      - cffi==1.14.6
+      - cycler==0.10.0
+      - decorator==5.1.0
+      - face-alignment==1.3.5
+      - ffmpeg==1.4
+      - imageio==2.9.0
+      - imageio-ffmpeg==0.4.5
+      - importlib-metadata==6.0.0
+      - joblib==1.2.0
+      - kiwisolver==1.3.2
+      - llvmlite==0.39.1
+      - matplotlib==3.4.3
+      - networkx==2.6.3
+      - numba==0.56.4
+      - numpy==1.20.3
+      - nvidia-cublas-cu11==11.10.3.66
+      - nvidia-cuda-nvrtc-cu11==11.7.99
+      - nvidia-cuda-runtime-cu11==11.7.99
+      - nvidia-cudnn-cu11==8.5.0.96
+      - opencv-python==4.7.0.72
+      - pandas==1.3.3
+      - pycparser==2.20
+      - pyparsing==2.4.7
+      - python-dateutil==2.8.2
+      - pytube==12.1.3
+      - pytz==2021.1
+      - pywavelets==1.1.1
+      - pyyaml==5.4.1
+      - scikit-image==0.18.3
+      - scikit-learn==1.0
+      - scipy==1.7.1
+      - threadpoolctl==3.1.0
+      - tifffile==2023.2.28
+      - torch==1.13.1
+      - tqdm==4.62.3
+      - typing-extensions==4.5.0
+      - zipp==3.15.0
+prefix: /home/songlc/miniconda3/envs/mesh-video

frames_dataset.py

@@ -0,0 +1,280 @@
+#CUDA_VISIBLE_DEVICES=1 python run.py --config log_TH1K/finetune-th1k-spade.yml --device_ids 0 --checkpoint log_TH1K/00000001-checkpoint.pth.tar
+import os
+from skimage import io, img_as_float32
+from skimage.color import gray2rgb
+from sklearn.model_selection import train_test_split
+from imageio import mimread
+from functools import partial
+from skimage.transform import resize
+
+
+import torch
+import random
+import numpy as np
+from torch.utils.data import Dataset
+import pandas as pd
+from augmentation import AllAugmentationTransform
+import glob
+import math
+
+import pickle
+from basicsr.data.degradations import circular_lowpass_kernel, random_mixed_kernels
+from basicsr.utils import FileClient, get_root_logger, imfrombytes, img2tensor
+
+
+
+def read_video(name, frame_shape):
+    """
+    Read video which can be:
+      - an image of concatenated frames
+      - '.mp4' and'.gif'
+      - folder with videos
+    """
+    
+    if os.path.isdir(name):
+        
+        frames = sorted(os.listdir(name))
+        num_frames = len(frames)
+        video_array = np.array(
+            [img_as_float32(io.imread(os.path.join(name, frames[idx]))) for idx in range(num_frames)])
+    elif name.lower().endswith('.png') or name.lower().endswith('.jpg'):
+        image = io.imread(name)
+
+        if len(image.shape) == 2 or image.shape[2] == 1:
+            image = gray2rgb(image)
+
+        if image.shape[2] == 4:
+            image = image[..., :3]
+
+        image = img_as_float32(image)
+
+        video_array = np.moveaxis(image, 1, 0)
+
+        video_array = video_array.reshape((-1,) + frame_shape)
+        video_array = np.moveaxis(video_array, 1, 2)
+        
+    elif name.lower().endswith('.gif') or name.lower().endswith('.mp4') or name.lower().endswith('.mov'):
+        video = np.array(mimread(name))
+        if len(video.shape) == 3:
+            video = np.array([gray2rgb(frame) for frame in video])
+        if video.shape[-1] == 4:
+            video = video[..., :3]
+        video_array = img_as_float32(video)
+    else:
+        raise Exception("Unknown file extensions  %s" % name)
+
+    return video_array
+
+
+class FramesDataset(Dataset):
+    """
+    Dataset of videos, each video can be represented as:
+      - an image of concatenated frames
+      - '.mp4' or '.gif'
+      - folder with all frames
+    """
+
+    def __init__(self, root_dir, frame_shape=(256, 256, 3), id_sampling=False, is_train=True,
+                 random_seed=0, pairs_list=None, augmentation_params=None):
+        self.root_dir = root_dir
+        
+        tmp_file = open(root_dir + 'train_file_list.pickle','rb')
+        self.train_files_list = pickle.load(tmp_file)
+        
+        self.videos = os.listdir(root_dir)
+        self.frame_shape = tuple(frame_shape)
+        self.pairs_list = pairs_list
+        self.id_sampling = id_sampling
+        if os.path.exists(os.path.join(root_dir, 'train')):
+            assert os.path.exists(os.path.join(root_dir, 'test'))
+            print("Use predefined train-test split.")
+            if id_sampling:
+                # train_videos = {os.path.basename(video).split('#')[0] for video in
+                #                 os.listdir(os.path.join(root_dir, 'train'))}
+                # train_videos = list(train_videos)
+                train_videos = list(self.train_files_list.keys())
+            else:
+                train_videos = os.listdir(os.path.join(root_dir, 'train'))
+            test_videos = os.listdir(os.path.join(root_dir, 'test'))
+            self.root_dir = os.path.join(self.root_dir, 'train' if is_train else 'test')
+        else:
+            print("Use random train-test split.")
+            train_videos, test_videos = train_test_split(self.videos, random_state=random_seed, test_size=0.2)
+
+        if is_train:
+            self.videos = train_videos
+        else:
+            self.videos = test_videos
+
+        self.is_train = is_train
+
+        if self.is_train:
+            self.transform = AllAugmentationTransform(**augmentation_params)
+
+            #### for degradation ####
+            
+
+            self.kernel_range = [2 * v + 1 for v in range(1,3)]
+            self.pulse_tensor = torch.zeros(11, 11).float()
+            self.pulse_tensor[5, 5] = 1
+
+            self.resize_range = [0.15, 1.5]
+
+            # blur settings for the first degradation
+            self.blur_kernel_size = 7
+            self.kernel_list = ['iso', 'aniso', 'generalized_iso', 'generalized_aniso', 'plateau_iso', 'plateau_aniso']
+            self.kernel_prob = [0.45, 0.25, 0.12, 0.03, 0.12, 0.03]  # a list for each kernel probability
+            self.blur_sigma = [0.1, 0.5]
+            self.betag_range = [0.2, 1] # betag used in generalized Gaussian blur kernels
+            self.betap_range = [0.5, 1.2] # betap used in plateau blur kernels
+            self.sinc_prob = 0.1  # the probability for sinc filters
+
+            # blur settings for the second degradation
+            self.blur_kernel_size2 = 7
+            self.kernel_list2 = ['iso', 'aniso', 'generalized_iso', 'generalized_aniso', 'plateau_iso', 'plateau_aniso']
+            self.kernel_prob2 = [0.45, 0.25, 0.12, 0.03, 0.12, 0.03]
+            self.blur_sigma2 = [0.1, 0.5]
+            self.betag_range2 = [0.2, 1]
+            self.betap_range2 = [1, 1.2]
+            self.sinc_prob2 = 0.1
+        else:
+            self.transform = None
+
+    def __len__(self):
+        return len(self.videos)
+
+    def __getitem__(self, idx):
+        if self.is_train and self.id_sampling:
+            # name = self.videos[idx]
+            # path = np.random.choice(glob.glob(os.path.join(self.root_dir, name + '*.mp4')))
+            name = self.videos[idx]
+            choice_list = self.train_files_list[name]
+            # if len(choice_list) == 0:
+            #     name = self.videos[idx-1]
+            #     choice_list = self.train_files_list[name]
+            paths = np.random.choice(choice_list)
+        else:
+            name = self.videos[idx]
+            paths = os.path.join(self.root_dir, name)
+
+        video_name = os.path.basename(paths)
+        if self.is_train and os.path.isdir(paths):
+            frames = os.listdir(paths)
+            num_frames = len(frames)
+            frame_idx = np.sort(np.random.choice(num_frames, replace=True, size=2))
+
+
+            if self.frame_shape is not None:
+                resize_fn = partial(resize, output_shape=self.frame_shape)
+            else:
+                resize_fn = img_as_float32
+            video_array = [resize_fn(img_as_float32(io.imread(paths + '/' + '%06d.jpg'%(idx) ))) for idx in frame_idx]
+
+
+        else:
+            video_array = read_video(paths, frame_shape=self.frame_shape)
+            num_frames = len(video_array)
+            frame_idx = np.sort(np.random.choice(num_frames, replace=True, size=2)) if self.is_train else range(
+                num_frames)
+            video_array = video_array[frame_idx]
+
+        if self.transform is not None:
+            video_array = self.transform(video_array)
+
+        out = {}
+        if self.is_train:
+            source = np.array(video_array[0], dtype='float32')
+            driving = np.array(video_array[1], dtype='float32')
+            out['driving'] = driving.transpose((2, 0, 1))
+            out['source'] = source.transpose((2, 0, 1))
+
+            # if self.degradation:
+            ############ run degradation ############
+            # ---- Generate kernels (used in the first degradation) ---- #
+            kernel_size = random.choice(self.kernel_range)
+            if np.random.uniform() <  0.1:
+                # this sinc filter setting is for kernels ranging from [7, 21]
+                if kernel_size < 11:
+                    omega_c = np.random.uniform(np.pi / 3, np.pi)
+                else:
+                    omega_c = np.random.uniform(np.pi / 5, np.pi)
+                kernel = circular_lowpass_kernel(omega_c, kernel_size, pad_to=False)
+            else:
+                kernel = random_mixed_kernels(
+                    self.kernel_list,
+                    self.kernel_prob,
+                    kernel_size,
+                    self.blur_sigma,
+                    self.blur_sigma, [-math.pi, math.pi],
+                    self.betag_range,
+                    self.betap_range,
+                    noise_range=None)
+            # pad kernel
+            pad_size = (21 - kernel_size) // 2
+            kernel = np.pad(kernel, ((pad_size, pad_size), (pad_size, pad_size)))
+            
+
+            # ----- Generate kernels (used in the second degradation) ---- #
+            kernel_size = random.choice(self.kernel_range)
+            if np.random.uniform() < 0.1:
+                if kernel_size < 13:
+                    omega_c = np.random.uniform(np.pi / 3, np.pi)
+                else:
+                    omega_c = np.random.uniform(np.pi / 5, np.pi)
+                kernel2 = circular_lowpass_kernel(omega_c, kernel_size, pad_to=False)
+            else:
+                kernel2 = random_mixed_kernels(
+                    self.kernel_list2,
+                    self.kernel_prob2,
+                    kernel_size,
+                    self.blur_sigma2,
+                    self.blur_sigma2, [-math.pi, math.pi],
+                    self.betag_range2,
+                    self.betap_range2,
+                    noise_range=None)
+            # pad kernel
+            pad_size = (21 - kernel_size) // 2
+            kernel2 = np.pad(kernel2, ((pad_size, pad_size), (pad_size, pad_size)))
+            
+            # ---- the final sinc kernel ---- #
+            if np.random.uniform() < 0.8:
+                kernel_size = random.choice(self.kernel_range)
+                omega_c = np.random.uniform(np.pi / 3, np.pi)
+                sinc_kernel = circular_lowpass_kernel(omega_c, kernel_size, pad_to=11)
+                sinc_kernel = torch.FloatTensor(sinc_kernel)
+            else:
+                sinc_kernel = self.pulse_tensor
+
+            # BGR to RGB, HWC to CHW, numpy to tensor
+            # img_gt = img2tensor([img_gt], bgr2rgb=True, float32=True)[0]
+            kernel = torch.FloatTensor(kernel)
+            kernel2 = torch.FloatTensor(kernel2)
+            #########################################
+
+            out['kernel'] = kernel
+            out['kernel2']= kernel2
+            out['sinc_kernel'] = sinc_kernel
+
+        else:
+            video = np.array(video_array, dtype='float32')
+            out['video'] = video.transpose((3, 0, 1, 2))
+
+        out['name'] = video_name
+
+        return out
+
+
+class DatasetRepeater(Dataset):
+    """
+    Pass several times over the same dataset for better i/o performance
+    """
+
+    def __init__(self, dataset, num_repeats=100):
+        self.dataset = dataset
+        self.num_repeats = num_repeats
+
+    def __len__(self):
+        return self.num_repeats * self.dataset.__len__()
+
+    def __getitem__(self, idx):
+        return self.dataset[idx % self.dataset.__len__()]

logger.py

@@ -0,0 +1,194 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+import imageio
+
+import os
+from skimage.draw import circle
+
+import matplotlib.pyplot as plt
+import collections
+
+
+class Logger:
+    def __init__(self, log_dir, checkpoint_freq=100, visualizer_params=None, zfill_num=8, log_file_name='log.txt'):
+
+        self.loss_list = []
+        self.cpk_dir = log_dir
+        self.visualizations_dir = os.path.join(log_dir, 'train-vis')
+        if not os.path.exists(self.visualizations_dir):
+            os.makedirs(self.visualizations_dir)
+        self.log_file = open(os.path.join(log_dir, log_file_name), 'a')
+        self.zfill_num = zfill_num
+        self.visualizer = Visualizer(**visualizer_params)
+        self.checkpoint_freq = checkpoint_freq
+        self.epoch = 0
+        self.best_loss = float('inf')
+        self.names = None
+
+    def log_scores(self, loss_names):
+        loss_mean = np.array(self.loss_list).mean(axis=0)
+
+        loss_string = "; ".join(["%s - %.5f" % (name, value) for name, value in zip(loss_names, loss_mean)])
+        loss_string = str(self.epoch).zfill(self.zfill_num) + ") " + loss_string
+
+        print(loss_string, file=self.log_file)
+        self.loss_list = []
+        self.log_file.flush()
+
+    def visualize_rec(self, inp, out):
+        image = self.visualizer.visualize(inp['driving'], inp['source'], out)
+        imageio.imsave(os.path.join(self.visualizations_dir, "%s-rec.png" % str(self.epoch).zfill(self.zfill_num)), image)
+
+    def save_cpk(self, emergent=False):
+        cpk = {k: v.state_dict() for k, v in self.models.items()}
+        cpk['epoch'] = self.epoch
+        cpk_path = os.path.join(self.cpk_dir, '%s-checkpoint.pth.tar' % str(self.epoch + 1).zfill(self.zfill_num)) 
+        if not (os.path.exists(cpk_path) and emergent):
+            torch.save(cpk, cpk_path)
+
+    @staticmethod
+    def load_cpk(checkpoint_path, generator=None, discriminator=None, kp_detector=None, he_estimator=None,
+                 optimizer_generator=None, optimizer_discriminator=None, optimizer_kp_detector=None, optimizer_he_estimator=None):
+        checkpoint = torch.load(checkpoint_path)
+        if generator is not None:
+            generator.load_state_dict(checkpoint['generator'])
+        if kp_detector is not None:
+            kp_detector.load_state_dict(checkpoint['kp_detector'])
+        if he_estimator is not None:
+            he_estimator.load_state_dict(checkpoint['he_estimator'])
+        if discriminator is not None:
+            try:
+               discriminator.load_state_dict(checkpoint['discriminator'])
+            except:
+               print ('No discriminator in the state-dict. Dicriminator will be randomly initialized')
+        if optimizer_generator is not None:
+            optimizer_generator.load_state_dict(checkpoint['optimizer_generator'])
+        if optimizer_discriminator is not None:
+            try:
+                optimizer_discriminator.load_state_dict(checkpoint['optimizer_discriminator'])
+            except RuntimeError as e:
+                print ('No discriminator optimizer in the state-dict. Optimizer will be not initialized')
+        if optimizer_kp_detector is not None:
+            optimizer_kp_detector.load_state_dict(checkpoint['optimizer_kp_detector'])
+        if optimizer_he_estimator is not None:
+            optimizer_he_estimator.load_state_dict(checkpoint['optimizer_he_estimator'])
+
+        return checkpoint['epoch']
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if 'models' in self.__dict__:
+            self.save_cpk()
+        self.log_file.close()
+
+    def log_iter(self, losses):
+        losses = collections.OrderedDict(losses.items())
+        if self.names is None:
+            self.names = list(losses.keys())
+        self.loss_list.append(list(losses.values()))
+
+    def log_epoch(self, epoch, models, inp, out):
+        self.epoch = epoch
+        self.models = models
+        if (self.epoch + 1) % self.checkpoint_freq == 0:
+            self.save_cpk()
+        self.log_scores(self.names)
+        self.visualize_rec(inp, out)
+
+
+class Visualizer:
+    def __init__(self, kp_size=5, draw_border=False, colormap='gist_rainbow'):
+        self.kp_size = kp_size
+        self.draw_border = draw_border
+        self.colormap = plt.get_cmap(colormap)
+
+    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_kp = kp_array.shape[0]
+        for kp_ind, kp in enumerate(kp_array):
+            rr, cc = circle(kp[1], kp[0], self.kp_size, shape=image.shape[:2])
+            image[rr, cc] = np.array(self.colormap(kp_ind / num_kp))[: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 keypoints
+        source = source.data.cpu()
+        kp_source = out['kp_source']['value'][:, :, :2].data.cpu().numpy()     # 3d -> 2d
+        source = np.transpose(source, [0, 2, 3, 1])
+        images.append((source, kp_source))
+
+        # 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_kp']['value'][:, :, :2].data.cpu().numpy()   # 3d -> 2d
+            images.append((transformed, transformed_kp))
+
+        # Driving image with keypoints
+        kp_driving = out['kp_driving']['value'][:, :, :2].data.cpu().numpy()    # 3d -> 2d
+        driving = driving.data.cpu().numpy()
+        driving = np.transpose(driving, [0, 2, 3, 1])
+        images.append((driving, kp_driving))
+
+        # 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)
+        
+        ## Mask
+        if 'mask' in out:
+            for i in range(out['mask'].shape[1]):
+                mask = out['mask'][:, i:(i+1)].data.cpu().sum(2).repeat(1, 3, 1, 1)    # (n, 3, h, w)
+                # mask = F.softmax(mask.view(mask.shape[0], mask.shape[1], -1), dim=2).view(mask.shape)
+                mask = F.interpolate(mask, size=source.shape[1:3]).numpy()
+                mask = np.transpose(mask, [0, 2, 3, 1])
+
+                if i != 0:
+                    color = np.array(self.colormap((i - 1) / (out['mask'].shape[1] - 1)))[:3]
+                else:
+                    color = np.array((0, 0, 0))
+
+                color = color.reshape((1, 1, 1, 3))
+                
+                if i != 0:
+                    images.append(mask * color)
+                else:
+                    images.append(mask)
+
+        image = self.create_image_grid(*images)
+        image = (255 * image).astype(np.uint8)
+        return image

modules/dense_motion.py

@@ -0,0 +1,128 @@
+from torch import nn
+import torch.nn.functional as F
+import torch
+from modules.util import Hourglass, make_coordinate_grid, kp2gaussian
+
+from sync_batchnorm import SynchronizedBatchNorm3d as BatchNorm3d
+
+
+class DenseMotionNetwork(nn.Module):
+    """
+    Module that predicting a dense motion from sparse motion representation given by kp_source and kp_driving
+    """
+
+    def __init__(self, block_expansion, num_blocks, max_features, num_kp, feature_channel, reshape_depth, compress,
+                 estimate_occlusion_map=False):
+        super(DenseMotionNetwork, self).__init__()
+        # self.hourglass = Hourglass(block_expansion=block_expansion, in_features=(num_kp+1)*(feature_channel+1), max_features=max_features, num_blocks=num_blocks)
+        self.hourglass = Hourglass(block_expansion=block_expansion, in_features=(num_kp+1)*(compress+1), max_features=max_features, num_blocks=num_blocks)
+
+        self.mask = nn.Conv3d(self.hourglass.out_filters, num_kp + 1, kernel_size=7, padding=3)
+
+        self.compress = nn.Conv3d(feature_channel, compress, kernel_size=1)
+        self.norm = BatchNorm3d(compress, affine=True)
+
+        if estimate_occlusion_map:
+            # self.occlusion = nn.Conv2d(reshape_channel*reshape_depth, 1, kernel_size=7, padding=3)
+            self.occlusion = nn.Conv2d(self.hourglass.out_filters*reshape_depth, 1, kernel_size=7, padding=3)
+        else:
+            self.occlusion = None
+
+        self.num_kp = num_kp
+
+
+    def create_sparse_motions(self, feature, kp_driving, kp_source):
+        bs, _, d, h, w = feature.shape
+        identity_grid = make_coordinate_grid((d, h, w), type=kp_source['value'].type())
+        identity_grid = identity_grid.view(1, 1, d, h, w, 3)
+        coordinate_grid = identity_grid - kp_driving['value'].view(bs, self.num_kp, 1, 1, 1, 3)
+        
+        k = coordinate_grid.shape[1]
+        
+        # if 'jacobian' in kp_driving:
+        if 'jacobian' in kp_driving and kp_driving['jacobian'] is not None:
+            jacobian = torch.matmul(kp_source['jacobian'], torch.inverse(kp_driving['jacobian']))
+            jacobian = jacobian.unsqueeze(-3).unsqueeze(-3).unsqueeze(-3)
+            jacobian = jacobian.repeat(1, 1, d, h, w, 1, 1)
+            coordinate_grid = torch.matmul(jacobian, coordinate_grid.unsqueeze(-1))
+            coordinate_grid = coordinate_grid.squeeze(-1)
+        '''
+        if 'rot' in kp_driving:
+            rot_s = kp_source['rot']
+            rot_d = kp_driving['rot']
+            rot = torch.einsum('bij, bjk->bki', rot_s, torch.inverse(rot_d))
+            rot = rot.unsqueeze(-3).unsqueeze(-3).unsqueeze(-3).unsqueeze(-3)
+            rot = rot.repeat(1, k, d, h, w, 1, 1)
+            # print(rot.shape)
+            coordinate_grid = torch.matmul(rot, coordinate_grid.unsqueeze(-1))
+            coordinate_grid = coordinate_grid.squeeze(-1)
+            # print(coordinate_grid.shape)
+        '''
+        driving_to_source = coordinate_grid + kp_source['value'].view(bs, self.num_kp, 1, 1, 1, 3)    # (bs, num_kp, d, h, w, 3)
+
+        #adding background feature
+        identity_grid = identity_grid.repeat(bs, 1, 1, 1, 1, 1)
+        sparse_motions = torch.cat([identity_grid, driving_to_source], dim=1)
+        
+        # sparse_motions = driving_to_source
+
+        return sparse_motions
+
+    def create_deformed_feature(self, feature, sparse_motions):
+        bs, _, d, h, w = feature.shape
+        feature_repeat = feature.unsqueeze(1).unsqueeze(1).repeat(1, self.num_kp+1, 1, 1, 1, 1, 1)      # (bs, num_kp+1, 1, c, d, h, w)
+        feature_repeat = feature_repeat.view(bs * (self.num_kp+1), -1, d, h, w)                         # (bs*(num_kp+1), c, d, h, w)
+        sparse_motions = sparse_motions.view((bs * (self.num_kp+1), d, h, w, -1))                       # (bs*(num_kp+1), d, h, w, 3)
+        sparse_deformed = F.grid_sample(feature_repeat, sparse_motions)
+        sparse_deformed = sparse_deformed.view((bs, self.num_kp+1, -1, d, h, w))                        # (bs, num_kp+1, c, d, h, w)
+        return sparse_deformed
+
+    def create_heatmap_representations(self, feature, kp_driving, kp_source):
+        spatial_size = feature.shape[3:]
+        gaussian_driving = kp2gaussian(kp_driving, spatial_size=spatial_size, kp_variance=0.01)
+        gaussian_source = kp2gaussian(kp_source, spatial_size=spatial_size, kp_variance=0.01)
+        heatmap = gaussian_driving - gaussian_source
+
+        # adding background feature
+        zeros = torch.zeros(heatmap.shape[0], 1, spatial_size[0], spatial_size[1], spatial_size[2]).type(heatmap.type())
+        heatmap = torch.cat([zeros, heatmap], dim=1)
+        heatmap = heatmap.unsqueeze(2)         # (bs, num_kp+1, 1, d, h, w)
+        return heatmap
+
+    def forward(self, feature, kp_driving, kp_source):
+        bs, _, d, h, w = feature.shape
+
+        feature = self.compress(feature)
+        feature = self.norm(feature)
+        feature = F.relu(feature)
+
+        out_dict = dict()
+        sparse_motion = self.create_sparse_motions(feature, kp_driving, kp_source)
+        deformed_feature = self.create_deformed_feature(feature, sparse_motion)
+
+        heatmap = self.create_heatmap_representations(deformed_feature, kp_driving, kp_source)
+
+        input = torch.cat([heatmap, deformed_feature], dim=2)
+        input = input.view(bs, -1, d, h, w)
+
+        # input = deformed_feature.view(bs, -1, d, h, w)      # (bs, num_kp+1 * c, d, h, w)
+
+        prediction = self.hourglass(input)
+
+        mask = self.mask(prediction)
+        mask = F.softmax(mask, dim=1)
+        out_dict['mask'] = mask
+        mask = mask.unsqueeze(2)                                   # (bs, num_kp+1, 1, d, h, w)
+        sparse_motion = sparse_motion.permute(0, 1, 5, 2, 3, 4)    # (bs, num_kp+1, 3, d, h, w)
+        deformation = (sparse_motion * mask).sum(dim=1)            # (bs, 3, d, h, w)
+        deformation = deformation.permute(0, 2, 3, 4, 1)           # (bs, d, h, w, 3)
+
+        out_dict['deformation'] = deformation
+
+        if self.occlusion:
+            bs, c, d, h, w = prediction.shape
+            prediction = prediction.view(bs, -1, h, w)
+            occlusion_map = torch.sigmoid(self.occlusion(prediction))
+            out_dict['occlusion_map'] = occlusion_map
+
+        return out_dict