Harden privacy and pin four-step model stack

AGENT.md

@@ -1,169 +1,49 @@
-# AGENT.md
+# Agent guidance
 
-This file provides guidance to AI coding agents when working with code in this repository.
+## Project
 
-## Project Overview
+This repository is a Hugging Face Gradio Space for image editing with:
 
-This is a Gradio Space that implements "Next Scene" cinematic image generation using Qwen-Image-Edit-2509 with LoRA fine-tuning. The application generates visually progressive image sequences with natural cinematic transitions from frame to frame, optimized for fast 4-step inference.
+- `Qwen/Qwen-Image-Edit-2511`
+- a four-step Rapid-AIO transformer
+- a custom Qwen pipeline under `qwenimage/`
+- optional FA3 attention acceleration
 
-**Key Model Components:**
-- Base model: `Qwen/Qwen-Image-Edit-2509` (image editing diffusion model)
-- Accelerated transformer: `linoyts/Qwen-Image-Edit-Rapid-AIO` (4-step optimized variant)
-- LoRA adapter: `lovis93/next-scene-qwen-image-lora-2509` (cinematic progression fine-tune)
-- Text encoder: `Qwen2.5-VL-72B-Instruct` (via Hugging Face InferenceClient for prompt enhancement)
+The base model, accelerated transformer, and Diffusers dependency are pinned to
+exact revisions. Update those pins deliberately and test the deployed Space
+before merging.
 
-## Running the Application
+## Privacy boundary
 
-**Start the Gradio interface:**
-```bash
-python app.py
-```
-
-**Install dependencies:**
-```bash
-pip install -r requirements.txt
-```
-
-The app requires GPU access. It uses the `@spaces.GPU` decorator for Hugging Face Spaces zero-GPU allocation.
-
-## Architecture
-
-### Pipeline Flow
-
-1. **Input Processing** (`app.py:infer`):
-   - Accepts input images via Gradio Gallery (filepath-based)
-   - Optional prompt rewriting using `Qwen2.5-VL-72B-Instruct` API
-   - Automatic "Next Scene" prompt generation from images
-
-2. **Image Generation** (`qwenimage/pipeline_qwenimage_edit_plus.py`):
-   - Custom pipeline extending `DiffusionPipeline`
-   - Encodes images using VAE at 1024x1024 for latents
-   - Encodes conditioning images at 384x384 for text encoder
-   - Packs latents into 2x2 patches (latent dims must be divisible by 2)
-   - Uses `FlowMatchEulerDiscreteScheduler` for denoising
-
-3. **Optimization** (`optimization.py`):
-   - Ahead-of-time (AOT) compilation using `torch.export` and `spaces.aoti_compile`
-   - Dynamic shapes for variable sequence lengths
-   - Custom inductor configs for performance (max_autotune, cudagraphs)
-   - FlashAttention 3 integration via `QwenDoubleStreamAttnProcessorFA3`
-
-4. **Output Handling**:
-   - Saves outputs to `outputs/` directory with unique timestamps
-   - Maintains 20-image history gallery
-   - Optional video generation via `multimodalart/wan-2-2-first-last-frame` Space
-
-### Custom QwenImage Components
-
-**Location:** `qwenimage/` package
-
-- `pipeline_qwenimage_edit_plus.py` - Main diffusion pipeline with LoRA support
-- `transformer_qwenimage.py` - Custom transformer model with cache management
-- `qwen_fa3_processor.py` - FlashAttention 3 attention processor
-
-**Key architectural features:**
-- Latent packing/unpacking for 2x2 patch processing
-- Multi-image conditioning support
-- True CFG (classifier-free guidance) with separate pos/neg paths
-- Dual-stream attention with rotary embeddings
-- Cache contexts for conditional/unconditional forward passes
-
-### Prompt Engineering
-
-**Two-stage prompt system:**
-
-1. **Edit Instruction Rewriter** (`SYSTEM_PROMPT`):
-   - Normalizes user prompts into professional editing instructions
-   - Handles text replacement (requires quotes), object manipulation, style transfer
-   - Used when `rewrite_prompt=True` checkbox is enabled
-
-2. **Next Scene Generator** (`NEXT_SCENE_SYSTEM_PROMPT`):
-   - Automatically suggests cinematic camera movements
-   - Focus on visual progression (dolly, pan, zoom, framing changes)
-   - Auto-triggers when input images change
+Image inference runs inside the Space. Do not add application code that sends
+prompts, input images, generated images, or generation parameters to another
+service without explicit user consent and prominent UI/README disclosure.
 
