Add optimized ControlNeXt-SVD-v2 implementation with direct pose input support

Major improvements:
- Add run_controlnext_optimized.py with FP16 support, xformers, and GEGLU optimization
- Add direct pose video/images input to bypass DWPose extraction
- Implement smart output naming based on input filename
- Add ComfyUI-ControlNeXt-SVD reference implementation for analysis
- Update README with optimized inference examples
- Add easy_dwpose integration for pose extraction
- Generate example pose videos with text2pose system

Performance optimizations:
- Default FP16 precision for faster inference
- Memory-efficient attention with xformers
- Chunked VAE decoding to reduce memory usage
- GEGLU inplace operations for memory savings

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

ControlNeXt-SVD-v2/git_push2.log

@@ -1,15 +0,0 @@
-Uploading LFS objects: 100% (25/25), 6.2 GB | 0 B/s, done.
-remote: -------------------------------------------------------------------------        
-remote: Your push was rejected because it contains binary files.        
-remote: Please use https://git-lfs.github.com/ to store binary files.        
-remote: See also: https://hf.co/docs/hub/repositories-getting-started#terminal        
-remote:         
-remote: Offending files:        
-remote:   - ref_img_dict/01.jpeg (ref: refs/heads/main)        
-remote:   - ref_img_dict/02.jpeg (ref: refs/heads/main)        
-remote:   - ref_img_dict/03.jpeg (ref: refs/heads/main)        
-remote:   - ref_img_dict/04.jpeg (ref: refs/heads/main)        
-remote: -------------------------------------------------------------------------        
-To hf.co:datasets/FangSen9000/StableSigner
- ! [remote rejected]   main -> main (pre-receive hook declined)
-error: failed to push some refs to 'hf.co:datasets/FangSen9000/StableSigner'

ControlNeXt-SVD-v2/run_controlnext_optimized.py

