import os import re import requests import numpy as np import gradio as gr from datetime import datetime from moviepy.editor import * from transformers import pipeline, AutoTokenizer, AutoModel import torch import torch.nn.functional as F import edge_tts import tempfile import logging from sklearn.metrics.pairwise import cosine_similarity from sklearn.feature_extraction.text import TfidfVectorizer from nltk.tokenize import sent_tokenize import nltk # Descargar recursos para NLTK nltk.download('punkt') # Configuración avanzada logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) # Configuración de modelos PEXELS_API_KEY = os.getenv("PEXELS_API_KEY") HF_TOKEN = os.getenv("HF_TOKEN") # Para modelos privados # 1. Modelo para generación de guiones (MBART grande para español) script_generator = pipeline( "text2text-generation", model="facebook/mbart-large-50", tokenizer="facebook/mbart-large-50", device=0 if torch.cuda.is_available() else -1 ) # 2. Modelo para embeddings semánticos (multilingüe) tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/paraphrase-multilingual-mpnet-base-v2") embedding_model = AutoModel.from_pretrained("sentence-transformers/paraphrase-multilingual-mpnet-base-v2") # 3. Lista de voces disponibles VOICES = [v for v in edge_tts.list_voices() if 'es' in v['ShortName'] or 'en' in v['ShortName']] VOICE_NAMES = [f"{v['Name']} ({v['Gender']}, {v['LocaleName']})" for v in VOICES] def generar_guion_avanzado(prompt): """Genera un guion largo y detallado usando IA""" try: response = script_generator( f"Escribe un guion detallado para un video de YouTube sobre '{prompt}' con introducción, 3 puntos principales y conclusión. Usa un estilo atractivo y profesional.", max_length=1000, num_beams=5, temperature=0.7, top_k=50, top_p=0.95, do_sample=True ) return response[0]['generated_text'] except Exception as e: logger.error(f"Error en generación de guion: {str(e)}") # Fallback a guion predefinido return f""" ¡Hola a todos! Hoy exploraremos el fascinante tema de {prompt}. En este video cubriremos tres aspectos clave: 1. Primer aspecto importante sobre {prompt} 2. Segundo elemento crucial 3. Tercer punto que no te puedes perder ¡Quedaos hasta el final para descubrir algo increíble! """ def obtener_embeddings(textos): """Obtiene embeddings semánticos para los textos""" inputs = tokenizer(textos, padding=True, truncation=True, return_tensors="pt", max_length=512) with torch.no_grad(): outputs = embedding_model(**inputs) embeddings = outputs.last_hidden_state.mean(dim=1).cpu().numpy() return embeddings def buscar_videos_semanticos(query, guion, num_videos=5): """Busca videos usando análisis semántico""" try: # Dividir el guion en oraciones oraciones = sent_tokenize(guion) # Obtener embeddings para cada oración embeddings_oraciones = obtener_embeddings(oraciones) # Embedding para la consulta general embedding_query = obtener_embeddings([query])[0] # Calcular similitud entre consulta y cada oración similitudes = cosine_similarity([embedding_query], embeddings_oraciones)[0] # Seleccionar las oraciones más relevantes indices_relevantes = np.argsort(similitudes)[-3:] oraciones_relevantes = [oraciones[i] for i in indices_relevantes] # Extraer palabras clave de las oraciones relevantes vectorizer = TfidfVectorizer(stop_words=['el', 'la', 'los', 'las', 'de', 'en', 'y']) tfidf = vectorizer.fit_transform(oraciones_relevantes) palabras = vectorizer.get_feature_names_out() scores = np.asarray(tfidf.sum(axis=0)).ravel() indices_importantes = np.argsort(scores)[-5:] palabras_clave = [palabras[i] for i in indices_importantes] # Realizar búsqueda en Pexels headers = {"Authorization": PEXELS_API_KEY} response = requests.get( f"https://api.pexels.com/videos/search?query={'+'.join(palabras_clave)}&per_page={num_videos}", headers=headers, timeout=20 ) videos = response.json().get('videos', []) logger.info(f"Encontrados {len(videos)} videos para palabras clave: {palabras_clave}") # Seleccionar los mejores videos por calidad videos_ordenados = sorted( videos, key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True ) return videos_ordenados[:num_videos] except Exception as e: logger.error(f"Error en búsqueda semántica: {str(e)}") # Fallback a búsqueda simple response = requests.get( f"https://api.pexels.com/videos/search?query={query}&per_page={num_videos}", headers={"Authorization": PEXELS_API_KEY}, timeout=10 ) return response.json().get('videos', [])[:num_videos] def crear_video_inteligente(prompt, custom_script, voz_index, musica=None): try: # 1. Generar o usar guion guion = custom_script if custom_script else generar_guion_avanzado(prompt) logger.info(f"Guion generado:\n{guion}") # 2. Seleccionar voz voz_seleccionada = VOICES[voz_index]['ShortName'] # 3. Generar archivo de voz voz_archivo = "voz.mp3" communicate = edge_tts.Communicate(guion, voz_seleccionada) communicate.save(voz_archivo) # 4. Buscar videos usando análisis semántico videos_data = buscar_videos_semanticos(prompt, guion, num_videos=5) if not videos_data: raise Exception("No se encontraron videos relevantes") # 5. Descargar y preparar videos clips = [] for video in videos_data: # Seleccionar la mejor calidad de video video_files = sorted( video['video_files'], key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True ) video_url = video_files[0]['link'] # Descargar video response = requests.get(video_url, stream=True) temp_video = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') for chunk in response.iter_content(chunk_size=1024*1024): temp_video.write(chunk) temp_video.close() # Crear clip clip = VideoFileClip(temp_video.name) clips.append(clip) # 6. Procesar audio audio = AudioFileClip(voz_archivo) total_duration = audio.duration if musica: musica_clip = AudioFileClip(musica.name) if musica_clip.duration < total_duration: musica_clip = musica_clip.loop(duration=total_duration) audio = CompositeAudioClip([audio, musica_clip.volumex(0.25)]) # 7. Crear video con sincronización inteligente # Calcular duración por clip clip_durations = [c.duration for c in clips] total_clip_duration = sum(clip_durations) # Ajustar clips para que coincidan con la duración del audio if total_clip_duration < total_duration: # Repetir la secuencia de videos si es necesario repetitions = int(total_duration / total_clip_duration) + 1 extended_clips = clips * repetitions final_clip = concatenate_videoclips(extended_clips).subclip(0, total_duration) else: # Ajustar velocidad para coincidir con la duración speed_factor = total_clip_duration / total_duration adjusted_clips = [clip.fx(vfx.speedx, speed_factor) for clip in clips] final_clip = concatenate_videoclips(adjusted_clips) final_clip = final_clip.set_audio(audio) # 8. Guardar video final output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4" final_clip.write_videofile( output_path, codec="libx264", audio_codec="aac", threads=4, preset='medium', fps=24 ) return output_path except Exception as e: logger.error(f"ERROR: {str(e)}") return None finally: # Limpieza if os.path.exists(voz_archivo): os.remove(voz_archivo) # Interfaz profesional with gr.Blocks(theme=gr.themes.Soft(), title="Generador de Videos con IA") as app: gr.Markdown("# 🎬 GENERADOR AVANZADO DE VIDEOS CON IA") with gr.Row(): with gr.Column(scale=1): gr.Markdown("### Configuración del Contenido") prompt = gr.Textbox(label="Tema principal", placeholder="Ej: 'Los misterios del universo'") custom_script = gr.TextArea( label="Guion personalizado (opcional)", placeholder="O escribe tu propio guion aquí...", lines=8 ) voz = gr.Dropdown( label="Selecciona una voz profesional", choices=VOICE_NAMES, value=VOICE_NAMES[0], type="index" ) musica = gr.File( label="Música de fondo profesional (opcional)", file_types=["audio"], type="filepath" ) btn = gr.Button("🚀 Generar Video Profesional", variant="primary", size="lg") with gr.Column(scale=2): output = gr.Video( label="Video Resultante", format="mp4", interactive=False, elem_id="video-output" ) with gr.Accordion("Detalles técnicos", open=False): gr.Markdown(""" **Tecnologías utilizadas:** - Generación de guiones: Meta MBART-large-50 - Búsqueda semántica: Sentence Transformers multilingüe - Síntesis de voz: Microsoft Edge TTS - Procesamiento de video: MoviePy """) # Ejemplos profesionales gr.Examples( examples=[ ["Los secretos de la inteligencia artificial", "", 0, None], ["Lugares históricos de Europa", "", 3, None], ["Innovaciones tecnológicas del futuro", "", 5, None] ], inputs=[prompt, custom_script, voz, musica], label="Ejemplos profesionales" ) btn.click( fn=crear_video_inteligente, inputs=[prompt, custom_script, voz, musica], outputs=output ) # CSS para mejor visualización app.css = """ #video-output { border-radius: 12px; box-shadow: 0 6px 16px rgba(0,0,0,0.15); margin: 20px auto; max-width: 100%; } """ if __name__ == "__main__": app.launch(server_name="0.0.0.0", server_port=7860)