Upload 4 files

app.py

@@ -0,0 +1,301 @@
+# PyTorch 2.8 (temporary hack)
+import os
+os.system('pip install --upgrade --pre --extra-index-url https://download.pytorch.org/whl/nightly/cu126 "torch<2.9" spaces')
+
+# Actual demo code
+import spaces
+import torch
+from diffusers import FlowMatchEulerDiscreteScheduler
+from diffusers.pipelines.wan.pipeline_wan_i2v import WanImageToVideoPipeline
+from diffusers.models.transformers.transformer_wan import WanTransformer3DModel
+from diffusers.utils.export_utils import export_to_video
+import gradio as gr
+import tempfile
+import numpy as np
+from PIL import Image
+import random
+import gc
+from optimization import optimize_pipeline_
+
+SECRET_KEY = os.environ.get("SECRET_KEY")
+
+# 如果在 Space 中没有设置密钥
+if not SECRET_KEY:
+    raise ValueError("请设置 SECRET_KEY 环境变量。")
+
+MODEL_ID = "Wan-AI/Wan2.2-I2V-A14B-Diffusers"
+
+# 在这里配置所有的 LoRA。
+LORA_REPO_ID = "IdlecloudX/Flux_and_Wan_Lora"
+LORA_SETS = {
+    "NF": {
+        "high_noise": {"file": "NSFW-22-H-e8.safetensors", "adapter_name": "nf_high"},
+        "low_noise": {"file": "NSFW-22-L-e8.safetensors", "adapter_name": "nf_low"}
+    },
+    "BP": {
+        "high_noise": {"file": "Wan2.2_BP-v1-HighNoise-I2V_T2V.safetensors", "adapter_name": "bp_high"},
+        "low_noise": {"file": "Wan2.2_BP-v1-LowNoise-I2V_T2V.safetensors", "adapter_name": "bp_low"}
+    },
+    "Py-v1": {
+        "high_noise": {"file": "WAN2.2-HighNoise_Pyv1-I2V_T2V.safetensors", "adapter_name": "py_high"},
+        "low_noise": {"file": "WAN2.2-LowNoise_Pyv1-I2V_T2V.safetensors", "adapter_name": "py_low"}
+    }
+}
+
+MAX_DIMENSION = 832
+MIN_DIMENSION = 576
+
+DIMENSION_MULTIPLE = 16
+SQUARE_SIZE = 640
+MAX_SEED = np.iinfo(np.int32).max
+FIXED_FPS = 16
+MIN_FRAMES_MODEL = 8
+MAX_FRAMES_MODEL = 81
+MIN_DURATION = round(MIN_FRAMES_MODEL/FIXED_FPS, 1)
+MAX_DURATION = round(MAX_FRAMES_MODEL/FIXED_FPS, 1)
+
+
+print("正在加载模型...")
+pipe = WanImageToVideoPipeline.from_pretrained(
+    MODEL_ID,
+    transformer=WanTransformer3DModel.from_pretrained('cbensimon/Wan2.2-I2V-A14B-bf16-Diffusers',
+        subfolder='transformer',
+        torch_dtype=torch.bfloat16,
+        device_map='cuda',
+    ),
+    transformer_2=WanTransformer3DModel.from_pretrained('cbensimon/Wan2.2-I2V-A14B-bf16-Diffusers',
+        subfolder='transformer_2',
+        torch_dtype=torch.bfloat16,
+        device_map='cuda',
+    ),
+    torch_dtype=torch.bfloat16,
+)
+# 使用新的调度器
+pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(pipe.scheduler.config, shift=8.0)
+pipe.to('cuda')
+print("模型加载完成。")
+
+
+print("开始优化 Pipeline...")
+optimize_pipeline_(pipe,
+    image=Image.new('RGB', (MAX_DIMENSION, MIN_DIMENSION)),
+    last_image=Image.new('RGB', (MAX_DIMENSION, MIN_DIMENSION)), # 为首尾帧功能添加 last_image
+    prompt='prompt',
+    height=MIN_DIMENSION,
+    width=MAX_DIMENSION,
+    num_frames=MAX_FRAMES_MODEL,
+)
+print("优化完成。")
+
+for name, lora_set in LORA_SETS.items():
+    print(f"--- 开始加载 LoRA 集合: {name} ---")
+
+    # 加载 High Noise
+    high_noise_config = lora_set["high_noise"]
+    print(f"正在加载 High Noise: {high_noise_config['file']}...")
+    pipe.load_lora_weights(LORA_REPO_ID, weight_name=high_noise_config['file'], adapter_name=high_noise_config['adapter_name'])
+    print("High Noise LoRA 加载完成。")
+
+    # 加载 Low Noise
+    low_noise_config = lora_set["low_noise"]
+    print(f"正在加载 Low Noise: {low_noise_config['file']}...")
+    pipe.load_lora_weights(LORA_REPO_ID, weight_name=low_noise_config['file'], adapter_name=low_noise_config['adapter_name'])
+    print("Low Noise LoRA 加载完成。")
+print("所有自定义 LoRA 加载完毕。")
+
+for i in range(3):
+    gc.collect()
+    torch.cuda.synchronize()
+    torch.cuda.empty_cache()
+
+default_prompt_i2v = "make this image come alive, cinematic motion, smooth animation"
+default_negative_prompt = "色调艳丽, 过曝, 静态, 细节模糊不清, 字幕, 风格, 作品, 画作, 画面, 静止, 整体发灰, 最差质量, 低质量, JPEG压缩残留, 丑陋的, 残缺的, 多余的手指, 画得不好的手部, 画得不好的脸部, 畸形的, 毁容的, 形态畸形的肢体, 手指融合, 静止不动的画面, 杂乱的背景, 三条腿, 背景人很多, 倒着走"
+
+
+def process_image_for_video(image: Image.Image) -> Image.Image:
+    width, height = image.size
+    if width == height:
+        return image.resize((SQUARE_SIZE, SQUARE_SIZE), Image.Resampling.LANCZOS)
+
+    aspect_ratio = width / height
+    new_width, new_height = width, height
+
+    if new_width > MAX_DIMENSION or new_height > MAX_DIMENSION:
+        scale = MAX_DIMENSION / (new_width if aspect_ratio > 1 else new_height)
+        new_width, new_height = new_width * scale, new_height * scale
+
+    if new_width < MIN_DIMENSION or new_height < MIN_DIMENSION:
+        scale = MIN_DIMENSION / (new_height if aspect_ratio > 1 else new_width)
+        new_width, new_height = new_width * scale, new_height * scale
+
+    final_width = int(round(new_width / DIMENSION_MULTIPLE) * DIMENSION_MULTIPLE)
+    final_height = int(round(new_height / DIMENSION_MULTIPLE) * DIMENSION_MULTIPLE)
+    
+    final_width = max(final_width, MIN_DIMENSION if aspect_ratio < 1 else SQUARE_SIZE)
+    final_height = max(final_height, MIN_DIMENSION if aspect_ratio > 1 else SQUARE_SIZE)
+
+    return image.resize((final_width, final_height), Image.Resampling.LANCZOS)
+
+def resize_and_crop_to_match(target_image, reference_image):
+    ref_width, ref_height = reference_image.size
+    target_width, target_height = target_image.size
+    scale = max(ref_width / target_width, ref_height / target_height)
+    new_width, new_height = int(target_width * scale), int(target_height * scale)
+    resized = target_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    left, top = (new_width - ref_width) // 2, (new_height - ref_height) // 2
+    return resized.crop((left, top, left + ref_width, top + ref_height))
+
+def get_duration(
+    secret_key,
+    input_image,
+    prompt,
+    steps,
+    negative_prompt,
+    duration_seconds,
+    guidance_scale,
+    guidance_scale_2,
+    seed,
+    randomize_seed,
+    selected_loras,
+    progress,
+):
+    return int(steps) * 15
+
+@spaces.GPU(duration=get_duration)
+def generate_video(
+    secret_key,
+    start_image_pil,
+    end_image_pil,
+    prompt,
+    steps = 8,
+    negative_prompt=default_negative_prompt,
+    duration_seconds=3.5,
+    guidance_scale=1,
+    guidance_scale_2=1,
+    seed=42,
+    randomize_seed=False,
+    selected_loras=[],
+    progress=gr.Progress(track_tqdm=True),
+):
+    if secret_key != SECRET_KEY:
+        raise gr.Error("无效的密钥！请输入正确的密钥。")
+
+    if start_image_pil is None or end_image_pil is None:
+        raise gr.Error("请上传开始帧和结束帧。")
+
+    progress(0.1, desc="正在预处理图像...")
+    processed_start_image = process_image_for_video(start_image_pil)
+    processed_end_image = resize_and_crop_to_match(end_image_pil, processed_start_image)
+    target_height, target_width = processed_start_image.height, processed_start_image.width
+
+    current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+    num_frames = np.clip(int(round(duration_seconds * FIXED_FPS)), MIN_FRAMES_MODEL, MAX_FRAMES_MODEL)
+    num_inference_steps = int(steps)
+    switch_step = num_inference_steps // 2
+
+    progress(0.2, desc=f"正在生成 {num_frames} 帧，尺寸 {target_width}x{target_height} (seed: {current_seed})...")
+
+    class LoraSwitcher:
+        def __init__(self, selected_lora_names):
+            self.switched = False
+            self.high_noise_adapters = []
+            self.low_noise_adapters = []
+            if selected_lora_names:
+                for name in selected_lora_names:
+                    if name in LORA_SETS:
+                        self.high_noise_adapters.append(LORA_SETS[name]["high_noise"]["adapter_name"])
+                        self.low_noise_adapters.append(LORA_SETS[name]["low_noise"]["adapter_name"])
+
+        def __call__(self, pipe, step_index, timestep, callback_kwargs):
+            if step_index == 0:
+                self.switched = False
+                if self.high_noise_adapters:
+                    print(f"激活 High Noise LoRA: {self.high_noise_adapters}")
+                    pipe.set_adapters(self.high_noise_adapters, adapter_weights=[1.0] * len(self.high_noise_adapters))
+                elif pipe.get_active_adapters():
+                    active_adapters = pipe.get_active_adapters()
+                    print(f"未选择 LoRA，通过设置权重为0来禁用残留的 LoRA: {active_adapters}")
+                    pipe.set_adapters(active_adapters, adapter_weights=[0.0] * len(active_adapters))
+            
+            if self.low_noise_adapters and step_index >= switch_step and not self.switched:
+                print(f"在第 {step_index} 步切换到 Low Noise LoRA: {self.low_noise_adapters}")
+                pipe.set_adapters(self.low_noise_adapters, adapter_weights=[1.0] * len(self.low_noise_adapters))
+                self.switched = True
+            return callback_kwargs
+
+    lora_switcher_callback = LoraSwitcher(selected_loras)
+
+    output_frames_list = pipe(
+        image=processed_start_image,
+        last_image=processed_end_image,
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        height=target_height,
+        width=target_width,
+        num_frames=num_frames,
+        guidance_scale=float(guidance_scale),
+        guidance_scale_2=float(guidance_scale_2),
+        num_inference_steps=num_inference_steps,
+        generator=torch.Generator(device="cuda").manual_seed(current_seed),
+        callback_on_step_end=lora_switcher_callback,
+    ).frames[0]
+    
+    progress(0.9, desc="正在编码和保存视频...")
+    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
+        video_path = tmpfile.name
+    export_to_video(output_frames_list, video_path, fps=FIXED_FPS)
+    
+    progress(1.0, desc="完成!")
+    return video_path, current_seed
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Wan 2.2 First/Last Frame with Custom LoRA")
+    with gr.Row():
+        with gr.Column():
+            secret_key_input = gr.Textbox(label="密钥 (Secret Key)", placeholder="Enter your key here...", type="password")
+
+            with gr.Row():
+                start_image_component = gr.Image(type="pil", label="开始帧 (Start Frame)", sources=["upload", "clipboard"])
+                end_image_component = gr.Image(type="pil", label="结束帧 (End Frame)", sources=["upload", "clipboard"])
+
+            prompt_input = gr.Textbox(label="Prompt", value=default_prompt_i2v)
+            duration_seconds_input = gr.Slider(minimum=MIN_DURATION, maximum=MAX_DURATION, step=0.1, value=3.5, label="视频时长 (秒)", info=f"将在 {FIXED_FPS}fps 下被限制在模型的 {MIN_FRAMES_MODEL}-{MAX_FRAMES_MODEL} 帧范围内。")
+            
+            # 保留您的 LoRA 选择器
+            lora_selection_checkbox = gr.CheckboxGroup(
+                choices=list(LORA_SETS.keys()),
+                label="选择要应用的 LoRA (可多选)",
+                info="选择一个或多个 LoRA 风格进行组合。"
+            )
+            
+            with gr.Accordion("高级设置", open=False):
+                negative_prompt_input = gr.Textbox(label="负面提示词", value=default_negative_prompt, lines=3)
+                seed_input = gr.Slider(label="种子", minimum=0, maximum=MAX_SEED, step=1, value=42, interactive=True)
+                randomize_seed_checkbox = gr.Checkbox(label="随机种子", value=True, interactive=True)
+                steps_slider = gr.Slider(minimum=1, maximum=30, step=1, value=8, label="推理步数")
+                guidance_scale_input = gr.Slider(minimum=0.0, maximum=10.0, step=0.5, value=1, label="引导系数 - 高噪声阶段")
+                guidance_scale_2_input = gr.Slider(minimum=0.0, maximum=10.0, step=0.5, value=1, label="引导系数 2 - 低噪声阶段")
+
+            generate_button = gr.Button("生成视频", variant="primary")
+        with gr.Column():
+            video_output = gr.Video(label="生成的视频", autoplay=True, interactive=False)
+
+    ui_inputs = [
+        secret_key_input,
+        start_image_component,
+        end_image_component,
+        prompt_input,
+        steps_slider,
+        negative_prompt_input,
+        duration_seconds_input,
+        guidance_scale_input,
+        guidance_scale_2_input,
+        seed_input,
+        randomize_seed_checkbox,
+        lora_selection_checkbox
+    ]
+    generate_button.click(fn=generate_video, inputs=ui_inputs, outputs=[video_output, seed_input])
+
+if __name__ == "__main__":
+    demo.queue().launch(mcp_server=True)