@@ -0,0 +1,383 @@
+import os
+import torch
+import numpy as np
+from PIL import Image
+from pipeline.pipeline_stable_video_diffusion_controlnext import StableVideoDiffusionPipelineControlNeXt
+from models.controlnext_vid_svd import ControlNeXtSDVModel
+from models.unet_spatio_temporal_condition_controlnext import UNetSpatioTemporalConditionControlNeXtModel
+from transformers import CLIPVisionModelWithProjection
+import re 
+from diffusers import AutoencoderKLTemporalDecoder
+from moviepy.editor import ImageSequenceClip
+from decord import VideoReader
+import argparse
+from safetensors.torch import load_file
+from utils.pre_process import preprocess
+from utils.pre_process_direct import preprocess_direct_pose, load_pose_from_images
+import gc
+
+# Patch GEGLU for memory optimization
+try:
+    import diffusers.models.activations
+    def patch_geglu_inplace():
+        """Patch GEGLU with inplace multiplication to save GPU memory."""
+        def forward(self, hidden_states):
+            hidden_states, gate = self.proj(hidden_states).chunk(2, dim=-1)
+            return hidden_states.mul_(self.gelu(gate))
+        diffusers.models.activations.GEGLU.forward = forward
+    patch_geglu_inplace()
+    print("✓ GEGLU optimization applied")
+except:
+    pass
+
+
+def write_mp4(video_path, samples, fps=14, audio_bitrate="192k"):
+    clip = ImageSequenceClip(samples, fps=fps)
+    clip.write_videofile(video_path, audio_codec="aac", audio_bitrate=audio_bitrate, 
+                         ffmpeg_params=["-crf", "18", "-preset", "slow"])
+
+def save_vid_side_by_side(batch_output, validation_control_images, output_folder, fps, base_filename="output"):
+    # Helper function to convert tensors to PIL images and save as GIF
+    flattened_batch_output = [img for sublist in batch_output for img in sublist]
+    
+    # Use base filename for the output files
+    video_path = os.path.join(output_folder, f'{base_filename}_combined.mp4')
+    final_images = []
+    outputs = []
+    # Helper function to concatenate images horizontally
+    def get_concat_h(im1, im2):
+        dst = Image.new('RGB', (im1.width + im2.width, max(im1.height, im2.height)))
+        dst.paste(im1, (0, 0))
+        dst.paste(im2, (im1.width, 0))
+        return dst
+    for image_list in zip(validation_control_images, flattened_batch_output):
+        predict_img = image_list[1].resize(image_list[0].size)
+        result = get_concat_h(image_list[0], predict_img)
+        final_images.append(np.array(result))
+        outputs.append(np.array(predict_img))
+    write_mp4(video_path, final_images, fps=fps)
+
+    output_path = os.path.join(output_folder, f'{base_filename}.mp4')
+    write_mp4(output_path, outputs, fps=fps)
+
+
+def load_tensor(tensor_path):
+    if os.path.splitext(tensor_path)[1] == '.bin':
+        return torch.load(tensor_path)
+    elif os.path.splitext(tensor_path)[1] == ".safetensors":
+        return load_file(tensor_path)
+    else:
+        print("without supported tensors")
+        os._exit()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Script to train Stable Diffusion XL for InstructPix2Pix."
+    )
+
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default=None,
+        required=True
+    )
+
+    parser.add_argument(
+        "--validation_control_video_path",
+        type=str,
+        default=None,
+        required=False,
+    )
+    
+    parser.add_argument(
+        "--pose_video_path",
+        type=str,
+        default=None,
+        help="Path to pre-extracted pose video (bypass DWPose)"
+    )
+    
+    parser.add_argument(
+        "--pose_images_dir",
+        type=str,
+        default=None,
+        help="Directory containing pose images (bypass DWPose)"
+    )
+
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default=None,
+        required=True
+    )
+
+    parser.add_argument(
+        "--height",
+        type=int,
+        default=768,
+        required=False
+    )
+
+    parser.add_argument(
+        "--width",
+        type=int,
+        default=512,
+        required=False
+    )
+
+    parser.add_argument(
+        "--guidance_scale",
+        type=float,
+        default=2.,
+        required=False
+    )
+
+    parser.add_argument(
+        "--num_inference_steps",
+        type=int,
+        default=25,
+        required=False
+    )
+
+    parser.add_argument(
+        "--controlnext_path",
+        type=str,
+        default=None,
+        required=True
+    )
+
+    parser.add_argument(
+        "--unet_path",
+        type=str,
+        default=None,
+        required=True
+    )
+    
+    parser.add_argument(
+        "--max_frame_num",
+        type=int,
+        default=50,
+        required=False
+    )
+
+    parser.add_argument(
+        "--ref_image_path",
+        type=str,
+        default=None,
+        required=True
+    )
+
+    parser.add_argument(
+        "--batch_frames",
+        type=int,
+        default=14,
+        required=False
+    )
+
+    parser.add_argument(
+        "--overlap",
+        type=int,
+        default=4,
+        required=False
+    )
+
+    parser.add_argument(
+        "--sample_stride",
+        type=int,
+        default=2,
+        required=False
+    )
+
+    parser.add_argument(
+        "--precision",
+        type=str,
+        default="fp16",
+        choices=["fp32", "fp16", "bf16"],
+        help="Model precision"
+    )
+
+    parser.add_argument(
+        "--enable_xformers",
+        action="store_true",
+        help="Enable xformers memory efficient attention"
+    )
+
+    parser.add_argument(
+        "--decode_chunk_size",
+        type=int,
+        default=2,
+        help="Chunk size for VAE decoding"
+    )
+
+    args = parser.parse_args()
+    return args
+
+
+# Main script
+if __name__ == "__main__":
+    args = parse_args()
+
+    # Set precision
+    dtype_map = {
+        "fp32": torch.float32,
+        "fp16": torch.float16,
+        "bf16": torch.bfloat16
+    }
+    dtype = dtype_map[args.precision]
+    
+    print(f"🚀 Using precision: {args.precision}")
+    
+    # Clear GPU cache
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        gc.collect()
+
+    # Load models with optimizations
+    print("📦 Loading UNet...")
+    unet = UNetSpatioTemporalConditionControlNeXtModel.from_pretrained(
+        args.pretrained_model_name_or_path,
+        subfolder="unet",
+        low_cpu_mem_usage=True,
+        torch_dtype=dtype,
+    )
+    
+    print("📦 Loading ControlNeXt...")
+    controlnext = ControlNeXtSDVModel()
+    controlnext.load_state_dict(load_tensor(args.controlnext_path))
+    controlnext = controlnext.to(dtype)
+    
+    # Load UNet weights
+    print("📦 Loading UNet weights...")
+    unet.load_state_dict(load_tensor(args.unet_path), strict=False)
+
+    print("📦 Loading other components...")
+    image_encoder = CLIPVisionModelWithProjection.from_pretrained(
+        args.pretrained_model_name_or_path, 
+        subfolder="image_encoder",
+        torch_dtype=dtype,
+        low_cpu_mem_usage=True,
+    )
+    
+    vae = AutoencoderKLTemporalDecoder.from_pretrained(
+        args.pretrained_model_name_or_path, 
+        subfolder="vae",
+        torch_dtype=dtype,
+        low_cpu_mem_usage=True,
+    )
+    
+    # Create pipeline
+    pipeline = StableVideoDiffusionPipelineControlNeXt.from_pretrained(
+        args.pretrained_model_name_or_path,
+        controlnext=controlnext, 
+        unet=unet,
+        vae=vae,
+        image_encoder=image_encoder,
+        torch_dtype=dtype,
+    )
+    
+    # Enable optimizations
+    if args.enable_xformers:
+        try:
+            pipeline.enable_xformers_memory_efficient_attention()
+            print("✓ Xformers memory efficient attention enabled")
+        except:
+            print("⚠️ Xformers not available, using default attention")
+    
+    # Enable model CPU offload for memory efficiency
+    pipeline.enable_model_cpu_offload()
+    
+    # Optional: Enable VAE slicing for lower memory usage
+    # pipeline.enable_vae_slicing()
+    
+    # Optional: Enable VAE tiling for very large images
+    # pipeline.enable_vae_tiling()
+
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    # Choose preprocessing method based on input
+    if args.pose_video_path:
+        print("🎬 Loading pre-extracted pose video...")
+        validation_control_images, ref_image = preprocess_direct_pose(
+            args.pose_video_path,
+            args.ref_image_path,
+            width=args.width,
+            height=args.height,
+            max_frame_num=args.max_frame_num,
+            sample_stride=args.sample_stride
+        )
+    elif args.pose_images_dir:
+        print("🎬 Loading pose images from directory...")
+        validation_control_images, ref_image = load_pose_from_images(
+            args.pose_images_dir,
+            args.ref_image_path,
+            width=args.width,
+            height=args.height,
+            max_frame_num=args.max_frame_num,
+            sample_stride=args.sample_stride
+        )
+    else:
+        print("🎬 Preprocessing video with DWPose extraction...")
+        validation_control_images, ref_image = preprocess(
+            args.validation_control_video_path, 
+            args.ref_image_path, 
+            width=args.width, 
+            height=args.height, 
+            max_frame_num=args.max_frame_num, 
+            sample_stride=args.sample_stride
+        )
+
+    final_result = []
+    frames = args.batch_frames
+    num_frames = min(args.max_frame_num, len(validation_control_images)) 
+
+    for i in range(num_frames):
+        validation_control_images[i] = Image.fromarray(np.array(validation_control_images[i]))
+    
+    print(f"🎯 Generating {num_frames} frames...")
+    
+    # Run inference with optimizations
+    video_frames = pipeline(
+        ref_image, 
+        validation_control_images[:num_frames], 
+        decode_chunk_size=args.decode_chunk_size,  # Chunked decoding
+        num_frames=num_frames,
+        motion_bucket_id=127.0, 
+        fps=7,
+        controlnext_cond_scale=1.0, 
+        width=args.width, 
+        height=args.height, 
+        min_guidance_scale=args.guidance_scale, 
+        max_guidance_scale=args.guidance_scale, 
+        frames_per_batch=frames, 
+        num_inference_steps=args.num_inference_steps, 
+        overlap=args.overlap
+    ).frames[0]
+    
+    final_result.append(video_frames)
+
+    # Determine FPS based on input type
+    if args.pose_video_path:
+        fps = VideoReader(args.pose_video_path).get_avg_fps() // args.sample_stride
+        # Extract base filename from pose video path
+        base_filename = os.path.splitext(os.path.basename(args.pose_video_path))[0]
+    elif args.pose_images_dir:
+        fps = 30 // args.sample_stride  # Default FPS for image sequences
+        # Use directory name as base filename
+        base_filename = os.path.basename(args.pose_images_dir.rstrip('/'))
+    else:
+        fps = VideoReader(args.validation_control_video_path).get_avg_fps() // args.sample_stride
+        # Extract base filename from control video path
+        base_filename = os.path.splitext(os.path.basename(args.validation_control_video_path))[0]
+    
+    print("💾 Saving results...")
+    save_vid_side_by_side(
+        final_result, 
+        validation_control_images[:num_frames], 
+        args.output_dir, 
+        fps=fps,
+        base_filename=base_filename
+    )
+    
+    print(f"✅ Done! Output saved as:")
+    print(f"   - {os.path.join(args.output_dir, base_filename + '.mp4')}")
+    print(f"   - {os.path.join(args.output_dir, base_filename + '_combined.mp4')}")