-Both use `Qwen2.5-VL-72B-Instruct` via Hugging Face InferenceClient with Nebius provider. Requires `HF_TOKEN` environment variable.
+Do not print prompt text or image contents to application logs. Let Gradio
+manage temporary files and keep `delete_cache` enabled.
 
-## Important Implementation Details
+## Model-loading boundary
 
-### Image Dimension Handling
+The four-step UI must use the matching accelerated transformer. Do not silently
+fall back to the standard Qwen transformer while retaining a four-step default;
+that produces broken or misleading output. A clear startup failure is safer
+than silently changing model behavior.
 
-Images are automatically resized based on `calculate_dimensions()` function:
-- VAE images: resized to maintain 1024×1024 area (1,048,576 pixels)
-- Condition images: resized to maintain 384×384 area (147,456 pixels)
-- Output dimensions must be divisible by 16 (vae_scale_factor × 2)
-- Height/width default to `None` which auto-calculates from input aspect ratio
+## Validation
 
-### LoRA Integration
+Before deployment:
 
-The pipeline fuses the "next-scene" LoRA adapter at initialization:
-```python
-pipe.load_lora_weights("lovis93/next-scene-qwen-image-lora-2509", ...)
-pipe.set_adapters(["next-scene"], adapter_weights=[1.])
-pipe.fuse_lora(adapter_names=["next-scene"], lora_scale=1.)
-pipe.unload_lora_weights()
-```
-
-After fusion, the adapter weights are merged into the base model and cannot be unfused.
-
-### Video Generation Integration
-
-The `turn_into_video()` function:
-- Connects to external Gradio Space `multimodalart/wan-2-2-first-last-frame`
-- Requires first input image and last output image
-- Uses the original prompt (or "smooth cinematic transition" fallback)
-- Returns video path for display
-
-### Gradio Gallery Format
-
-Input/output galleries use `type="filepath"` (string paths) rather than PIL Image tuples. Helper functions handle format compatibility for legacy tuple support.
-
-## Environment Variables
-
-- `HF_TOKEN` - Required for Qwen2.5-VL API access (prompt rewriting/generation)
-
-## File Outputs
-
-Generated images are saved to `outputs/` directory with format:
-```
-output_{seed}_{index}_{timestamp_ms}.png
-```
-
-## Local Development and API Testing
-
-The `custom/` directory is fully gitignored and used for local development files. Specifically, it contains:
-
-- **API client scripts** - For testing the Gradio Space remotely via API after deployment to Hugging Face
-- **`API_GUIDE.txt`** - Auto-generated Gradio API documentation showing endpoint signatures and example usage
-- **Local testing environments** - Virtual environments or test data that shouldn't be committed
-
-**API Integration Pattern:**
-Once the Space is deployed to Hugging Face, you can interact with it programmatically using `gradio_client`:
-
-```python
-from gradio_client import Client, handle_file
-
-client = Client("Sneak-Moose/Qwen-Image-Edit-next-scene")
-result = client.predict(
-    images=[],
-    prompt="Next Scene: Camera dollies forward...",
-    seed=42,
-    randomize_seed=False,
-    true_guidance_scale=1.0,
-    num_inference_steps=4,
-    height=1024,
-    width=1024,
-    rewrite_prompt=False,
-    api_name="/infer"
-)
+```bash
+python3 -m compileall -q .
+git diff --check
 ```
 
-The `custom/API_GUIDE.txt` contains full documentation of all available endpoints including `/infer`, `/turn_into_video`, `/suggest_next_scene_prompt`, and utility functions.
+After deployment, verify:
 
-## Development Notes
+- the Space reaches `RUNNING`
+- a harmless synthetic edit succeeds
+- prompts do not appear in application logs
+- no unexpected application-level outbound upload paths exist
 
-- The model loads on startup and applies AOT compilation during first inference
-- Compilation uses dynamic shapes to support variable text/image sequence lengths
-- The transformer uses custom cache contexts ("cond"/"uncond") to optimize CFG passes
-- True CFG applies norm-based rescaling: `comb_pred * (cond_norm / noise_norm)`
-- FlashAttention 3 processor must be set before compilation
+The Space uses ZeroGPU and requires Hugging Face infrastructure for model
+downloads, builds, uploads, and inference hosting.

CLAUDE.md

@@ -1,154 +1,4 @@
-# CLAUDE.md
+# Claude Code guidance
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-This is a Gradio Space that implements "Next Scene" cinematic image generation using Qwen-Image-Edit-2511 with LoRA fine-tuning. The application generates visually progressive image sequences with natural cinematic transitions from frame to frame, optimized for fast 4-step inference.
-
-**Key Model Components:**
-- Base model: `Qwen/Qwen-Image-Edit-2511` (image editing diffusion model)
-- Accelerated transformer: `Sneak-Moose/Qwen-Rapid-AIO-v18-NSFW-diffusers` (extracted from Phr00t's v18, 4-step optimized)
-- LoRA adapter: `lovis93/next-scene-qwen-image-lora-2509` (cinematic progression fine-tune, trained on 2509)
-
-## Running the Application
-
-**Start the Gradio interface:**
-```bash
-python app.py
-```
-
-**Install dependencies:**
-```bash
-pip install -r requirements.txt
-```
-
-The app requires GPU access. It uses the `@spaces.GPU` decorator for Hugging Face Spaces zero-GPU allocation.
-
-## Architecture
-
-### Pipeline Flow
-
-1. **Input Processing** (`app.py:infer`):
-   - Accepts input images via Gradio Gallery (filepath-based)
-   - Uses user-provided prompts directly without modification
-
-2. **Image Generation** (`qwenimage/pipeline_qwenimage_edit_plus.py`):
-   - Custom pipeline extending `DiffusionPipeline`
-   - Encodes images using VAE at 1024x1024 for latents
-   - Encodes conditioning images at 384x384 for text encoder
-   - Packs latents into 2x2 patches (latent dims must be divisible by 2)
-   - Uses `FlowMatchEulerDiscreteScheduler` for denoising
-
-3. **Optimization** (`optimization.py`):
-   - Ahead-of-time (AOT) compilation using `torch.export` and `spaces.aoti_compile`
-   - Dynamic shapes for variable sequence lengths
-   - Custom inductor configs for performance (max_autotune, cudagraphs)
-   - FlashAttention 3 integration via `QwenDoubleStreamAttnProcessorFA3`
-
-4. **Output Handling**:
-   - Saves outputs to `outputs/` directory with unique timestamps
-   - Maintains 20-image history gallery
-   - Optional video generation via `multimodalart/wan-2-2-first-last-frame` Space
-
-### Custom QwenImage Components
-
-**Location:** `qwenimage/` package
-
-- `pipeline_qwenimage_edit_plus.py` - Main diffusion pipeline with LoRA support
-- `transformer_qwenimage.py` - Custom transformer model with cache management
-- `qwen_fa3_processor.py` - FlashAttention 3 attention processor
-
-**Key architectural features:**
-- Latent packing/unpacking for 2x2 patch processing
-- Multi-image conditioning support
-- True CFG (classifier-free guidance) with separate pos/neg paths
-- Dual-stream attention with rotary embeddings
-- Cache contexts for conditional/unconditional forward passes
-
-### Prompt Handling
-
-The application uses user-provided prompts directly without any preprocessing, rewriting, or AI-based enhancement. Users have full control over the exact prompt text that gets passed to the diffusion model.
-
-## Important Implementation Details
-
-### Image Dimension Handling
-
-Images are automatically resized based on `calculate_dimensions()` function:
-- VAE images: resized to maintain 1024×1024 area (1,048,576 pixels)
-- Condition images: resized to maintain 384×384 area (147,456 pixels)
-- Output dimensions must be divisible by 16 (vae_scale_factor × 2)
-- Height/width default to `None` which auto-calculates from input aspect ratio
-
-### LoRA Integration
-
-The pipeline fuses the "next-scene" LoRA adapter at initialization:
-```python
-pipe.load_lora_weights("lovis93/next-scene-qwen-image-lora-2509", ...)
-pipe.set_adapters(["next-scene"], adapter_weights=[1.])
-pipe.fuse_lora(adapter_names=["next-scene"], lora_scale=1.)
-pipe.unload_lora_weights()
-```
-
-After fusion, the adapter weights are merged into the base model and cannot be unfused.
-
-### Video Generation Integration
-
-The `turn_into_video()` function:
-- Connects to external Gradio Space `multimodalart/wan-2-2-first-last-frame`
-- Requires first input image and last output image
-- Uses the original prompt (or "smooth cinematic transition" fallback)
-- Returns video path for display
-
-### Gradio Gallery Format
-
-Input/output galleries use `type="filepath"` (string paths) rather than PIL Image tuples. Helper functions handle format compatibility for legacy tuple support.
-
-## Environment Variables
-
-No environment variables are required for basic operation. The application runs entirely with local models.
-
-## File Outputs
-
-Generated images are saved to `outputs/` directory with format:
-```
-output_{seed}_{index}_{timestamp_ms}.png
-```
-
-## Local Development and API Testing
-
-The `custom/` directory is fully gitignored and used for local development files. Specifically, it contains:
-
-- **API client scripts** - For testing the Gradio Space remotely via API after deployment to Hugging Face
-- **`API_GUIDE.txt`** - Auto-generated Gradio API documentation showing endpoint signatures and example usage
-- **Local testing environments** - Virtual environments or test data that shouldn't be committed
-
-**API Integration Pattern:**
-Once the Space is deployed to Hugging Face, you can interact with it programmatically using `gradio_client`:
-
-```python
-from gradio_client import Client, handle_file
-
-client = Client("Sneak-Moose/Qwen-Image-Edit-next-scene")
-result = client.predict(
-    images=[],
-    prompt="Camera dollies forward, revealing more of the scene",
-    seed=42,
-    randomize_seed=False,
-    true_guidance_scale=1.0,
-    num_inference_steps=4,
-    height=1024,
-    width=1024,
-    api_name="/infer"
-)
-```
-
-The `custom/API_GUIDE.txt` contains full documentation of all available endpoints including `/infer`, `/turn_into_video`, and utility functions.
-
-## Development Notes
-
-- The model loads on startup and applies AOT compilation during first inference
-- Compilation uses dynamic shapes to support variable text/image sequence lengths
-- The transformer uses custom cache contexts ("cond"/"uncond") to optimize CFG passes
-- True CFG applies norm-based rescaling: `comb_pred * (cond_norm / noise_norm)`
-- FlashAttention 3 processor must be set before compilation
+Follow [AGENT.md](AGENT.md). It is the canonical contributor and agent guide
+for this repository.

README.md

@@ -13,4 +13,13 @@ short_description: Powerful image editing - supports one or two input images.
 
 Pro Realism Edit Studio is a powerful image editor powered by [Qwen-Image-Edit-2511](https://huggingface.co/Qwen/Qwen-Image-Edit-2511) with [Phr00t's Rapid-AIO v18](https://huggingface.co/Phr00t/Qwen-Image-Edit-Rapid-AIO) accelerated transformer for 4-step inference. Upload one or two input images, write a prompt, get high-quality results.
 
-*This space includes a Debug Diagnostic Dashboard that collects anonymous usage data for ongoing performance monitoring.*
+## Privacy
+
+- Image editing runs inside this Hugging Face Space using locally loaded model weights.
+- The application does not send prompts or images to a separate diagnostics, analytics, or video-generation service.
+- Prompts are not written to application logs.
+- Hugging Face and Gradio necessarily process uploads to operate the Space. Gradio-managed temporary files are configured to expire after 24 hours.
+
+## Reproducibility
+
+The base model, accelerated transformer, and development version of Diffusers are pinned to exact revisions. If the accelerated four-step transformer cannot load, the Space stops with a clear error rather than silently switching to an incompatible model.

app.py

@@ -5,68 +5,12 @@ import torch
 import spaces
 
 from PIL import Image
-from diffusers import FlowMatchEulerDiscreteScheduler
-from optimization import optimize_pipeline_
 from qwenimage.pipeline_qwenimage_edit_plus import QwenImageEditPlusPipeline
 from qwenimage.transformer_qwenimage import QwenImageTransformer2DModel
 from qwenimage.qwen_fa3_processor import QwenDoubleStreamAttnProcessorFA3
 
-import math
-from huggingface_hub import hf_hub_download
-from safetensors.torch import load_file
-
-import os
-import time  # Added for history update delay
-import threading
-
-from gradio_client import Client, handle_file
-import tempfile
-from PIL import Image
 import os
-import gradio as gr
-
-def turn_into_video(input_image, output_images, prompt, progress=gr.Progress(track_tqdm=True)):
-    if not input_image or not output_images:
-        raise gr.Error("Please generate an output image first.")
-
-    progress(0.02, desc="Preparing images...")
-
-    def extract_pil(img_entry):
-        if isinstance(img_entry, tuple) and isinstance(img_entry[0], Image.Image):
-            return img_entry[0]
-        elif isinstance(img_entry, Image.Image):
-            return img_entry
-        elif isinstance(img_entry, str):
-            return Image.open(img_entry)
-        else:
-            raise gr.Error(f"Unsupported image format: {type(img_entry)}")
-
-    start_img = extract_pil(input_image)
-    end_img   = extract_pil(output_images[0])
-
-    progress(0.10, desc="Saving temp files...")
-
-    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_start, \
-         tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_end:
-        start_img.save(tmp_start.name)
-        end_img.save(tmp_end.name)
-
-    progress(0.20, desc="Connecting to Wan space...")
-
-    client = Client("multimodalart/wan-2-2-first-last-frame")  
-
-    progress(0.35, desc="Generating video...")
-
-    video_path, seed = client.predict(
-        start_image_pil=handle_file(tmp_start.name),
-        end_image_pil=handle_file(tmp_end.name),
-        prompt=prompt or "smooth cinematic transition",
-        api_name="/generate_video"
-    )
-
-    progress(0.95, desc="Finalizing...")
-    print(video_path)
-    return video_path['video']
+import time
 
 
 def update_history(new_images, history):
@@ -93,32 +37,32 @@ def use_history_as_input(evt: gr.SelectData):
 dtype = torch.bfloat16
 device = "cuda" if torch.cuda.is_available() else "cpu"
 hf_token = os.environ.get("HF_TOKEN") or None
-
-# Load Qwen-Image-Edit-2511. The upstream Space points at a private/unlisted
-# Sneak-Moose accelerated transformer, which breaks duplicated Spaces unless
-# the duplicating account has explicit access. Try it when available, but fall
-# back to the public Qwen transformer so this Space can boot independently.
+BASE_MODEL_ID = "Qwen/Qwen-Image-Edit-2511"
+BASE_MODEL_REVISION = "6f3ccc0b56e431dc6a0c2b2039706d7d26f22cb9"
+ACCELERATED_TRANSFORMER_ID = "Sneak-Moose/Qwen-Rapid-AIO-v18-NSFW-diffusers"
+ACCELERATED_TRANSFORMER_REVISION = "5641245ab83ffd498c986485eb8c3e9f6f3f2184"
+
+# This UI is tuned for four-step inference and must use the matching accelerated
+# transformer. Do not silently fall back to the standard transformer: doing so
+# produces misleading low-quality output while presenting the app as healthy.
 try:
     transformer = QwenImageTransformer2DModel.from_pretrained(
-        "Sneak-Moose/Qwen-Rapid-AIO-v18-NSFW-diffusers",
+        ACCELERATED_TRANSFORMER_ID,
         subfolder="transformer",
+        revision=ACCELERATED_TRANSFORMER_REVISION,
         torch_dtype=dtype,
         device_map="cuda" if torch.cuda.is_available() else None,
         token=hf_token,
     )
-    print("Loaded accelerated Sneak-Moose transformer.")
 except Exception as exc:
-    print(f"Accelerated transformer unavailable; falling back to public Qwen transformer: {exc}")
-    transformer = QwenImageTransformer2DModel.from_pretrained(
-        "Qwen/Qwen-Image-Edit-2511",
-        subfolder="transformer",
-        torch_dtype=dtype,
-        device_map="cuda" if torch.cuda.is_available() else None,
-        token=hf_token,
-    )
+    raise RuntimeError(
+        "The pinned four-step accelerated transformer could not be loaded. "
+        "Generation is disabled rather than silently using an incompatible fallback."
+    ) from exc
 
 pipe = QwenImageEditPlusPipeline.from_pretrained(
-    "Qwen/Qwen-Image-Edit-2511",
+    BASE_MODEL_ID,
+    revision=BASE_MODEL_REVISION,
     transformer=transformer,
     torch_dtype=dtype,
     token=hf_token,
@@ -213,9 +157,10 @@ def infer(
 
     if height==256 and width==256:
         height, width = None, None
-    print(f"Calling pipeline with prompt: '{prompt}'")
-    print(f"Negative Prompt: '{negative_prompt}'")
-    print(f"Seed: {seed}, Steps: {num_inference_steps}, Guidance: {true_guidance_scale}, Size: {width}x{height}")
+    print(
+        f"Starting generation: seed={seed}, steps={num_inference_steps}, "
+        f"guidance={true_guidance_scale}, size={width}x{height}, inputs={len(pil_images)}"
+    )
 
     # Generate the image
     images_pil = pipe(
@@ -230,16 +175,8 @@ def infer(
         num_images_per_prompt=num_images_per_prompt,
     ).images
 
-    # Save images to temporary files for proper serving
-    output_paths = []
-    os.makedirs("outputs", exist_ok=True)
-    for idx, img in enumerate(images_pil):
-        output_path = f"outputs/output_{seed}_{idx}_{int(time.time()*1000)}.png"
-        img.save(output_path)
-        output_paths.append(output_path)
-
-    # Return image paths, seed, and make button visible
-    return output_paths, seed, gr.update(visible=True), gr.update(visible=True)
+    # Let Gradio manage temporary result files so delete_cache can expire them.
+    return images_pil, seed, gr.update(visible=True)
 
 
 # --- UI Layout ---
@@ -257,12 +194,12 @@ css = """
 #edit_text{margin-top: -62px !important}
 """
 
-with gr.Blocks(css=css) as demo:
+with gr.Blocks(css=css, delete_cache=(3600, 86400)) as demo:
     with gr.Column(elem_id="col-container"):
         gr.HTML("""
         <div id="logo-title">
-            <img src="https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-Image/qwen_image_edit_logo.png" alt="Qwen-Image Edit Logo" width="400" style="display: block; margin: 0 auto;">
-            <h2 style="font-style: italic;color: #5b47d1;margin-top: -27px !important;margin-left: 96px">Rapid Edit ⚡</h2>
+            <h1>Pro Realism Edit Studio 🎨</h1>
+            <h2 style="font-style: italic;color: #5b47d1">Rapid Edit ⚡</h2>
         </div>
         """)
         gr.Markdown("""
@@ -336,8 +273,6 @@ with gr.Blocks(css=css) as demo:
                 result = gr.Gallery(label="Result", show_label=False, type="filepath")
                 with gr.Row():
                     use_output_btn = gr.Button("↗️ Use as input", variant="secondary", size="sm", visible=False)
-                    turn_video_btn = gr.Button("🎬 Turn into Video", variant="secondary", size="sm", visible=False)
-                output_video = gr.Video(label="Generated Video", autoplay=True, visible=False)
 
                 with gr.Row(visible=False):
                     gr.Markdown("### 📜 History")
@@ -368,7 +303,7 @@ with gr.Blocks(css=css) as demo:
             height,
             width,
         ],
-        outputs=[result, seed, use_output_btn, turn_video_btn],
+        outputs=[result, seed, use_output_btn],
 
     ).then(
     fn=update_history,
@@ -399,16 +334,5 @@ with gr.Blocks(css=css) as demo:
 
     )
 
-    turn_video_btn.click(
-    fn=lambda: gr.update(visible=True),   
-    inputs=None,
-    outputs=[output_video],
-).then(
-    fn=turn_into_video,
-    inputs=[image_1, result, prompt],
-    outputs=[output_video],
-)
-
-
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()

requirements.txt

@@ -1,11 +1,10 @@
-git+https://github.com/huggingface/diffusers.git
+git+https://github.com/huggingface/diffusers.git@7685bffe89041496c2c0ae07ea933df1c80d1f43
 
 transformers
 accelerate
 safetensors
 sentencepiece
-dashscope
 kernels<0.15.1
 torchvision
 peft
-torchao==0.11.0
+torchao==0.11.0