import argparse import copy import os from pathlib import Path import logging from collections import OrderedDict from pprint import pprint import random import numpy as np from omegaconf import OmegaConf, SCMode import torch from einops import rearrange, repeat import cv2 from PIL import Image from diffusers.models.autoencoder_kl import AutoencoderKL from mmcm.utils.load_util import load_pyhon_obj from mmcm.utils.seed_util import set_all_seed from mmcm.utils.signature import get_signature_of_string from mmcm.utils.task_util import fiss_tasks, generate_tasks as generate_tasks_from_table from mmcm.vision.utils.data_type_util import is_video, is_image, read_image_as_5d from mmcm.utils.str_util import clean_str_for_save from mmcm.vision.data.video_dataset import DecordVideoDataset from musev.auto_prompt.util import generate_prompts from musev.models.controlnet import PoseGuider from musev.models.facein_loader import load_facein_extractor_and_proj_by_name from musev.models.referencenet_loader import load_referencenet_by_name from musev.models.ip_adapter_loader import ( load_ip_adapter_vision_clip_encoder_by_name, load_vision_clip_encoder_by_name, load_ip_adapter_image_proj_by_name, ) from musev.models.ip_adapter_face_loader import ( load_ip_adapter_face_extractor_and_proj_by_name, ) from musev.pipelines.pipeline_controlnet_predictor import ( DiffusersPipelinePredictor, ) from musev.models.referencenet import ReferenceNet2D from musev.models.unet_loader import load_unet_by_name from musev.utils.util import save_videos_grid_with_opencv from musev import logger logger.setLevel("INFO") file_dir = os.path.dirname(__file__) PROJECT_DIR = os.path.join(os.path.dirname(__file__), "../..") DATA_DIR = os.path.join(PROJECT_DIR, "data") # TODO：use group to group arguments def parse_args(): parser = argparse.ArgumentParser(description="musev video to video") parser.add_argument( "-test_data_path", type=str, help=( "Path to the test data configuration file, now only support yaml ext, " "task file simialr to musev/configs/tasks/example.yaml" ), ) parser.add_argument( "--target_datas", type=str, default="all", help="Names of the test data to run, to select sub tasks, default=`all`", ) parser.add_argument( "--sd_model_cfg_path", type=str, default=os.path.join(PROJECT_DIR, "configs/model/T2I_all_model.py"), help="Path to the model configuration file", ) parser.add_argument( "--sd_model_name", type=str, default="all", help="Names of the models to run, or path.", ) parser.add_argument( "--unet_model_cfg_path", type=str, default=os.path.join(PROJECT_DIR, "./configs/model/motion_model.py"), help="Path to motion_cfg path or motion unet path", ) parser.add_argument( "--unet_model_name", type=str, default="musev_referencenet", help=( "class Name of the unet model, use load_unet_by_name to init unet," "now only support `musev`, `musev_referencenet`," ), ) parser.add_argument( "--lcm_model_cfg_path", type=str, default=os.path.join(PROJECT_DIR, "./configs/model/lcm_model.py"), help="Path to lcm lora path", ) parser.add_argument( "--lcm_model_name", type=str, default=None, help="lcm model name, None means do not use lcm_lora default=`None`", choices=[ "lcm", ], ) parser.add_argument( "--referencenet_model_cfg_path", type=str, default=os.path.join(PROJECT_DIR, "./configs/model/referencenet.py"), help="Path to referencenet model config path", ) parser.add_argument( "--referencenet_model_name", type=str, default=None, help="referencenet model name, None means do not use referencenet, default=`None`", choices=["musev_referencenet", "musev_referencenet_pose"], ) parser.add_argument( "--ip_adapter_model_cfg_path", type=str, default=os.path.join(PROJECT_DIR, "./configs/model/ip_adapter.py"), help="Path to ip_adapter model config path", ) parser.add_argument( "--ip_adapter_model_name", type=str, default=None, help="ip_adapter model name, None means do not use ip_adapter, default=`None`", choices=["musev_referencenet", "musev_referencenet_pose"], ) parser.add_argument( "--vision_clip_model_path", type=str, default="./checkpoints/ip_adapter/models/image_encoder", help="vision_clip_extractor_class_name vision_clip_model_path, default=`./checkpoints/ip_adapter/models/image_encoder`", ) parser.add_argument( "--vision_clip_extractor_class_name", type=str, default=None, help="vision_clip_extractor_class_name None means according to ip_adapter_model_name, default=`None`", choices=["ImageClipVisionFeatureExtractor"], ) parser.add_argument( "--facein_model_cfg_path", type=str, default=os.path.join(PROJECT_DIR, "./configs/model/facein.py"), help="Path to facein model config path", ) parser.add_argument( "--facein_model_name", type=str, default=None, help="facein model name, None means do not use facein, now unsupported default=`None`", ) parser.add_argument( "--ip_adapter_face_model_cfg_path", type=str, default=os.path.join(PROJECT_DIR, "./configs/model/ip_adapter.py"), help="Path to facein model config path", ) parser.add_argument( "--ip_adapter_face_model_name", type=str, default=None, help="facein model name, None means do not use ip_adapter_face, default=`None`", ) parser.add_argument( "--output_dir", type=str, default=os.path.join(PROJECT_DIR, "results"), help="Output directory, default=`musev/results`", ) parser.add_argument( "--save_filetype", type=str, default="mp4", help="Type of file to save the video, default=`mp4`", choices=["gif", "mp4", "webp", "images"], ) parser.add_argument( "--save_images", action="store_true", default=False, help="more than video, whether save generated video into images, default=`False`", ) parser.add_argument( "--overwrite", action="store_true", help="Whether to overwrite existing files, default=`False`", ) parser.add_argument( "--seed", type=int, default=None, help="Random seed, default=`None`", ) parser.add_argument( "--cross_attention_dim", type=int, default=768, help="Cross attention dimension, default=`768`", ) parser.add_argument( "--n_batch", type=int, default=1, help="Maximum number of iterations to run, total_frames=n_batch*time_size, default=`1`", ) parser.add_argument( "--fps", type=int, default=4, help="Frames per second for save video,default is same to of training, default=`4`", ) parser.add_argument( "--use_condition_image", action="store_false", help=( "Whether to use the first frame of the test dataset as the initial image, default=`True`" "now only support image" ), ) parser.add_argument( "--fix_condition_images", action="store_true", help=("Whether to fix condition_image for every shot, default=`False`"), ) parser.add_argument( "--redraw_condition_image", action="store_true", help="Whether to use the redrawn first frame as the initial image, default=`False`", ) parser.add_argument( "--need_img_based_video_noise", action="store_false", help="Whether to use noise based on the initial frame when adding noise to the video, default=`True`", ) parser.add_argument( "--img_weight", type=float, default=1e-3, help="Weight of the vision_condtion frame to video noise, default=`1e-3`", ) parser.add_argument( "--write_info", action="store_true", help="Whether to write frame index, default=`False`", ) parser.add_argument( "--height", type=int, default=None, help="Height of the generated video, if none then use height of condition_image, if all none raise error, default=`None`", ) parser.add_argument( "--width", type=int, default=None, help="Width of the generated video, if none then use height of condition_image, if all none raise error, default=`None`", ) parser.add_argument( "--img_length_ratio", type=float, default=1.0, help="ratio to resize target width, target height of generated video, default=`1.0`", ) parser.add_argument( "--n_cols", type=int, default=3, help="Number of columns in the output video grid, unused, now", ) parser.add_argument( "--time_size", type=int, default=12, help="Number of frames to generate per iteration, same as of training, default=`12`", ) parser.add_argument( "--noise_type", type=str, default="video_fusion", help="Type of noise to add to the video, default=`video_fusion`", choices=["video_fusion", "random"], ) parser.add_argument( "--guidance_scale", type=float, default=7.5, help="guidance_scale of first frame, default=`7.5`", ) parser.add_argument( "--video_guidance_scale", type=float, default=3.5, help="video_guidance_scale of video, the greater the value, the greater the video change, the more likely video error, default=`3.5`", ) parser.add_argument( "--video_guidance_scale_end", type=float, default=None, help="changed video_guidance_scale_end with timesteps, None means unchanged, default=`None`", ), parser.add_argument( "--video_guidance_scale_method", type=str, default="linear", help="generate changed video_guidance_scale with timesteps, default=`linear`", choices=["linear", "two_stage", "three_stage", "fix_two_stage"], ), parser.add_argument( "--num_inference_steps", type=int, default=30, help="inference steps of first frame redraw, default=`30", ) parser.add_argument( "--video_num_inference_steps", type=int, default=10, help="inference steps of video, default=`10`", ) parser.add_argument( "--strength", type=float, default=0.8, help="Strength of the redrawn image, default=`0.8`", ) parser.add_argument( "--video_strength", type=float, default=1.0, help="Strength of the redrawn video, default=`1.0`", ) parser.add_argument( "--negprompt_cfg_path", type=str, default=os.path.join(PROJECT_DIR, "configs/model/negative_prompt.py"), help="Path to the negtive prompt configuration file", ) parser.add_argument( "--video_negative_prompt", type=str, default="V2", help="video negative prompt", ), parser.add_argument( "--negative_prompt", type=str, default="V2", help="first frame negative prompt", ), parser.add_argument( "--motion_speed", type=float, default=8.0, help="motion speed, sample rate in training stage, default=`8.0`", ), parser.add_argument( "--need_hist_match", default=False, action="store_true", help="wthether hist match video with vis cond, default=`False`", ), parser.add_argument( "--log_level", type=str, default="INFO", ) parser.add_argument( "--add_static_video_prompt", action="store_true", default=False, help="add static_video_prompt in head of prompt", ) parser.add_argument( "--n_vision_condition", type=int, default=1, help="num of vision_condition , default=`1`", ) parser.add_argument( "--controlnet_name", type=str, default=None, help="controlnet for video2video, if multicontrolnet, use `,` sep, such as `a,b`, default=`None`", ) parser.add_argument( "--sample_rate", type=int, default=1, help="get one per sample_rate frames from given video, default=`1`", ) parser.add_argument( "--controlnet_conditioning_scale", type=float, default=1.0, help="controlnet 的重绘参数, default=`1.0", ) parser.add_argument( "--which2video", default="video", type=str, choices=["video", "video_middle"], help=( "which part to guide video generateion" "video_middle, only controlnet condition, or called videio middle, like pose, depth" "video2video, more than video middle, use video guide noise like img2img pipeline, default=`video`" ), ), parser.add_argument( "--end_to_end", default=True, action="store_false", help="whether end2end to generate long video, default=`True`", ), parser.add_argument( "--fixed_refer_image", action="store_false", default=True, help="whether fix referencenet image or not, if none and referencenet is not None, use vision condition frame, default=`True`", ) parser.add_argument( "--fixed_ip_adapter_image", action="store_false", default=True, help="whether fixed_ip_adapter_image or not , if none and ipadapter is not None, use vision condition frame, default=`True`", ) parser.add_argument( "--fixed_refer_face_image", action="store_false", default=True, help="whether fix facein image or not, if not and ipadapterfaceid is not None, use vision condition frame, default=`True`", ) parser.add_argument( "--redraw_condition_image_with_referencenet", action="store_false", default=True, help="whether use ip_adapter when redrawing vision condition image default=`True`", ) parser.add_argument( "--redraw_condition_image_with_ipdapter", action="store_false", default=True, help="whether use ip_adapter when redrawing vision condition image default=`True`", ) parser.add_argument( "--need_video2video", action="store_true", default=False, help="whether use video guide initial noise, default=`False`", ) parser.add_argument( "--redraw_condition_image_with_facein", action="store_false", default=True, help="whether use face tool when redrawing vision condition image, default=`True`", ) parser.add_argument( "--w_ind_noise", default=0.5, type=float, help="videofusion_noise 中 独立噪声的比例， default=`0.5`", ) parser.add_argument( "--ip_adapter_scale", default=1.0, type=float, help="ipadapter weight， default=`1.0`", ) parser.add_argument( "--facein_scale", default=1.0, type=float, help="facein weight， default=`1.0`", ) parser.add_argument( "--face_image_path", default=None, type=str, help="face_image_str, default=`None`", ) parser.add_argument( "--ipadapter_image_path", default=None, type=str, help="face_image_str, default=`None`", ) parser.add_argument( "--referencenet_image_path", default=None, type=str, help="referencenet_image_path, default=`None`", ) parser.add_argument( "--vae_model_path", default="./checkpoints/vae/sd-vae-ft-mse", type=str, help="vae path, default=`./checkpoints/vae/sd-vae-ft-mse`", ) parser.add_argument( "--redraw_condition_image_with_ip_adapter_face", action="store_false", default=True, help="whether use facein when redrawing vision condition image, default=`True`", ) parser.add_argument( "--ip_adapter_face_scale", default=1.0, type=float, help="ip_adapter face default=`1.0`", ) parser.add_argument( "--prompt_only_use_image_prompt", action="store_true", default=False, help="prompt_only_use_image_prompt, if true, replace text_prompt_emb with image_prompt_emb in ip_adapter_cross_attn, default=`False`", ) # moore animateanyone start parser.add_argument( "--pose_guider_model_path", type=str, default=None, help="moore pose_guider, refer to MooreAnimateAnyone, similar to controlnet, default=`None`", ) parser.add_argument( "--enable_zero_snr", action="store_true", default=False, help="whether use zero_snr in scheduler, include v_prediction、trailing, etc , default=`False`", ) # moore animateanyone end parser.add_argument( "--record_mid_video_noises", action="store_true", default=False, help="whether record middle timestep noise of the last frames of last shot, default=`False`", ) parser.add_argument( "--record_mid_video_latents", action="store_true", default=False, help="whether record middle timestep latent of the last frames of last shot, default=`False`", ) parser.add_argument( "--video_overlap", default=1, type=int, help="overlap when generate long video with end2end method, default=`1`", ) parser.add_argument( "--context_schedule", default="uniform_v2", type=str, help="how to generate multi shot index when parallel denoise, default=`uniform_v2`", choices=["uniform", "uniform_v2"], ) parser.add_argument( "--context_frames", default=12, type=int, help="window size of a subshot in parallel denoise, default=`12`", ) parser.add_argument( "--context_stride", default=1, type=int, help="window stride of a subshot in parallel denoise, unvalid paramter, to delete, default=`1`", ) parser.add_argument( "--context_overlap", default=4, type=int, help="window overlap of a subshot in parallel denoise,default=`4`", ) parser.add_argument( "--context_batch_size", default=1, type=int, help="num of subshot in parallel denoise, change in batch_size, need more gpu memory, default=`1`", ) parser.add_argument( "--interpolation_factor", default=1, type=int, help="whether do super resolution to latents, `1` means do nothing, default=`1`", ) parser.add_argument( "--video_is_middle", action="store_true", default=False, help="input video_path is natural rgb video or not, False means pose default=`False`", ) parser.add_argument( "--video_has_condition", action="store_false", default=True, help="if video_is_middle true, whether condition of vision condition image is same as of first frame of video_path or not, default=`True`", ) parser.add_argument( "--need_return_videos", action="store_true", default=False, help="whether save video_path with generated video together, default=`False`", ) parser.add_argument( "--need_return_condition", action="store_true", default=False, help="whether save controlnet_middle with generated video together, default=`False`", ) parser.add_argument( "--n_repeat", default=1, type=int, help="repeat times for every task, default=`1`", ) args = parser.parse_args() return args args = parse_args() print("args") pprint(args.__dict__) print("\n") logger.setLevel(args.log_level) overwrite = args.overwrite cross_attention_dim = args.cross_attention_dim time_size = args.time_size # 一次视频生成的帧数 n_batch = args.n_batch # 按照time_size的尺寸 生成n_batch次，总帧数 = time_size * n_batch fps = args.fps fix_condition_images = args.fix_condition_images use_condition_image = args.use_condition_image # 当 test_data 中有图像时，作为初始图像 redraw_condition_image = args.redraw_condition_image # 用于视频生成的首帧是否使用重绘后的 need_img_based_video_noise = ( args.need_img_based_video_noise ) # 视频加噪过程中是否使用首帧 condition_images img_weight = args.img_weight height = args.height # 如果测试数据中没有单独指定宽高，则默认这里 width = args.width # 如果测试数据中没有单独指定宽高，则默认这里 img_length_ratio = args.img_length_ratio # 如果测试数据中没有单独指定图像宽高比resize比例，则默认这里 n_cols = args.n_cols noise_type = args.noise_type strength = args.strength # 首帧重绘程度参数 video_guidance_scale = args.video_guidance_scale # 视频 condition与 uncond的权重参数 guidance_scale = args.guidance_scale # 时序条件帧 condition与uncond的权重参数 video_num_inference_steps = args.video_num_inference_steps # 视频迭代次数 num_inference_steps = args.num_inference_steps # 时序条件帧 重绘参数 seed = args.seed save_filetype = args.save_filetype save_images = args.save_images sd_model_cfg_path = args.sd_model_cfg_path sd_model_name = ( args.sd_model_name if args.sd_model_name == "all" else args.sd_model_name.split(",") ) unet_model_cfg_path = args.unet_model_cfg_path unet_model_name = args.unet_model_name test_data_path = args.test_data_path target_datas = ( args.target_datas if args.target_datas == "all" else args.target_datas.split(",") ) device = "cuda" if torch.cuda.is_available() else "cpu" torch_dtype = torch.float16 controlnet_name = args.controlnet_name controlnet_name_str = controlnet_name if controlnet_name is not None: controlnet_name = controlnet_name.split(",") if len(controlnet_name) == 1: controlnet_name = controlnet_name[0] video_strength = args.video_strength # 视频重绘程度参数 sample_rate = args.sample_rate controlnet_conditioning_scale = args.controlnet_conditioning_scale end_to_end = args.end_to_end # 是否首尾相连生成长视频 control_guidance_start = 0.0 control_guidance_end = 0.5 control_guidance_end = 1.0 negprompt_cfg_path = args.negprompt_cfg_path video_negative_prompt = args.video_negative_prompt negative_prompt = args.negative_prompt motion_speed = args.motion_speed need_hist_match = args.need_hist_match video_guidance_scale_end = args.video_guidance_scale_end video_guidance_scale_method = args.video_guidance_scale_method add_static_video_prompt = args.add_static_video_prompt n_vision_condition = args.n_vision_condition lcm_model_cfg_path = args.lcm_model_cfg_path lcm_model_name = args.lcm_model_name referencenet_model_cfg_path = args.referencenet_model_cfg_path referencenet_model_name = args.referencenet_model_name ip_adapter_model_cfg_path = args.ip_adapter_model_cfg_path ip_adapter_model_name = args.ip_adapter_model_name vision_clip_model_path = args.vision_clip_model_path vision_clip_extractor_class_name = args.vision_clip_extractor_class_name facein_model_cfg_path = args.facein_model_cfg_path facein_model_name = args.facein_model_name ip_adapter_face_model_cfg_path = args.ip_adapter_face_model_cfg_path ip_adapter_face_model_name = args.ip_adapter_face_model_name fixed_refer_image = args.fixed_refer_image fixed_ip_adapter_image = args.fixed_ip_adapter_image fixed_refer_face_image = args.fixed_refer_face_image redraw_condition_image_with_referencenet = args.redraw_condition_image_with_referencenet redraw_condition_image_with_ipdapter = args.redraw_condition_image_with_ipdapter redraw_condition_image_with_facein = args.redraw_condition_image_with_facein redraw_condition_image_with_ip_adapter_face = ( args.redraw_condition_image_with_ip_adapter_face ) w_ind_noise = args.w_ind_noise ip_adapter_scale = args.ip_adapter_scale facein_scale = args.facein_scale ip_adapter_face_scale = args.ip_adapter_face_scale face_image_path = args.face_image_path ipadapter_image_path = args.ipadapter_image_path referencenet_image_path = args.referencenet_image_path vae_model_path = args.vae_model_path prompt_only_use_image_prompt = args.prompt_only_use_image_prompt pose_guider_model_path = args.pose_guider_model_path need_video2video = args.need_video2video # serial_denoise parameter start record_mid_video_noises = args.record_mid_video_noises record_mid_video_latents = args.record_mid_video_latents video_overlap = args.video_overlap # serial_denoise parameter end # parallel_denoise parameter start context_schedule = args.context_schedule context_frames = args.context_frames context_stride = args.context_stride context_overlap = args.context_overlap context_batch_size = args.context_batch_size interpolation_factor = args.interpolation_factor n_repeat = args.n_repeat video_is_middle = args.video_is_middle video_has_condition = args.video_has_condition need_return_videos = args.need_return_videos need_return_condition = args.need_return_condition # parallel_denoise parameter end need_controlnet = controlnet_name is not None which2video = args.which2video if which2video == "video": which2video_name = "v2v" elif which2video == "video_middle": which2video_name = "vm2v" else: raise ValueError( "which2video only support video, video_middle, but given {which2video}" ) b = 1 negative_embedding = [ ["./checkpoints/embedding/badhandv4.pt", "badhandv4"], [ "./checkpoints/embedding/ng_deepnegative_v1_75t.pt", "ng_deepnegative_v1_75t", ], [ "./checkpoints/embedding/EasyNegativeV2.safetensors", "EasyNegativeV2", ], [ "./checkpoints/embedding/bad_prompt_version2-neg.pt", "bad_prompt_version2-neg", ], ] prefix_prompt = "" suffix_prompt = ", beautiful, masterpiece, best quality" suffix_prompt = "" if sd_model_name != "None": # use sd_model_path in sd_model_cfg_path sd_model_params_dict_src = load_pyhon_obj(sd_model_cfg_path, "MODEL_CFG") sd_model_params_dict = { k: v for k, v in sd_model_params_dict_src.items() if sd_model_name == "all" or k in sd_model_name } else: # get sd_model_path in sd_model_cfg_path by sd_model_name # if set path of sd_model_path in cmd, should set sd_model_name as None， sd_model_name = os.path.basename(sd_model_cfg_path).split(".")[0] sd_model_params_dict = {sd_model_name: {"sd": sd_model_cfg_path}} sd_model_params_dict_src = sd_model_params_dict if len(sd_model_params_dict) == 0: raise ValueError( "has not target model, please set one of {}".format( " ".join(list(sd_model_params_dict_src.keys())) ) ) print("running model, T2I SD") pprint(sd_model_params_dict) # lcm parameters if lcm_model_name is not None: lcm_model_params_dict_src = load_pyhon_obj(lcm_model_cfg_path, "MODEL_CFG") print("lcm_model_params_dict_src") lcm_lora_dct = lcm_model_params_dict_src[lcm_model_name] else: lcm_lora_dct = None print("lcm: ", lcm_model_name, lcm_lora_dct) # motion net parameters if os.path.isdir(unet_model_cfg_path): unet_model_path = unet_model_cfg_path elif os.path.isfile(unet_model_cfg_path): unet_model_params_dict_src = load_pyhon_obj(unet_model_cfg_path, "MODEL_CFG") print("unet_model_params_dict_src", unet_model_params_dict_src.keys()) unet_model_path = unet_model_params_dict_src[unet_model_name]["unet"] else: raise ValueError(f"expect dir or file, but given {unet_model_cfg_path}") print("unet: ", unet_model_name, unet_model_path) # referencenet parameters if referencenet_model_name is not None: if os.path.isdir(referencenet_model_cfg_path): referencenet_model_path = referencenet_model_cfg_path elif os.path.isfile(referencenet_model_cfg_path): referencenet_model_params_dict_src = load_pyhon_obj( referencenet_model_cfg_path, "MODEL_CFG" ) print( "referencenet_model_params_dict_src", referencenet_model_params_dict_src.keys(), ) referencenet_model_path = referencenet_model_params_dict_src[ referencenet_model_name ]["net"] else: raise ValueError(f"expect dir or file, but given {referencenet_model_cfg_path}") else: referencenet_model_path = None print("referencenet: ", referencenet_model_name, referencenet_model_path) # ip_adapter parameters if ip_adapter_model_name is not None: ip_adapter_model_params_dict_src = load_pyhon_obj( ip_adapter_model_cfg_path, "MODEL_CFG" ) print("ip_adapter_model_params_dict_src", ip_adapter_model_params_dict_src.keys()) ip_adapter_model_params_dict = ip_adapter_model_params_dict_src[ ip_adapter_model_name ] else: ip_adapter_model_params_dict = None print("ip_adapter: ", ip_adapter_model_name, ip_adapter_model_params_dict) # facein parameters if facein_model_name is not None: raise NotImplementedError("unsupported facein by now") facein_model_params_dict_src = load_pyhon_obj(facein_model_cfg_path, "MODEL_CFG") print("facein_model_params_dict_src", facein_model_params_dict_src.keys()) facein_model_params_dict = facein_model_params_dict_src[facein_model_name] else: facein_model_params_dict = None print("facein: ", facein_model_name, facein_model_params_dict) # ip_adapter_face if ip_adapter_face_model_name is not None: ip_adapter_face_model_params_dict_src = load_pyhon_obj( ip_adapter_face_model_cfg_path, "MODEL_CFG" ) print( "ip_adapter_face_model_params_dict_src", ip_adapter_face_model_params_dict_src.keys(), ) ip_adapter_face_model_params_dict = ip_adapter_face_model_params_dict_src[ ip_adapter_face_model_name ] else: ip_adapter_face_model_params_dict = None print( "ip_adapter_face: ", ip_adapter_face_model_name, ip_adapter_face_model_params_dict ) # negative_prompt def get_negative_prompt(negative_prompt, cfg_path=None, n: int = 10): name = negative_prompt[:n] if cfg_path is not None and cfg_path not in ["None", "none"]: dct = load_pyhon_obj(cfg_path, "Negative_Prompt_CFG") negative_prompt = dct[negative_prompt]["prompt"] return name, negative_prompt negtive_prompt_length = 10 video_negative_prompt_name, video_negative_prompt = get_negative_prompt( video_negative_prompt, cfg_path=negprompt_cfg_path, n=negtive_prompt_length, ) negative_prompt_name, negative_prompt = get_negative_prompt( negative_prompt, cfg_path=negprompt_cfg_path, n=negtive_prompt_length, ) print("video_negprompt", video_negative_prompt_name, video_negative_prompt) print("negprompt", negative_prompt_name, negative_prompt) output_dir = args.output_dir os.makedirs(output_dir, exist_ok=True) # test_data_parameters def load_yaml(path): tasks = OmegaConf.to_container( OmegaConf.load(path), structured_config_mode=SCMode.INSTANTIATE, resolve=True ) return tasks if test_data_path.endswith(".yaml"): test_datas_src = load_yaml(test_data_path) elif test_data_path.endswith(".csv"): test_datas_src = generate_tasks_from_table(test_data_path) else: raise ValueError("expect yaml or csv, but given {}".format(test_data_path)) test_datas = [ test_data for test_data in test_datas_src if target_datas == "all" or test_data.get("name", None) in target_datas ] test_datas = fiss_tasks(test_datas) test_datas = generate_prompts(test_datas) n_test_datas = len(test_datas) if n_test_datas == 0: raise ValueError( "n_test_datas == 0, set target_datas=None or set atleast one of {}".format( " ".join(list(d.get("name", "None") for d in test_datas_src)) ) ) print("n_test_datas", n_test_datas) # pprint(test_datas) def read_image(path): name = os.path.basename(path).split(".")[0] image = read_image_as_5d(path) return image, name def read_image_lst(path): images_names = [read_image(x) for x in path] images, names = zip(*images_names) images = np.concatenate(images, axis=2) name = "_".join(names) return images, name def read_image_and_name(path): if isinstance(path, str): path = [path] images, name = read_image_lst(path) return images, name # load referencenet if referencenet_model_name is not None: referencenet = load_referencenet_by_name( model_name=referencenet_model_name, # sd_model=sd_model_path, # sd_model="./checkpoints/Moore-AnimateAnyone/AnimateAnyone/reference_unet.pth", sd_referencenet_model=referencenet_model_path, cross_attention_dim=cross_attention_dim, ) else: referencenet = None referencenet_model_name = "no" # load vision_clip_extractor if vision_clip_extractor_class_name is not None: vision_clip_extractor = load_vision_clip_encoder_by_name( ip_image_encoder=vision_clip_model_path, vision_clip_extractor_class_name=vision_clip_extractor_class_name, ) logger.info( f"vision_clip_extractor, name={vision_clip_extractor_class_name}, path={vision_clip_model_path}" ) else: vision_clip_extractor = None logger.info(f"vision_clip_extractor, None") # load ip_adapter_model if ip_adapter_model_name is not None: ip_adapter_image_proj = load_ip_adapter_image_proj_by_name( model_name=ip_adapter_model_name, ip_image_encoder=ip_adapter_model_params_dict.get( "ip_image_encoder", vision_clip_model_path ), ip_ckpt=ip_adapter_model_params_dict["ip_ckpt"], cross_attention_dim=cross_attention_dim, clip_embeddings_dim=ip_adapter_model_params_dict["clip_embeddings_dim"], clip_extra_context_tokens=ip_adapter_model_params_dict[ "clip_extra_context_tokens" ], ip_scale=ip_adapter_model_params_dict["ip_scale"], device=device, ) else: ip_adapter_image_proj = None ip_adapter_model_name = "no" if pose_guider_model_path is not None: logger.info(f"PoseGuider ={pose_guider_model_path}") pose_guider = PoseGuider.from_pretrained( pose_guider_model_path, conditioning_embedding_channels=320, block_out_channels=(16, 32, 96, 256), ) else: pose_guider = None for model_name, sd_model_params in sd_model_params_dict.items(): lora_dict = sd_model_params.get("lora", None) model_sex = sd_model_params.get("sex", None) model_style = sd_model_params.get("style", None) sd_model_path = sd_model_params["sd"] test_model_vae_model_path = sd_model_params.get("vae", vae_model_path) # load unet according test_data unet = load_unet_by_name( model_name=unet_model_name, sd_unet_model=unet_model_path, sd_model=sd_model_path, # sd_model="./checkpoints/Moore-AnimateAnyone/AnimateAnyone/denoising_unet.pth", cross_attention_dim=cross_attention_dim, need_t2i_facein=facein_model_name is not None, # ip_adapter_face_model_name not train in unet, need load individually strict=not (ip_adapter_face_model_name is not None), need_t2i_ip_adapter_face=ip_adapter_face_model_name is not None, ) # load facein according test_data if facein_model_name is not None: ( face_emb_extractor, facein_image_proj, ) = load_facein_extractor_and_proj_by_name( model_name=facein_model_name, ip_image_encoder=facein_model_params_dict["ip_image_encoder"], ip_ckpt=facein_model_params_dict["ip_ckpt"], cross_attention_dim=cross_attention_dim, clip_embeddings_dim=facein_model_params_dict["clip_embeddings_dim"], clip_extra_context_tokens=facein_model_params_dict[ "clip_extra_context_tokens" ], ip_scale=facein_model_params_dict["ip_scale"], device=device, unet=unet, ) else: face_emb_extractor = None facein_image_proj = None # load ipadapter_face model according test_data if ip_adapter_face_model_name is not None: ( ip_adapter_face_emb_extractor, ip_adapter_face_image_proj, ) = load_ip_adapter_face_extractor_and_proj_by_name( model_name=ip_adapter_face_model_name, ip_image_encoder=ip_adapter_face_model_params_dict["ip_image_encoder"], ip_ckpt=ip_adapter_face_model_params_dict["ip_ckpt"], cross_attention_dim=cross_attention_dim, clip_embeddings_dim=ip_adapter_face_model_params_dict[ "clip_embeddings_dim" ], clip_extra_context_tokens=ip_adapter_face_model_params_dict[ "clip_extra_context_tokens" ], ip_scale=ip_adapter_face_model_params_dict["ip_scale"], device=device, unet=unet, ) else: ip_adapter_face_emb_extractor = None ip_adapter_face_image_proj = None print("test_model_vae_model_path", test_model_vae_model_path) # init sd_predictor sd_predictor = DiffusersPipelinePredictor( sd_model_path=sd_model_path, unet=unet, lora_dict=lora_dict, lcm_lora_dct=lcm_lora_dct, device=device, dtype=torch_dtype, negative_embedding=negative_embedding, referencenet=referencenet, ip_adapter_image_proj=ip_adapter_image_proj, vision_clip_extractor=vision_clip_extractor, facein_image_proj=facein_image_proj, face_emb_extractor=face_emb_extractor, vae_model=test_model_vae_model_path, ip_adapter_face_emb_extractor=ip_adapter_face_emb_extractor, ip_adapter_face_image_proj=ip_adapter_face_image_proj, pose_guider=pose_guider, controlnet_name=controlnet_name, enable_zero_snr=args.enable_zero_snr, ) logger.debug(f"load referencenet"), for i_test_data, test_data in enumerate(test_datas): batch = [] texts = [] video_path = test_data.get("video_path") video_reader = DecordVideoDataset( video_path, time_size=time_size, step=time_size, sample_rate=sample_rate, device="cpu", data_type="rgb", channels_order="c t h w", drop_last=True, ) video_height = video_reader.height video_width = video_reader.width print("\n i_test_data", i_test_data, model_name) test_data_name = test_data.get("name", i_test_data) prompt = test_data["prompt"] prompt = prefix_prompt + prompt + suffix_prompt prompt_hash = get_signature_of_string(prompt, length=5) test_data["prompt_hash"] = prompt_hash test_data_height = test_data.get("height", height) test_data_width = test_data.get("width", width) test_data_condition_images_path = test_data.get("condition_images", None) test_data_condition_images_index = test_data.get("condition_images_index", None) test_data_redraw_condition_image = test_data.get( "redraw_condition_image", redraw_condition_image ) # read condition_image if ( test_data_condition_images_path is not None and use_condition_image and ( isinstance(test_data_condition_images_path, list) or ( isinstance(test_data_condition_images_path, str) and is_image(test_data_condition_images_path) ) ) ): ( test_data_condition_images, test_data_condition_images_name, ) = read_image_and_name(test_data_condition_images_path) condition_image_height = test_data_condition_images.shape[3] condition_image_width = test_data_condition_images.shape[4] logger.debug( f"test_data_condition_images use {test_data_condition_images_path}" ) else: test_data_condition_images = None test_data_condition_images_name = "no" condition_image_height = None condition_image_width = None logger.debug(f"test_data_condition_images is None") # if test_data_height is not assigned, use height of condition, if still None, use of video if test_data_height is None: test_data_height = ( condition_image_height if condition_image_height is not None else video_height ) if test_data_width is None: test_data_width = ( condition_image_width if condition_image_width is not None else video_width ) test_data_img_length_ratio = float( test_data.get("img_length_ratio", img_length_ratio) ) # to align height of generated video with video2video, use `64`` as basic pixel unit instead of `8`` test_data_height = int(test_data_height * test_data_img_length_ratio // 64 * 64) test_data_width = int(test_data_width * test_data_img_length_ratio // 64 * 64) pprint(test_data) print(f"test_data_height={test_data_height}") print(f"test_data_width={test_data_width}") # continue test_data_style = test_data.get("style", None) test_data_sex = test_data.get("sex", None) # if paramters in test_data is str, but float in fact, convert it into float,int. test_data_motion_speed = float(test_data.get("motion_speed", motion_speed)) test_data_w_ind_noise = float(test_data.get("w_ind_noise", w_ind_noise)) test_data_img_weight = float(test_data.get("img_weight", img_weight)) logger.debug( f"test_data_condition_images_path {test_data_condition_images_path}" ) logger.debug( f"test_data_condition_images_index {test_data_condition_images_index}" ) test_data_refer_image_path = test_data.get( "refer_image", referencenet_image_path ) test_data_ipadapter_image_path = test_data.get( "ipadapter_image", ipadapter_image_path ) test_data_refer_face_image_path = test_data.get("face_image", face_image_path) test_data_video_is_middle = test_data.get("video_is_middle", video_is_middle) test_data_video_has_condition = test_data.get( "video_has_condition", video_has_condition ) controlnet_processor_params = { "detect_resolution": min(test_data_height, test_data_width), "image_resolution": min(test_data_height, test_data_width), } if negprompt_cfg_path is not None: if "video_negative_prompt" in test_data: ( test_data_video_negative_prompt_name, test_data_video_negative_prompt, ) = get_negative_prompt( test_data.get( "video_negative_prompt", ), cfg_path=negprompt_cfg_path, n=negtive_prompt_length, ) else: test_data_video_negative_prompt_name = video_negative_prompt_name test_data_video_negative_prompt = video_negative_prompt if "negative_prompt" in test_data: ( test_data_negative_prompt_name, test_data_negative_prompt, ) = get_negative_prompt( test_data.get( "negative_prompt", ), cfg_path=negprompt_cfg_path, n=negtive_prompt_length, ) else: test_data_negative_prompt_name = negative_prompt_name test_data_negative_prompt = negative_prompt else: test_data_video_negative_prompt = test_data.get( "video_negative_prompt", video_negative_prompt ) test_data_video_negative_prompt_name = test_data_video_negative_prompt[ :negtive_prompt_length ] test_data_negative_prompt = test_data.get( "negative_prompt", negative_prompt ) test_data_negative_prompt_name = test_data_negative_prompt[ :negtive_prompt_length ] # prepare test_data_refer_image if referencenet is not None: if test_data_refer_image_path is None: test_data_refer_image = test_data_condition_images test_data_refer_image_name = test_data_condition_images_name logger.debug(f"test_data_refer_image use test_data_condition_images") else: test_data_refer_image, test_data_refer_image_name = read_image_and_name( test_data_refer_image_path ) logger.debug(f"test_data_refer_image use {test_data_refer_image_path}") else: test_data_refer_image = None test_data_refer_image_name = "no" logger.debug(f"test_data_refer_image is None") # prepare test_data_ipadapter_image if vision_clip_extractor is not None: if test_data_ipadapter_image_path is None: test_data_ipadapter_image = test_data_condition_images test_data_ipadapter_image_name = test_data_condition_images_name logger.debug( f"test_data_ipadapter_image use test_data_condition_images" ) else: ( test_data_ipadapter_image, test_data_ipadapter_image_name, ) = read_image_and_name(test_data_ipadapter_image_path) logger.debug( f"test_data_ipadapter_image use f{test_data_ipadapter_image_path}" ) else: test_data_ipadapter_image = None test_data_ipadapter_image_name = "no" logger.debug(f"test_data_ipadapter_image is None") # prepare test_data_refer_face_image if facein_image_proj is not None or ip_adapter_face_image_proj is not None: if test_data_refer_face_image_path is None: test_data_refer_face_image = test_data_condition_images test_data_refer_face_image_name = test_data_condition_images_name logger.debug( f"test_data_refer_face_image use test_data_condition_images" ) else: ( test_data_refer_face_image, test_data_refer_face_image_name, ) = read_image_and_name(test_data_refer_face_image_path) logger.debug( f"test_data_refer_face_image use f{test_data_refer_face_image_path}" ) else: test_data_refer_face_image = None test_data_refer_face_image_name = "no" logger.debug(f"test_data_refer_face_image is None") # if sex, style of test_data is not aligned with of model # skip this test_data if ( model_sex is not None and test_data_sex is not None and model_sex != test_data_sex ) or ( model_style is not None and test_data_style is not None and model_style != test_data_style ): print("model doesnt match test_data") print("model name: ", model_name) print("test_data: ", test_data) continue # video filename = os.path.basename(video_path).split(".")[0] for i_num in range(n_repeat): test_data_seed = random.randint(0, 1e8) if seed is None else seed cpu_generator, gpu_generator = set_all_seed(test_data_seed) save_file_name = ( f"{which2video_name}_m={model_name}_rm={referencenet_model_name}_c={test_data_name}" f"_w={test_data_width}_h={test_data_height}_t={time_size}_n={n_batch}" f"_vn={video_num_inference_steps}" f"_w={test_data_img_weight}_w={test_data_w_ind_noise}" f"_s={test_data_seed}_n={controlnet_name_str}" f"_s={strength}_g={guidance_scale}_vs={video_strength}_vg={video_guidance_scale}" f"_p={prompt_hash}_{test_data_video_negative_prompt_name[:10]}" f"_r={test_data_refer_image_name[:3]}_ip={test_data_refer_image_name[:3]}_f={test_data_refer_face_image_name[:3]}" ) save_file_name = clean_str_for_save(save_file_name) output_path = os.path.join( output_dir, f"{save_file_name}.{save_filetype}", ) if os.path.exists(output_path) and not overwrite: print("existed", output_path) continue if which2video in ["video", "video_middle"]: if which2video == "video": need_video2video = True ( out_videos, out_condition, videos, ) = sd_predictor.run_pipe_video2video( video=video_path, time_size=time_size, step=time_size, sample_rate=sample_rate, need_return_videos=need_return_videos, need_return_condition=need_return_condition, controlnet_conditioning_scale=controlnet_conditioning_scale, control_guidance_start=control_guidance_start, control_guidance_end=control_guidance_end, end_to_end=end_to_end, need_video2video=need_video2video, video_strength=video_strength, prompt=prompt, width=test_data_width, height=test_data_height, generator=gpu_generator, noise_type=noise_type, negative_prompt=test_data_negative_prompt, video_negative_prompt=test_data_video_negative_prompt, max_batch_num=n_batch, strength=strength, need_img_based_video_noise=need_img_based_video_noise, video_num_inference_steps=video_num_inference_steps, condition_images=test_data_condition_images, fix_condition_images=fix_condition_images, video_guidance_scale=video_guidance_scale, guidance_scale=guidance_scale, num_inference_steps=num_inference_steps, redraw_condition_image=test_data_redraw_condition_image, img_weight=test_data_img_weight, w_ind_noise=test_data_w_ind_noise, n_vision_condition=n_vision_condition, motion_speed=test_data_motion_speed, need_hist_match=need_hist_match, video_guidance_scale_end=video_guidance_scale_end, video_guidance_scale_method=video_guidance_scale_method, vision_condition_latent_index=test_data_condition_images_index, refer_image=test_data_refer_image, fixed_refer_image=fixed_refer_image, redraw_condition_image_with_referencenet=redraw_condition_image_with_referencenet, ip_adapter_image=test_data_ipadapter_image, refer_face_image=test_data_refer_face_image, fixed_refer_face_image=fixed_refer_face_image, facein_scale=facein_scale, redraw_condition_image_with_facein=redraw_condition_image_with_facein, ip_adapter_face_scale=ip_adapter_face_scale, redraw_condition_image_with_ip_adapter_face=redraw_condition_image_with_ip_adapter_face, fixed_ip_adapter_image=fixed_ip_adapter_image, ip_adapter_scale=ip_adapter_scale, redraw_condition_image_with_ipdapter=redraw_condition_image_with_ipdapter, prompt_only_use_image_prompt=prompt_only_use_image_prompt, controlnet_processor_params=controlnet_processor_params, # serial_denoise parameter start record_mid_video_noises=record_mid_video_noises, record_mid_video_latents=record_mid_video_latents, video_overlap=video_overlap, # serial_denoise parameter end # parallel_denoise parameter start context_schedule=context_schedule, context_frames=context_frames, context_stride=context_stride, context_overlap=context_overlap, context_batch_size=context_batch_size, interpolation_factor=interpolation_factor, # parallel_denoise parameter end video_is_middle=test_data_video_is_middle, video_has_condition=test_data_video_has_condition, ) else: raise ValueError( f"only support video, videomiddle2video, but given {which2video_name}" ) print("out_videos.shape", out_videos.shape) batch = [out_videos] texts = ["out"] if videos is not None: print("videos.shape", videos.shape) batch.insert(0, videos / 255.0) texts.insert(0, "videos") if need_controlnet and out_condition is not None: if not isinstance(out_condition, list): print("out_condition", out_condition.shape) batch.append(out_condition / 255.0) texts.append(controlnet_name) else: batch.extend([x / 255.0 for x in out_condition]) texts.extend(controlnet_name) out = np.concatenate(batch, axis=0) save_videos_grid_with_opencv( out, output_path, texts=texts, fps=fps, tensor_order="b c t h w", n_cols=n_cols, write_info=args.write_info, save_filetype=save_filetype, save_images=save_images, ) print("Save to", output_path) print("\n" * 2)