ControlNeXt-SVD-v2/utils/pre_process_direct.py

@@ -0,0 +1,182 @@
+import os
+import argparse
+import logging
+import math
+from omegaconf import OmegaConf
+from datetime import datetime
+from pathlib import Path
+from PIL import Image
+import numpy as np
+import torch.jit
+from torchvision.datasets.folder import pil_loader
+from torchvision.transforms.functional import pil_to_tensor, resize, center_crop
+from torchvision.transforms.functional import to_pil_image
+from dwpose.preprocess import get_image_pose, get_video_pose
+import cv2
+
+ASPECT_RATIO = 9 / 16
+
+def preprocess(video_path, image_path, width=576, height=1024, sample_stride=2, max_frame_num=None):
+    """preprocess ref image pose and video pose
+
+    Args:
+        video_path (str): input video pose path
+        image_path (str): reference image path
+        resolution (int, optional):  Defaults to 576.
+        sample_stride (int, optional): Defaults to 2.
+    """
+    image_pixels = pil_loader(image_path)
+    image_pixels = pil_to_tensor(image_pixels) # (c, h, w)
+    h, w = image_pixels.shape[-2:]
+    ############################ compute target h/w according to original aspect ratio ###############################
+    # if h>w:
+    #     w_target, h_target = resolution, int(resolution / ASPECT_RATIO // 64) * 64
+    # else:
+    #     w_target, h_target = int(resolution / ASPECT_RATIO // 64) * 64, resolution
+    w_target, h_target = width, height
+    h_w_ratio = float(h) / float(w)
+    if h_w_ratio < h_target / w_target:
+        h_resize, w_resize = h_target, math.ceil(h_target / h_w_ratio)
+    else:
+        h_resize, w_resize = math.ceil(w_target * h_w_ratio), w_target
+    image_pixels = resize(image_pixels, [h_resize, w_resize], antialias=None)
+    image_pixels = center_crop(image_pixels, [h_target, w_target])
+    image_pixels = image_pixels.permute((1, 2, 0)).numpy()
+    ##################################### get image&video pose value #################################################
+    image_pose = get_image_pose(image_pixels)
+    video_pose = get_video_pose(video_path, image_pixels, sample_stride=sample_stride, max_frame_num=max_frame_num)
+    pose_pixels = np.concatenate([np.expand_dims(image_pose, 0), video_pose])
+    # image_pixels = np.transpose(np.expand_dims(image_pixels, 0), (0, 3, 1, 2))
+    image_pixels = Image.fromarray(image_pixels)
+    pose_pixels = [Image.fromarray(p.transpose((1,2,0))) for p in pose_pixels]
+    # return torch.from_numpy(pose_pixels.copy()) / 127.5 - 1, torch.from_numpy(image_pixels) / 127.5 - 1
+    return pose_pixels, image_pixels
+
+
+def preprocess_direct_pose(pose_video_path, image_path, width=576, height=1024, sample_stride=2, max_frame_num=None):
+    """Preprocess with pre-extracted pose video (bypass DWPose extraction)
+    
+    Args:
+        pose_video_path (str): Path to pre-extracted pose video (MP4 with pose skeleton)
+        image_path (str): reference image path
+        width (int): target width
+        height (int): target height
+        sample_stride (int): frame sampling stride
+        max_frame_num (int): maximum number of frames to process
+    """
+    # Process reference image
+    image_pixels = pil_loader(image_path)
+    image_pixels = pil_to_tensor(image_pixels) # (c, h, w)
+    h, w = image_pixels.shape[-2:]
+    
+    w_target, h_target = width, height
+    h_w_ratio = float(h) / float(w)
+    if h_w_ratio < h_target / w_target:
+        h_resize, w_resize = h_target, math.ceil(h_target / h_w_ratio)
+    else:
+        h_resize, w_resize = math.ceil(w_target * h_w_ratio), w_target
+    image_pixels = resize(image_pixels, [h_resize, w_resize], antialias=None)
+    image_pixels = center_crop(image_pixels, [h_target, w_target])
+    image_pixels = image_pixels.permute((1, 2, 0)).numpy()
+    
+    # Get pose for reference image
+    image_pose = get_image_pose(image_pixels)
+    
+    # Load pre-extracted pose video
+    cap = cv2.VideoCapture(pose_video_path)
+    pose_frames = []
+    frame_count = 0
+    
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+            
+        # Apply sample stride
+        if frame_count % sample_stride == 0:
+            # Convert BGR to RGB
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            
+            # Resize frame to target size if needed
+            if frame_rgb.shape[:2] != (h_target, w_target):
+                frame_rgb = cv2.resize(frame_rgb, (w_target, h_target))
+            
+            pose_frames.append(frame_rgb)
+            
+            # Check max frame limit
+            if max_frame_num is not None and len(pose_frames) >= max_frame_num:
+                break
+        
+        frame_count += 1
+    
+    cap.release()
+    
+    # Convert to numpy array and prepare output
+    video_pose = np.array(pose_frames).transpose((0, 3, 1, 2))  # (n, c, h, w)
+    pose_pixels = np.concatenate([np.expand_dims(image_pose, 0), video_pose])
+    
+    # Convert to PIL Images
+    image_pixels = Image.fromarray(image_pixels)
+    pose_pixels = [Image.fromarray(p.transpose((1,2,0))) for p in pose_pixels]
+    
+    return pose_pixels, image_pixels
+
+
+def load_pose_from_images(pose_images_dir, image_path, width=576, height=1024, sample_stride=1, max_frame_num=None):
+    """Load pose from a directory of pose images
+    
+    Args:
+        pose_images_dir (str): Directory containing pose images (PNG/JPG files)
+        image_path (str): reference image path
+        width (int): target width
+        height (int): target height
+        sample_stride (int): frame sampling stride (1 means use all frames)
+        max_frame_num (int): maximum number of frames to process
+    """
+    # Process reference image
+    image_pixels = pil_loader(image_path)
+    image_pixels = pil_to_tensor(image_pixels) # (c, h, w)
+    h, w = image_pixels.shape[-2:]
+    
+    w_target, h_target = width, height
+    h_w_ratio = float(h) / float(w)
+    if h_w_ratio < h_target / w_target:
+        h_resize, w_resize = h_target, math.ceil(h_target / h_w_ratio)
+    else:
+        h_resize, w_resize = math.ceil(w_target * h_w_ratio), w_target
+    image_pixels = resize(image_pixels, [h_resize, w_resize], antialias=None)
+    image_pixels = center_crop(image_pixels, [h_target, w_target])
+    image_pixels = image_pixels.permute((1, 2, 0)).numpy()
+    
+    # Get pose for reference image
+    image_pose = get_image_pose(image_pixels)
+    
+    # Load pose images from directory
+    pose_files = sorted([f for f in os.listdir(pose_images_dir) 
+                        if f.lower().endswith(('.png', '.jpg', '.jpeg'))])
+    
+    pose_frames = []
+    for i, pose_file in enumerate(pose_files):
+        if i % sample_stride == 0:
+            pose_path = os.path.join(pose_images_dir, pose_file)
+            pose_img = Image.open(pose_path).convert('RGB')
+            
+            # Resize if needed
+            if pose_img.size != (w_target, h_target):
+                pose_img = pose_img.resize((w_target, h_target), Image.LANCZOS)
+            
+            pose_frames.append(np.array(pose_img))
+            
+            # Check max frame limit
+            if max_frame_num is not None and len(pose_frames) >= max_frame_num:
+                break
+    
+    # Convert to numpy array
+    video_pose = np.array(pose_frames).transpose((0, 3, 1, 2))  # (n, c, h, w)
+    pose_pixels = np.concatenate([np.expand_dims(image_pose, 0), video_pose])
+    
+    # Convert to PIL Images
+    image_pixels = Image.fromarray(image_pixels)
+    pose_pixels = [Image.fromarray(p.transpose((1,2,0))) for p in pose_pixels]
+    
+    return pose_pixels, image_pixels

