Update app.py

app.py

@@ -4,15 +4,12 @@ from transformers import (
     BlipProcessor, 
     BlipForQuestionAnswering,
     pipeline,
-    AutoTokenizer 
+    AutoTokenizer, 
+    AutoModelForCausalLM
 )
-from modelscope.pipelines import pipeline as ms_pipeline
-from modelscope.outputs import OutputKeys
 from PIL import Image
 import os
 import logging
-import tempfile
-import moviepy.editor as mp
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -20,7 +17,6 @@ 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"""
@@ -29,43 +25,14 @@ class MultimodalProcessor:
             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_revision='v1.0.0'
-            )
-            
+                                           model="openai/whisper-small")
+            self.text_generator = pipeline("text-generation", 
+                                        model="gpt2")
             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 et retourne une description"""
         try:
@@ -108,62 +75,48 @@ class MultimodalProcessor:
             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 à partir d'un prompt"""
+    def generate_text(self, prompt):
+        """Génère du texte à partir d'un prompt"""
         try:
             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 os.path.exists(output_path):
-                return output_path
-            else:
-                raise Exception("La vidéo n'a pas été générée correctement")
-                
+                return ""
+            response = self.text_generator(prompt, 
+                                        max_length=200,
+                                        num_return_sequences=1)[0]["generated_text"]
+            return response
         except Exception as e:
-            logger.error(f"Erreur lors de la génération de vidéo: {str(e)}")
-            return None
+            logger.error(f"Erreur lors de la génération de texte: {str(e)}")
+            return "Erreur lors de la génération de texte."
 
-    def process_inputs(self, image, audio, video, text):
+    def process_inputs(self, image, audio, text):
         """Traite les entrées multimodales"""
         try:
-            combined_input = []
-            
             # Analyse de l'image
-            if image is not None:
-                image_desc = self.analyze_image(image)
-                combined_input.append(f"Visual description: {image_desc}")
+            image_description = self.analyze_image(image) if image is not None else ""
             
             # Transcription audio
-            if audio is not None:
-                audio_text = self.transcribe_audio(audio)
-                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
+            audio_text = self.transcribe_audio(audio) if audio is not None else ""
+            
+            # 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"
             if text:
-                combined_input.append(f"Additional context: {text}")
+                combined_input += f"Additional context: {text}\n"
             
-            # 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)
+            # Génération du prompt final
+            if combined_input:
+                final_prompt = self.generate_text(combined_input)
+            else:
+                final_prompt = "Aucune entrée fournie."
             
-            return output_video, final_prompt
+            return 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."
+            return "Une erreur est survenue lors du traitement des entrées."
 
 def create_interface():
     """Crée l'interface Gradio"""
@@ -174,22 +127,19 @@ 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="Prompt généré")
+            gr.Textbox(label="Description générée")
         ],
-        title="Générateur de Vidéo Multimodal",
+        title="Analyseur de Contenu Multimodal",
         description="""
-        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
+        Cette application analyse vos contenus multimodaux :
+        - Images : génère une description détaillée
+        - Audio : transcrit le contenu
+        - Texte : enrichit la description
         
-        Le résultat est une nouvelle vidéo générée à partir de la description combinée.
+        La sortie combine toutes ces informations en une description cohérente.
         """
     )