Update app.py

app.py

@@ -3,13 +3,13 @@ import torch
 from transformers import (
     BlipProcessor, 
     BlipForQuestionAnswering,
-    pipeline,
-    AutoTokenizer, 
-    AutoModelForCausalLM
+    pipeline
 )
+from modelscope.pipelines import pipeline as ms_pipeline
 from PIL import Image
 import os
 import logging
+import tempfile
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -17,24 +17,33 @@ logger = logging.getLogger(__name__)
 class MultimodalProcessor:
     def __init__(self):
         self.load_models()
+        self.temp_dir = tempfile.mkdtemp()
     
     def load_models(self):
-        """Charge les modèles avec gestion d'erreurs"""
+        """Charge les modèles"""
         try:
             logger.info("Chargement des modèles...")
+            # BLIP pour l'analyse d'image
             self.blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
             self.blip_model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
+            
+            # Whisper pour la transcription audio
             self.audio_transcriber = pipeline("automatic-speech-recognition", 
-                                           model="openai/whisper-small")
-            self.text_generator = pipeline("text-generation", 
-                                        model="gpt2")
+                                           model="openai/whisper-base")
+            
+            # ModelScope pour la génération vidéo
+            self.video_pipeline = ms_pipeline(
+                'text-to-video-synthesis',
+                model='damo/text-to-video-synthesis'
+            )
+            
             logger.info("Modèles chargés avec succès")
         except Exception as e:
             logger.error(f"Erreur lors du chargement des modèles: {str(e)}")
             raise
 
     def analyze_image(self, image):
-        """Analyse une image et retourne une description"""
+        """Analyse une image avec BLIP"""
         try:
             if image is None:
                 return ""
@@ -42,8 +51,7 @@ class MultimodalProcessor:
             questions = [
                 "What is in the picture?",
                 "What are the main colors?",
-                "What is the setting or background?",
-                "What is happening in the image?",
+                "What is the setting or background?"
             ]
             
             responses = {}
@@ -56,8 +64,7 @@ class MultimodalProcessor:
             description = (
                 f"This image shows {responses['What is in the picture?']}. "
                 f"The main colors are {responses['What are the main colors?']}. "
-                f"The setting is {responses['What is the setting or background?']}. "
-                f"In the scene, {responses['What is happening in the image?']}"
+                f"The setting is {responses['What is the setting or background?']}."
             )
             
             return description
@@ -66,7 +73,7 @@ class MultimodalProcessor:
             return "Erreur lors de l'analyse de l'image."
 
     def transcribe_audio(self, audio_path):
-        """Transcrit un fichier audio"""
+        """Transcrit un fichier audio avec Whisper"""
         try:
             if audio_path is None:
                 return ""
@@ -75,48 +82,61 @@ class MultimodalProcessor:
             logger.error(f"Erreur lors de la transcription audio: {str(e)}")
             return "Erreur lors de la transcription audio."
 
-    def generate_text(self, prompt):
-        """Génère du texte à partir d'un prompt"""
+    def generate_video(self, prompt):
+        """Génère une vidéo avec ModelScope"""
         try:
             if not prompt:
-                return ""
-            response = self.text_generator(prompt, 
-                                        max_length=200,
-                                        num_return_sequences=1)[0]["generated_text"]
-            return response
+                return None
+                
+            output_path = os.path.join(self.temp_dir, "output.mp4")
+            result = self.video_pipeline({
+                'text': prompt,
+                'output_path': output_path
+            })
+            
+            if os.path.exists(output_path):
+                return output_path
+            raise Exception("La vidéo n'a pas été générée correctement")
+                
         except Exception as e:
-            logger.error(f"Erreur lors de la génération de texte: {str(e)}")
-            return "Erreur lors de la génération de texte."
+            logger.error(f"Erreur lors de la génération de vidéo: {str(e)}")
+            return None
 
     def process_inputs(self, image, audio, text):
         """Traite les entrées multimodales"""
         try:
-            # Analyse de l'image
-            image_description = self.analyze_image(image) if image is not None else ""
+            combined_parts = []
             
-            # Transcription audio
-            audio_text = self.transcribe_audio(audio) if audio is not None else ""
+            # Analyse de l'image si présente
+            if image is not None:
+                image_desc = self.analyze_image(image)
+                if image_desc:
+                    combined_parts.append(f"Scene: {image_desc}")
             
-            # Combinaison des entrées
-            combined_input = ""
-            if image_description:
-                combined_input += f"Visual description: {image_description}\n"
-            if audio_text:
-                combined_input += f"Audio content: {audio_text}\n"
+            # Transcription audio si présent
+            if audio is not None:
+                audio_text = self.transcribe_audio(audio)
+                if audio_text:
+                    combined_parts.append(f"Audio narration: {audio_text}")
+            
+            # Ajout du texte si présent
             if text:
-                combined_input += f"Additional context: {text}\n"
+                combined_parts.append(f"Additional context: {text}")
             
-            # Génération du prompt final
-            if combined_input:
-                final_prompt = self.generate_text(combined_input)
+            # Création du prompt final
+            if combined_parts:
+                final_prompt = " ".join(combined_parts)
             else:
-                final_prompt = "Aucune entrée fournie."
+                final_prompt = "Empty scene with neutral background"
+            
+            # Génération de la vidéo
+            output_video = self.generate_video(final_prompt)
             
-            return final_prompt
+            return output_video, final_prompt
             
         except Exception as e:
             logger.error(f"Erreur lors du traitement des entrées: {str(e)}")
-            return "Une erreur est survenue lors du traitement des entrées."
+            return None, "Une erreur est survenue lors du traitement des entrées."
 
 def create_interface():
     """Crée l'interface Gradio"""
@@ -130,16 +150,17 @@ def create_interface():
             gr.Textbox(label="Entrez du texte additionnel")
         ],
         outputs=[
-            gr.Textbox(label="Description générée")
+            gr.Video(label="Vidéo générée"),
+            gr.Textbox(label="Description utilisée")
         ],
-        title="Analyseur de Contenu Multimodal",
+        title="Générateur de Vidéo Multimodal",
         description="""
-        Cette application analyse vos contenus multimodaux :
-        - Images : génère une description détaillée
-        - Audio : transcrit le contenu
-        - Texte : enrichit la description
-        
-        La sortie combine toutes ces informations en une description cohérente.
+        Téléchargez une image, un fichier audio et/ou ajoutez du texte.
+        L'application va:
+        1. Analyser l'image pour en extraire une description
+        2. Transcrire l'audio en texte
+        3. Combiner ces éléments avec votre texte
+        4. Générer une vidéo basée sur la description combinée
         """
     )