| import os | |
| import argparse | |
| import torch | |
| import torchvision | |
| import json | |
| from einops import rearrange | |
| from diffusers import DDIMScheduler, AutoencoderKL, DDIMInverseScheduler | |
| from transformers import CLIPTextModel, CLIPTokenizer | |
| from models.pipeline_flatten import FlattenPipeline | |
| from models.util import save_videos_grid, read_video, sample_trajectories | |
| from models.unet import UNet3DConditionModel | |
| def get_args(): | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--jsonl_path", type=str, help="Path to the JSONL file containing video paths and prompts") | |
| parser.add_argument("--prompt", type=str, help="Textual prompt for video editing") | |
| parser.add_argument("--neg_prompt", type=str, default="none", help="Negative prompt for guidance") | |
| parser.add_argument("--guidance_scale", default=20.0, type=float, help="Guidance scale") | |
| parser.add_argument("--video_path", type=str, help="Path to a source video") | |
| parser.add_argument("--sd_path", type=str, default="checkpoints/stable-diffusion-2-1-base", help="Path of Stable Diffusion") | |
| parser.add_argument("--output_path", type=str, default="./outputs", help="Directory of output") | |
| parser.add_argument("--video_length", type=int, default=32, help="Length of output video") | |
| parser.add_argument("--old_qk", type=int, default=0, help="Whether to use old queries and keys for flow-guided attention") | |
| parser.add_argument("--height", type=int, default=512, help="Height of synthesized video, and should be a multiple of 32") | |
| parser.add_argument("--width", type=int, default=512, help="Width of synthesized video, and should be a multiple of 32") | |
| parser.add_argument("--sample_steps", type=int, default=50, help="Steps for feature injection") | |
| parser.add_argument("--inject_step", type=int, default=40, help="Steps for feature injection") | |
| parser.add_argument("--seed", type=int, default=66, help="Random seed of generator") | |
| parser.add_argument("--frame_rate", type=int, default=2, help="The frame rate of loading input video") | |
| parser.add_argument("--fps", type=int, default=15, help="FPS of the output video") | |
| args = parser.parse_args() | |
| return args | |
| if __name__ == "__main__": | |
| args = get_args() | |
| os.makedirs(args.output_path, exist_ok=True) | |
| device = "cuda" | |
| args.height = (args.height // 32) * 32 | |
| args.width = (args.width // 32) * 32 | |
| tokenizer = CLIPTokenizer.from_pretrained(args.sd_path, subfolder="tokenizer") | |
| text_encoder = CLIPTextModel.from_pretrained(args.sd_path, subfolder="text_encoder").to(dtype=torch.float16) | |
| vae = AutoencoderKL.from_pretrained(args.sd_path, subfolder="vae").to(dtype=torch.float16) | |
| unet = UNet3DConditionModel.from_pretrained_2d(args.sd_path, subfolder="unet").to(dtype=torch.float16) | |
| scheduler = DDIMScheduler.from_pretrained(args.sd_path, subfolder="scheduler") | |
| inverse = DDIMInverseScheduler.from_pretrained(args.sd_path, subfolder="scheduler") | |
| pipe = FlattenPipeline( | |
| vae=vae, text_encoder=text_encoder, tokenizer=tokenizer, unet=unet, | |
| scheduler=scheduler, inverse_scheduler=inverse) | |
| pipe.enable_vae_slicing() | |
| pipe.enable_xformers_memory_efficient_attention() | |
| pipe.to(device) | |
| generator = torch.Generator(device=device) | |
| generator.manual_seed(args.seed) | |
| if args.jsonl_path: | |
| with open(args.jsonl_path, 'r') as f: | |
| lines = f.readlines() | |
| video_tasks = [json.loads(line) for line in lines] | |
| else: | |
| if not args.video_path or not args.prompt: | |
| raise ValueError("For single video editing, --video_path and --prompt are required") | |
| video_tasks = [{"video": args.video_path, "edit_prompt": args.prompt}] | |
| base_dir = "/home/wangjuntong/video_editing_dataset/all_sourse/" | |
| os.makedirs("tmp", exist_ok=True) | |
| for task in video_tasks: | |
| video_path = os.path.join(base_dir, task["video"]) | |
| prompt = task["edit_prompt"] | |
| video = read_video(video_path=video_path, video_length=args.video_length, | |
| width=args.width, height=args.height, frame_rate=args.frame_rate) | |
| original_pixels = rearrange(video, "(b f) c h w -> b c f h w", b=1) | |
| video_name = os.path.splitext(os.path.basename(video_path))[0] | |
| source_video_path = os.path.join(args.output_path, f"{video_name}_source.mp4") | |
| save_videos_grid(original_pixels, source_video_path, rescale=True) | |
| t2i_transform = torchvision.transforms.ToPILImage() | |
| real_frames = [] | |
| for i, frame in enumerate(video): | |
| real_frames.append(t2i_transform(((frame+1)/2*255).to(torch.uint8))) | |
| temp_dir = os.path.join("tmp", video_name) | |
| os.makedirs(temp_dir, exist_ok=True) | |
| trajectories = sample_trajectories(source_video_path, device) | |
| torch.cuda.empty_cache() | |
| for k in trajectories.keys(): | |
| trajectories[k] = trajectories[k].to(device) | |
| sample = pipe(prompt, video_length=args.video_length, frames=real_frames, | |
| num_inference_steps=args.sample_steps, generator=generator, guidance_scale=args.guidance_scale, | |
| negative_prompt=args.neg_prompt, width=args.width, height=args.height, | |
| trajs=trajectories, output_dir=temp_dir, inject_step=args.inject_step, old_qk=args.old_qk).videos | |
| output_video_path = os.path.join(args.output_path, f"{video_name}_edited.mp4") | |
| save_videos_grid(sample, output_video_path, fps=args.fps) |