Transcripción de Audio con Whisper
La transcripción automática de audio es una herramienta poderosa que facilita la conversión de audio a texto. En este artículo, exploraremos un script que utiliza la biblioteca Whisper para realizar esta tarea de manera eficiente. Aprenderás desde la instalación de las bibliotecas necesarias hasta el uso del script, así como consejos para optimizar su rendimiento.
¿Qué hace el script?
Este script está diseñado para transcribir archivos de audio en diferentes formatos (como WAV, MP3, M4A, FLAC y OGG) utilizando el modelo de aprendizaje profundo Whisper. El proceso incluye la identificación del archivo de audio en el directorio actual, la selección de un modelo de transcripción según la precisión requerida, y la opción de traducir la transcripción al español si el audio es en inglés. Además, el script genera archivos de subtítulos en formato SRT y guarda la transcripción completa en un archivo de texto.
Instalación de Librerías Necesarias
Antes de ejecutar el script, es necesario instalar las bibliotecas requeridas. Asegúrate de tener Python instalado en tu sistema, y luego utiliza los siguientes comandos:
pip install openai-whisper deepl
- Whisper: La biblioteca principal para la transcripción de audio.
- DeepL: Usada para la traducción de texto, si es necesario.
Uso del Script: Paso a Paso
import whisper
import os
import time
import deepl
def find_audio_file():
supported_formats = ['wav', 'mp3', 'm4a', 'flac', 'ogg', 'MP3']
for file in os.listdir():
if any(file.endswith(f'.{ext}') for ext in supported_formats):
return file
return None
def format_time(seconds):
hours = int(seconds // 3600)
minutes = int((seconds % 3600) // 60)
seconds = seconds % 60
milliseconds = int((seconds - int(seconds)) * 1000)
return f"{hours:02d}:{minutes:02d}:{int(seconds):02d},{milliseconds:03d}"
def create_srt_content(segments):
srt_content = ""
for i, segment in enumerate(segments, start=1):
start_time = format_time(segment['start'])
end_time = format_time(segment['end'])
text = segment['text'].strip()
srt_content += f"{i}\n{start_time} --> {end_time}\n{text}\n\n"
return srt_content
def select_model():
models = {
1: ("tiny", "El más rápido y ligero (1GB). Precisión básica, ideal para pruebas rápidas."),
2: ("base", "Modelo equilibrado (1GB). Buena precisión para uso general."),
3: ("small", "Más preciso que base (2GB). Recomendado para uso diario."),
4: ("medium", "Alta precisión (5GB). Ideal para contenido profesional."),
5: ("large", "Máxima precisión (10GB). Mejor calidad pero más lento.")
}
print("\nModelos disponibles:")
for num, (model_name, description) in models.items():
print(f"{num}. {model_name}: {description}")
while True:
try:
choice = int(input("\nSeleccione el número del modelo (1-5): "))
if choice in models:
return models[choice][0]
print("Por favor, seleccione un número válido (1-5)")
except ValueError:
print("Por favor, ingrese un número válido")
script_directory = os.path.dirname(os.path.realpath(__file__))
os.chdir(script_directory)
current_directory = os.getcwd()
print(f"Directorio de trabajo actual: {current_directory}")
audio_file_name = find_audio_file()
if not audio_file_name:
print("No se encontró ningún archivo de audio en el directorio del script.")
exit()
audio_file_path = os.path.join(current_directory, audio_file_name)
print(f"Archivo de audio encontrado: {audio_file_path}")
# Selección del modelo
print("Cargando el modelo Whisper...")
selected_model = select_model()
model = whisper.load_model(selected_model)
print(f"Modelo '{selected_model}' cargado con éxito.")
# Solicitar idioma al usuario
while True:
language_choice = input("Ingrese el número del idioma del audio (1 para español, 2 para inglés): ")
if language_choice == "1":
audio_language = "es"
break
elif language_choice == "2":
audio_language = "en"
break
else:
print("Por favor, ingrese 1 o 2.")
print("Iniciando transcripción...")
start_time = time.time()
result = model.transcribe(audio_file_path, fp16=False, language=audio_language)
end_time = time.time()
print("Transcripción completada.")
transcription_time = end_time - start_time
transcription_time_minutes = transcription_time / 60
print(f"Tiempo de transcripción: {transcription_time_minutes:.2f} minutos")
# Generar contenido SRT
srt_content = create_srt_content(result["segments"])
# Guardar archivo SRT
srt_file_name = os.path.splitext(audio_file_name)[0] + '.srt'
srt_file_path = os.path.join(current_directory, srt_file_name)
with open(srt_file_path, 'w', encoding='utf-8') as srt_file:
srt_file.write(srt_content)
print(f"Archivo de subtítulos SRT guardado en {srt_file_path}")
# Guardar transcripción completa en formato de texto
transcription = result["text"]
txt_file_name = os.path.splitext(audio_file_name)[0] + '_transcription.txt'
txt_file_path = os.path.join(current_directory, txt_file_name)
with open(txt_file_path, 'w', encoding='utf-8') as txt_file:
txt_file.write(transcription)
print(f"Transcripción completa guardada en {txt_file_path}")
# Traducir la transcripción al español si el usuario lo solicita
if language_choice == "2":
translate_choice = input("¿Desea traducir la transcripción al español? (s/n): ")
if translate_choice.lower() == "s":
print("Traduciendo la transcripción al español...")
# Utilizar la API de DeepL para traducir
auth_key = "APIKEY" # Reemplaza con tu clave de autenticación
translator = deepl.Translator(auth_key)
translated_result = translator.translate_text(transcription, target_lang="ES")
# Guardar la transcripción traducida en un archivo separado
translated_txt_file_name = os.path.splitext(audio_file_name)[0] + '_transcription_es.txt'
translated_txt_file_path = os.path.join(current_directory, translated_txt_file_name)
with open(translated_txt_file_path, 'w', encoding='utf-8') as translated_txt_file:
translated_txt_file.write(translated_result.text)
print(f"Transcripción traducida al español guardada en {translated_txt_file_path}")
# Traducir los subtítulos SRT
translated_srt_content = create_srt_content([
{"start": segment["start"], "end": segment["end"], "text": translator.translate_text(segment["text"], target_lang="ES").text}
for segment in result["segments"]
])
translated_srt_file_name = os.path.splitext(audio_file_name)[0] + '_subtitles_es.srt'
translated_srt_file_path = os.path.join(current_directory, translated_srt_file_name)
with open(translated_srt_file_path, 'w', encoding='utf-8') as translated_srt_file:
translated_srt_file.write(translated_srt_content)
print(f"Archivo de subtítulos SRT traducido al español guardado en {translated_srt_file_path}")
input("Presiona Enter para cerrar...")
1. Prepara tu Entorno
Coloca el archivo de audio que deseas transcribir en la misma carpeta donde se encuentra el script. Asegúrate de que el archivo sea uno de los formatos soportados.
2. Ejecuta el Script
Ejecuta el script en tu terminal o consola de comandos:
python nombre_del_script.py
3. Selección del Modelo
Al ejecutar el script, se te presentará una lista de modelos de Whisper. Cada modelo tiene diferentes características:
- Tiny: El más rápido y ligero, ideal para pruebas rápidas.
- Base: Buen equilibrio entre velocidad y precisión.
- Small: Mayor precisión para tareas diarias.
- Medium: Alta precisión, ideal para contenido profesional.
- Large: Máxima precisión, recomendado para situaciones donde la calidad es esencial.
Selecciona el modelo que mejor se adapte a tus necesidades ingresando el número correspondiente.
4. Elige el Idioma del Audio
A continuación, se te pedirá que indiques el idioma del audio. Puedes elegir entre español (1) e inglés (2). Esto es importante para que el modelo pueda transcribir el audio correctamente.
5. Inicia la Transcripción
Una vez que hayas seleccionado el modelo y el idioma, el script comenzará la transcripción del archivo de audio. El tiempo de transcripción se mostrará en la consola.
6. Guarda los Resultados
Al finalizar la transcripción, el script generará dos archivos:
- Un archivo de subtítulos en formato SRT.
- Un archivo de texto con la transcripción completa.
Ambos archivos se guardarán en el mismo directorio que el archivo de audio original.
7. Traducción (Opcional)
Si seleccionaste inglés como idioma del audio, el script te preguntará si deseas traducir la transcripción al español. Si eliges ‘sí’, el script utilizará la API de DeepL para traducir tanto el texto como los subtítulos.
Nota: Para utilizar la traducción, necesitas una clave de autenticación de DeepL. Asegúrate de reemplazar "APIKEY" en el script con tu clave.
8. Optimización para GPU
Si tienes una tarjeta gráfica compatible, puedes mejorar el rendimiento de la transcripción cambiando el valor de fp16 a True en la llamada model.transcribe(). Esto permite usar precisión de punto flotante de 16 bits, lo que puede acelerar el proceso. Simplemente cambia:
result = model.transcribe(audio_file_path, fp16=False, language=audio_language)
a:
result = model.transcribe(audio_file_path, fp16=True, language=audio_language)
Este script es una herramienta efectiva para la transcripción automática de audio utilizando Whisper. Con su fácil uso y la posibilidad de traducir al español, puedes adaptarlo a tus necesidades de transcripción y traducción. Un plus de este script es que los subtítulos traducidos los puedes integrar en diferentes aplicaciones, incluso en YouTube, por medio de extensiones como Substital.