README.md

@@ -6,6 +6,10 @@ The entire project is divided into two parts: `text_or_gloss2pose` and `pose2vid
 
 - In the pose2video section, we render the visualized poses of the skeletons generated by each word. I used the ControlNext-SVD model for this. 
 
+# For Users
+
+
+
 # For developers
 
 1. git clone https://huggingface.co/datasets/FangSen9000/StableSigner
@@ -33,6 +37,10 @@ The entire project is divided into two parts: `text_or_gloss2pose` and `pose2vid
 ## tutorial02 get pose video from text input
 
 ```python
+
+# Default
+python text2pose.py --gloss "good afternoon" --smoothing fade --smoothing-frames 5 --width 512 --height 768 --fps 30
+
 # Single gloss
 python text2pose.py --gloss "hello"
 
@@ -40,7 +48,7 @@ python text2pose.py --gloss "hello"
 python text2pose.py --gloss "hello world" --smoothing fade --smoothing-frames 5
 
 # Custom video parameters
-python text2pose.py --gloss "afternoon" --width 640 --height 480 --fps 25
+python text2pose.py --gloss "good afternoon" --width 512 --height 768 --fps 30
 ```
 
 ## tutorial03 render pose video
@@ -51,9 +59,9 @@ python text2pose.py --gloss "afternoon" --width 640 --height 480 --fps 25
 4. run `pip install -r env/requirements02_controlnext.txt`
 
 ```python
-CUDA_VISIBLE_DEVICES=0 python ControlNeXt-SVD-v2/run_controlnext.py \
+CUDA_VISIBLE_DEVICES=0 python ControlNeXt-SVD-v2/run_controlnext_optimized.py \
   --pretrained_model_name_or_path stabilityai/stable-video-diffusion-img2vid-xt-1-1 \
-  --output_dir generated_sign_video \
+  --output_dir generated_sign_video_direct \
   --max_frame_num 240 \
   --guidance_scale 3 \
   --batch_frames 24 \
@@ -63,30 +71,10 @@ CUDA_VISIBLE_DEVICES=0 python ControlNeXt-SVD-v2/run_controlnext.py \
   --width 512 \
   --controlnext_path ControlNeXt-SVD-v2/pretrained/controlnet.bin \
   --unet_path ControlNeXt-SVD-v2/pretrained/unet.bin \
-  --validation_control_video_path ControlNeXt-SVD-v2/examples/video/02.mp4 \
-  --ref_image_path ref_img_dict/03.jpeg
+  --pose_video_path generated_pose_video/GOOD_AFTERNOON_25073_01435_20250803_222800.mp4 \
+  --ref_image_path ref_img_dict/03.jpeg \
+  --precision fp16 \
+  --enable_xformers \
+  --decode_chunk_size 2
 ```
 
