Update app.py

app.py

@@ -3,66 +3,82 @@ import torch
 from transformers import (
     BlipProcessor, 
     BlipForQuestionAnswering,
-    pipeline
+    pipeline,
+    AutoTokenizer 
 )
 from modelscope.pipelines import pipeline as ms_pipeline
+from modelscope.outputs import OutputKeys
 from PIL import Image
 import os
 import logging
 import tempfile
-import shutil
-import atexit
+import moviepy.editor as mp
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-class TempFileManager:
-    def __init__(self):
-        self.temp_dir = tempfile.mkdtemp(prefix='multimodal_app_')
-        atexit.register(self.cleanup)
-        
-    def get_path(self, filename):
-        return os.path.join(self.temp_dir, filename)
-    
-    def cleanup(self):
-        try:
-            if os.path.exists(self.temp_dir):
-                shutil.rmtree(self.temp_dir, ignore_errors=True)
-        except Exception as e:
-            logger.error(f"Erreur lors du nettoyage des fichiers temporaires: {str(e)}")
-
 class MultimodalProcessor:
     def __init__(self):
-        self.temp_manager = TempFileManager()
         self.load_models()
+        self.temp_dir = tempfile.mkdtemp()
     
     def load_models(self):
-        """Charge les modèles"""
+        """Charge les modèles avec gestion d'erreurs"""
         try:
             logger.info("Chargement des modèles...")
             self.blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
             self.blip_model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
             self.audio_transcriber = pipeline("automatic-speech-recognition", 
                                            model="openai/whisper-base")
+            
+            # Initialisation du pipeline text-to-video ModelScope
             self.video_pipeline = ms_pipeline(
                 'text-to-video-synthesis',
-                model='damo/text-to-video-synthesis'
+                model='damo/text-to-video-synthesis',
+                model_revision='v1.0.0'
             )
+            
             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 transcribe_video(self, video_path):
+        """Transcrit une vidéo en utilisant Whisper"""
+        try:
+            if video_path is None:
+                return ""
+            
+            # Extraction de l'audio de la vidéo
+            video = mp.VideoFileClip(video_path)
+            audio_path = os.path.join(self.temp_dir, "temp_audio.wav")
+            video.audio.write_audiofile(audio_path, logger=None)
+            
+            # Transcription avec Whisper
+            transcription = self.audio_transcriber(audio_path)["text"]
+            
+            # Nettoyage
+            os.remove(audio_path)
+            video.close()
+            
+            return transcription
+        except Exception as e:
+            logger.error(f"Erreur lors de la transcription vidéo: {str(e)}")
+            return "Erreur lors de la transcription vidéo."
+
     def analyze_image(self, image):
-        """Analyse une image avec BLIP"""
-        if image is None:
-            return ""
+        """Analyse une image et retourne une description"""
         try:
+            if image is None:
+                return ""
+            
             questions = [
                 "What is in the picture?",
                 "What are the main colors?",
-                "What is the setting or background?"
+                "What is the setting or background?",
+                "What is happening in the image?",
             ]
+            
             responses = {}
             for question in questions:
                 inputs = self.blip_processor(images=image, text=question, return_tensors="pt")
@@ -73,77 +89,81 @@ 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"The setting is {responses['What is the setting or background?']}. "
+                f"In the scene, {responses['What is happening in the image?']}"
             )
+            
             return description
         except Exception as e:
             logger.error(f"Erreur lors de l'analyse de l'image: {str(e)}")
             return "Erreur lors de l'analyse de l'image."
 
     def transcribe_audio(self, audio_path):
-        """Transcrit un fichier audio avec Whisper"""
-        if audio_path is None:
-            return ""
+        """Transcrit un fichier audio"""
         try:
+            if audio_path is None:
+                return ""
             return self.audio_transcriber(audio_path)["text"]
         except Exception as e:
             logger.error(f"Erreur lors de la transcription audio: {str(e)}")
             return "Erreur lors de la transcription audio."
 
     def generate_video(self, prompt):
-        """Génère une vidéo avec ModelScope"""
-        if not prompt:
-            return None
+        """Génère une vidéo à partir d'un prompt"""
         try:
-            output_path = self.temp_manager.get_path("output.mp4")
+            if not prompt:
+                return None
+                
+            output_path = os.path.join(self.temp_dir, "generated_video.mp4")
             result = self.video_pipeline({
                 'text': prompt,
                 'output_path': output_path
             })
             
-            if not os.path.exists(output_path):
+            if os.path.exists(output_path):
+                return output_path
+            else:
                 raise Exception("La vidéo n'a pas été générée correctement")
                 
-            # Copie la vidéo vers un emplacement permanent si nécessaire
-            permanent_path = f"outputs/video_{hash(prompt)}.mp4"
-            os.makedirs(os.path.dirname(permanent_path), exist_ok=True)
-            shutil.copy2(output_path, permanent_path)
-            
-            return permanent_path
-                
         except Exception as e:
             logger.error(f"Erreur lors de la génération de vidéo: {str(e)}")
             return None
 
-    def process_inputs(self, image, audio, text):
+    def process_inputs(self, image, audio, video, text):
         """Traite les entrées multimodales"""
         try:
-            combined_parts = []
+            combined_input = []
             
+            # Analyse de l'image
             if image is not None:
                 image_desc = self.analyze_image(image)
-                if image_desc:
-                    combined_parts.append(f"Scene: {image_desc}")
+                combined_input.append(f"Visual description: {image_desc}")
             
+            # Transcription audio
             if audio is not None:
                 audio_text = self.transcribe_audio(audio)
-                if audio_text:
-                    combined_parts.append(f"Audio narration: {audio_text}")
+                combined_input.append(f"Audio content: {audio_text}")
+            
+            # Transcription vidéo
+            if video is not None:
+                video_text = self.transcribe_video(video)
+                combined_input.append(f"Video content: {video_text}")
             
+            # Ajout du texte additionnel
             if text:
-                combined_parts.append(f"Additional context: {text}")
+                combined_input.append(f"Additional context: {text}")
             
-            final_prompt = " ".join(combined_parts) if combined_parts else "Empty scene with neutral background"
+            # Création du prompt final
+            final_prompt = " ".join(combined_input) if combined_input else "Empty scene"
             
+            # Génération de la vidéo
             output_video = self.generate_video(final_prompt)
+            
             return output_video, final_prompt
             
         except Exception as e:
             logger.error(f"Erreur lors du traitement des entrées: {str(e)}")
             return None, "Une erreur est survenue lors du traitement des entrées."
-        finally:
-            # Nettoyage explicite des fichiers temporaires après chaque traitement
-            self.temp_manager.cleanup()
 
 def create_interface():
     """Crée l'interface Gradio"""
@@ -154,22 +174,25 @@ def create_interface():
         inputs=[
             gr.Image(type="pil", label="Télécharger une image"),
             gr.Audio(type="filepath", label="Télécharger un fichier audio"),
+            gr.Video(label="Télécharger une vidéo"),
             gr.Textbox(label="Entrez du texte additionnel")
         ],
         outputs=[
             gr.Video(label="Vidéo générée"),
-            gr.Textbox(label="Description utilisée")
+            gr.Textbox(label="Prompt généré")
         ],
         title="Générateur de Vidéo Multimodal",
         description="""
-        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
+        Cette application combine vos entrées multimodales pour générer une vidéo :
+        - Images : analyse et description
+        - Audio : transcription
+        - Vidéo : transcription
+        - Texte : contexte additionnel
+        
+        Le résultat est une nouvelle vidéo générée à partir de la description combinée.
         """
     )
+    
     return interface
 
 if __name__ == "__main__":