Create app.py

app.py

@@ -0,0 +1,305 @@
+###TEST03 JUSTE CHARGER FLUX-SCHNELL
+###https://huggingface.co/spaces/black-forest-labs/FLUX.1-schnell/blob/main/app.py
+###
+import os
+import gradio as gr
+from huggingface_hub import login
+from diffusers import FluxPipeline
+import torch
+from PIL import Image
+import fitz  # PyMuPDF pour la gestion des PDF
+import sentencepiece
+
+import numpy as np
+import random
+import spaces
+
+
+
+
+
+#
+#import gradio as gr
+#import numpy as np
+#import random
+#import spaces
+#import torch
+#from diffusers import DiffusionPipeline
+#
+#dtype = torch.bfloat16
+#device = "cuda" if torch.cuda.is_available() else "cpu"
+#
+#pipe = DiffusionPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=dtype).to(device)
+#
+#MAX_SEED = np.iinfo(np.int32).max
+#MAX_IMAGE_SIZE = 2048
+#
+#@spaces.GPU()
+#def infer(prompt, seed=42, randomize_seed=False, width=1024, height=1024, num_inference_steps=4, progress=gr.Progress(track_tqdm=True)):
+#    if randomize_seed:
+#        seed = random.randint(0, MAX_SEED)
+#    generator = torch.Generator().manual_seed(seed)
+#    image = pipe(
+#            prompt = prompt, 
+#            width = width,
+#            height = height,
+#            num_inference_steps = num_inference_steps, 
+#            generator = generator,
+#            guidance_scale=0.0
+#    ).images[0] 
+#    return image, seed
+# 
+#examples = [
+#    "a tiny astronaut hatching from an egg on the moon",
+#    "a cat holding a sign that says hello world",
+#    "an anime illustration of a wiener schnitzel",
+#]
+#
+#css="""
+##col-container {
+#    margin: 0 auto;
+#    max-width: 520px;
+#}
+#"""
+#
+#with gr.Blocks(css=css) as demo:
+#    
+#    with gr.Column(elem_id="col-container"):
+#        gr.Markdown(f"""# FLUX.1 [schnell]
+#12B param rectified flow transformer distilled from [FLUX.1 [pro]](https://blackforestlabs.ai/) for 4 step generation
+#[[blog](https://blackforestlabs.ai/announcing-black-forest-labs/)] [[model](https://huggingface.co/black-forest-labs/FLUX.1-schnell)]
+#        """)
+#        
+#        with gr.Row():
+#            
+#            prompt = gr.Text(
+#                label="Prompt",
+#                show_label=False,
+#                max_lines=1,
+#                placeholder="Enter your prompt",
+#                container=False,
+#            )
+#            
+#            run_button = gr.Button("Run", scale=0)
+#        
+#        result = gr.Image(label="Result", show_label=False)
+#        
+#        with gr.Accordion("Advanced Settings", open=False):
+#            
+#            seed = gr.Slider(
+#                label="Seed",
+#                minimum=0,
+#                maximum=MAX_SEED,
+#                step=1,
+#                value=0,
+#            )
+#            
+#            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+#            
+#            with gr.Row():
+#                
+#                width = gr.Slider(
+#                    label="Width",
+#                    minimum=256,
+#                    maximum=MAX_IMAGE_SIZE,
+#                    step=32,
+#                    value=1024,
+#                )
+#                
+#                height = gr.Slider(
+#                    label="Height",
+#                    minimum=256,
+#                    maximum=MAX_IMAGE_SIZE,
+#                    step=32,
+#                    value=1024,
+#                )
+#            
+#            with gr.Row():
+#                
+#  
+#                num_inference_steps = gr.Slider(
+#                    label="Number of inference steps",
+#                    minimum=1,
+#                    maximum=50,
+#                    step=1,
+#                    value=4,
+#                )
+#        
+#        gr.Examples(
+#            examples = examples,
+#            fn = infer,
+#            inputs = [prompt],
+#            outputs = [result, seed],
+#            cache_examples="lazy"
+#        )
+#
+#    gr.on(
+#        triggers=[run_button.click, prompt.submit],
+#        fn = infer,
+#        inputs = [prompt, seed, randomize_seed, width, height, num_inference_steps],
+#        outputs = [result, seed]
+#    )
+#
+#demo.launch()
+#
+#
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Force l'utilisation du CPU pour tout PyTorch
+#torch.set_default_device("cpu")
+
+
+#dtype = torch.bfloat16
+device = "cuda" if torch.cuda.is_available() else "cpu"
+#
+#pipe = DiffusionPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=dtype).to(device)
+
+
+
+
+
+
+
+
+
+
+
+
+def load_pdf(pdf_path):
+    """Traite le texte d'un fichier PDF"""
+    if pdf_path is None:
+        return None
+    text = ""
+    try:
+        doc = fitz.open(pdf_path)
+        for page in doc:
+            text += page.get_text()
+        doc.close()
+        return text
+    except Exception as e:
+        print(f"Erreur lors de la lecture du PDF: {str(e)}")
+        return None
+
+class FluxGenerator:
+    def __init__(self):
+        self.token = os.getenv('Authentification_HF')
+        if not self.token:
+            raise ValueError("Token d'authentification HuggingFace non trouvé")
+        login(self.token)
+        self.pipeline = None
+        self.device = "cpu"  # Force l'utilisation du CPU
+        self.load_model()
+
+    def load_model(self):
+        """Charge le modèle FLUX avec des paramètres optimisés pour CPU"""
+        try:
+            print("Chargement du modèle FLUX sur CPU...")
+            # Configuration spécifique pour CPU
+            torch.set_grad_enabled(False)  # Désactive le calcul des gradients
+            
+            self.pipeline = FluxPipeline.from_pretrained(
+                "black-forest-labs/FLUX.1-schnell",
+                revision="refs/pr/1",
+                torch_dtype=torch.float32  # Utilise float32 au lieu de bfloat16 pour meilleure compatibilité CPU
+            )
+#                device_map={"cpu": self.device}  # Force tous les composants sur CPU
+#            )device
+            
+            # Désactive les optimisations GPU
+            self.pipeline.to(self.device)
+            print(f"Utilisation forcée du CPU")
+            print("Modèle FLUX chargé avec succès!")
+            
+        except Exception as e:
+            print(f"Erreur lors du chargement du modèle: {str(e)}")
+            raise
+
+    def generate_image(self, prompt, reference_image=None, pdf_file=None):
+        """Génère une image à partir d'un prompt et optionnellement une référence"""
+        try:
+            # Si un PDF est fourni, ajoute son contenu au prompt
+            if pdf_file is not None:
+                pdf_text = load_pdf(pdf_file)
+                if pdf_text:
+                    prompt = f"{prompt}\nContexte du PDF:\n{pdf_text}"
+
+            # Configuration pour génération sur CPU
+            with torch.no_grad():  # Désactive le calcul des gradients pendant la génération
+                image = self.pipeline(
+                    prompt=prompt,
+                    num_inference_steps=20,  # Réduit le nombre d'étapes pour accélérer sur CPU
+                    guidance_scale=0.0,
+                    max_sequence_length=256,
+                    generator=torch.Generator(device=self.device).manual_seed(0)
+                ).images[0]
+
+            return image
+
+        except Exception as e:
+            print(f"Erreur lors de la génération de l'image: {str(e)}")
+            return None
+
+# Instance globale du générateur
+generator = FluxGenerator()
+
+def generate(prompt, reference_file):
+    """Fonction de génération pour l'interface Gradio"""
+    try:
+        # Gestion du fichier de référence
+        if reference_file is not None:
+            if isinstance(reference_file, dict):  # Si le fichier est fourni par Gradio
+                file_path = reference_file.name
+            else:  # Si c'est un chemin direct
+                file_path = reference_file
+                
+            file_type = file_path.split('.')[-1].lower()
+            if file_type in ['pdf']:
+                return generator.generate_image(prompt, pdf_file=file_path)
+            elif file_type in ['png', 'jpg', 'jpeg']:
+                return generator.generate_image(prompt, reference_image=file_path)
+
+        # Génération sans référence
+        return generator.generate_image(prompt)
+
+    except Exception as e:
+        print(f"Erreur détaillée: {str(e)}")
+        return None
+
+# Interface Gradio simple
+demo = gr.Interface(
+    fn=generate,
+    inputs=[
+        gr.Textbox(label="Prompt", placeholder="Décrivez l'image que vous souhaitez générer..."),
+        gr.File(label="Image ou PDF de référence (optionnel)", type="file")
+    ],
+    outputs=gr.Image(label="Image générée"),
+    title="Test du modèle FLUX (CPU)",
+    description="Interface simple pour tester la génération d'images avec FLUX (optimisé pour CPU)"
+)
+
+if __name__ == "__main__":
+    demo.launch()