-<!-- official
-```python
-CUDA_VISIBLE_DEVICES=0 python ControlNeXt-SVD-v2/run_controlnext.py \
-  --pretrained_model_name_or_path stabilityai/stable-video-diffusion-img2vid-xt-1-1 \
-  --output_dir generated_sign_video \
-  --max_frame_num 240 \
-  --guidance_scale 3 \
-  --batch_frames 24 \
-  --sample_stride 2 \
-  --overlap 6 \
-  --height 1024 \
-  --width 576 \
-  --controlnext_path ControlNeXt-SVD-v2/pretrained/controlnet.bin \
-  --unet_path ControlNeXt-SVD-v2/pretrained/unet.bin \
-  --validation_control_video_path ControlNeXt-SVD-v2/examples/video/02.mp4 \
-  --ref_image_path ControlNeXt-SVD-v2/examples/ref_imgs/01.jpeg
-```
--->
-
-
-# For Users
-
-## start00 just start as a user

generated_pose_video/GOOD_AFTERNOON_25073_01435_20250803_222800.mp4

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

generated_sign_video/output.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cd8e1c631af4113c8fe07bc7a64edccd5885c2b6e507ab89c3b369742dc8ab5d
-size 3325227
+oid sha256:ccdd0d86c5a15ceded93ed45c5c7c5d224edb54292537430c5707760f64e72f5
+size 1608860