optimization.py

@@ -0,0 +1,132 @@
+"""
+"""
+
+from typing import Any
+from typing import Callable
+from typing import ParamSpec
+
+import spaces
+import torch
+from torch.utils._pytree import tree_map_only
+from torchao.quantization import quantize_
+from torchao.quantization import Float8DynamicActivationFloat8WeightConfig
+from torchao.quantization import Int8WeightOnlyConfig
+
+from optimization_utils import capture_component_call
+from optimization_utils import aoti_compile
+from optimization_utils import drain_module_parameters
+
+
+P = ParamSpec('P')
+
+# --- 新的、更精确的动态塑形定义 ---
+
+# VAE 时间缩放因子为 1，latent_frames = num_frames。范围是 [8, 81]。
+LATENT_FRAMES_DIM = torch.export.Dim('num_latent_frames', min=8, max=81)
+
+# Transformer 的 patch_size 为 (1, 2, 2)，这意味着输入潜像的高度和宽度
+# 实际上被除以 2。如果符号追踪器假设奇数是可能的，这会产生约束失败。
+#
+# 为了解决这个问题，我们为 *打过补丁后* (即除法后) 的尺寸定义动态维度，
+# 然后将输入形状表示为该维度的 2 倍。这在数学上向编译器保证了
+# 输入潜像维度始终为偶数，从而满足约束。
+
+# 应用的像素尺寸范围：[480, 832]。VAE 缩放因子为 8。
+# 潜像维度范围：[480/8, 832/8] = [60, 104]。
+# 打过补丁后的潜像维度范围：[60/2, 104/2] = [30, 52]。
+LATENT_PATCHED_HEIGHT_DIM = torch.export.Dim('latent_patched_height', min=30, max=52)
+LATENT_PATCHED_WIDTH_DIM = torch.export.Dim('latent_patched_width', min=30, max=52)
+
+# 现在，我们为 transformer 的 `hidden_states` 输入定义动态形状，
+# 其形状为 (batch_size, channels, num_frames, height, width)。
+TRANSFORMER_DYNAMIC_SHAPES = {
+    'hidden_states': {
+        2: LATENT_FRAMES_DIM,
+        3: 2 * LATENT_PATCHED_HEIGHT_DIM, # 保证高度为偶数
+        4: 2 * LATENT_PATCHED_WIDTH_DIM,  # 保证宽度为偶数
+    },
+}
+
+# --- 定义结束 ---
+
+
+INDUCTOR_CONFIGS = {
+    'conv_1x1_as_mm': True,
+    'epilogue_fusion': False,
+    'coordinate_descent_tuning': True,
+    'coordinate_descent_check_all_directions': True,
+    'max_autotune': True,
+    'triton.cudagraphs': True,
+}
+
+
+def optimize_pipeline_(pipeline: Callable[P, Any], *args: P.args, **kwargs: P.kwargs):
+
+    @spaces.GPU(duration=1500)
+    def compile_transformer():
+        
+        # LoRA 融合部分保持不变
+        pipeline.load_lora_weights(
+            "Kijai/WanVideo_comfy", 
+            weight_name="Lightx2v/lightx2v_I2V_14B_480p_cfg_step_distill_rank128_bf16.safetensors", 
+            adapter_name="lightx2v"
+        )
+        kwargs_lora = {}
+        kwargs_lora["load_into_transformer_2"] = True
+        pipeline.load_lora_weights(
+            "Kijai/WanVideo_comfy", 
+            weight_name="Lightx2v/lightx2v_I2V_14B_480p_cfg_step_distill_rank128_bf16.safetensors", 
+            adapter_name="lightx2v_2", **kwargs_lora
+        )
+        pipeline.set_adapters(["lightx2v", "lightx2v_2"], adapter_weights=[1., 1.])
+        pipeline.fuse_lora(adapter_names=["lightx2v"], lora_scale=3., components=["transformer"])
+        pipeline.fuse_lora(adapter_names=["lightx2v_2"], lora_scale=1., components=["transformer_2"])
+        pipeline.unload_lora_weights()
+        
+        # 捕获单次调用以获取 args/kwargs 结构
+        with capture_component_call(pipeline, 'transformer') as call:
+            pipeline(*args, **kwargs)
+        
+        dynamic_shapes = tree_map_only((torch.Tensor, bool), lambda t: None, call.kwargs)
+        dynamic_shapes |= TRANSFORMER_DYNAMIC_SHAPES
+
+        # 量化保持不变
+        quantize_(pipeline.transformer, Float8DynamicActivationFloat8WeightConfig())
+        quantize_(pipeline.transformer_2, Float8DynamicActivationFloat8WeightConfig())
+        
+        # --- 简化的编译流程 ---
+        
+        exported_1 = torch.export.export(
+            mod=pipeline.transformer,
+            args=call.args,
+            kwargs=call.kwargs,
+            dynamic_shapes=dynamic_shapes,
+        )
+        
+        exported_2 = torch.export.export(
+            mod=pipeline.transformer_2,
+            args=call.args,
+            kwargs=call.kwargs,
+            dynamic_shapes=dynamic_shapes,
+        )
+
+        compiled_1 = aoti_compile(exported_1, INDUCTOR_CONFIGS)
+        compiled_2 = aoti_compile(exported_2, INDUCTOR_CONFIGS)
+        
+        # 返回两个已编译的模型
+        return compiled_1, compiled_2
+
+
+    # 量化文本编码器 (与之前相同)
+    quantize_(pipeline.text_encoder, Int8WeightOnlyConfig())
+    
+    # 获取两个经过动态塑形的已编译模型
+    compiled_transformer_1, compiled_transformer_2 = compile_transformer()
+
+    # --- 简化的赋值流程 ---
+    
+    pipeline.transformer.forward = compiled_transformer_1
+    drain_module_parameters(pipeline.transformer)
+
+    pipeline.transformer_2.forward = compiled_transformer_2
+    drain_module_parameters(pipeline.transformer_2)

