Create app.py

app.py

@@ -0,0 +1,151 @@
+import gradio as gr
+import torch
+import gc
+from diffusers import StableDiffusionPipeline
+from transformers import logging
+import os
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+import numpy as np
+
+# Configuration système optimisée
+@dataclass
+class SystemConfig:
+    """Configuration système optimisée"""
+    model_id: str = "CompVis/stable-diffusion-v1-4"  # Modèle plus léger que SDXL
+    torch_dtype: torch.dtype = torch.float32  # Plus stable sur CPU
+    image_size: int = 512
+    optimization_level: str = "balanced"
+    max_batch_size: int = 1
+
+    steps_config = {
+        "fast": 15,
+        "balanced": 25,
+        "quality": 35
+    }
+
+class ImageGenerator:
+    def __init__(self, config: SystemConfig):
+        self.config = config
+        self.model = None
+        self.styles = {
+            "Réaliste": {
+                "prompt": "professional photograph, highly detailed, sharp focus {}",
+                "negative": "cartoon, painting, artwork, drawing, anime"
+            },
+            "Artistique": {
+                "prompt": "artistic masterpiece, creative interpretation {}",
+                "negative": "photo, photorealistic, mundane"
+            },
+            "Moderne": {
+                "prompt": "modern digital art, trending on artstation {}",
+                "negative": "outdated, classic, traditional"
+            }
+        }
+
+    def initialize_model(self):
+        """Initialisation optimisée du modèle"""
+        if self.model is None:
+            gc.collect()
+            self.model = StableDiffusionPipeline.from_pretrained(
+                self.config.model_id,
+                torch_dtype=self.config.torch_dtype,
+                safety_checker=None,
+                requires_safety_checker=False
+            ).to("cpu")
+            self.model.enable_attention_slicing()
+            self.model.enable_vae_slicing()
+        return self.model
+
+    def generate_image(
+        self, 
+        prompt: str,
+        style: str = "Réaliste",
+        seed: int = -1,
+        optimization_level: str = "balanced"
+    ) -> np.ndarray:
+        """Génération d'image avec gestion optimisée des ressources"""
+        try:
+            model = self.initialize_model()
+            
+            # Préparation du prompt
+            base_style = self.styles[style]
+            full_prompt = base_style["prompt"].format(prompt)
+            negative_prompt = base_style["negative"]
+            
+            # Configuration des étapes selon l'optimisation
+            num_steps = self.config.steps_config[optimization_level]
+            
+            # Gestion de la seed
+            if seed != -1:
+                torch.manual_seed(seed)
+                
+            # Génération
+            with torch.no_grad():
+                image = model(
+                    prompt=full_prompt,
+                    negative_prompt=negative_prompt,
+                    num_inference_steps=num_steps,
+                    height=self.config.image_size,
+                    width=self.config.image_size,
+                ).images[0]
+            
+            return image
+            
+        except Exception as e:
+            print(f"Erreur lors de la génération: {str(e)}")
+            raise e
+        finally:
+            gc.collect()
+
+# Interface Gradio
+def create_interface():
+    # Initialisation
+    config = SystemConfig()
+    generator = ImageGenerator(config)
+    
+    # Définition de l'interface
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# Générateur d'Images Professionnel")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                prompt = gr.Textbox(
+                    label="Description de l'image souhaitée",
+                    placeholder="Décrivez l'image que vous souhaitez générer..."
+                )
+                style = gr.Dropdown(
+                    choices=list(generator.styles.keys()),
+                    value="Réaliste",
+                    label="Style"
+                )
+                with gr.Row():
+                    seed = gr.Number(
+                        value=-1,
+                        label="Seed (-1 pour aléatoire)",
+                        precision=0
+                    )
+                    optimization = gr.Dropdown(
+                        choices=list(config.steps_config.keys()),
+                        value="balanced",
+                        label="Niveau d'optimisation"
+                    )
+                
+                generate_btn = gr.Button("Générer", variant="primary")
+            
+            with gr.Column(scale=2):
+                output = gr.Image(label="Image générée")
+        
+        # Logique de génération
+        generate_btn.click(
+            fn=generator.generate_image,
+            inputs=[prompt, style, seed, optimization],
+            outputs=output
+        )
+    
+    return demo
+
+# Lancement de l'interface
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()