generated_sign_video/test_1.mp4

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0f74ca31c3ba3b11394f750e90611dd1f68982d5e68b4ada62aa22767528bf38
-size 4044690
+oid sha256:2c15c4d8ceaa750251f5247a29610a1b02678fa3d1a17ebc51385a7ebc545c8b
+size 2229479

generated_sign_video_direct/GOOD_AFTERNOON_25073_01435_20250803_222800.mp4

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

generated_sign_video_direct/GOOD_AFTERNOON_25073_01435_20250803_222800_combined.mp4

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

useless/abandon_cmd.md

@@ -0,0 +1,64 @@
+<!--
+cd code/StableSigner3
+
+```python 有优化，但是不支持直接以pose video作为输入
+CUDA_VISIBLE_DEVICES=0 python ControlNeXt-SVD-v2/run_controlnext_optimized.py \
+    --pretrained_model_name_or_path stabilityai/stable-video-diffusion-img2vid-xt-1-1 \
+    --output_dir generated_sign_video \
+    --max_frame_num 240 \
+    --guidance_scale 3 \
+    --batch_frames 24 \
+    --sample_stride 2 \
+    --overlap 4 \
+    --height 768 \
+    --width 512 \
+    --controlnext_path ControlNeXt-SVD-v2/pretrained/controlnet.bin \
+    --unet_path ControlNeXt-SVD-v2/pretrained/unet.bin \
+    --validation_control_video_path ControlNeXt-SVD-v2/examples/video/02.mp4 \
+    --ref_image_path ref_img_dict/03.jpeg \
+    --precision fp16 \
+    --enable_xformers \
+    --decode_chunk_size 2
+```
+-->
+
+<!--
+cd code/StableSigner3
+
+CUDA_VISIBLE_DEVICES=0 python ControlNeXt-SVD-v2/run_controlnext_v1(无优化).py \
+  --pretrained_model_name_or_path stabilityai/stable-video-diffusion-img2vid-xt-1-1 \
+  --output_dir generated_sign_video \
+  --max_frame_num 240 \
+  --guidance_scale 3 \
+  --batch_frames 24 \
+  --sample_stride 2 \
+  --overlap 4 \
+  --height 768 \
+  --width 512 \
+  --controlnext_path ControlNeXt-SVD-v2/pretrained/controlnet.bin \
+  --unet_path ControlNeXt-SVD-v2/pretrained/unet.bin \
+  --validation_control_video_path ControlNeXt-SVD-v2/examples/video/02.mp4 \
+  --ref_image_path ref_img_dict/03.jpeg
+-->
+
+<!-- official
+
+cd ControlNeXt-SVD-v2
+
+```python
+CUDA_VISIBLE_DEVICES=0 python ControlNeXt-SVD-v2/run_controlnext.py \
+  --pretrained_model_name_or_path stabilityai/stable-video-diffusion-img2vid-xt-1-1 \
+  --output_dir generated_sign_video \
+  --max_frame_num 240 \
+  --guidance_scale 3 \
+  --batch_frames 24 \
+  --sample_stride 2 \
+  --overlap 6 \
+  --height 1024 \
+  --width 576 \
+  --controlnext_path ControlNeXt-SVD-v2/pretrained/controlnet.bin \
+  --unet_path ControlNeXt-SVD-v2/pretrained/unet.bin \
+  --validation_control_video_path ControlNeXt-SVD-v2/examples/video/02.mp4 \
+  --ref_image_path ControlNeXt-SVD-v2/examples/ref_imgs/01.jpeg
+```
+-->

