En este tutorial, exploramos Microsoft VibeVoice en Colab y creamos un flujo de trabajo práctico completo para el reconocimiento de voz y la síntesis de voz en tiempo real. Configuramos el entorno desde cero, instalamos las dependencias requeridas, verificamos la compatibilidad con los últimos modelos de VibeVoice y luego analizamos capacidades avanzadas como transcripción consciente del hablante, ASR guiado por contexto, procesamiento de audio por lotes, generación expresiva de texto a voz y un canal de voz a voz de un extremo a otro. A medida que avanzamos en el tutorial, interactuamos con ejemplos prácticos, probamos diferentes ajustes preestablecidos de voz, generamos audio de formato largo, iniciamos una interfaz Gradio y entendemos cómo adaptar el sistema para nuestros propios archivos y experimentos.
!pip uninstall -y transformadores -q !pip install -q git+https://github.com/huggingface/transformers.git !pip install -q torch torchaudio acelerar el archivo de sonido librosa scipy numpy !pip install -q huggingface_hub ipywidgets gradio einops !pip install -q flash-attn –no-build-isolation 2>/dev/null || echo "flash-attn opcional" !git clone -q –profundidad 1 https://github.com/microsoft/VibeVoice.git /content/VibeVoice 2>/dev/null || echo "Ya clonado" !pip install -q -e /content/VibeVoice print("="*70) print("IMPORTANTE: ¡Si esta es su primera ejecución, reinicie el tiempo de ejecución ahora!") print("Vaya a: Tiempo de ejecución -> Reiniciar el tiempo de ejecución, luego ejecute desde la CELDA 2.") print("="*70) import torch import numpy as np import soundfile as sf import advertencias import sys desde IPython.display importar audio, mostrar advertencias.filterwarnings('ignore') sys.path.insert(0, '/content/VibeVoice') importar transformadores imprimir(f"Versión de transformadores: {transformers.__version__}") intente: desde transformadores importar VibeVoiceAsrForConditionalGeneration print("VibeVoice ASR: disponible") excepto ImportError: print("ERROR: VibeVoice no disponible. Reinicie runtime y ejecute la Celda 1 nuevamente.") rise SAMPLE_PODCAST = "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav" SAMPLE_GERMAN = "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav" print("¡Configuración completa!")
Preparamos el entorno completo de Google Colab para VibeVoice instalando y actualizando todos los paquetes necesarios. Clonamos el repositorio oficial de VibeVoice, configuramos el tiempo de ejecución y verificamos que el soporte especial para ASR esté disponible en la versión de Transformers instalada. También importamos las bibliotecas principales y definimos fuentes de audio de muestra, lo que prepara nuestro tutorial para los pasos posteriores de transcripción y generación de voz.
de transformadores import AutoProcessor, VibeVoiceAsrForConditionalGeneration print("Cargando el modelo VibeVoice ASR (parámetros 7B)…") print("Primera ejecución de descargas ~14 GB; espere…") asr_processor = AutoProcessor.from_pretrained("microsoft/VibeVoice-ASR-HF") asr_model = VibeVoiceAsrForConditionalGeneration.from_pretrained( "microsoft/VibeVoice-ASR-HF", device_map="auto", torch_dtype=torch.float16, ) print(f"Modelo ASR cargado en {asr_model.device}") def transcribe(audio_path, context=None, output_format="parsed"): entradas = asr_processor.apply_transcription_request( audio=audio_path, solicitud=contexto, ).to(asr_model.device, asr_model.dtype)output_ids = asr_model.generate(**inputs) generate_ids =output_ids[:, inputs["input_ids"].shape[1]:] resultado = asr_processor.decode(generated_ids, return_format=output_format)[0]return result print("="*70) print("ASR DEMO: Transcripción de podcast con diario de locutor") print("="*70) print("nReproduciendo audio de muestra:") display(Audio(SAMPLE_PODCAST)) print("nTranscripción con identificación de locutor…") result = transcribe(SAMPLE_PODCAST, output_format="parsed") print("nRESULTADOS DE LA TRANSCRIPCIÓN:") print("-"*70) para el segmento en el resultado: altavoz = segmento['Altavoz'] inicio = segmento['Inicio'] fin = segmento['End'] contenido = segmento['Contenido'] print(f"n[Altavoz {altavoz}] {inicio:.2f}s – {end:.2f}s") print(f" {contenido}") print("n" + "="*70) print("ASR DEMO: Context-Aware Transcripción") print("="*70) print("nComparación de transcripción CON y SIN palabras activas de contexto:") print("-"*70) result_no_ctx = transcribe(SAMPLE_GERMAN, context=None, output_format="transcription_only") print(f"nSIN contexto: {result_no_ctx}") result_with_ctx = transcribe(SAMPLE_GERMAN, context="Acerca de VibeVoice", output_format="transcription_only") print(f"WITH contexto: {result_with_ctx}") print("n¡Observe cómo 'VibeVoice' se reconoce correctamente cuando se proporciona contexto!")
Cargamos el modelo y procesador VibeVoice ASR para convertir voz en texto. Definimos una función de transcripción reutilizable que permite la inferencia con contexto opcional y múltiples formatos de salida. Luego probamos el modelo en audio de muestra para observar la diariotización del hablante y comparar las mejoras en la calidad del reconocimiento a partir de la transcripción contextual.
print("n" + "="*70) print("ASR DEMO: Procesamiento por lotes") print("="*70) audio_batch = [SAMPLE_GERMAN, SAMPLE_PODCAST] Prompts_batch = ["Acerca de VibeVoice", Ninguno] inputs = asr_processor.apply_transcription_request( audio=audio_batch, Prompt=prompts_batch ).to(asr_model.device, asr_model.dtype)output_ids = asr_model.generate(**inputs) generate_ids =output_ids[:, inputs["input_ids"].shape[1]:] transcripciones = asr_processor.decode(generated_ids, return_format="transcription_only") print("nResultados de la transcripción por lotes:") print("-"*70) for i, trans in enumerate(transcripciones): vista previa = trans[:150] + "…" si len(trans) > 150 else trans print(f"nAudio {i+1}: {preview}") de la importación de transformadores AutoModelForCausalLM de vibevoice.modular.modular_vibevoice_text_tokenizer import VibeVoiceTextTokenizerFast print("n" + "="*70) print("Cargando el modelo TTS de VibeVoice Realtime (0.5B de parámetros)…") print("="*70) tts_model = AutoModelForCausalLM.from_pretrained( "microsoft/VibeVoice-Realtime-0.5B", trust_remote_code=True, torch_dtype=torch.float16, ).to("cuda" if torch.cuda.is_available() else "cpu") tts_tokenizer = VibeVoiceTextTokenizerFast.from_pretrained("microsoft/VibeVoice-Realtime-0.5B") tts_model.set_ddpm_inference_steps(20) print(f"Modelo TTS cargado en {next(tts_model.parameters()).dispositivo}") VOCES = ["Carter", "Grace", "Emma", "Davis"] def sintetizar(text, voice="Grace", cfg_scale=3.0, pasos=20, save_path=Ninguno): tts_model.set_ddpm_inference_steps(pasos) input_ids = tts_tokenizer(text, return_tensors="pt").input_ids.to(tts_model.device) salida = tts_model.generate( inputs=input_ids, tokenizer=tts_tokenizer, cfg_scale=cfg_scale, return_speech=True, show_progress_bar=True, nombre_altavoz=voz, ) audio = salida.audio.squeeze().cpu().numpy() sample_rate = 24000 if save_path: sf.write(save_path, audio, sample_rate) print(f"Guardado en: {save_path}") return audio, sample_rate
Ampliamos el flujo de trabajo ASR procesando varios archivos de audio juntos en modo por lotes. Luego pasamos al lado de texto a voz del tutorial cargando el modelo TTS en tiempo real de VibeVoice y su tokenizador. También definimos la función auxiliar de síntesis de voz y los ajustes preestablecidos de voz para generar audio natural a partir del texto en las siguientes etapas.
print("n" + "="*70) print("DEMOSTRACIÓN TTS: Síntesis básica del habla") print("="*70) demo_texts = [ ("¡Hola! Bienvenido a VibeVoice, la IA de voz de código abierto de Microsoft.", "Grace"), ("Este modelo genera un habla natural y expresiva en tiempo real.", "Carter"), ("Puedes elegir entre múltiples ajustes preestablecidos de voz para diferentes estilos.", "Emma"), ] para texto, voz en demo_texts: print(f"nTexto: {texto}") print(f"Voz: {voz}") audio, sr = sintetizar(texto, voz=voz) print(f"Duración: {len(audio)/sr:.2f} segundos") display(Audio(audio, rate=sr)) print("n" + "="*70) print("TTS DEMO: Comparar todos los ajustes preestablecidos de voz") print("="*70) compare_text = "VibeVoice produce una síntesis de voz notablemente natural y expresiva." print(f"nMismo texto con diferentes voces: "{comparison_text}"n") para voz en VOCES: print(f"Voice: {voice}") audio, sr = synthesize(comparison_text, voice=voice, pasos=15) display(Audio(audio, rate=sr)) print() print("n" + "="*70) print("TTS DEMO: formato largo Speech Generation") print("="*70) long_text = """ ¡Bienvenido al podcast de tecnología de hoy! Me complace compartir los últimos avances en inteligencia artificial y síntesis de voz. VibeVoice de Microsoft representa un gran avance en la inteligencia artificial de voz. A diferencia de los sistemas tradicionales de conversión de texto a voz, que tienen dificultades con el contenido de formato largo, VibeVoice puede generar voz coherente durante períodos prolongados. La innovación clave son los tokenizadores de velocidad de fotogramas ultrabaja que funcionan a 7,5 hercios. preserva la calidad del audio al tiempo que mejora drásticamente la eficiencia computacional. El sistema utiliza un marco de difusión de siguiente token que combina un modelo de lenguaje grande para la comprensión del contexto con un cabezal de difusión para la generación de audio de alta fidelidad. momento)…") audio, sr = synthesize(long_text.strip(), voice="Carter", cfg_scale=3.5, pasos=25) print(f"nGeneró {len(audio)/sr:.2f} segundos de voz") display(Audio(audio, rate=sr)) sf.write("/content/longform_output.wav", audio, sr) print("Guardado en: /content/longform_output.wav") print("n" + "="*70) print("AVANZADO: Canalización de voz a voz") print("="*70) print("nPaso 1: Transcripción del audio de entrada…") transcription = transcribe(SAMPLE_GERMAN, context="Acerca de VibeVoice", output_format="transcription_only") print(f"Transcripción: {transcripción}") Response_text = f"Entendí que dijiste: {transcripción} ¡Ese es un tema fascinante sobre la tecnología de IA!" print(f"nPaso 2: Generar respuesta de voz…") print(f"Respuesta: {response_text}") audio, sr = synthesize(response_text, voice="Grace", cfg_scale=3.0, pasos=20) print(f"nPaso 3: Reproducir la respuesta generada ({len(audio)/sr:.2f}s)") display(Audio(audio, rate=sr))
Usamos la canalización TTS para generar voz a partir de diferentes textos de ejemplo y escuchar las salidas en múltiples voces. Comparamos ajustes preestablecidos de voz, creamos una narración estilo podcast más larga y guardamos la forma de onda generada como un archivo de salida. También combinamos ASR y TTS en un flujo de trabajo de voz a voz, donde primero transcribimos audio y luego generamos una respuesta hablada a partir del texto reconocido.
importar gradio como gr def tts_gradio(texto, voz, cfg, pasos): si no text.strip(): return Ninguno audio, sr = sintetizar(texto, voz=voz, cfg_scale=cfg, pasos=int(pasos)) return (sr, audio) demo = gr.Interface( fn=tts_gradio, inputs=[ gr.Textbox(label="Texto a sintetizar", líneas=5, value="¡Hola! Este es VibeVoice texto a voz en tiempo real."), gr.Dropdown(choices=VOICES, value="Grace", label="Voice"), gr.Slider(1.0, 5.0, value=3.0, step=0.5, label="CFG Scale"), gr.Slider(5, 50, value=20, step=5, label="Pasos de inferencia"), ], outputs=gr.Audio(label="Generated Speech"), title="VibeVoice Realtime TTS", descripción="Genere voz natural a partir de texto usando el modelo VibeVoice de Microsoft.", ) print("nIniciando la interfaz TTS interactiva…") demo.launch(share=True, quiet=True) desde google.colab import files import os print("n" + "="*70) print("CARGA TU AUDIO PROPIO") print("="*70) print("nSubir un archivo de audio (wav, mp3, flac, etc.):") uploaded = files.upload() si está cargado: para el nombre del archivo, datos en uploaded.items(): filepath = f"/content/{filename}" con open(filepath, 'wb') como f: f.write(data) print(f"nProcessing: {filename}") display(Audio(filepath)) result = transcribe(filepath, output_format="parsed") print("nTranscripción:") print("-"*50) if isinstance(resultado, list): for seg in result: print(f"[{seg.get('Start',0):.2f}s-{seg.get('End',0):.2f}s] Altavoz {seg.get('Speaker',0)}: {seg.get('Content','')}") else: print(resultado) else: print("No se ha cargado ningún archivo – omitir este paso") print("n" + "="*70) print("CONSEJOS PARA OPTIMIZACIÓN DE LA MEMORIA") print("="*70) print(""" 1. REDUCIR EL TAMAÑO DEL FRAGMENTO ASR (si no hay memoria con audio largo): output_ids = asr_model.generate(**inputs, acústico_tokenizer_chunk_size=64000) 2. UTILIZAR BFLOAT16 DTYPE: model = VibeVoiceAsrForConditionalGeneration.from_pretrained( model_id, torch_dtype=torch.bfloat16, device_map="auto") 3. REDUCIR LOS PASOS DE INFERENCIA DE TTS (más rápido pero de menor calidad): tts_model.set_ddpm_inference_steps(10) 4. BORRAR CACHÉ DE GPU: import gc torch.cuda.empty_cache() gc.collect() 5. PUNTOS DE VERIFICACIÓN DE GRADIENTE PARA ENTRENAMIENTO: model.gradient_checkpointing_enable() """) print("n" + "="*70) print("DESCARGAR ARCHIVOS GENERADOS") print("="*70) archivos_salida = ["/content/longform_output.wav"] para ruta de archivo en archivos_salida: if os.path.exists(ruta_archivo): print(f"Descargando: {os.path.basename(ruta_archivo)}") files.download(ruta_archivo) else: print(f"Archivo no encontrado: {ruta_archivo}") print("n" + "="*70) print("¡TUTORIAL COMPLETO!") print("="*70) print(""" LO QUE APRENDISTE: VIBEVOICE ASR (Voz a texto): – Transcripción de un solo paso de 60 minutos – Diario del hablante (quién dijo qué, cuándo) – Reconocimiento de palabras clave según el contexto – Compatibilidad con más de 50 idiomas – Procesamiento por lotes VIBEVOICE REALTIME TTS (Texto a voz): – Transmisión en tiempo real (latencia de ~300 ms) – Múltiples ajustes preestablecidos de voz – Generación de formato largo (~10 minutos) – Calidad/velocidad configurable RECURSOS: GitHub: https://github.com/microsoft/VibeVoice Modelo ASR: https://huggingface.co/microsoft/VibeVoice-ASR-HF Modelo TTS: https://huggingface.co/microsoft/VibeVoice-Realtime-0.5B Papel ASR: https://arxiv.org/pdf/2601.18184 Papel TTS: https://openreview.net/pdf?id=FihSkzyxdv USO RESPONSABLE: – Esto es solo para investigación/desarrollo – Siempre divulgue contenido generado por IA – No lo use para suplantación de identidad o fraude – Siga las leyes y regulaciones aplicables """)
Creamos una interfaz interactiva de Gradio que nos permite escribir texto y generar voz de una manera más fácil de usar. También cargamos nuestros propios archivos de audio para su transcripción, revisamos los resultados y evaluamos sugerencias de optimización de memoria para mejorar la ejecución en Colab. Además, descargamos los archivos generados y resumimos el conjunto completo de capacidades que exploramos a lo largo del tutorial.
En conclusión, obtuvimos una sólida comprensión práctica sobre cómo ejecutar y experimentar con Microsoft VibeVoice en Colab para tareas ASR y TTS en tiempo real. Aprendimos cómo transcribir audio con información del hablante y contexto de palabras clave, y también cómo sintetizar el habla natural, comparar voces, crear salidas de audio más largas y conectar la transcripción con la generación en un flujo de trabajo unificado. A través de estos experimentos, vimos cómo VibeVoice puede servir como una poderosa base de código abierto para asistentes de voz, herramientas de transcripción, sistemas de accesibilidad, demostraciones interactivas y aplicaciones de inteligencia artificial del habla más amplias, al mismo tiempo que aprendimos las consideraciones de optimización e implementación necesarias para un uso más fluido en el mundo real.
Consulte los códigos completos aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 130.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.
¿Necesita asociarse con nosotros para promocionar su repositorio de GitHub O su página principal de Hugging O su lanzamiento de producto O seminario web, etc.? Conéctate con nosotros
