init project

.gitignore

@@ -0,0 +1,56 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Model files and cache
+LoRAs/
+*.safetensors
+*.bin
+*.ckpt
+*.pth
+
+# Temporary files
+*.tmp
+*.log
+temp/
+gradio_cached_examples/
+
+# Environment variables
+.env
+.env.local
+
+# Hugging Face cache
+.cache/

Dockerfile

@@ -0,0 +1,34 @@
+# Use the official Python runtime as the base image
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    wget \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create directory for LoRA weights
+RUN mkdir -p LoRAs
+
+# Expose the port that Gradio runs on
+EXPOSE 7860
+
+# Set environment variables
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+ENV GRADIO_SERVER_PORT=7860
+
+# Run the application
+CMD ["python", "app.py"]

README.md

@@ -1,12 +1,114 @@
 ---
-title: Owen777 Kontext Style Loras
-emoji: ⚡
-colorFrom: yellow
-colorTo: blue
+title: FLUX Kontext Style Transfer
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.42.0
+sdk_version: 4.0.0
 app_file: app.py
 pinned: false
+license: apache-2.0
+hardware: zero-gpu
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎨 FLUX Kontext Style Transfer
+
+Transform your images with 20+ artistic styles using the powerful FLUX.1 Kontext model and style-specific LoRA adapters!
+
+This Hugging Face Space provides an easy-to-use interface for applying various artistic styles to your images using the [Owen777/Kontext-Style-Loras](https://huggingface.co/Owen777/Kontext-Style-Loras) model.
+
+## 🌟 Features
+
+- **20+ Artistic Styles**: From Studio Ghibli to Van Gogh, Pixel Art to 3D Chibi
+- **High-Quality Results**: Powered by FLUX.1 Kontext model
+- **Easy-to-Use Interface**: Simple upload and style selection
+- **Customizable**: Adjust inference steps, guidance scale, and LoRA strength
+- **GPU-Accelerated**: Runs on Hugging Face ZeroGPU for fast inference
+
+## 🎭 Available Styles
+
+| Style | Description |
+|-------|-------------|
+| **3D_Chibi** | Cute 3D chibi character style |
+| **American_Cartoon** | Classic American cartoon aesthetics |
+| **Chinese_Ink** | Traditional Chinese ink painting |
+| **Clay_Toy** | Clay toy/sculpture appearance |
+| **Fabric** | Textile and fabric textures |
+| **Ghibli** | Studio Ghibli anime style |
+| **Irasutoya** | Japanese illustration style |
+| **Jojo** | JoJo's Bizarre Adventure anime style |
+| **Oil_Painting** | Classic oil painting technique |
+| **Pixel** | Retro pixel art style |
+| **Snoopy** | Peanuts comic strip style |
+| **Poly** | Low-poly 3D art style |
+| **LEGO** | LEGO brick construction style |
+| **Origami** | Paper folding art style |
+| **Pop_Art** | Pop art movement style |
+| **Van_Gogh** | Van Gogh's distinctive painting style |
+| **Paper_Cutting** | Paper cutting art technique |
+| **Line** | Clean line art style |
+| **Vector** | Vector graphics style |
+| **Picasso** | Picasso's cubist style |
+| **Macaron** | Soft pastel macaron colors |
+| **Rick_Morty** | Rick and Morty cartoon style |
+
+## 🚀 How to Use
+
+1. **Upload an Image**: Click on the image upload area and select your image
+2. **Choose a Style**: Select from 20+ available artistic styles
+3. **Customize (Optional)**: 
+   - Add a custom prompt for specific styling
+   - Adjust advanced settings like inference steps and LoRA strength
+4. **Generate**: Click the "Generate Styled Image" button
+5. **Download**: Save your stylized image
+
+## ⚙️ Advanced Settings
+
+- **Inference Steps**: Higher values (20-50) generally produce better quality but take longer
+- **Guidance Scale**: Controls how closely the model follows the prompt (7.5 is recommended)
+- **LoRA Strength**: Adjusts the intensity of the style application (0.1-2.0)
+- **Dimensions**: Control output image size (512-1536 pixels)
+- **Seed**: Set a specific seed for reproducible results
+
+## 🎯 Tips for Best Results
+
+- Use high-quality input images (1024x1024 recommended)
+- Experiment with different LoRA strengths for varying style intensity
+- Try custom prompts to guide the style transformation
+- For detailed styles like "Line" or "Vector", consider using higher inference steps
+
+## 🔧 Technical Details
+
+- **Base Model**: [black-forest-labs/FLUX.1-Kontext-dev](https://huggingface.co/black-forest-labs/FLUX.1-Kontext-dev)
+- **LoRA Adapters**: [Owen777/Kontext-Style-Loras](https://huggingface.co/Owen777/Kontext-Style-Loras)
+- **Framework**: Diffusers, PyTorch
+- **Interface**: Gradio
+- **Hardware**: Hugging Face ZeroGPU
+
+## 📚 Model Information
+
+The LoRA adapters are trained on high-quality paired data generated by GPT-4o and sourced from Omniconsistency. The training methodology ensures consistent and high-quality style transfers across various artistic domains.
+
+**Training Code**: Available at [Owen718/Kontext-Lora-Trainer](https://github.com/Owen718/Kontext-Lora-Trainer)
+
+## 🏆 Contributors
+
+- **Tian YE & Song FEI** - HKUST Guangzhou
+
+## 📄 License
+
+This project is licensed under the Apache 2.0 License. See the original model repository for detailed license information.
+
+## 🤝 Contributing
+
+Feel free to open issues or contact the original authors for feedback or collaboration! More style LoRAs will be released soon.
+
+## 🔗 Links
+
+- [Model Repository](https://huggingface.co/Owen777/Kontext-Style-Loras)
+- [Training Code](https://github.com/Owen718/Kontext-Lora-Trainer)
+- [FLUX.1 Kontext Base Model](https://huggingface.co/black-forest-labs/FLUX.1-Kontext-dev)
+
+---
+
+*Transform your creativity with AI-powered artistic style transfer!* ✨

app.py

@@ -0,0 +1,311 @@
+import gradio as gr
+import torch
+from huggingface_hub import hf_hub_download
+from diffusers import FluxKontextPipeline
+from diffusers.utils import load_image
+from PIL import Image
+import spaces
+import os
+import gc
+
+# Style LoRA mapping
+STYLE_TYPE_LORA_DICT = {
+    "3D_Chibi": "3D_Chibi_lora_weights.safetensors",
+    "American_Cartoon": "American_Cartoon_lora_weights.safetensors",
+    "Chinese_Ink": "Chinese_Ink_lora_weights.safetensors",
+    "Clay_Toy": "Clay_Toy_lora_weights.safetensors",
+    "Fabric": "Fabric_lora_weights.safetensors",
+    "Ghibli": "Ghibli_lora_weights.safetensors",
+    "Irasutoya": "Irasutoya_lora_weights.safetensors",
+    "Jojo": "Jojo_lora_weights.safetensors",
+    "Oil_Painting": "Oil_Painting_lora_weights.safetensors",
+    "Pixel": "Pixel_lora_weights.safetensors",
+    "Snoopy": "Snoopy_lora_weights.safetensors",
+    "Poly": "Poly_lora_weights.safetensors",
+    "LEGO": "LEGO_lora_weights.safetensors",
+    "Origami": "Origami_lora_weights.safetensors",
+    "Pop_Art": "Pop_Art_lora_weights.safetensors",
+    "Van_Gogh": "Van_Gogh_lora_weights.safetensors",
+    "Paper_Cutting": "Paper_Cutting_lora_weights.safetensors",
+    "Line": "Line_lora_weights.safetensors",
+    "Vector": "Vector_lora_weights.safetensors",
+    "Picasso": "Picasso_lora_weights.safetensors",
+    "Macaron": "Macaron_lora_weights.safetensors",
+    "Rick_Morty": "Rick_Morty_lora_weights.safetensors"
+}
+
+# Global variables for pipeline management
+pipeline = None
+current_lora = None
+
+def load_pipeline():
+    """Load the base FLUX Kontext pipeline"""
+    global pipeline
+    if pipeline is None:
+        print("Loading FLUX Kontext pipeline...")
+        pipeline = FluxKontextPipeline.from_pretrained(
+            "black-forest-labs/FLUX.1-Kontext-dev", 
+            torch_dtype=torch.bfloat16
+        ).to('cuda')
+        print("Pipeline loaded successfully!")
+    return pipeline
+
+def download_lora(style_name):
+    """Download LoRA weights if not already cached"""
+    lora_filename = STYLE_TYPE_LORA_DICT[style_name]
+    local_path = f"./LoRAs/{lora_filename}"
+    
+    if not os.path.exists(local_path):
+        print(f"Downloading LoRA for {style_name}...")
+        os.makedirs("./LoRAs", exist_ok=True)
+        hf_hub_download(
+            repo_id="Owen777/Kontext-Style-Loras", 
+            filename=lora_filename, 
+            local_dir="./LoRAs"
+        )
+        print(f"LoRA downloaded: {local_path}")
+    return local_path
+
+@spaces.GPU
+def generate_styled_image(
+    input_image, 
+    style_name, 
+    custom_prompt="", 
+    num_inference_steps=24, 
+    guidance_scale=7.5,
+    lora_strength=1.0,
+    width=1024,
+    height=1024,
+    seed=-1
+):
+    """Generate styled image using FLUX Kontext with LoRA"""
+    global pipeline, current_lora
+    
+    try:
+        # Load pipeline if not loaded
+        pipeline = load_pipeline()
+        
+        # Download and load LoRA if different from current
+        if current_lora != style_name:
+            lora_path = download_lora(style_name)
+            
+            # Unload previous LoRA if any
+            if current_lora is not None:
+                try:
+                    pipeline.unload_lora_weights()
+                except:
+                    pass
+            
+            # Load new LoRA
+            pipeline.load_lora_weights(lora_path, adapter_name="lora")
+            pipeline.set_adapters(["lora"], adapter_weights=[lora_strength])
+            current_lora = style_name
+            print(f"Loaded LoRA: {style_name}")
+        else:
+            # Update LoRA strength if same LoRA
+            pipeline.set_adapters(["lora"], adapter_weights=[lora_strength])
+        
+        # Prepare input image
+        if input_image is None:
+            raise ValueError("Please provide an input image")
+        
+        # Resize input image
+        input_image = input_image.resize((width, height))
+        
+        # Prepare prompt
+        if custom_prompt.strip():
+            prompt = custom_prompt
+        else:
+            prompt = f"Turn this image into the {style_name.replace('_', ' ')} style."
+        
+        # Set seed for reproducibility
+        if seed != -1:
+            torch.manual_seed(seed)
+        
+        # Generate image
+        print(f"Generating image with style: {style_name}")
+        print(f"Prompt: {prompt}")
+        
+        with torch.autocast("cuda"):
+            result = pipeline(
+                image=input_image,
+                prompt=prompt,
+                height=height,
+                width=width,
+                num_inference_steps=num_inference_steps,
+                guidance_scale=guidance_scale
+            )
+        
+        output_image = result.images[0]
+        
+        # Clean up GPU memory
+        torch.cuda.empty_cache()
+        gc.collect()
+        
+        return output_image
+        
+    except Exception as e:
+        print(f"Error generating image: {str(e)}")
+        return None
+
+# Custom CSS for better UI
+css = """
+.gradio-container {
+    font-family: 'Helvetica Neue', Arial, sans-serif;
+}
+.title {
+    text-align: center;
+    font-size: 2.5em;
+    font-weight: bold;
+    margin-bottom: 1em;
+    color: #2c3e50;
+}
+.subtitle {
+    text-align: center;
+    font-size: 1.2em;
+    color: #7f8c8d;
+    margin-bottom: 2em;
+}
+"""
+
+# Create Gradio interface
+with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
+    gr.HTML('<div class="title">🎨 FLUX Kontext Style Transfer</div>')
+    gr.HTML('<div class="subtitle">Transform your images with 20+ artistic styles using LoRA adapters</div>')
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Input")
+            input_image = gr.Image(
+                label="Upload Image",
+                type="pil",
+                height=400
+            )
+            
+            style_dropdown = gr.Dropdown(
+                choices=list(STYLE_TYPE_LORA_DICT.keys()),
+                label="Choose Style",
+                value="Ghibli",
+                interactive=True
+            )
+            
+            custom_prompt = gr.Textbox(
+                label="Custom Prompt (Optional)",
+                placeholder="Leave empty to use default style prompt",
+                lines=2
+            )
+            
+            with gr.Accordion("Advanced Settings", open=False):
+                num_inference_steps = gr.Slider(
+                    minimum=10,
+                    maximum=50,
+                    value=24,
+                    step=1,
+                    label="Inference Steps"
+                )
+                
+                guidance_scale = gr.Slider(
+                    minimum=1.0,
+                    maximum=20.0,
+                    value=7.5,
+                    step=0.1,
+                    label="Guidance Scale"
+                )
+                
+                lora_strength = gr.Slider(
+                    minimum=0.1,
+                    maximum=2.0,
+                    value=1.0,
+                    step=0.1,
+                    label="LoRA Strength"
+                )
+                
+                with gr.Row():
+                    width = gr.Slider(
+                        minimum=512,
+                        maximum=1536,
+                        value=1024,
+                        step=64,
+                        label="Width"
+                    )
+                    height = gr.Slider(
+                        minimum=512,
+                        maximum=1536,
+                        value=1024,
+                        step=64,
+                        label="Height"
+                    )
+                
+                seed = gr.Number(
+                    label="Seed (-1 for random)",
+                    value=-1,
+                    precision=0
+                )
+            
+            generate_btn = gr.Button("🎨 Generate Styled Image", variant="primary", size="lg")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### Output")
+            output_image = gr.Image(
+                label="Styled Image",
+                height=400
+            )
+    
+    # Examples
+    gr.Markdown("### Examples")
+    gr.Examples(
+        examples=[
+            ["https://huggingface.co/datasets/black-forest-labs/kontext-bench/resolve/main/test/images/0003.jpg", "Ghibli", "", 24, 7.5, 1.0, 1024, 1024, -1],
+            ["https://huggingface.co/datasets/black-forest-labs/kontext-bench/resolve/main/test/images/0003.jpg", "Pixel", "", 24, 7.5, 1.0, 1024, 1024, -1],
+            ["https://huggingface.co/datasets/black-forest-labs/kontext-bench/resolve/main/test/images/0003.jpg", "Van_Gogh", "", 24, 7.5, 1.0, 1024, 1024, -1],
+        ],
+        inputs=[input_image, style_dropdown, custom_prompt, num_inference_steps, guidance_scale, lora_strength, width, height, seed],
+        outputs=[output_image],
+        fn=generate_styled_image,
+        cache_examples=False,
+    )
+    
+    # Event handlers
+    generate_btn.click(
+        fn=generate_styled_image,
+        inputs=[
+            input_image, 
+            style_dropdown, 
+            custom_prompt, 
+            num_inference_steps, 
+            guidance_scale,
+            lora_strength,
+            width,
+            height,
+            seed
+        ],
+        outputs=[output_image]
+    )
+    
+    # Information section
+    with gr.Accordion("About", open=False):
+        gr.Markdown("""
+        ### FLUX Kontext Style Transfer
+        
+        This application uses the FLUX.1 Kontext model with style-specific LoRA adapters to transform images into various artistic styles.
+        
+        **Available Styles:**
+        - 3D Chibi, American Cartoon, Chinese Ink, Clay Toy
+        - Fabric, Ghibli, Irasutoya, Jojo, Oil Painting
+        - Pixel, Snoopy, Poly, LEGO, Origami
+        - Pop Art, Van Gogh, Paper Cutting, Line, Vector
+        - Picasso, Macaron, Rick & Morty
+        
+        **Tips:**
+        - Upload high-quality images for best results
+        - Experiment with different LoRA strengths
+        - Use custom prompts for more specific styling
+        - Higher inference steps generally produce better quality
+        
+        **Model:** [Owen777/Kontext-Style-Loras](https://huggingface.co/Owen777/Kontext-Style-Loras)
+        
+        **Training Code:** [GitHub Repository](https://github.com/Owen718/Kontext-Lora-Trainer)
+        """)
+
+if __name__ == "__main__":
+    demo.launch()

config.py

@@ -0,0 +1,71 @@
+"""
+Configuration file for FLUX Kontext Style Transfer Space
+"""
+
+import os
+
+# Model configuration
+BASE_MODEL_ID = "black-forest-labs/FLUX.1-Kontext-dev"
+LORA_REPO_ID = "Owen777/Kontext-Style-Loras"
+
+# Default generation parameters
+DEFAULT_INFERENCE_STEPS = 24
+DEFAULT_GUIDANCE_SCALE = 7.5
+DEFAULT_LORA_STRENGTH = 1.0
+DEFAULT_WIDTH = 1024
+DEFAULT_HEIGHT = 1024
+
+# GPU and memory settings
+USE_TORCH_COMPILE = False  # Set to True if you want to use torch.compile for faster inference
+ENABLE_CPU_OFFLOAD = True  # Enable CPU offloading to save GPU memory
+LOW_VRAM_MODE = False  # Set to True for systems with limited VRAM
+
+# Gradio configuration
+GRADIO_SHARE = False
+GRADIO_DEBUG = False
+GRADIO_ENABLE_QUEUE = True
+MAX_QUEUE_SIZE = 20
+
+# Cache settings
+CACHE_DIR = "./cache"
+LORA_CACHE_DIR = "./LoRAs"
+
+# Security settings
+MAX_IMAGE_SIZE = 2048  # Maximum image dimension
+MIN_IMAGE_SIZE = 256   # Minimum image dimension
+MAX_BATCH_SIZE = 1     # Maximum number of images to process at once
+
+# Hugging Face settings
+HF_TOKEN = os.getenv("HF_TOKEN", None)  # Optional: Set if you need authentication
+
+# Style configuration with descriptions
+STYLE_DESCRIPTIONS = {
+    "3D_Chibi": "Transform images into cute 3D chibi character style",
+    "American_Cartoon": "Apply classic American cartoon aesthetics",
+    "Chinese_Ink": "Convert to traditional Chinese ink painting style",
+    "Clay_Toy": "Give images a clay toy/sculpture appearance",
+    "Fabric": "Apply textile and fabric texture effects",
+    "Ghibli": "Transform into Studio Ghibli anime style",
+    "Irasutoya": "Apply Japanese Irasutoya illustration style",
+    "Jojo": "Convert to JoJo's Bizarre Adventure anime style",
+    "Oil_Painting": "Apply classic oil painting techniques",
+    "Pixel": "Transform into retro pixel art style",
+    "Snoopy": "Apply Peanuts comic strip style",
+    "Poly": "Convert to low-poly 3D art style",
+    "LEGO": "Transform into LEGO brick construction style",
+    "Origami": "Apply paper folding origami art style",
+    "Pop_Art": "Convert to pop art movement style",
+    "Van_Gogh": "Apply Van Gogh's distinctive painting style",
+    "Paper_Cutting": "Transform using paper cutting art technique",
+    "Line": "Convert to clean line art style",
+    "Vector": "Apply vector graphics style",
+    "Picasso": "Transform using Picasso's cubist style",
+    "Macaron": "Apply soft pastel macaron color palette",
+    "Rick_Morty": "Convert to Rick and Morty cartoon style"
+}
+
+# Example images for demonstration
+EXAMPLE_IMAGES = [
+    "https://huggingface.co/datasets/black-forest-labs/kontext-bench/resolve/main/test/images/0003.jpg",
+    # Add more example image URLs here if needed
+]

deploy.md

@@ -0,0 +1,121 @@
+# Deployment Guide for FLUX Kontext Style Transfer Space
+
+## Quick Start
+
+### 1. Create a New Hugging Face Space
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Choose:
+   - **Space name**: `flux-kontext-style-transfer` (or your preferred name)
+   - **License**: Apache 2.0
+   - **SDK**: Gradio
+   - **Hardware**: ZeroGPU (recommended) or T4 Medium
+4. Click "Create Space"
+
+### 2. Upload Files
+
+Upload all the files from this directory to your new Space:
+
+- `app.py` - Main application file
+- `requirements.txt` - Python dependencies
+- `README.md` - Space documentation
+- `config.py` - Configuration settings
+- `.gitignore` - Git ignore file
+- `Dockerfile` - Docker configuration (optional)
+
+### 3. Space Configuration
+
+The Space should automatically start building once you upload the files. The `README.md` contains the necessary YAML frontmatter with the Space configuration.
+
+### 4. Hardware Requirements
+
+For optimal performance, use:
+- **ZeroGPU**: Best for public spaces (free with queue)
+- **T4 Medium or Large**: For consistent performance
+- **A10G Small or Medium**: For faster inference
+
+### 5. Environment Variables (Optional)
+
+If you need to set environment variables:
+1. Go to your Space settings
+2. Add variables in the "Variables and secrets" section
+3. Common variables:
+   - `HF_TOKEN`: Hugging Face token (if needed for private models)
+
+## File Structure
+
+```
+your-space/
+├── app.py              # Main Gradio application
+├── requirements.txt    # Python dependencies
+├── README.md          # Space documentation with metadata
+├── config.py          # Configuration settings
+├── .gitignore         # Git ignore patterns
+├── Dockerfile         # Docker configuration (optional)
+└── deploy.md          # This deployment guide
+```
+
+## Features Included
+
+- **Complete Gradio Interface**: Ready-to-use web interface
+- **20+ Style LoRAs**: All styles from the original model
+- **GPU Optimization**: Configured for ZeroGPU
+- **Memory Management**: Efficient GPU memory usage
+- **Examples**: Pre-loaded example images
+- **Advanced Settings**: Customizable parameters
+- **Professional UI**: Clean, modern interface
+
+## Customization Options
+
+### Adding New Styles
+1. Update `STYLE_TYPE_LORA_DICT` in `app.py`
+2. Add new LoRA files to the model repository
+3. Update style descriptions in `config.py`
+
+### UI Modifications
+- Edit the CSS in `app.py` for custom styling
+- Modify the Gradio layout in the interface section
+- Add new components or remove existing ones
+
+### Performance Tuning
+- Adjust default parameters in `config.py`
+- Modify memory management settings
+- Update hardware requirements in README.md
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Out of Memory Errors**
+   - Reduce default image size
+   - Enable CPU offloading in config
+   - Use smaller batch sizes
+
+2. **Slow Loading**
+   - LoRAs are downloaded on first use
+   - Consider pre-downloading popular LoRAs
+   - Use faster hardware tier
+
+3. **Import Errors**
+   - Check requirements.txt versions
+   - Ensure all dependencies are compatible
+   - Update to latest diffusers version
+
+### Performance Tips
+
+- Use ZeroGPU for cost-effective deployment
+- Cache LoRA files for faster loading
+- Implement model compilation for speed
+- Monitor GPU memory usage
+
+## Support
+
+For issues with:
+- **Original Model**: Contact [Owen777](https://huggingface.co/Owen777)
+- **Training Code**: Check [GitHub Repository](https://github.com/Owen718/Kontext-Lora-Trainer)
+- **Hugging Face Spaces**: Use [Community Forums](https://huggingface.co/forums)
+
+## License
+
+This deployment is under Apache 2.0 License, following the original model's licensing.

requirements.txt

@@ -0,0 +1,13 @@
+torch>=2.0.0
+diffusers>=0.28.0
+transformers>=4.38.0
+accelerate>=0.26.0
+safetensors>=0.4.0
+huggingface-hub>=0.20.0
+gradio>=4.0.0
+spaces>=0.19.0
+Pillow>=9.5.0
+numpy>=1.24.0
+xformers>=0.0.20
+sentencepiece>=0.1.99
+protobuf>=3.20.3