useless/run_with_pose_video.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+# Example 1: Run with pre-extracted pose video (bypass DWPose)
+echo "Running with pre-extracted pose video..."
+CUDA_VISIBLE_DEVICES=0 python ControlNeXt-SVD-v2/run_controlnext_optimized.py \
+  --pretrained_model_name_or_path stabilityai/stable-video-diffusion-img2vid-xt-1-1 \
+  --output_dir generated_sign_video_direct \
+  --max_frame_num 240 \
+  --guidance_scale 3 \
+  --batch_frames 24 \
+  --sample_stride 2 \
+  --overlap 4 \
+  --height 768 \
+  --width 512 \
+  --controlnext_path ControlNeXt-SVD-v2/pretrained/controlnet.bin \
+  --unet_path ControlNeXt-SVD-v2/pretrained/unet.bin \
+  --pose_video_path path/to/your/pose_video.mp4 \
+  --ref_image_path ref_img_dict/03.jpeg \
+  --precision fp16 \
+  --enable_xformers \
+  --decode_chunk_size 2
+
+# Example 2: Run with pose images directory (bypass DWPose)
+# CUDA_VISIBLE_DEVICES=0 python ControlNeXt-SVD-v2/run_controlnext_optimized.py \
+#   --pretrained_model_name_or_path stabilityai/stable-video-diffusion-img2vid-xt-1-1 \
+#   --output_dir generated_sign_video_direct \
+#   --max_frame_num 240 \
+#   --guidance_scale 3 \
+#   --batch_frames 24 \
+#   --sample_stride 1 \
+#   --overlap 4 \
+#   --height 768 \
+#   --width 512 \
+#   --controlnext_path ControlNeXt-SVD-v2/pretrained/controlnet.bin \
+#   --unet_path ControlNeXt-SVD-v2/pretrained/unet.bin \
+#   --pose_images_dir path/to/pose/images/directory \
+#   --ref_image_path ref_img_dict/03.jpeg \
+#   --precision fp16 \
+#   --enable_xformers \
+#   --decode_chunk_size 2
+
+# Example 3: Original mode with DWPose extraction
+# CUDA_VISIBLE_DEVICES=0 python ControlNeXt-SVD-v2/run_controlnext_optimized.py \
+#   --pretrained_model_name_or_path stabilityai/stable-video-diffusion-img2vid-xt-1-1 \
+#   --output_dir generated_sign_video_optimized \
+#   --max_frame_num 240 \
+#   --guidance_scale 3 \
+#   --batch_frames 24 \
+#   --sample_stride 2 \
+#   --overlap 4 \
+#   --height 768 \
+#   --width 512 \
+#   --controlnext_path ControlNeXt-SVD-v2/pretrained/controlnet.bin \
+#   --unet_path ControlNeXt-SVD-v2/pretrained/unet.bin \
+#   --validation_control_video_path ControlNeXt-SVD-v2/examples/video/02.mp4 \
+#   --ref_image_path ref_img_dict/03.jpeg \
+#   --precision fp16 \
+#   --enable_xformers \
+#   --decode_chunk_size 2