optimization_utils.py

@@ -0,0 +1,107 @@
+"""
+"""
+import contextlib
+from contextvars import ContextVar
+from io import BytesIO
+from typing import Any
+from typing import cast
+from unittest.mock import patch
+
+import torch
+from torch._inductor.package.package import package_aoti
+from torch.export.pt2_archive._package import AOTICompiledModel
+from torch.export.pt2_archive._package_weights import Weights
+
+
+INDUCTOR_CONFIGS_OVERRIDES = {
+    'aot_inductor.package_constants_in_so': False,
+    'aot_inductor.package_constants_on_disk': True,
+    'aot_inductor.package': True,
+}
+
+
+class ZeroGPUWeights:
+    def __init__(self, constants_map: dict[str, torch.Tensor], to_cuda: bool = False):
+        if to_cuda:
+            self.constants_map = {name: tensor.to('cuda') for name, tensor in constants_map.items()}
+        else:
+            self.constants_map = constants_map
+    def __reduce__(self):
+        constants_map: dict[str, torch.Tensor] = {}
+        for name, tensor in self.constants_map.items():
+            tensor_ = torch.empty_like(tensor, device='cpu').pin_memory()
+            constants_map[name] = tensor_.copy_(tensor).detach().share_memory_()
+        return ZeroGPUWeights, (constants_map, True)
+
+
+class ZeroGPUCompiledModel:
+    def __init__(self, archive_file: torch.types.FileLike, weights: ZeroGPUWeights):
+        self.archive_file = archive_file
+        self.weights = weights
+        self.compiled_model: ContextVar[AOTICompiledModel | None] = ContextVar('compiled_model', default=None)
+    def __call__(self, *args, **kwargs):
+        if (compiled_model := self.compiled_model.get()) is None:
+            compiled_model = cast(AOTICompiledModel, torch._inductor.aoti_load_package(self.archive_file))
+            compiled_model.load_constants(self.weights.constants_map, check_full_update=True, user_managed=True)
+            self.compiled_model.set(compiled_model)
+        return compiled_model(*args, **kwargs)
+    def __reduce__(self):
+        return ZeroGPUCompiledModel, (self.archive_file, self.weights)
+
+
+def aoti_compile(
+    exported_program: torch.export.ExportedProgram,
+    inductor_configs: dict[str, Any] | None = None,
+):
+    inductor_configs = (inductor_configs or {}) | INDUCTOR_CONFIGS_OVERRIDES
+    gm = cast(torch.fx.GraphModule, exported_program.module())
+    assert exported_program.example_inputs is not None
+    args, kwargs = exported_program.example_inputs
+    artifacts = torch._inductor.aot_compile(gm, args, kwargs, options=inductor_configs)
+    archive_file = BytesIO()
+    files: list[str | Weights] = [file for file in artifacts if isinstance(file, str)]
+    package_aoti(archive_file, files)
+    weights, = (artifact for artifact in artifacts if isinstance(artifact, Weights))
+    zerogpu_weights = ZeroGPUWeights({name: weights.get_weight(name)[0] for name in weights})
+    return ZeroGPUCompiledModel(archive_file, zerogpu_weights)
+
+
+@contextlib.contextmanager
+def capture_component_call(
+    pipeline: Any,
+    component_name: str,
+    component_method='forward',
+):
+
+    class CapturedCallException(Exception):
+        def __init__(self, *args, **kwargs):
+            super().__init__()
+            self.args = args
+            self.kwargs = kwargs
+
+    class CapturedCall:
+        def __init__(self):
+            self.args: tuple[Any, ...] = ()
+            self.kwargs: dict[str, Any] = {}
+
+    component = getattr(pipeline, component_name)
+    captured_call = CapturedCall()
+
+    def capture_call(*args, **kwargs):
+        raise CapturedCallException(*args, **kwargs)
+
+    with patch.object(component, component_method, new=capture_call):
+        try:
+            yield captured_call
+        except CapturedCallException as e:
+            captured_call.args = e.args
+            captured_call.kwargs = e.kwargs
+
+
+def drain_module_parameters(module: torch.nn.Module):
+    state_dict_meta = {name: {'device': tensor.device, 'dtype': tensor.dtype} for name, tensor in module.state_dict().items()}
+    state_dict = {name: torch.nn.Parameter(torch.empty_like(tensor, device='cpu')) for name, tensor in module.state_dict().items()}
+    module.load_state_dict(state_dict, assign=True)
+    for name, param in state_dict.items():
+        meta = state_dict_meta[name]
+        param.data = torch.Tensor([]).to(**meta)

requirements.txt

@@ -0,0 +1,11 @@
+git+https://github.com/linoytsaban/diffusers.git@wan22-loras
+
+transformers
+accelerate
+safetensors
+sentencepiece
+peft
+ftfy
+imageio-ffmpeg
+opencv-python
+torchao==0.11.0