• first-order-model实现照片动起来（附工具代码） | 机器学习

    目录

    前言

    资源下载和安装

    安装补充 

    工具代码验证

    总结 

    前言

    看到一个很有意思的项目，其实在之前就在百度飞浆等平台上看到类似的实现效果。

    可以将照片按照视频的表情，动起来。看一下项目给出的效果。

    项目地址：first-order-model项目地址

    还是老样子，不管作者给出的种种效果，自己测试一下。

    资源下载和安装

    我们先看一下README关于项目的基本信息，可以看出除了表情驱动照片，还可以姿态迁移。

     

    模型文件提供了线上的下载地址。

    文件很大而且难下，我下好了放到我的云盘上，可以从下面云盘下载。

    链接：https://pan.baidu.com/s/1ANQjl4SBEjBZuX87KPXmnA 
    提取码：tuan

    模型文件放到根目录下新建的checkpoint文件夹下。

     

    将requirements.txt中的依赖安装一下。

    安装补充 

    在测试README中的命令的时候，如果出现一下报错。

    Traceback (most recent call last):
      File "demo.py", line 17, in <module>
        from animate import normalize_kp
      File "D:\spyder\first-order-model\animate.py", line 7, in <module>
        from frames_dataset import PairedDataset
      File "D:\spyder\first-order-model\frames_dataset.py", line 10, in <module>
        from augmentation import AllAugmentationTransform
      File "D:\spyder\first-order-model\augmentation.py", line 13, in <module>
        import torchvision
      File "C:\Users\huyi\.conda\envs\fom\lib\site-packages\torchvision\__init__.py", line 2, in <module>
        from torchvision import datasets
      File "C:\Users\huyi\.conda\envs\fom\lib\site-packages\torchvision\datasets\__init__.py", line 9, in <module>
        from .fakedata import FakeData
      File "C:\Users\huyi\.conda\envs\fom\lib\site-packages\torchvision\datasets\fakedata.py", line 3, in <module>
        from .. import transforms
      File "C:\Users\huyi\.conda\envs\fom\lib\site-packages\torchvision\transforms\__init__.py", line 1, in <module>
        from .transforms import *
      File "C:\Users\huyi\.conda\envs\fom\lib\site-packages\torchvision\transforms\transforms.py", line 16, in <module>
        from . import functional as F
      File "C:\Users\huyi\.conda\envs\fom\lib\site-packages\torchvision\transforms\functional.py", line 5, in <module>
        from PIL import Image, ImageOps, ImageEnhance, PILLOW_VERSION
    ImportError: cannot import name 'PILLOW_VERSION' from 'PIL' (C:\Users\huyi\.conda\envs\fom\lib\site-packages\PIL\__init__.py)

    这个问题主要是我使用的pillow版本过高的原因，如果不想找对应的低版本，可以按照我的方式解决。 

    1、修改functional.py代码，将PILLOW_VERSION调整为__version__。

    2、将imageio升级。

    pip install --upgrade imageio -i https://pypi.douban.com/simple

    3、安装imageio_ffmpeg模块。

    pip install imageio-ffmpeg -i https://pypi.douban.com/simple

    工具代码验证

    官方给出的使用方法我就不重复测试，大家可以按照下面的命令去测试一下。

    这里我推荐一个可视化的库gradio，下面我将demo.py的代码改造了一下。

    新的工具文件代码如下：

    1. #!/user/bin/env python
    2. # coding=utf-8
    3. """
    4. @project : first-order-model
    5. @author  : 剑客阿良_ALiang
    6. @file   : hy_gradio.py
    7. @ide    : PyCharm
    8. @time   : 2022-06-23 14:35:28
    9. """
    10. import uuid
    11. from typing import Optional
    12.  
    13. import gradio as gr
    14. import matplotlib
    15.  
    16. matplotlib.use('Agg')
    17. import os, sys
    18. import yaml
    19. from argparse import ArgumentParser
    20. from tqdm import tqdm
    21.  
    22. import imageio
    23. import numpy as np
    24. from skimage.transform import resize
    25. from skimage import img_as_ubyte
    26. import torch
    27. from sync_batchnorm import DataParallelWithCallback
    28.  
    29. from modules.generator import OcclusionAwareGenerator
    30. from modules.keypoint_detector import KPDetector
    31. from animate import normalize_kp
    32. from scipy.spatial import ConvexHull
    33.  
    34. if sys.version_info[0] < 3:
    35.     raise Exception("You must use Python 3 or higher. Recommended version is Python 3.7")
    36.  
    37.  
    38. def load_checkpoints(config_path, checkpoint_path, cpu=False):
    39.     with open(config_path) as f:
    40.         config = yaml.load(f)
    41.  
    42.     generator = OcclusionAwareGenerator(**config['model_params']['generator_params'],
    43.                                         **config['model_params']['common_params'])
    44.     if not cpu:
    45.         generator.cuda()
    46.  
    47.     kp_detector = KPDetector(**config['model_params']['kp_detector_params'],
    48.                              **config['model_params']['common_params'])
    49.     if not cpu:
    50.         kp_detector.cuda()
    51.  
    52.     if cpu:
    53.         checkpoint = torch.load(checkpoint_path, map_location=torch.device('cpu'))
    54.     else:
    55.         checkpoint = torch.load(checkpoint_path)
    56.  
    57.     generator.load_state_dict(checkpoint['generator'])
    58.     kp_detector.load_state_dict(checkpoint['kp_detector'])
    59.  
    60.     if not cpu:
    61.         generator = DataParallelWithCallback(generator)
    62.         kp_detector = DataParallelWithCallback(kp_detector)
    63.  
    64.     generator.eval()
    65.     kp_detector.eval()
    66.  
    67.     return generator, kp_detector
    68.  
    69.  
    70. def make_animation(source_image, driving_video, generator, kp_detector, relative=True, adapt_movement_scale=True,
    71.                    cpu=False):
    72.     with torch.no_grad():
    73.         predictions = []
    74.         source = torch.tensor(source_image[np.newaxis].astype(np.float32)).permute(0, 3, 1, 2)
    75.         if not cpu:
    76.             source = source.cuda()
    77.         driving = torch.tensor(np.array(driving_video)[np.newaxis].astype(np.float32)).permute(0, 4, 1, 2, 3)
    78.         kp_source = kp_detector(source)
    79.         kp_driving_initial = kp_detector(driving[:, :, 0])
    80.  
    81.         for frame_idx in tqdm(range(driving.shape[2])):
    82.             driving_frame = driving[:, :, frame_idx]
    83.             if not cpu:
    84.                 driving_frame = driving_frame.cuda()
    85.             kp_driving = kp_detector(driving_frame)
    86.             kp_norm = normalize_kp(kp_source=kp_source, kp_driving=kp_driving,
    87.                                    kp_driving_initial=kp_driving_initial, use_relative_movement=relative,
    88.                                    use_relative_jacobian=relative, adapt_movement_scale=adapt_movement_scale)
    89.             out = generator(source, kp_source=kp_source, kp_driving=kp_norm)
    90.  
    91.             predictions.append(np.transpose(out['prediction'].data.cpu().numpy(), [0, 2, 3, 1])[0])
    92.     return predictions
    93.  
    94.  
    95. def find_best_frame(source, driving, cpu=False):
    96.     import face_alignment
    97.  
    98.     def normalize_kp(kp):
    99.         kp = kp - kp.mean(axis=0, keepdims=True)
    100.         area = ConvexHull(kp[:, :2]).volume
    101.         area = np.sqrt(area)
    102.         kp[:, :2] = kp[:, :2] / area
    103.         return kp
    104.  
    105.     fa = face_alignment.FaceAlignment(face_alignment.LandmarksType._2D, flip_input=True,
    106.                                       device='cpu' if cpu else 'cuda')
    107.     kp_source = fa.get_landmarks(255 * source)[0]
    108.     kp_source = normalize_kp(kp_source)
    109.     norm = float('inf')
    110.     frame_num = 0
    111.     for i, image in tqdm(enumerate(driving)):
    112.         kp_driving = fa.get_landmarks(255 * image)[0]
    113.         kp_driving = normalize_kp(kp_driving)
    114.         new_norm = (np.abs(kp_source - kp_driving) ** 2).sum()
    115.         if new_norm < norm:
    116.             norm = new_norm
    117.             frame_num = i
    118.     return frame_num
    119.  
    120.  
    121. def h_interface(input_image: str):
    122.     parser = ArgumentParser()
    123.     opt = parser.parse_args()
    124.     opt.config = "./config/vox-256.yaml"
    125.     opt.checkpoint = "./checkpoint/vox-cpk.pth.tar"
    126.     opt.source_image = input_image
    127.     opt.driving_video = "./data/input/ts.mp4"
    128.     opt.result_video = "./data/result/{}.mp4".format(uuid.uuid1().hex)
    129.     opt.relative = True
    130.     opt.adapt_scale = True
    131.     opt.cpu = True
    132.     opt.find_best_frame = False
    133.     opt.best_frame = False
    134.     # source_image = imageio.imread(opt.source_image)
    135.     source_image = opt.source_image
    136.     reader = imageio.get_reader(opt.driving_video)
    137.     fps = reader.get_meta_data()['fps']
    138.     driving_video = []
    139.     try:
    140.         for im in reader:
    141.             driving_video.append(im)
    142.     except RuntimeError:
    143.         pass
    144.     reader.close()
    145.  
    146.     source_image = resize(source_image, (256, 256))[..., :3]
    147.     driving_video = [resize(frame, (256, 256))[..., :3] for frame in driving_video]
    148.     generator, kp_detector = load_checkpoints(config_path=opt.config, checkpoint_path=opt.checkpoint, cpu=opt.cpu)
    149.  
    150.     if opt.find_best_frame or opt.best_frame is not None:
    151.         i = opt.best_frame if opt.best_frame is not None else find_best_frame(source_image, driving_video, cpu=opt.cpu)
    152.         print("Best frame: " + str(i))
    153.         driving_forward = driving_video[i:]
    154.         driving_backward = driving_video[:(i + 1)][::-1]
    155.         predictions_forward = make_animation(source_image, driving_forward, generator, kp_detector,
    156.                                              relative=opt.relative, adapt_movement_scale=opt.adapt_scale, cpu=opt.cpu)
    157.         predictions_backward = make_animation(source_image, driving_backward, generator, kp_detector,
    158.                                               relative=opt.relative, adapt_movement_scale=opt.adapt_scale, cpu=opt.cpu)
    159.         predictions = predictions_backward[::-1] + predictions_forward[1:]
    160.     else:
    161.         predictions = make_animation(source_image, driving_video, generator, kp_detector, relative=opt.relative,
    162.                                      adapt_movement_scale=opt.adapt_scale, cpu=opt.cpu)
    163.     imageio.mimsave(opt.result_video, [img_as_ubyte(frame) for frame in predictions], fps=fps)
    164.     return opt.result_video
    165.  
    166.  
    167. if __name__ == "__main__":
    168.     demo = gr.Interface(h_interface, inputs=[gr.Image(shape=(500, 500))], outputs=[gr.Video()])
    169.  
    170.     demo.launch()
    171.     # h_interface("C:\\Users\\huyi\\Desktop\\xx3.jpg")

    代码说明

    1、将原demo.py中的main函数内容，重新编辑为h_interface方法，输入是想要驱动的图片。

    2、其中driving_video参数使用了我自己录制的一段表情视频ts.mp4，我建议在使用的时候可以自己用手机录制一段替换。

    3、使用gradio来生成方法的页面，下面会展示给大家看。

    4、使用uuid为结果视频命名。

    执行结果如下

    Running on local URL:  http://127.0.0.1:7860/

    To create a public link, set `share=True` in `launch()`.

    打开本地的地址：http://localhost:7860/

    可以看到我们实现的交互界面如下：

    我们上传一下我准备的样例图片，提交制作。

    看一下执行的日志，如下图。

    看一下制作结果。

    由于上传不了视频，我将视频转成了gif。

     

    还是蛮有意思的，具体的参数调优我就不弄了，大家可能根据需要调整我提供的方法里面的参数。

    总结 

    还是非常推荐gradio，大家有兴趣还是可以玩玩。

    分享：

     

            人们觉得你只能在以下二者中居其一：要么你是条鲨鱼，要么你只得躺在那里，任鲨鱼活生生地把你吃掉——这个世界就是这样。而我，我是那种会走出去，与鲨鱼搏斗的人。

                                                                                                            ——《十一种孤独》

  • 相关阅读:
    Linux性能优化--性能追踪3：系统级迟缓（prelink）
    一、鼎捷T100成本系统快速上手(大楖了解)
    Linux知识点 -- 网络基础 -- 数据链路层
    HTML 基础知识
    JavaScript面试题
    Node.js 是如何处理请求的
    基于gewe制作第一个微信聊天机器人
    13:大数据与Hadoop｜分布式文件系统｜分布式Hadoop集群
    注解、AOP
    对象头markword-锁升级
  • 原文地址：https://blog.csdn.net/zhiweihongyan1/article/details/125432506