Spaces:
Sleeping
Sleeping
| import tensorflow as tf | |
| import numpy as np | |
| import cv2 | |
| import gradio as gr | |
| import os | |
| # Fonction pour chercher le modèle dans tout le système de fichiers | |
| def find_model_file(filename="generator.h5"): | |
| # Parcourir tous les répertoires du serveur pour trouver le fichier | |
| for root, dirs, files in os.walk("/"): | |
| if filename in files: | |
| model_path = os.path.join(root, filename) | |
| print(f"Modèle trouvé à : {model_path}") | |
| return model_path | |
| return None | |
| # Fonction pour charger le modèle en toute sécurité | |
| def load_model_safe(model_path): | |
| try: | |
| # Charger le modèle sans compilation pour éviter des erreurs liées au batch_shape | |
| model = tf.keras.models.load_model(model_path, compile=False) | |
| return model | |
| except ValueError as e: | |
| print(f"Erreur lors du chargement du modèle: {e}") | |
| return None | |
| # Chercher le modèle 'generator.h5' dans le système | |
| model_path = find_model_file("generator.h5") | |
| # Vérifier si le modèle est trouvé et charger | |
| if model_path is not None: | |
| generator = load_model_safe(model_path) | |
| print(f"Modèle chargé depuis : {model_path}") | |
| else: | |
| print("Le modèle 'generator.h5' n'a pas été trouvé sur le serveur.") | |
| generator = None | |
| # Fonction pour générer une vidéo à partir du générateur | |
| def generate_video(): | |
| if generator is None: | |
| return "Le modèle n'a pas pu être chargé." | |
| # Générer un bruit aléatoire (entrée pour le générateur) | |
| noise = np.random.normal(0, 1, (1, 16, 64, 64, 3)) # Exemple de bruit pour 16 frames de 64x64x3 | |
| generated_video = generator.predict(noise) # Générer la vidéo | |
| # Vérifier la forme des données générées | |
| print(f"Shape of generated video: {generated_video.shape}") | |
| # Normaliser les données générées | |
| video = (generated_video[0] * 255).astype(np.uint8) # Convertir en entier 8 bits | |
| # Vérifier si la vidéo générée a la bonne forme | |
| if len(video.shape) != 4 or video.shape[0] != 16: | |
| return "Erreur dans les dimensions de la vidéo générée." | |
| # Créer le répertoire pour la vidéo | |
| output_dir = "/content/generated_videos" | |
| os.makedirs(output_dir, exist_ok=True) | |
| filename = os.path.join(output_dir, "generated_video.mp4") | |
| # Enregistrer la vidéo avec OpenCV | |
| fourcc = cv2.VideoWriter_fourcc(*'mp4v') # Codec vidéo | |
| height, width, _ = video[0].shape | |
| out = cv2.VideoWriter(filename, fourcc, 15, (width, height)) # 15 FPS | |
| # Ajouter les frames dans le fichier vidéo | |
| for frame in video: | |
| out.write(frame) | |
| out.release() | |
| # Retourner le chemin de la vidéo générée | |
| return filename | |
| # Interface Gradio | |
| def interface_function(): | |
| # Appeler la fonction de génération et retourner la vidéo générée | |
| video_file = generate_video() | |
| return video_file | |
| # Définir l'interface avec Gradio | |
| gr.Interface( | |
| fn=interface_function, # Fonction à exécuter | |
| inputs=[], # Pas d'entrée utilisateur | |
| outputs=gr.Video(label="Vidéo générée", type="file"), # Vidéo en sortie avec type 'file' pour le téléchargement | |
| title="Générateur de Vidéos avec IA", | |
| description="Cliquez sur le bouton ci-dessous pour générer une vidéo aléatoire avec l'IA." | |
| ).launch(server_name="0.0.0.0", server_port=7860) |