You've learned this already. ✅
Click here to view the next lesson.
Capítulo 6: Conjuntos de IA de Modelo Cruzado
6.3 Automatizando Resúmenes, Transcripciones e Imágenes
Ahora es momento de ir un nivel más profundo — hacia la automatización. Esta sección demostrará cómo crear un sofisticado flujo de trabajo de procesamiento en segundo plano que revoluciona la forma en que manejamos el contenido de audio. En lugar de requerir intervención manual, este sistema opera de forma autónoma:
- Monitoreando continuamente las carpetas designadas para nuevas cargas de archivos de audio
- Iniciando automáticamente el proceso de transcripción usando reconocimiento de voz avanzado
- Creando resúmenes inteligentes que capturan los puntos clave y el contexto
- Generando imágenes contextualmente relevantes basadas en el contenido
- Organizando y almacenando todas las salidas en un formato estructurado
Esta pipeline automatizada elimina la necesidad de procesamiento manual, ahorrando considerable tiempo y esfuerzo mientras mantiene la consistencia en la calidad de salida. El sistema puede manejar múltiples archivos simultáneamente y funciona 24/7, haciéndolo ideal para organizaciones que procesan grandes volúmenes de contenido de audio.
6.3.1 Lo que vas a construir
En esta sección, crearás un sofisticado script de automatización en Python que transforma la forma de procesar archivos de audio. Esta pipeline de automatización monitorea un directorio específico y entra en acción cada vez que aparece nuevo contenido de audio. Veamos en detalle exactamente lo que logra este potente sistema:
- Transcribir el audio usando Whisper - El script aprovecha el avanzado modelo de reconocimiento de voz de OpenAI para convertir las palabras habladas en texto preciso, manejando múltiples acentos e idiomas con impresionante precisión.
- Resumir la transcripción usando GPT-4o - Después de la transcripción, el sistema emplea la avanzada comprensión del lenguaje de GPT-4o para destilar los puntos clave y las ideas principales en un resumen conciso y coherente.
- Generar una instrucción para imagen a partir de la transcripción usando GPT-4o - El script luego analiza el contenido y contexto de la transcripción para crear instrucciones detalladas y vívidas que capturan la esencia del audio en términos visuales.
- Generar una imagen a partir de la instrucción usando DALL·E 3 - Usando estas instrucciones cuidadosamente elaboradas, DALL·E 3 crea imágenes de alta calidad y contextualmente relevantes que complementan el contenido del audio.
- Guardar la transcripción, resumen, instrucción e imagen generada en archivos separados - El sistema organiza automáticamente todas las salidas de manera estructurada, facilitando el acceso y uso del contenido generado.
Esta completa solución de automatización transforma el audio sin procesar en una rica colección de activos digitales. La versatilidad de este sistema permite que se integre en varios entornos de producción:
- Un gestor de tareas en segundo plano (p. ej., Celery) para procesamiento asíncrono - Perfecto para manejar múltiples archivos simultáneamente sin bloquear otras operaciones, asegurando una escalabilidad fluida.
- Una función en la nube (p. ej., AWS Lambda o Google Cloud Functions) para ejecución sin servidor - Permite un procesamiento rentable y bajo demanda sin mantener una infraestructura de servidor constante.
- Un script local programado para procesamiento por lotes - Ideal para el procesamiento automatizado regular de archivos de audio acumulados en intervalos específicos.
Para este capítulo, nos centraremos en construir un prototipo local, que sirve como un excelente punto de partida para creadores, investigadores o desarrolladores que necesitan una forma confiable y eficiente de procesar archivos de audio. Este enfoque permite pruebas e iteraciones fáciles antes de escalar a implementaciones más grandes.
6.3.2 Implementación paso a paso
Paso 1: Configuración del proyecto
Descarga el audio de muestra: https://files.cuantum.tech/audio/automating-summaries.mp3
Crea un nuevo directorio para tu proyecto y navega hacia él:
mkdir audio_processing_automation
cd audio_processing_automationSe recomienda configurar un entorno virtual:
python -m venv venv
source venv/bin/activate # En macOS/Linux
venv\\Scripts\\activate # En WindowsInstala los paquetes de Python necesarios:
pip install openai python-dotenv requestsOrganiza los archivos de tu proyecto de la siguiente manera:
/audio_processing_automation
│
├── main.py
├── .env
└── utils/
├── __init__.py
├── transcribe.py
├── summarize.py
├── generate_prompt.py
└── generate_image.py/audio_processing_automation: El directorio raíz de tu proyecto.main.py: El script de Python que automatizará el procesamiento de audio..env: Un archivo para almacenar tu clave de API de OpenAI.utils/: Un directorio para módulos de Python que contiene funciones reutilizables.__init__.py: Convierte el directorioutilsen un paquete de Python.transcribe.py: Contiene la función para transcribir audio usando Whisper.summarize.py: Contiene la función para resumir la transcripción usando un Modelo de Lenguaje Grande.generate_prompt.py: Contiene la función para generar una instrucción de imagen a partir del resumen usando un Modelo de Lenguaje Grande.generate_image.py: Contiene la función para generar una imagen con DALL·E 3.
Paso 2: Crear los Módulos de Utilidad
Crea los siguientes archivos Python en el directorio utils/:
utils/transcribe.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def transcribe_audio(file_path: str) -> Optional[str]:
"""
Transcribes an audio file using OpenAI's Whisper API.
Args:
file_path (str): The path to the audio file.
Returns:
Optional[str]: The transcribed text, or None on error.
"""
try:
logger.info(f"Transcribing audio: {file_path}")
audio_file = open(file_path, "rb")
response = openai.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
)
transcript = response.text
audio_file.close()
return transcript
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error during transcription: {e}")
return None- Este módulo define la función
transcribe_audio, que toma como entrada la ruta a un archivo de audio y utiliza la API de Whisper de OpenAI para generar una transcripción de texto. - La función abre el archivo de audio en modo lectura binaria (
"rb"). - Llama a
openai.audio.transcriptions.create()para realizar la transcripción, especificando el modelo "whisper-1". - Extrae el texto transcrito de la respuesta de la API.
- Incluye manejo de errores usando un bloque
try...exceptpara capturar posibles excepcionesopenai.error.OpenAIError(específicas de OpenAI) yExceptiongeneral para otros errores. Si ocurre un error, registra el error y devuelveNone. - Registra la ruta del archivo antes de la transcripción y la longitud del texto transcrito después de una transcripción exitosa.
- El archivo de audio se cierra después de la transcripción.
utils/summarize.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def summarize_transcript(text: str) -> Optional[str]:
"""
Summarizes a text transcript using OpenAI's Chat Completion API.
Args:
text (str): The text transcript to summarize.
Returns:
Optional[str]: The summarized text, or None on error.
"""
try:
logger.info("Summarizing transcript")
response = openai.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system",
"content": "You are a helpful assistant. Provide a concise summary of the text, suitable for generating a visual representation."},
{"role": "user", "content": text}
],
)
summary = response.choices[0].message.content
logger.info(f"Summary: {summary}")
return summary
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating summary: {e}")
return None- Este módulo define la función
summarize_transcript, que toma una transcripción de texto como entrada y utiliza la API de Chat Completion de OpenAI para generar un resumen conciso. - El mensaje del sistema instruye al modelo a actuar como un asistente servicial y proporcionar un resumen conciso del texto, adecuado para generar una representación visual.
- El mensaje del usuario proporciona la transcripción como contenido para que el modelo la resuma.
- La función extrae el resumen de la respuesta de la API.
- Incluye manejo de errores.
utils/generate_prompt.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def create_image_prompt(transcription: str) -> Optional[str]:
"""
Generates a detailed image prompt from a text transcription using OpenAI's Chat Completion API.
Args:
transcription (str): The text transcription of the audio.
Returns:
Optional[str]: A detailed text prompt suitable for image generation, or None on error.
"""
try:
logger.info("Generating image prompt from transcription")
response = openai.chat.completions.create(
model="gpt-4o", # Use a powerful chat model
messages=[
{
"role": "system",
"content": "You are a creative assistant. Your task is to create a vivid and detailed text description of a scene that could be used to generate an image with an AI image generation model. Focus on capturing the essence and key visual elements of the audio content. Do not include any phrases like 'based on the audio' or 'from the user audio'. Incorporate scene lighting, time of day, weather, and camera angle into the description. Limit the description to 200 words.",
},
{"role": "user", "content": transcription},
],
)
prompt = response.choices[0].message.content
prompt = prompt.strip() # Remove leading/trailing spaces
logger.info(f"Generated prompt: {prompt}")
return prompt
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating image prompt: {e}")
return None- Este módulo define la función
create_image_prompt, que toma el texto transcrito como entrada y utiliza la API de Chat Completion de OpenAI para generar una instrucción detallada para la generación de imágenes. - El mensaje del sistema instruye al modelo a actuar como un asistente creativo y generar una descripción vívida de la escena. La instrucción del sistema es crucial para guiar al MLG a generar una instrucción de alta calidad. Indicamos al MLG que se centre en elementos visuales e incorpore detalles como la iluminación, hora del día, clima y ángulo de la cámara. También limitamos la longitud de la descripción a 200 palabras.
- El mensaje del usuario proporciona el texto transcrito como contenido para que el modelo trabaje.
- La función extrae la instrucción generada de la respuesta de la API.
- Elimina los espacios iniciales y finales de la instrucción generada.
- Incluye manejo de errores.
utils/generate_image.py:
import openai
import logging
from typing import Optional, Dict
logger = logging.getLogger(__name__)
def generate_dalle_image(prompt: str, model: str = "dall-e-3", size: str = "1024x1024",
response_format: str = "url", quality: str = "standard") -> Optional[str]:
"""
Generates an image using OpenAI's DALL·E API.
Args:
prompt (str): The text prompt to generate the image from.
model (str, optional): The DALL·E model to use. Defaults to "dall-e-3".
size (str, optional): The size of the generated image. Defaults to "1024x1024".
response_format (str, optional): The format of the response. Defaults to "url".
quality (str, optional): The quality of the image. Defaults to "standard".
Returns:
Optional[str]: The URL of the generated image, or None on error.
"""
try:
logger.info(f"Generating image with prompt: {prompt}, model: {model}, size: {size}, format: {response_format}, quality: {quality}")
response = openai.images.generate(
prompt=prompt,
model=model,
size=size,
response_format=response_format,
quality=quality
)
image_url = response.data[0].url
logger.info(f"Image URL: {image_url}")
return image_url
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating image: {e}")
return None- Este módulo define la función
generate_dalle_image, que toma como entrada una instrucción de texto y utiliza la API DALL·E de OpenAI para generar una imagen. - Llama al método
openai.images.generate()para generar la imagen. - Acepta parámetros opcionales de
model,size,response_formatyquality, permitiendo al usuario configurar la generación de la imagen. - Extrae la URL de la imagen generada de la respuesta de la API.
- Incluye manejo de errores.
Paso 4: Crear el Script Principal (main.py)
Crea un archivo Python llamado main.py en el directorio raíz de tu proyecto y agrega el siguiente código:
import os
import time
import logging
from typing import Optional
# Import the utility functions from the utils directory
from utils.transcribe import transcribe_audio
from utils.generate_prompt import create_image_prompt
from utils.generate_image import generate_dalle_image
from utils.summarize import summarize_transcript
# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
UPLOAD_DIR = "uploads" # Directory where audio files are placed
OUTPUT_DIR = "outputs" # Directory where results are saved
ALLOWED_EXTENSIONS = {'mp3', 'mp4', 'wav', 'm4a'}
def process_audio(file_path: str) -> None:
"""
Processes an audio file, transcribing, summarizing, generating a prompt, and generating an image.
Args:
file_path (str): The path to the audio file to process.
"""
logger.info(f"Processing audio file: {file_path}")
base_name = os.path.splitext(os.path.basename(file_path))[0] # Get filename without extension
# Create output directory for this file
output_path = os.path.join(OUTPUT_DIR, base_name)
os.makedirs(output_path, exist_ok=True)
try:
# Transcription
transcript = transcribe_audio(file_path)
if transcript:
transcript_file_path = os.path.join(output_path, f"{base_name}_transcript.txt")
with open(transcript_file_path, "w") as f:
f.write(transcript)
logger.info(f"Transcription saved to {transcript_file_path}")
else:
logger.error(f"Transcription failed for {file_path}")
return # Stop processing if transcription fails
# Summary
summary = summarize_transcript(transcript)
if summary:
summary_file_path = os.path.join(output_path, f"{base_name}_summary.txt")
with open(summary_file_path, "w") as f:
f.write(summary)
logger.info(f"Summary saved to {summary_file_path}")
else:
logger.error(f"Summary failed for {file_path}")
return
# Image Prompt
prompt = create_image_prompt(transcript)
if prompt:
prompt_file_path = os.path.join(output_path, f"{base_name}_prompt.txt")
with open(prompt_file_path, "w") as f:
f.write(prompt)
logger.info(f"Prompt saved to {prompt_file_path}")
else:
logger.error(f"Prompt generation failed for {file_path}")
return
# Image Generation
image_url = generate_dalle_image(prompt)
if image_url:
try:
import requests
img_data = requests.get(image_url).content
image_file_path = os.path.join(output_path, f"{base_name}_image.png")
with open(image_file_path, "wb") as f:
f.write(img_data)
logger.info(f"Image saved to {image_file_path}")
except requests.exceptions.RequestException as e:
logger.error(f"Error downloading image: {e}")
return
else:
logger.error(f"Image generation failed for {file_path}")
return
logger.info(f"Successfully processed audio file: {file_path}")
except Exception as e:
logger.error(f"An error occurred while processing {file_path}: {e}")
def watch_folder(upload_dir: str, output_dir: str) -> None:
"""
Monitors a folder for new audio files and processes them.
Args:
upload_dir (str): The path to the directory to watch for new audio files.
output_dir (str): The path to the directory where results should be saved.
"""
logger.info(f"Watching folder: {upload_dir} for new audio files...")
processed_files = set()
while True:
try:
files = [
os.path.join(upload_dir, f)
for f in os.listdir(upload_dir)
if f.lower().endswith(tuple(ALLOWED_EXTENSIONS))
]
for file_path in files:
if file_path not in processed_files and os.path.isfile(file_path):
process_audio(file_path)
processed_files.add(file_path)
except Exception as e:
logger.error(f"Error while watching folder: {e}")
time.sleep(5) # Check for new files every 5 seconds
if __name__ == "__main__":
os.makedirs(UPLOAD_DIR, exist_ok=True)
os.makedirs(OUTPUT_DIR, exist_ok=True)
watch_folder(UPLOAD_DIR, OUTPUT_DIR)Desglose del Código:
- Declaraciones de Importación: Importa las bibliotecas necesarias:
os: Para interactuar con el sistema operativo (rutas de archivos, directorios).time: Para agregar retrasos (pausas entre verificaciones).logging: Para registrar eventos.typing: Para sugerencias de tipo.werkzeug.utils: Parasecure_filename.werkzeug.datastructures: ParaFileStorage.
- Constantes:
UPLOAD_DIR: El directorio donde se espera que se suban los archivos de audio.OUTPUT_DIR: El directorio donde se guardarán los resultados procesados (transcripciones, instrucciones, imágenes).ALLOWED_EXTENSIONS: Un conjunto de extensiones de archivo de audio permitidas
- Función
allowed_file:- Verifica si un archivo tiene una extensión permitida.
- Función
transcribe_audio:- Toma la ruta del archivo de audio como entrada.
- Abre el archivo de audio en modo de lectura binaria (
"rb"). - Llama al método
openai.Audio.transcriptions.create()de la API de OpenAI para transcribir el audio. - Extrae el texto transcrito de la respuesta de la API.
- Registra la ruta del archivo antes de la transcripción y la longitud del texto transcrito después de una transcripción exitosa.
- Incluye manejo de errores usando un bloque
try...exceptpara capturar posibles excepcionesopenai.error.OpenAIError(específicas de OpenAI) yExceptiongeneral para otros errores.
- Función
generate_image_prompt:- Toma el texto transcrito como entrada.
- Utiliza la API de Chat Completion de OpenAI (
openai.chat.completions.create()) con el modelogpt-4opara generar una instrucción detallada de texto adecuada para la generación de imágenes. - El mensaje del sistema instruye al modelo a actuar como un asistente creativo y proporcionar una descripción vívida y detallada de una escena que podría usarse para generar una imagen con un modelo de generación de imágenes de IA.
- Extrae la instrucción generada de la respuesta de la API.
- Incluye manejo de errores.
- Función
generate_image:- Toma la instrucción de imagen como entrada.
- Llama al método
openai.Image.create()de la API de OpenAI para generar una imagen usando DALL·E 3. - Acepta parámetros opcionales para
model,size,response_formatyquality. - Extrae la URL de la imagen generada de la respuesta de la API.
- Incluye manejo de errores.
process_audioFunción:- Toma la ruta de un archivo de audio como entrada.
- Realiza los siguientes pasos:
- Registra el inicio del procesamiento.
- Extrae el nombre base del archivo (sin extensión) de la ruta del archivo de audio.
- Crea un directorio dentro de
OUTPUT_DIRusando el nombre base del archivo para almacenar los resultados de este archivo de audio específico. - Llama a
transcribe_audio()para transcribir el audio. Si la transcripción falla, registra un error y retorna. - Guarda la transcripción en un archivo de texto en el directorio de salida.
- Llama a
summarize_transcript()para resumir la transcripción. Si el resumen falla, registra un error y retorna. - Guarda el resumen en un archivo de texto en el directorio de salida.
- Llama a
create_image_prompt()para generar una instrucción de imagen. Si la generación de la instrucción falla, registra un error y retorna. - Guarda la instrucción en un archivo de texto en el directorio de salida.
- Llama a
generate_dalle_image()para generar una imagen a partir de la instrucción. Si la generación de la imagen falla, registra un error y retorna. - Descarga la imagen desde la URL y la guarda como archivo PNG en el directorio de salida.
- Registra la finalización exitosa del procesamiento.
- Incluye un bloque amplio
try...exceptpara capturar cualquier excepción durante el procesamiento de un archivo de audio individual. Cualquier error durante el proceso es registrado. watch_folderFunción:- Toma las rutas de los directorios de carga y salida como entrada.
- Registra el inicio del proceso de monitoreo de carpeta.
- Inicializa un conjunto vacío
processed_filespara realizar un seguimiento de los archivos procesados. - Entra en un bucle infinito:
- Lista todos los archivos en el
upload_dirque tienen extensiones de archivo de audio permitidas. - Itera a través de los archivos:
- Si un archivo no ha sido procesado aún:
- Llama a
process_audio()para procesar el archivo. - Añade la ruta del archivo al conjunto
processed_files.
- Llama a
- Si un archivo no ha sido procesado aún:
- Pausa durante 5 segundos usando
time.sleep(5)antes de verificar nuevos archivos nuevamente.
- Lista todos los archivos en el
- Incluye un bloque
try...exceptpara capturar cualquier excepción que pueda ocurrir durante el proceso de monitoreo de carpeta. Cualquier error es registrado.
- Bloque de Ejecución Principal:
if __name__ == "__main__":: Asegura que el siguiente código se ejecute solo cuando el script se ejecuta directamente (no cuando se importa como módulo).- Crea los directorios
UPLOAD_DIRyOUTPUT_DIRsi no existen. - Llama a la función
watch_folder()para comenzar a monitorear el directorio de carga.
6.3.3 Consejos para Escalar este Flujo de Trabajo
- Agregar notificaciones por correo electrónico/SMS/Slack cuando un elemento esté listoImplementa notificaciones automatizadas para mantener a los usuarios informados cuando su contenido haya sido procesado. Esto se puede hacer usando servicios como SendGrid para correo electrónico, Twilio para SMS, o la API de webhooks de Slack para mensajería instantánea. Esto asegura que los usuarios no necesiten verificar constantemente los elementos completados.
- Almacenar resultados en una base de datos o almacenamiento en la nubeEn lugar de almacenar archivos localmente, utiliza soluciones de almacenamiento en la nube como AWS S3, Google Cloud Storage o Azure Blob Storage. Esto proporciona mejor escalabilidad, protección de respaldo y gestión de acceso más sencilla. Para datos estructurados, considera usar bases de datos como PostgreSQL o MongoDB para permitir consultas eficientes y gestión de resultados procesados.
- Usar bibliotecas de hilos o asíncronas (como
watchdog,aiofiles) para mejor rendimientoReemplaza el bucle básico de monitoreo de archivos con soluciones más sofisticadas. La bibliotecawatchdogproporciona monitoreo confiable de eventos del sistema de archivos, mientras queaiofilespermite operaciones de archivo asíncronas. Esto evita operaciones bloqueantes y mejora la capacidad de respuesta general del sistema. - Conectar con las APIs de Google Drive o Dropbox para monitorear cargas remotamenteExpande más allá del monitoreo de archivos locales integrándote con APIs de almacenamiento en la nube. Esto permite a los usuarios activar el procesamiento simplemente subiendo archivos a su servicio de almacenamiento en la nube preferido. Implementa receptores de webhooks o usa sondeo de API para detectar nuevas cargas.
- Agregar una cola de tareas (ej., Celery o RQ) para procesamiento concurrenteReemplaza el procesamiento síncrono con un sistema de cola de tareas distribuido. Celery o Redis Queue (RQ) pueden gestionar múltiples trabajadores procesando archivos simultáneamente, manejar reintentos en caso de fallos y proporcionar priorización de tareas. Esto es esencial para manejar grandes volúmenes de cargas y prevenir la sobrecarga del sistema.
En esta sección, transformaste tu colección de herramientas de IA en un potente motor creativo automatizado. Este sistema representa un avance significativo en el procesamiento de IA multimodal - en lugar de alimentar manualmente el contenido a través de diferentes modelos, has creado un proceso inteligente que maneja automáticamente todo el flujo de trabajo. El script que construiste monitorea activamente nuevos archivos, los procesa sin problemas a través de tres sofisticados modelos de OpenAI (Whisper, GPT y DALL·E), y organiza los resultados en una colección estructurada de resúmenes, instrucciones creativas e imágenes generadas.
Este tipo de automatización revoluciona el procesamiento de contenido al eliminar pasos manuales y crear un flujo de trabajo continuo y automatizado. Las aplicaciones para este sistema son diversas y potentes, particularmente beneficiosas para:
- Equipos de contenido: Agilizar la creación de contenido multimedia generando automáticamente recursos complementarios a partir de grabaciones de audio
- Creadores individuales: Permitir que los creadores de contenido individuales multipliquen su producción creativa sin esfuerzo manual adicional
- Investigadores: Automatizar la transcripción y visualización de entrevistas, grabaciones de campo y notas de investigación
- Aplicaciones de diario de voz: Convertir diarios hablados en experiencias multimedia enriquecidas con imágenes generadas
- Herramientas educativas: Transformar conferencias y contenido educativo en materiales visuales y textuales atractivos
- Sistemas de documentación basados en IA: Generar automáticamente documentación completa con ayudas visuales a partir de grabaciones de voz
Quizás lo más notable es que has logrado esta sofisticada automatización con solo unos pocos archivos Python. Esto representa una democratización de la tecnología que anteriormente habría requerido un equipo de ingenieros especializados e infraestructura compleja para implementar. Al aprovechar las modernas APIs de IA y prácticas inteligentes de programación, has creado un sistema de automatización creativa de nivel empresarial que puede ser mantenido y modificado por un solo desarrollador.
6.3 Automatizando Resúmenes, Transcripciones e Imágenes
Ahora es momento de ir un nivel más profundo — hacia la automatización. Esta sección demostrará cómo crear un sofisticado flujo de trabajo de procesamiento en segundo plano que revoluciona la forma en que manejamos el contenido de audio. En lugar de requerir intervención manual, este sistema opera de forma autónoma:
- Monitoreando continuamente las carpetas designadas para nuevas cargas de archivos de audio
- Iniciando automáticamente el proceso de transcripción usando reconocimiento de voz avanzado
- Creando resúmenes inteligentes que capturan los puntos clave y el contexto
- Generando imágenes contextualmente relevantes basadas en el contenido
- Organizando y almacenando todas las salidas en un formato estructurado
Esta pipeline automatizada elimina la necesidad de procesamiento manual, ahorrando considerable tiempo y esfuerzo mientras mantiene la consistencia en la calidad de salida. El sistema puede manejar múltiples archivos simultáneamente y funciona 24/7, haciéndolo ideal para organizaciones que procesan grandes volúmenes de contenido de audio.
6.3.1 Lo que vas a construir
En esta sección, crearás un sofisticado script de automatización en Python que transforma la forma de procesar archivos de audio. Esta pipeline de automatización monitorea un directorio específico y entra en acción cada vez que aparece nuevo contenido de audio. Veamos en detalle exactamente lo que logra este potente sistema:
- Transcribir el audio usando Whisper - El script aprovecha el avanzado modelo de reconocimiento de voz de OpenAI para convertir las palabras habladas en texto preciso, manejando múltiples acentos e idiomas con impresionante precisión.
- Resumir la transcripción usando GPT-4o - Después de la transcripción, el sistema emplea la avanzada comprensión del lenguaje de GPT-4o para destilar los puntos clave y las ideas principales en un resumen conciso y coherente.
- Generar una instrucción para imagen a partir de la transcripción usando GPT-4o - El script luego analiza el contenido y contexto de la transcripción para crear instrucciones detalladas y vívidas que capturan la esencia del audio en términos visuales.
- Generar una imagen a partir de la instrucción usando DALL·E 3 - Usando estas instrucciones cuidadosamente elaboradas, DALL·E 3 crea imágenes de alta calidad y contextualmente relevantes que complementan el contenido del audio.
- Guardar la transcripción, resumen, instrucción e imagen generada en archivos separados - El sistema organiza automáticamente todas las salidas de manera estructurada, facilitando el acceso y uso del contenido generado.
Esta completa solución de automatización transforma el audio sin procesar en una rica colección de activos digitales. La versatilidad de este sistema permite que se integre en varios entornos de producción:
- Un gestor de tareas en segundo plano (p. ej., Celery) para procesamiento asíncrono - Perfecto para manejar múltiples archivos simultáneamente sin bloquear otras operaciones, asegurando una escalabilidad fluida.
- Una función en la nube (p. ej., AWS Lambda o Google Cloud Functions) para ejecución sin servidor - Permite un procesamiento rentable y bajo demanda sin mantener una infraestructura de servidor constante.
- Un script local programado para procesamiento por lotes - Ideal para el procesamiento automatizado regular de archivos de audio acumulados en intervalos específicos.
Para este capítulo, nos centraremos en construir un prototipo local, que sirve como un excelente punto de partida para creadores, investigadores o desarrolladores que necesitan una forma confiable y eficiente de procesar archivos de audio. Este enfoque permite pruebas e iteraciones fáciles antes de escalar a implementaciones más grandes.
6.3.2 Implementación paso a paso
Paso 1: Configuración del proyecto
Descarga el audio de muestra: https://files.cuantum.tech/audio/automating-summaries.mp3
Crea un nuevo directorio para tu proyecto y navega hacia él:
mkdir audio_processing_automation
cd audio_processing_automationSe recomienda configurar un entorno virtual:
python -m venv venv
source venv/bin/activate # En macOS/Linux
venv\\Scripts\\activate # En WindowsInstala los paquetes de Python necesarios:
pip install openai python-dotenv requestsOrganiza los archivos de tu proyecto de la siguiente manera:
/audio_processing_automation
│
├── main.py
├── .env
└── utils/
├── __init__.py
├── transcribe.py
├── summarize.py
├── generate_prompt.py
└── generate_image.py/audio_processing_automation: El directorio raíz de tu proyecto.main.py: El script de Python que automatizará el procesamiento de audio..env: Un archivo para almacenar tu clave de API de OpenAI.utils/: Un directorio para módulos de Python que contiene funciones reutilizables.__init__.py: Convierte el directorioutilsen un paquete de Python.transcribe.py: Contiene la función para transcribir audio usando Whisper.summarize.py: Contiene la función para resumir la transcripción usando un Modelo de Lenguaje Grande.generate_prompt.py: Contiene la función para generar una instrucción de imagen a partir del resumen usando un Modelo de Lenguaje Grande.generate_image.py: Contiene la función para generar una imagen con DALL·E 3.
Paso 2: Crear los Módulos de Utilidad
Crea los siguientes archivos Python en el directorio utils/:
utils/transcribe.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def transcribe_audio(file_path: str) -> Optional[str]:
"""
Transcribes an audio file using OpenAI's Whisper API.
Args:
file_path (str): The path to the audio file.
Returns:
Optional[str]: The transcribed text, or None on error.
"""
try:
logger.info(f"Transcribing audio: {file_path}")
audio_file = open(file_path, "rb")
response = openai.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
)
transcript = response.text
audio_file.close()
return transcript
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error during transcription: {e}")
return None- Este módulo define la función
transcribe_audio, que toma como entrada la ruta a un archivo de audio y utiliza la API de Whisper de OpenAI para generar una transcripción de texto. - La función abre el archivo de audio en modo lectura binaria (
"rb"). - Llama a
openai.audio.transcriptions.create()para realizar la transcripción, especificando el modelo "whisper-1". - Extrae el texto transcrito de la respuesta de la API.
- Incluye manejo de errores usando un bloque
try...exceptpara capturar posibles excepcionesopenai.error.OpenAIError(específicas de OpenAI) yExceptiongeneral para otros errores. Si ocurre un error, registra el error y devuelveNone. - Registra la ruta del archivo antes de la transcripción y la longitud del texto transcrito después de una transcripción exitosa.
- El archivo de audio se cierra después de la transcripción.
utils/summarize.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def summarize_transcript(text: str) -> Optional[str]:
"""
Summarizes a text transcript using OpenAI's Chat Completion API.
Args:
text (str): The text transcript to summarize.
Returns:
Optional[str]: The summarized text, or None on error.
"""
try:
logger.info("Summarizing transcript")
response = openai.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system",
"content": "You are a helpful assistant. Provide a concise summary of the text, suitable for generating a visual representation."},
{"role": "user", "content": text}
],
)
summary = response.choices[0].message.content
logger.info(f"Summary: {summary}")
return summary
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating summary: {e}")
return None- Este módulo define la función
summarize_transcript, que toma una transcripción de texto como entrada y utiliza la API de Chat Completion de OpenAI para generar un resumen conciso. - El mensaje del sistema instruye al modelo a actuar como un asistente servicial y proporcionar un resumen conciso del texto, adecuado para generar una representación visual.
- El mensaje del usuario proporciona la transcripción como contenido para que el modelo la resuma.
- La función extrae el resumen de la respuesta de la API.
- Incluye manejo de errores.
utils/generate_prompt.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def create_image_prompt(transcription: str) -> Optional[str]:
"""
Generates a detailed image prompt from a text transcription using OpenAI's Chat Completion API.
Args:
transcription (str): The text transcription of the audio.
Returns:
Optional[str]: A detailed text prompt suitable for image generation, or None on error.
"""
try:
logger.info("Generating image prompt from transcription")
response = openai.chat.completions.create(
model="gpt-4o", # Use a powerful chat model
messages=[
{
"role": "system",
"content": "You are a creative assistant. Your task is to create a vivid and detailed text description of a scene that could be used to generate an image with an AI image generation model. Focus on capturing the essence and key visual elements of the audio content. Do not include any phrases like 'based on the audio' or 'from the user audio'. Incorporate scene lighting, time of day, weather, and camera angle into the description. Limit the description to 200 words.",
},
{"role": "user", "content": transcription},
],
)
prompt = response.choices[0].message.content
prompt = prompt.strip() # Remove leading/trailing spaces
logger.info(f"Generated prompt: {prompt}")
return prompt
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating image prompt: {e}")
return None- Este módulo define la función
create_image_prompt, que toma el texto transcrito como entrada y utiliza la API de Chat Completion de OpenAI para generar una instrucción detallada para la generación de imágenes. - El mensaje del sistema instruye al modelo a actuar como un asistente creativo y generar una descripción vívida de la escena. La instrucción del sistema es crucial para guiar al MLG a generar una instrucción de alta calidad. Indicamos al MLG que se centre en elementos visuales e incorpore detalles como la iluminación, hora del día, clima y ángulo de la cámara. También limitamos la longitud de la descripción a 200 palabras.
- El mensaje del usuario proporciona el texto transcrito como contenido para que el modelo trabaje.
- La función extrae la instrucción generada de la respuesta de la API.
- Elimina los espacios iniciales y finales de la instrucción generada.
- Incluye manejo de errores.
utils/generate_image.py:
import openai
import logging
from typing import Optional, Dict
logger = logging.getLogger(__name__)
def generate_dalle_image(prompt: str, model: str = "dall-e-3", size: str = "1024x1024",
response_format: str = "url", quality: str = "standard") -> Optional[str]:
"""
Generates an image using OpenAI's DALL·E API.
Args:
prompt (str): The text prompt to generate the image from.
model (str, optional): The DALL·E model to use. Defaults to "dall-e-3".
size (str, optional): The size of the generated image. Defaults to "1024x1024".
response_format (str, optional): The format of the response. Defaults to "url".
quality (str, optional): The quality of the image. Defaults to "standard".
Returns:
Optional[str]: The URL of the generated image, or None on error.
"""
try:
logger.info(f"Generating image with prompt: {prompt}, model: {model}, size: {size}, format: {response_format}, quality: {quality}")
response = openai.images.generate(
prompt=prompt,
model=model,
size=size,
response_format=response_format,
quality=quality
)
image_url = response.data[0].url
logger.info(f"Image URL: {image_url}")
return image_url
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating image: {e}")
return None- Este módulo define la función
generate_dalle_image, que toma como entrada una instrucción de texto y utiliza la API DALL·E de OpenAI para generar una imagen. - Llama al método
openai.images.generate()para generar la imagen. - Acepta parámetros opcionales de
model,size,response_formatyquality, permitiendo al usuario configurar la generación de la imagen. - Extrae la URL de la imagen generada de la respuesta de la API.
- Incluye manejo de errores.
Paso 4: Crear el Script Principal (main.py)
Crea un archivo Python llamado main.py en el directorio raíz de tu proyecto y agrega el siguiente código:
import os
import time
import logging
from typing import Optional
# Import the utility functions from the utils directory
from utils.transcribe import transcribe_audio
from utils.generate_prompt import create_image_prompt
from utils.generate_image import generate_dalle_image
from utils.summarize import summarize_transcript
# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
UPLOAD_DIR = "uploads" # Directory where audio files are placed
OUTPUT_DIR = "outputs" # Directory where results are saved
ALLOWED_EXTENSIONS = {'mp3', 'mp4', 'wav', 'm4a'}
def process_audio(file_path: str) -> None:
"""
Processes an audio file, transcribing, summarizing, generating a prompt, and generating an image.
Args:
file_path (str): The path to the audio file to process.
"""
logger.info(f"Processing audio file: {file_path}")
base_name = os.path.splitext(os.path.basename(file_path))[0] # Get filename without extension
# Create output directory for this file
output_path = os.path.join(OUTPUT_DIR, base_name)
os.makedirs(output_path, exist_ok=True)
try:
# Transcription
transcript = transcribe_audio(file_path)
if transcript:
transcript_file_path = os.path.join(output_path, f"{base_name}_transcript.txt")
with open(transcript_file_path, "w") as f:
f.write(transcript)
logger.info(f"Transcription saved to {transcript_file_path}")
else:
logger.error(f"Transcription failed for {file_path}")
return # Stop processing if transcription fails
# Summary
summary = summarize_transcript(transcript)
if summary:
summary_file_path = os.path.join(output_path, f"{base_name}_summary.txt")
with open(summary_file_path, "w") as f:
f.write(summary)
logger.info(f"Summary saved to {summary_file_path}")
else:
logger.error(f"Summary failed for {file_path}")
return
# Image Prompt
prompt = create_image_prompt(transcript)
if prompt:
prompt_file_path = os.path.join(output_path, f"{base_name}_prompt.txt")
with open(prompt_file_path, "w") as f:
f.write(prompt)
logger.info(f"Prompt saved to {prompt_file_path}")
else:
logger.error(f"Prompt generation failed for {file_path}")
return
# Image Generation
image_url = generate_dalle_image(prompt)
if image_url:
try:
import requests
img_data = requests.get(image_url).content
image_file_path = os.path.join(output_path, f"{base_name}_image.png")
with open(image_file_path, "wb") as f:
f.write(img_data)
logger.info(f"Image saved to {image_file_path}")
except requests.exceptions.RequestException as e:
logger.error(f"Error downloading image: {e}")
return
else:
logger.error(f"Image generation failed for {file_path}")
return
logger.info(f"Successfully processed audio file: {file_path}")
except Exception as e:
logger.error(f"An error occurred while processing {file_path}: {e}")
def watch_folder(upload_dir: str, output_dir: str) -> None:
"""
Monitors a folder for new audio files and processes them.
Args:
upload_dir (str): The path to the directory to watch for new audio files.
output_dir (str): The path to the directory where results should be saved.
"""
logger.info(f"Watching folder: {upload_dir} for new audio files...")
processed_files = set()
while True:
try:
files = [
os.path.join(upload_dir, f)
for f in os.listdir(upload_dir)
if f.lower().endswith(tuple(ALLOWED_EXTENSIONS))
]
for file_path in files:
if file_path not in processed_files and os.path.isfile(file_path):
process_audio(file_path)
processed_files.add(file_path)
except Exception as e:
logger.error(f"Error while watching folder: {e}")
time.sleep(5) # Check for new files every 5 seconds
if __name__ == "__main__":
os.makedirs(UPLOAD_DIR, exist_ok=True)
os.makedirs(OUTPUT_DIR, exist_ok=True)
watch_folder(UPLOAD_DIR, OUTPUT_DIR)Desglose del Código:
- Declaraciones de Importación: Importa las bibliotecas necesarias:
os: Para interactuar con el sistema operativo (rutas de archivos, directorios).time: Para agregar retrasos (pausas entre verificaciones).logging: Para registrar eventos.typing: Para sugerencias de tipo.werkzeug.utils: Parasecure_filename.werkzeug.datastructures: ParaFileStorage.
- Constantes:
UPLOAD_DIR: El directorio donde se espera que se suban los archivos de audio.OUTPUT_DIR: El directorio donde se guardarán los resultados procesados (transcripciones, instrucciones, imágenes).ALLOWED_EXTENSIONS: Un conjunto de extensiones de archivo de audio permitidas
- Función
allowed_file:- Verifica si un archivo tiene una extensión permitida.
- Función
transcribe_audio:- Toma la ruta del archivo de audio como entrada.
- Abre el archivo de audio en modo de lectura binaria (
"rb"). - Llama al método
openai.Audio.transcriptions.create()de la API de OpenAI para transcribir el audio. - Extrae el texto transcrito de la respuesta de la API.
- Registra la ruta del archivo antes de la transcripción y la longitud del texto transcrito después de una transcripción exitosa.
- Incluye manejo de errores usando un bloque
try...exceptpara capturar posibles excepcionesopenai.error.OpenAIError(específicas de OpenAI) yExceptiongeneral para otros errores.
- Función
generate_image_prompt:- Toma el texto transcrito como entrada.
- Utiliza la API de Chat Completion de OpenAI (
openai.chat.completions.create()) con el modelogpt-4opara generar una instrucción detallada de texto adecuada para la generación de imágenes. - El mensaje del sistema instruye al modelo a actuar como un asistente creativo y proporcionar una descripción vívida y detallada de una escena que podría usarse para generar una imagen con un modelo de generación de imágenes de IA.
- Extrae la instrucción generada de la respuesta de la API.
- Incluye manejo de errores.
- Función
generate_image:- Toma la instrucción de imagen como entrada.
- Llama al método
openai.Image.create()de la API de OpenAI para generar una imagen usando DALL·E 3. - Acepta parámetros opcionales para
model,size,response_formatyquality. - Extrae la URL de la imagen generada de la respuesta de la API.
- Incluye manejo de errores.
process_audioFunción:- Toma la ruta de un archivo de audio como entrada.
- Realiza los siguientes pasos:
- Registra el inicio del procesamiento.
- Extrae el nombre base del archivo (sin extensión) de la ruta del archivo de audio.
- Crea un directorio dentro de
OUTPUT_DIRusando el nombre base del archivo para almacenar los resultados de este archivo de audio específico. - Llama a
transcribe_audio()para transcribir el audio. Si la transcripción falla, registra un error y retorna. - Guarda la transcripción en un archivo de texto en el directorio de salida.
- Llama a
summarize_transcript()para resumir la transcripción. Si el resumen falla, registra un error y retorna. - Guarda el resumen en un archivo de texto en el directorio de salida.
- Llama a
create_image_prompt()para generar una instrucción de imagen. Si la generación de la instrucción falla, registra un error y retorna. - Guarda la instrucción en un archivo de texto en el directorio de salida.
- Llama a
generate_dalle_image()para generar una imagen a partir de la instrucción. Si la generación de la imagen falla, registra un error y retorna. - Descarga la imagen desde la URL y la guarda como archivo PNG en el directorio de salida.
- Registra la finalización exitosa del procesamiento.
- Incluye un bloque amplio
try...exceptpara capturar cualquier excepción durante el procesamiento de un archivo de audio individual. Cualquier error durante el proceso es registrado. watch_folderFunción:- Toma las rutas de los directorios de carga y salida como entrada.
- Registra el inicio del proceso de monitoreo de carpeta.
- Inicializa un conjunto vacío
processed_filespara realizar un seguimiento de los archivos procesados. - Entra en un bucle infinito:
- Lista todos los archivos en el
upload_dirque tienen extensiones de archivo de audio permitidas. - Itera a través de los archivos:
- Si un archivo no ha sido procesado aún:
- Llama a
process_audio()para procesar el archivo. - Añade la ruta del archivo al conjunto
processed_files.
- Llama a
- Si un archivo no ha sido procesado aún:
- Pausa durante 5 segundos usando
time.sleep(5)antes de verificar nuevos archivos nuevamente.
- Lista todos los archivos en el
- Incluye un bloque
try...exceptpara capturar cualquier excepción que pueda ocurrir durante el proceso de monitoreo de carpeta. Cualquier error es registrado.
- Bloque de Ejecución Principal:
if __name__ == "__main__":: Asegura que el siguiente código se ejecute solo cuando el script se ejecuta directamente (no cuando se importa como módulo).- Crea los directorios
UPLOAD_DIRyOUTPUT_DIRsi no existen. - Llama a la función
watch_folder()para comenzar a monitorear el directorio de carga.
6.3.3 Consejos para Escalar este Flujo de Trabajo
- Agregar notificaciones por correo electrónico/SMS/Slack cuando un elemento esté listoImplementa notificaciones automatizadas para mantener a los usuarios informados cuando su contenido haya sido procesado. Esto se puede hacer usando servicios como SendGrid para correo electrónico, Twilio para SMS, o la API de webhooks de Slack para mensajería instantánea. Esto asegura que los usuarios no necesiten verificar constantemente los elementos completados.
- Almacenar resultados en una base de datos o almacenamiento en la nubeEn lugar de almacenar archivos localmente, utiliza soluciones de almacenamiento en la nube como AWS S3, Google Cloud Storage o Azure Blob Storage. Esto proporciona mejor escalabilidad, protección de respaldo y gestión de acceso más sencilla. Para datos estructurados, considera usar bases de datos como PostgreSQL o MongoDB para permitir consultas eficientes y gestión de resultados procesados.
- Usar bibliotecas de hilos o asíncronas (como
watchdog,aiofiles) para mejor rendimientoReemplaza el bucle básico de monitoreo de archivos con soluciones más sofisticadas. La bibliotecawatchdogproporciona monitoreo confiable de eventos del sistema de archivos, mientras queaiofilespermite operaciones de archivo asíncronas. Esto evita operaciones bloqueantes y mejora la capacidad de respuesta general del sistema. - Conectar con las APIs de Google Drive o Dropbox para monitorear cargas remotamenteExpande más allá del monitoreo de archivos locales integrándote con APIs de almacenamiento en la nube. Esto permite a los usuarios activar el procesamiento simplemente subiendo archivos a su servicio de almacenamiento en la nube preferido. Implementa receptores de webhooks o usa sondeo de API para detectar nuevas cargas.
- Agregar una cola de tareas (ej., Celery o RQ) para procesamiento concurrenteReemplaza el procesamiento síncrono con un sistema de cola de tareas distribuido. Celery o Redis Queue (RQ) pueden gestionar múltiples trabajadores procesando archivos simultáneamente, manejar reintentos en caso de fallos y proporcionar priorización de tareas. Esto es esencial para manejar grandes volúmenes de cargas y prevenir la sobrecarga del sistema.
En esta sección, transformaste tu colección de herramientas de IA en un potente motor creativo automatizado. Este sistema representa un avance significativo en el procesamiento de IA multimodal - en lugar de alimentar manualmente el contenido a través de diferentes modelos, has creado un proceso inteligente que maneja automáticamente todo el flujo de trabajo. El script que construiste monitorea activamente nuevos archivos, los procesa sin problemas a través de tres sofisticados modelos de OpenAI (Whisper, GPT y DALL·E), y organiza los resultados en una colección estructurada de resúmenes, instrucciones creativas e imágenes generadas.
Este tipo de automatización revoluciona el procesamiento de contenido al eliminar pasos manuales y crear un flujo de trabajo continuo y automatizado. Las aplicaciones para este sistema son diversas y potentes, particularmente beneficiosas para:
- Equipos de contenido: Agilizar la creación de contenido multimedia generando automáticamente recursos complementarios a partir de grabaciones de audio
- Creadores individuales: Permitir que los creadores de contenido individuales multipliquen su producción creativa sin esfuerzo manual adicional
- Investigadores: Automatizar la transcripción y visualización de entrevistas, grabaciones de campo y notas de investigación
- Aplicaciones de diario de voz: Convertir diarios hablados en experiencias multimedia enriquecidas con imágenes generadas
- Herramientas educativas: Transformar conferencias y contenido educativo en materiales visuales y textuales atractivos
- Sistemas de documentación basados en IA: Generar automáticamente documentación completa con ayudas visuales a partir de grabaciones de voz
Quizás lo más notable es que has logrado esta sofisticada automatización con solo unos pocos archivos Python. Esto representa una democratización de la tecnología que anteriormente habría requerido un equipo de ingenieros especializados e infraestructura compleja para implementar. Al aprovechar las modernas APIs de IA y prácticas inteligentes de programación, has creado un sistema de automatización creativa de nivel empresarial que puede ser mantenido y modificado por un solo desarrollador.
6.3 Automatizando Resúmenes, Transcripciones e Imágenes
Ahora es momento de ir un nivel más profundo — hacia la automatización. Esta sección demostrará cómo crear un sofisticado flujo de trabajo de procesamiento en segundo plano que revoluciona la forma en que manejamos el contenido de audio. En lugar de requerir intervención manual, este sistema opera de forma autónoma:
- Monitoreando continuamente las carpetas designadas para nuevas cargas de archivos de audio
- Iniciando automáticamente el proceso de transcripción usando reconocimiento de voz avanzado
- Creando resúmenes inteligentes que capturan los puntos clave y el contexto
- Generando imágenes contextualmente relevantes basadas en el contenido
- Organizando y almacenando todas las salidas en un formato estructurado
Esta pipeline automatizada elimina la necesidad de procesamiento manual, ahorrando considerable tiempo y esfuerzo mientras mantiene la consistencia en la calidad de salida. El sistema puede manejar múltiples archivos simultáneamente y funciona 24/7, haciéndolo ideal para organizaciones que procesan grandes volúmenes de contenido de audio.
6.3.1 Lo que vas a construir
En esta sección, crearás un sofisticado script de automatización en Python que transforma la forma de procesar archivos de audio. Esta pipeline de automatización monitorea un directorio específico y entra en acción cada vez que aparece nuevo contenido de audio. Veamos en detalle exactamente lo que logra este potente sistema:
- Transcribir el audio usando Whisper - El script aprovecha el avanzado modelo de reconocimiento de voz de OpenAI para convertir las palabras habladas en texto preciso, manejando múltiples acentos e idiomas con impresionante precisión.
- Resumir la transcripción usando GPT-4o - Después de la transcripción, el sistema emplea la avanzada comprensión del lenguaje de GPT-4o para destilar los puntos clave y las ideas principales en un resumen conciso y coherente.
- Generar una instrucción para imagen a partir de la transcripción usando GPT-4o - El script luego analiza el contenido y contexto de la transcripción para crear instrucciones detalladas y vívidas que capturan la esencia del audio en términos visuales.
- Generar una imagen a partir de la instrucción usando DALL·E 3 - Usando estas instrucciones cuidadosamente elaboradas, DALL·E 3 crea imágenes de alta calidad y contextualmente relevantes que complementan el contenido del audio.
- Guardar la transcripción, resumen, instrucción e imagen generada en archivos separados - El sistema organiza automáticamente todas las salidas de manera estructurada, facilitando el acceso y uso del contenido generado.
Esta completa solución de automatización transforma el audio sin procesar en una rica colección de activos digitales. La versatilidad de este sistema permite que se integre en varios entornos de producción:
- Un gestor de tareas en segundo plano (p. ej., Celery) para procesamiento asíncrono - Perfecto para manejar múltiples archivos simultáneamente sin bloquear otras operaciones, asegurando una escalabilidad fluida.
- Una función en la nube (p. ej., AWS Lambda o Google Cloud Functions) para ejecución sin servidor - Permite un procesamiento rentable y bajo demanda sin mantener una infraestructura de servidor constante.
- Un script local programado para procesamiento por lotes - Ideal para el procesamiento automatizado regular de archivos de audio acumulados en intervalos específicos.
Para este capítulo, nos centraremos en construir un prototipo local, que sirve como un excelente punto de partida para creadores, investigadores o desarrolladores que necesitan una forma confiable y eficiente de procesar archivos de audio. Este enfoque permite pruebas e iteraciones fáciles antes de escalar a implementaciones más grandes.
6.3.2 Implementación paso a paso
Paso 1: Configuración del proyecto
Descarga el audio de muestra: https://files.cuantum.tech/audio/automating-summaries.mp3
Crea un nuevo directorio para tu proyecto y navega hacia él:
mkdir audio_processing_automation
cd audio_processing_automationSe recomienda configurar un entorno virtual:
python -m venv venv
source venv/bin/activate # En macOS/Linux
venv\\Scripts\\activate # En WindowsInstala los paquetes de Python necesarios:
pip install openai python-dotenv requestsOrganiza los archivos de tu proyecto de la siguiente manera:
/audio_processing_automation
│
├── main.py
├── .env
└── utils/
├── __init__.py
├── transcribe.py
├── summarize.py
├── generate_prompt.py
└── generate_image.py/audio_processing_automation: El directorio raíz de tu proyecto.main.py: El script de Python que automatizará el procesamiento de audio..env: Un archivo para almacenar tu clave de API de OpenAI.utils/: Un directorio para módulos de Python que contiene funciones reutilizables.__init__.py: Convierte el directorioutilsen un paquete de Python.transcribe.py: Contiene la función para transcribir audio usando Whisper.summarize.py: Contiene la función para resumir la transcripción usando un Modelo de Lenguaje Grande.generate_prompt.py: Contiene la función para generar una instrucción de imagen a partir del resumen usando un Modelo de Lenguaje Grande.generate_image.py: Contiene la función para generar una imagen con DALL·E 3.
Paso 2: Crear los Módulos de Utilidad
Crea los siguientes archivos Python en el directorio utils/:
utils/transcribe.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def transcribe_audio(file_path: str) -> Optional[str]:
"""
Transcribes an audio file using OpenAI's Whisper API.
Args:
file_path (str): The path to the audio file.
Returns:
Optional[str]: The transcribed text, or None on error.
"""
try:
logger.info(f"Transcribing audio: {file_path}")
audio_file = open(file_path, "rb")
response = openai.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
)
transcript = response.text
audio_file.close()
return transcript
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error during transcription: {e}")
return None- Este módulo define la función
transcribe_audio, que toma como entrada la ruta a un archivo de audio y utiliza la API de Whisper de OpenAI para generar una transcripción de texto. - La función abre el archivo de audio en modo lectura binaria (
"rb"). - Llama a
openai.audio.transcriptions.create()para realizar la transcripción, especificando el modelo "whisper-1". - Extrae el texto transcrito de la respuesta de la API.
- Incluye manejo de errores usando un bloque
try...exceptpara capturar posibles excepcionesopenai.error.OpenAIError(específicas de OpenAI) yExceptiongeneral para otros errores. Si ocurre un error, registra el error y devuelveNone. - Registra la ruta del archivo antes de la transcripción y la longitud del texto transcrito después de una transcripción exitosa.
- El archivo de audio se cierra después de la transcripción.
utils/summarize.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def summarize_transcript(text: str) -> Optional[str]:
"""
Summarizes a text transcript using OpenAI's Chat Completion API.
Args:
text (str): The text transcript to summarize.
Returns:
Optional[str]: The summarized text, or None on error.
"""
try:
logger.info("Summarizing transcript")
response = openai.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system",
"content": "You are a helpful assistant. Provide a concise summary of the text, suitable for generating a visual representation."},
{"role": "user", "content": text}
],
)
summary = response.choices[0].message.content
logger.info(f"Summary: {summary}")
return summary
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating summary: {e}")
return None- Este módulo define la función
summarize_transcript, que toma una transcripción de texto como entrada y utiliza la API de Chat Completion de OpenAI para generar un resumen conciso. - El mensaje del sistema instruye al modelo a actuar como un asistente servicial y proporcionar un resumen conciso del texto, adecuado para generar una representación visual.
- El mensaje del usuario proporciona la transcripción como contenido para que el modelo la resuma.
- La función extrae el resumen de la respuesta de la API.
- Incluye manejo de errores.
utils/generate_prompt.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def create_image_prompt(transcription: str) -> Optional[str]:
"""
Generates a detailed image prompt from a text transcription using OpenAI's Chat Completion API.
Args:
transcription (str): The text transcription of the audio.
Returns:
Optional[str]: A detailed text prompt suitable for image generation, or None on error.
"""
try:
logger.info("Generating image prompt from transcription")
response = openai.chat.completions.create(
model="gpt-4o", # Use a powerful chat model
messages=[
{
"role": "system",
"content": "You are a creative assistant. Your task is to create a vivid and detailed text description of a scene that could be used to generate an image with an AI image generation model. Focus on capturing the essence and key visual elements of the audio content. Do not include any phrases like 'based on the audio' or 'from the user audio'. Incorporate scene lighting, time of day, weather, and camera angle into the description. Limit the description to 200 words.",
},
{"role": "user", "content": transcription},
],
)
prompt = response.choices[0].message.content
prompt = prompt.strip() # Remove leading/trailing spaces
logger.info(f"Generated prompt: {prompt}")
return prompt
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating image prompt: {e}")
return None- Este módulo define la función
create_image_prompt, que toma el texto transcrito como entrada y utiliza la API de Chat Completion de OpenAI para generar una instrucción detallada para la generación de imágenes. - El mensaje del sistema instruye al modelo a actuar como un asistente creativo y generar una descripción vívida de la escena. La instrucción del sistema es crucial para guiar al MLG a generar una instrucción de alta calidad. Indicamos al MLG que se centre en elementos visuales e incorpore detalles como la iluminación, hora del día, clima y ángulo de la cámara. También limitamos la longitud de la descripción a 200 palabras.
- El mensaje del usuario proporciona el texto transcrito como contenido para que el modelo trabaje.
- La función extrae la instrucción generada de la respuesta de la API.
- Elimina los espacios iniciales y finales de la instrucción generada.
- Incluye manejo de errores.
utils/generate_image.py:
import openai
import logging
from typing import Optional, Dict
logger = logging.getLogger(__name__)
def generate_dalle_image(prompt: str, model: str = "dall-e-3", size: str = "1024x1024",
response_format: str = "url", quality: str = "standard") -> Optional[str]:
"""
Generates an image using OpenAI's DALL·E API.
Args:
prompt (str): The text prompt to generate the image from.
model (str, optional): The DALL·E model to use. Defaults to "dall-e-3".
size (str, optional): The size of the generated image. Defaults to "1024x1024".
response_format (str, optional): The format of the response. Defaults to "url".
quality (str, optional): The quality of the image. Defaults to "standard".
Returns:
Optional[str]: The URL of the generated image, or None on error.
"""
try:
logger.info(f"Generating image with prompt: {prompt}, model: {model}, size: {size}, format: {response_format}, quality: {quality}")
response = openai.images.generate(
prompt=prompt,
model=model,
size=size,
response_format=response_format,
quality=quality
)
image_url = response.data[0].url
logger.info(f"Image URL: {image_url}")
return image_url
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating image: {e}")
return None- Este módulo define la función
generate_dalle_image, que toma como entrada una instrucción de texto y utiliza la API DALL·E de OpenAI para generar una imagen. - Llama al método
openai.images.generate()para generar la imagen. - Acepta parámetros opcionales de
model,size,response_formatyquality, permitiendo al usuario configurar la generación de la imagen. - Extrae la URL de la imagen generada de la respuesta de la API.
- Incluye manejo de errores.
Paso 4: Crear el Script Principal (main.py)
Crea un archivo Python llamado main.py en el directorio raíz de tu proyecto y agrega el siguiente código:
import os
import time
import logging
from typing import Optional
# Import the utility functions from the utils directory
from utils.transcribe import transcribe_audio
from utils.generate_prompt import create_image_prompt
from utils.generate_image import generate_dalle_image
from utils.summarize import summarize_transcript
# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
UPLOAD_DIR = "uploads" # Directory where audio files are placed
OUTPUT_DIR = "outputs" # Directory where results are saved
ALLOWED_EXTENSIONS = {'mp3', 'mp4', 'wav', 'm4a'}
def process_audio(file_path: str) -> None:
"""
Processes an audio file, transcribing, summarizing, generating a prompt, and generating an image.
Args:
file_path (str): The path to the audio file to process.
"""
logger.info(f"Processing audio file: {file_path}")
base_name = os.path.splitext(os.path.basename(file_path))[0] # Get filename without extension
# Create output directory for this file
output_path = os.path.join(OUTPUT_DIR, base_name)
os.makedirs(output_path, exist_ok=True)
try:
# Transcription
transcript = transcribe_audio(file_path)
if transcript:
transcript_file_path = os.path.join(output_path, f"{base_name}_transcript.txt")
with open(transcript_file_path, "w") as f:
f.write(transcript)
logger.info(f"Transcription saved to {transcript_file_path}")
else:
logger.error(f"Transcription failed for {file_path}")
return # Stop processing if transcription fails
# Summary
summary = summarize_transcript(transcript)
if summary:
summary_file_path = os.path.join(output_path, f"{base_name}_summary.txt")
with open(summary_file_path, "w") as f:
f.write(summary)
logger.info(f"Summary saved to {summary_file_path}")
else:
logger.error(f"Summary failed for {file_path}")
return
# Image Prompt
prompt = create_image_prompt(transcript)
if prompt:
prompt_file_path = os.path.join(output_path, f"{base_name}_prompt.txt")
with open(prompt_file_path, "w") as f:
f.write(prompt)
logger.info(f"Prompt saved to {prompt_file_path}")
else:
logger.error(f"Prompt generation failed for {file_path}")
return
# Image Generation
image_url = generate_dalle_image(prompt)
if image_url:
try:
import requests
img_data = requests.get(image_url).content
image_file_path = os.path.join(output_path, f"{base_name}_image.png")
with open(image_file_path, "wb") as f:
f.write(img_data)
logger.info(f"Image saved to {image_file_path}")
except requests.exceptions.RequestException as e:
logger.error(f"Error downloading image: {e}")
return
else:
logger.error(f"Image generation failed for {file_path}")
return
logger.info(f"Successfully processed audio file: {file_path}")
except Exception as e:
logger.error(f"An error occurred while processing {file_path}: {e}")
def watch_folder(upload_dir: str, output_dir: str) -> None:
"""
Monitors a folder for new audio files and processes them.
Args:
upload_dir (str): The path to the directory to watch for new audio files.
output_dir (str): The path to the directory where results should be saved.
"""
logger.info(f"Watching folder: {upload_dir} for new audio files...")
processed_files = set()
while True:
try:
files = [
os.path.join(upload_dir, f)
for f in os.listdir(upload_dir)
if f.lower().endswith(tuple(ALLOWED_EXTENSIONS))
]
for file_path in files:
if file_path not in processed_files and os.path.isfile(file_path):
process_audio(file_path)
processed_files.add(file_path)
except Exception as e:
logger.error(f"Error while watching folder: {e}")
time.sleep(5) # Check for new files every 5 seconds
if __name__ == "__main__":
os.makedirs(UPLOAD_DIR, exist_ok=True)
os.makedirs(OUTPUT_DIR, exist_ok=True)
watch_folder(UPLOAD_DIR, OUTPUT_DIR)Desglose del Código:
- Declaraciones de Importación: Importa las bibliotecas necesarias:
os: Para interactuar con el sistema operativo (rutas de archivos, directorios).time: Para agregar retrasos (pausas entre verificaciones).logging: Para registrar eventos.typing: Para sugerencias de tipo.werkzeug.utils: Parasecure_filename.werkzeug.datastructures: ParaFileStorage.
- Constantes:
UPLOAD_DIR: El directorio donde se espera que se suban los archivos de audio.OUTPUT_DIR: El directorio donde se guardarán los resultados procesados (transcripciones, instrucciones, imágenes).ALLOWED_EXTENSIONS: Un conjunto de extensiones de archivo de audio permitidas
- Función
allowed_file:- Verifica si un archivo tiene una extensión permitida.
- Función
transcribe_audio:- Toma la ruta del archivo de audio como entrada.
- Abre el archivo de audio en modo de lectura binaria (
"rb"). - Llama al método
openai.Audio.transcriptions.create()de la API de OpenAI para transcribir el audio. - Extrae el texto transcrito de la respuesta de la API.
- Registra la ruta del archivo antes de la transcripción y la longitud del texto transcrito después de una transcripción exitosa.
- Incluye manejo de errores usando un bloque
try...exceptpara capturar posibles excepcionesopenai.error.OpenAIError(específicas de OpenAI) yExceptiongeneral para otros errores.
- Función
generate_image_prompt:- Toma el texto transcrito como entrada.
- Utiliza la API de Chat Completion de OpenAI (
openai.chat.completions.create()) con el modelogpt-4opara generar una instrucción detallada de texto adecuada para la generación de imágenes. - El mensaje del sistema instruye al modelo a actuar como un asistente creativo y proporcionar una descripción vívida y detallada de una escena que podría usarse para generar una imagen con un modelo de generación de imágenes de IA.
- Extrae la instrucción generada de la respuesta de la API.
- Incluye manejo de errores.
- Función
generate_image:- Toma la instrucción de imagen como entrada.
- Llama al método
openai.Image.create()de la API de OpenAI para generar una imagen usando DALL·E 3. - Acepta parámetros opcionales para
model,size,response_formatyquality. - Extrae la URL de la imagen generada de la respuesta de la API.
- Incluye manejo de errores.
process_audioFunción:- Toma la ruta de un archivo de audio como entrada.
- Realiza los siguientes pasos:
- Registra el inicio del procesamiento.
- Extrae el nombre base del archivo (sin extensión) de la ruta del archivo de audio.
- Crea un directorio dentro de
OUTPUT_DIRusando el nombre base del archivo para almacenar los resultados de este archivo de audio específico. - Llama a
transcribe_audio()para transcribir el audio. Si la transcripción falla, registra un error y retorna. - Guarda la transcripción en un archivo de texto en el directorio de salida.
- Llama a
summarize_transcript()para resumir la transcripción. Si el resumen falla, registra un error y retorna. - Guarda el resumen en un archivo de texto en el directorio de salida.
- Llama a
create_image_prompt()para generar una instrucción de imagen. Si la generación de la instrucción falla, registra un error y retorna. - Guarda la instrucción en un archivo de texto en el directorio de salida.
- Llama a
generate_dalle_image()para generar una imagen a partir de la instrucción. Si la generación de la imagen falla, registra un error y retorna. - Descarga la imagen desde la URL y la guarda como archivo PNG en el directorio de salida.
- Registra la finalización exitosa del procesamiento.
- Incluye un bloque amplio
try...exceptpara capturar cualquier excepción durante el procesamiento de un archivo de audio individual. Cualquier error durante el proceso es registrado. watch_folderFunción:- Toma las rutas de los directorios de carga y salida como entrada.
- Registra el inicio del proceso de monitoreo de carpeta.
- Inicializa un conjunto vacío
processed_filespara realizar un seguimiento de los archivos procesados. - Entra en un bucle infinito:
- Lista todos los archivos en el
upload_dirque tienen extensiones de archivo de audio permitidas. - Itera a través de los archivos:
- Si un archivo no ha sido procesado aún:
- Llama a
process_audio()para procesar el archivo. - Añade la ruta del archivo al conjunto
processed_files.
- Llama a
- Si un archivo no ha sido procesado aún:
- Pausa durante 5 segundos usando
time.sleep(5)antes de verificar nuevos archivos nuevamente.
- Lista todos los archivos en el
- Incluye un bloque
try...exceptpara capturar cualquier excepción que pueda ocurrir durante el proceso de monitoreo de carpeta. Cualquier error es registrado.
- Bloque de Ejecución Principal:
if __name__ == "__main__":: Asegura que el siguiente código se ejecute solo cuando el script se ejecuta directamente (no cuando se importa como módulo).- Crea los directorios
UPLOAD_DIRyOUTPUT_DIRsi no existen. - Llama a la función
watch_folder()para comenzar a monitorear el directorio de carga.
6.3.3 Consejos para Escalar este Flujo de Trabajo
- Agregar notificaciones por correo electrónico/SMS/Slack cuando un elemento esté listoImplementa notificaciones automatizadas para mantener a los usuarios informados cuando su contenido haya sido procesado. Esto se puede hacer usando servicios como SendGrid para correo electrónico, Twilio para SMS, o la API de webhooks de Slack para mensajería instantánea. Esto asegura que los usuarios no necesiten verificar constantemente los elementos completados.
- Almacenar resultados en una base de datos o almacenamiento en la nubeEn lugar de almacenar archivos localmente, utiliza soluciones de almacenamiento en la nube como AWS S3, Google Cloud Storage o Azure Blob Storage. Esto proporciona mejor escalabilidad, protección de respaldo y gestión de acceso más sencilla. Para datos estructurados, considera usar bases de datos como PostgreSQL o MongoDB para permitir consultas eficientes y gestión de resultados procesados.
- Usar bibliotecas de hilos o asíncronas (como
watchdog,aiofiles) para mejor rendimientoReemplaza el bucle básico de monitoreo de archivos con soluciones más sofisticadas. La bibliotecawatchdogproporciona monitoreo confiable de eventos del sistema de archivos, mientras queaiofilespermite operaciones de archivo asíncronas. Esto evita operaciones bloqueantes y mejora la capacidad de respuesta general del sistema. - Conectar con las APIs de Google Drive o Dropbox para monitorear cargas remotamenteExpande más allá del monitoreo de archivos locales integrándote con APIs de almacenamiento en la nube. Esto permite a los usuarios activar el procesamiento simplemente subiendo archivos a su servicio de almacenamiento en la nube preferido. Implementa receptores de webhooks o usa sondeo de API para detectar nuevas cargas.
- Agregar una cola de tareas (ej., Celery o RQ) para procesamiento concurrenteReemplaza el procesamiento síncrono con un sistema de cola de tareas distribuido. Celery o Redis Queue (RQ) pueden gestionar múltiples trabajadores procesando archivos simultáneamente, manejar reintentos en caso de fallos y proporcionar priorización de tareas. Esto es esencial para manejar grandes volúmenes de cargas y prevenir la sobrecarga del sistema.
En esta sección, transformaste tu colección de herramientas de IA en un potente motor creativo automatizado. Este sistema representa un avance significativo en el procesamiento de IA multimodal - en lugar de alimentar manualmente el contenido a través de diferentes modelos, has creado un proceso inteligente que maneja automáticamente todo el flujo de trabajo. El script que construiste monitorea activamente nuevos archivos, los procesa sin problemas a través de tres sofisticados modelos de OpenAI (Whisper, GPT y DALL·E), y organiza los resultados en una colección estructurada de resúmenes, instrucciones creativas e imágenes generadas.
Este tipo de automatización revoluciona el procesamiento de contenido al eliminar pasos manuales y crear un flujo de trabajo continuo y automatizado. Las aplicaciones para este sistema son diversas y potentes, particularmente beneficiosas para:
- Equipos de contenido: Agilizar la creación de contenido multimedia generando automáticamente recursos complementarios a partir de grabaciones de audio
- Creadores individuales: Permitir que los creadores de contenido individuales multipliquen su producción creativa sin esfuerzo manual adicional
- Investigadores: Automatizar la transcripción y visualización de entrevistas, grabaciones de campo y notas de investigación
- Aplicaciones de diario de voz: Convertir diarios hablados en experiencias multimedia enriquecidas con imágenes generadas
- Herramientas educativas: Transformar conferencias y contenido educativo en materiales visuales y textuales atractivos
- Sistemas de documentación basados en IA: Generar automáticamente documentación completa con ayudas visuales a partir de grabaciones de voz
Quizás lo más notable es que has logrado esta sofisticada automatización con solo unos pocos archivos Python. Esto representa una democratización de la tecnología que anteriormente habría requerido un equipo de ingenieros especializados e infraestructura compleja para implementar. Al aprovechar las modernas APIs de IA y prácticas inteligentes de programación, has creado un sistema de automatización creativa de nivel empresarial que puede ser mantenido y modificado por un solo desarrollador.
6.3 Automatizando Resúmenes, Transcripciones e Imágenes
Ahora es momento de ir un nivel más profundo — hacia la automatización. Esta sección demostrará cómo crear un sofisticado flujo de trabajo de procesamiento en segundo plano que revoluciona la forma en que manejamos el contenido de audio. En lugar de requerir intervención manual, este sistema opera de forma autónoma:
- Monitoreando continuamente las carpetas designadas para nuevas cargas de archivos de audio
- Iniciando automáticamente el proceso de transcripción usando reconocimiento de voz avanzado
- Creando resúmenes inteligentes que capturan los puntos clave y el contexto
- Generando imágenes contextualmente relevantes basadas en el contenido
- Organizando y almacenando todas las salidas en un formato estructurado
Esta pipeline automatizada elimina la necesidad de procesamiento manual, ahorrando considerable tiempo y esfuerzo mientras mantiene la consistencia en la calidad de salida. El sistema puede manejar múltiples archivos simultáneamente y funciona 24/7, haciéndolo ideal para organizaciones que procesan grandes volúmenes de contenido de audio.
6.3.1 Lo que vas a construir
En esta sección, crearás un sofisticado script de automatización en Python que transforma la forma de procesar archivos de audio. Esta pipeline de automatización monitorea un directorio específico y entra en acción cada vez que aparece nuevo contenido de audio. Veamos en detalle exactamente lo que logra este potente sistema:
- Transcribir el audio usando Whisper - El script aprovecha el avanzado modelo de reconocimiento de voz de OpenAI para convertir las palabras habladas en texto preciso, manejando múltiples acentos e idiomas con impresionante precisión.
- Resumir la transcripción usando GPT-4o - Después de la transcripción, el sistema emplea la avanzada comprensión del lenguaje de GPT-4o para destilar los puntos clave y las ideas principales en un resumen conciso y coherente.
- Generar una instrucción para imagen a partir de la transcripción usando GPT-4o - El script luego analiza el contenido y contexto de la transcripción para crear instrucciones detalladas y vívidas que capturan la esencia del audio en términos visuales.
- Generar una imagen a partir de la instrucción usando DALL·E 3 - Usando estas instrucciones cuidadosamente elaboradas, DALL·E 3 crea imágenes de alta calidad y contextualmente relevantes que complementan el contenido del audio.
- Guardar la transcripción, resumen, instrucción e imagen generada en archivos separados - El sistema organiza automáticamente todas las salidas de manera estructurada, facilitando el acceso y uso del contenido generado.
Esta completa solución de automatización transforma el audio sin procesar en una rica colección de activos digitales. La versatilidad de este sistema permite que se integre en varios entornos de producción:
- Un gestor de tareas en segundo plano (p. ej., Celery) para procesamiento asíncrono - Perfecto para manejar múltiples archivos simultáneamente sin bloquear otras operaciones, asegurando una escalabilidad fluida.
- Una función en la nube (p. ej., AWS Lambda o Google Cloud Functions) para ejecución sin servidor - Permite un procesamiento rentable y bajo demanda sin mantener una infraestructura de servidor constante.
- Un script local programado para procesamiento por lotes - Ideal para el procesamiento automatizado regular de archivos de audio acumulados en intervalos específicos.
Para este capítulo, nos centraremos en construir un prototipo local, que sirve como un excelente punto de partida para creadores, investigadores o desarrolladores que necesitan una forma confiable y eficiente de procesar archivos de audio. Este enfoque permite pruebas e iteraciones fáciles antes de escalar a implementaciones más grandes.
6.3.2 Implementación paso a paso
Paso 1: Configuración del proyecto
Descarga el audio de muestra: https://files.cuantum.tech/audio/automating-summaries.mp3
Crea un nuevo directorio para tu proyecto y navega hacia él:
mkdir audio_processing_automation
cd audio_processing_automationSe recomienda configurar un entorno virtual:
python -m venv venv
source venv/bin/activate # En macOS/Linux
venv\\Scripts\\activate # En WindowsInstala los paquetes de Python necesarios:
pip install openai python-dotenv requestsOrganiza los archivos de tu proyecto de la siguiente manera:
/audio_processing_automation
│
├── main.py
├── .env
└── utils/
├── __init__.py
├── transcribe.py
├── summarize.py
├── generate_prompt.py
└── generate_image.py/audio_processing_automation: El directorio raíz de tu proyecto.main.py: El script de Python que automatizará el procesamiento de audio..env: Un archivo para almacenar tu clave de API de OpenAI.utils/: Un directorio para módulos de Python que contiene funciones reutilizables.__init__.py: Convierte el directorioutilsen un paquete de Python.transcribe.py: Contiene la función para transcribir audio usando Whisper.summarize.py: Contiene la función para resumir la transcripción usando un Modelo de Lenguaje Grande.generate_prompt.py: Contiene la función para generar una instrucción de imagen a partir del resumen usando un Modelo de Lenguaje Grande.generate_image.py: Contiene la función para generar una imagen con DALL·E 3.
Paso 2: Crear los Módulos de Utilidad
Crea los siguientes archivos Python en el directorio utils/:
utils/transcribe.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def transcribe_audio(file_path: str) -> Optional[str]:
"""
Transcribes an audio file using OpenAI's Whisper API.
Args:
file_path (str): The path to the audio file.
Returns:
Optional[str]: The transcribed text, or None on error.
"""
try:
logger.info(f"Transcribing audio: {file_path}")
audio_file = open(file_path, "rb")
response = openai.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
)
transcript = response.text
audio_file.close()
return transcript
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error during transcription: {e}")
return None- Este módulo define la función
transcribe_audio, que toma como entrada la ruta a un archivo de audio y utiliza la API de Whisper de OpenAI para generar una transcripción de texto. - La función abre el archivo de audio en modo lectura binaria (
"rb"). - Llama a
openai.audio.transcriptions.create()para realizar la transcripción, especificando el modelo "whisper-1". - Extrae el texto transcrito de la respuesta de la API.
- Incluye manejo de errores usando un bloque
try...exceptpara capturar posibles excepcionesopenai.error.OpenAIError(específicas de OpenAI) yExceptiongeneral para otros errores. Si ocurre un error, registra el error y devuelveNone. - Registra la ruta del archivo antes de la transcripción y la longitud del texto transcrito después de una transcripción exitosa.
- El archivo de audio se cierra después de la transcripción.
utils/summarize.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def summarize_transcript(text: str) -> Optional[str]:
"""
Summarizes a text transcript using OpenAI's Chat Completion API.
Args:
text (str): The text transcript to summarize.
Returns:
Optional[str]: The summarized text, or None on error.
"""
try:
logger.info("Summarizing transcript")
response = openai.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system",
"content": "You are a helpful assistant. Provide a concise summary of the text, suitable for generating a visual representation."},
{"role": "user", "content": text}
],
)
summary = response.choices[0].message.content
logger.info(f"Summary: {summary}")
return summary
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating summary: {e}")
return None- Este módulo define la función
summarize_transcript, que toma una transcripción de texto como entrada y utiliza la API de Chat Completion de OpenAI para generar un resumen conciso. - El mensaje del sistema instruye al modelo a actuar como un asistente servicial y proporcionar un resumen conciso del texto, adecuado para generar una representación visual.
- El mensaje del usuario proporciona la transcripción como contenido para que el modelo la resuma.
- La función extrae el resumen de la respuesta de la API.
- Incluye manejo de errores.
utils/generate_prompt.py:
import openai
import logging
from typing import Optional
logger = logging.getLogger(__name__)
def create_image_prompt(transcription: str) -> Optional[str]:
"""
Generates a detailed image prompt from a text transcription using OpenAI's Chat Completion API.
Args:
transcription (str): The text transcription of the audio.
Returns:
Optional[str]: A detailed text prompt suitable for image generation, or None on error.
"""
try:
logger.info("Generating image prompt from transcription")
response = openai.chat.completions.create(
model="gpt-4o", # Use a powerful chat model
messages=[
{
"role": "system",
"content": "You are a creative assistant. Your task is to create a vivid and detailed text description of a scene that could be used to generate an image with an AI image generation model. Focus on capturing the essence and key visual elements of the audio content. Do not include any phrases like 'based on the audio' or 'from the user audio'. Incorporate scene lighting, time of day, weather, and camera angle into the description. Limit the description to 200 words.",
},
{"role": "user", "content": transcription},
],
)
prompt = response.choices[0].message.content
prompt = prompt.strip() # Remove leading/trailing spaces
logger.info(f"Generated prompt: {prompt}")
return prompt
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating image prompt: {e}")
return None- Este módulo define la función
create_image_prompt, que toma el texto transcrito como entrada y utiliza la API de Chat Completion de OpenAI para generar una instrucción detallada para la generación de imágenes. - El mensaje del sistema instruye al modelo a actuar como un asistente creativo y generar una descripción vívida de la escena. La instrucción del sistema es crucial para guiar al MLG a generar una instrucción de alta calidad. Indicamos al MLG que se centre en elementos visuales e incorpore detalles como la iluminación, hora del día, clima y ángulo de la cámara. También limitamos la longitud de la descripción a 200 palabras.
- El mensaje del usuario proporciona el texto transcrito como contenido para que el modelo trabaje.
- La función extrae la instrucción generada de la respuesta de la API.
- Elimina los espacios iniciales y finales de la instrucción generada.
- Incluye manejo de errores.
utils/generate_image.py:
import openai
import logging
from typing import Optional, Dict
logger = logging.getLogger(__name__)
def generate_dalle_image(prompt: str, model: str = "dall-e-3", size: str = "1024x1024",
response_format: str = "url", quality: str = "standard") -> Optional[str]:
"""
Generates an image using OpenAI's DALL·E API.
Args:
prompt (str): The text prompt to generate the image from.
model (str, optional): The DALL·E model to use. Defaults to "dall-e-3".
size (str, optional): The size of the generated image. Defaults to "1024x1024".
response_format (str, optional): The format of the response. Defaults to "url".
quality (str, optional): The quality of the image. Defaults to "standard".
Returns:
Optional[str]: The URL of the generated image, or None on error.
"""
try:
logger.info(f"Generating image with prompt: {prompt}, model: {model}, size: {size}, format: {response_format}, quality: {quality}")
response = openai.images.generate(
prompt=prompt,
model=model,
size=size,
response_format=response_format,
quality=quality
)
image_url = response.data[0].url
logger.info(f"Image URL: {image_url}")
return image_url
except openai.error.OpenAIError as e:
logger.error(f"OpenAI API Error: {e}")
return None
except Exception as e:
logger.error(f"Error generating image: {e}")
return None- Este módulo define la función
generate_dalle_image, que toma como entrada una instrucción de texto y utiliza la API DALL·E de OpenAI para generar una imagen. - Llama al método
openai.images.generate()para generar la imagen. - Acepta parámetros opcionales de
model,size,response_formatyquality, permitiendo al usuario configurar la generación de la imagen. - Extrae la URL de la imagen generada de la respuesta de la API.
- Incluye manejo de errores.
Paso 4: Crear el Script Principal (main.py)
Crea un archivo Python llamado main.py en el directorio raíz de tu proyecto y agrega el siguiente código:
import os
import time
import logging
from typing import Optional
# Import the utility functions from the utils directory
from utils.transcribe import transcribe_audio
from utils.generate_prompt import create_image_prompt
from utils.generate_image import generate_dalle_image
from utils.summarize import summarize_transcript
# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
UPLOAD_DIR = "uploads" # Directory where audio files are placed
OUTPUT_DIR = "outputs" # Directory where results are saved
ALLOWED_EXTENSIONS = {'mp3', 'mp4', 'wav', 'm4a'}
def process_audio(file_path: str) -> None:
"""
Processes an audio file, transcribing, summarizing, generating a prompt, and generating an image.
Args:
file_path (str): The path to the audio file to process.
"""
logger.info(f"Processing audio file: {file_path}")
base_name = os.path.splitext(os.path.basename(file_path))[0] # Get filename without extension
# Create output directory for this file
output_path = os.path.join(OUTPUT_DIR, base_name)
os.makedirs(output_path, exist_ok=True)
try:
# Transcription
transcript = transcribe_audio(file_path)
if transcript:
transcript_file_path = os.path.join(output_path, f"{base_name}_transcript.txt")
with open(transcript_file_path, "w") as f:
f.write(transcript)
logger.info(f"Transcription saved to {transcript_file_path}")
else:
logger.error(f"Transcription failed for {file_path}")
return # Stop processing if transcription fails
# Summary
summary = summarize_transcript(transcript)
if summary:
summary_file_path = os.path.join(output_path, f"{base_name}_summary.txt")
with open(summary_file_path, "w") as f:
f.write(summary)
logger.info(f"Summary saved to {summary_file_path}")
else:
logger.error(f"Summary failed for {file_path}")
return
# Image Prompt
prompt = create_image_prompt(transcript)
if prompt:
prompt_file_path = os.path.join(output_path, f"{base_name}_prompt.txt")
with open(prompt_file_path, "w") as f:
f.write(prompt)
logger.info(f"Prompt saved to {prompt_file_path}")
else:
logger.error(f"Prompt generation failed for {file_path}")
return
# Image Generation
image_url = generate_dalle_image(prompt)
if image_url:
try:
import requests
img_data = requests.get(image_url).content
image_file_path = os.path.join(output_path, f"{base_name}_image.png")
with open(image_file_path, "wb") as f:
f.write(img_data)
logger.info(f"Image saved to {image_file_path}")
except requests.exceptions.RequestException as e:
logger.error(f"Error downloading image: {e}")
return
else:
logger.error(f"Image generation failed for {file_path}")
return
logger.info(f"Successfully processed audio file: {file_path}")
except Exception as e:
logger.error(f"An error occurred while processing {file_path}: {e}")
def watch_folder(upload_dir: str, output_dir: str) -> None:
"""
Monitors a folder for new audio files and processes them.
Args:
upload_dir (str): The path to the directory to watch for new audio files.
output_dir (str): The path to the directory where results should be saved.
"""
logger.info(f"Watching folder: {upload_dir} for new audio files...")
processed_files = set()
while True:
try:
files = [
os.path.join(upload_dir, f)
for f in os.listdir(upload_dir)
if f.lower().endswith(tuple(ALLOWED_EXTENSIONS))
]
for file_path in files:
if file_path not in processed_files and os.path.isfile(file_path):
process_audio(file_path)
processed_files.add(file_path)
except Exception as e:
logger.error(f"Error while watching folder: {e}")
time.sleep(5) # Check for new files every 5 seconds
if __name__ == "__main__":
os.makedirs(UPLOAD_DIR, exist_ok=True)
os.makedirs(OUTPUT_DIR, exist_ok=True)
watch_folder(UPLOAD_DIR, OUTPUT_DIR)Desglose del Código:
- Declaraciones de Importación: Importa las bibliotecas necesarias:
os: Para interactuar con el sistema operativo (rutas de archivos, directorios).time: Para agregar retrasos (pausas entre verificaciones).logging: Para registrar eventos.typing: Para sugerencias de tipo.werkzeug.utils: Parasecure_filename.werkzeug.datastructures: ParaFileStorage.
- Constantes:
UPLOAD_DIR: El directorio donde se espera que se suban los archivos de audio.OUTPUT_DIR: El directorio donde se guardarán los resultados procesados (transcripciones, instrucciones, imágenes).ALLOWED_EXTENSIONS: Un conjunto de extensiones de archivo de audio permitidas
- Función
allowed_file:- Verifica si un archivo tiene una extensión permitida.
- Función
transcribe_audio:- Toma la ruta del archivo de audio como entrada.
- Abre el archivo de audio en modo de lectura binaria (
"rb"). - Llama al método
openai.Audio.transcriptions.create()de la API de OpenAI para transcribir el audio. - Extrae el texto transcrito de la respuesta de la API.
- Registra la ruta del archivo antes de la transcripción y la longitud del texto transcrito después de una transcripción exitosa.
- Incluye manejo de errores usando un bloque
try...exceptpara capturar posibles excepcionesopenai.error.OpenAIError(específicas de OpenAI) yExceptiongeneral para otros errores.
- Función
generate_image_prompt:- Toma el texto transcrito como entrada.
- Utiliza la API de Chat Completion de OpenAI (
openai.chat.completions.create()) con el modelogpt-4opara generar una instrucción detallada de texto adecuada para la generación de imágenes. - El mensaje del sistema instruye al modelo a actuar como un asistente creativo y proporcionar una descripción vívida y detallada de una escena que podría usarse para generar una imagen con un modelo de generación de imágenes de IA.
- Extrae la instrucción generada de la respuesta de la API.
- Incluye manejo de errores.
- Función
generate_image:- Toma la instrucción de imagen como entrada.
- Llama al método
openai.Image.create()de la API de OpenAI para generar una imagen usando DALL·E 3. - Acepta parámetros opcionales para
model,size,response_formatyquality. - Extrae la URL de la imagen generada de la respuesta de la API.
- Incluye manejo de errores.
process_audioFunción:- Toma la ruta de un archivo de audio como entrada.
- Realiza los siguientes pasos:
- Registra el inicio del procesamiento.
- Extrae el nombre base del archivo (sin extensión) de la ruta del archivo de audio.
- Crea un directorio dentro de
OUTPUT_DIRusando el nombre base del archivo para almacenar los resultados de este archivo de audio específico. - Llama a
transcribe_audio()para transcribir el audio. Si la transcripción falla, registra un error y retorna. - Guarda la transcripción en un archivo de texto en el directorio de salida.
- Llama a
summarize_transcript()para resumir la transcripción. Si el resumen falla, registra un error y retorna. - Guarda el resumen en un archivo de texto en el directorio de salida.
- Llama a
create_image_prompt()para generar una instrucción de imagen. Si la generación de la instrucción falla, registra un error y retorna. - Guarda la instrucción en un archivo de texto en el directorio de salida.
- Llama a
generate_dalle_image()para generar una imagen a partir de la instrucción. Si la generación de la imagen falla, registra un error y retorna. - Descarga la imagen desde la URL y la guarda como archivo PNG en el directorio de salida.
- Registra la finalización exitosa del procesamiento.
- Incluye un bloque amplio
try...exceptpara capturar cualquier excepción durante el procesamiento de un archivo de audio individual. Cualquier error durante el proceso es registrado. watch_folderFunción:- Toma las rutas de los directorios de carga y salida como entrada.
- Registra el inicio del proceso de monitoreo de carpeta.
- Inicializa un conjunto vacío
processed_filespara realizar un seguimiento de los archivos procesados. - Entra en un bucle infinito:
- Lista todos los archivos en el
upload_dirque tienen extensiones de archivo de audio permitidas. - Itera a través de los archivos:
- Si un archivo no ha sido procesado aún:
- Llama a
process_audio()para procesar el archivo. - Añade la ruta del archivo al conjunto
processed_files.
- Llama a
- Si un archivo no ha sido procesado aún:
- Pausa durante 5 segundos usando
time.sleep(5)antes de verificar nuevos archivos nuevamente.
- Lista todos los archivos en el
- Incluye un bloque
try...exceptpara capturar cualquier excepción que pueda ocurrir durante el proceso de monitoreo de carpeta. Cualquier error es registrado.
- Bloque de Ejecución Principal:
if __name__ == "__main__":: Asegura que el siguiente código se ejecute solo cuando el script se ejecuta directamente (no cuando se importa como módulo).- Crea los directorios
UPLOAD_DIRyOUTPUT_DIRsi no existen. - Llama a la función
watch_folder()para comenzar a monitorear el directorio de carga.
6.3.3 Consejos para Escalar este Flujo de Trabajo
- Agregar notificaciones por correo electrónico/SMS/Slack cuando un elemento esté listoImplementa notificaciones automatizadas para mantener a los usuarios informados cuando su contenido haya sido procesado. Esto se puede hacer usando servicios como SendGrid para correo electrónico, Twilio para SMS, o la API de webhooks de Slack para mensajería instantánea. Esto asegura que los usuarios no necesiten verificar constantemente los elementos completados.
- Almacenar resultados en una base de datos o almacenamiento en la nubeEn lugar de almacenar archivos localmente, utiliza soluciones de almacenamiento en la nube como AWS S3, Google Cloud Storage o Azure Blob Storage. Esto proporciona mejor escalabilidad, protección de respaldo y gestión de acceso más sencilla. Para datos estructurados, considera usar bases de datos como PostgreSQL o MongoDB para permitir consultas eficientes y gestión de resultados procesados.
- Usar bibliotecas de hilos o asíncronas (como
watchdog,aiofiles) para mejor rendimientoReemplaza el bucle básico de monitoreo de archivos con soluciones más sofisticadas. La bibliotecawatchdogproporciona monitoreo confiable de eventos del sistema de archivos, mientras queaiofilespermite operaciones de archivo asíncronas. Esto evita operaciones bloqueantes y mejora la capacidad de respuesta general del sistema. - Conectar con las APIs de Google Drive o Dropbox para monitorear cargas remotamenteExpande más allá del monitoreo de archivos locales integrándote con APIs de almacenamiento en la nube. Esto permite a los usuarios activar el procesamiento simplemente subiendo archivos a su servicio de almacenamiento en la nube preferido. Implementa receptores de webhooks o usa sondeo de API para detectar nuevas cargas.
- Agregar una cola de tareas (ej., Celery o RQ) para procesamiento concurrenteReemplaza el procesamiento síncrono con un sistema de cola de tareas distribuido. Celery o Redis Queue (RQ) pueden gestionar múltiples trabajadores procesando archivos simultáneamente, manejar reintentos en caso de fallos y proporcionar priorización de tareas. Esto es esencial para manejar grandes volúmenes de cargas y prevenir la sobrecarga del sistema.
En esta sección, transformaste tu colección de herramientas de IA en un potente motor creativo automatizado. Este sistema representa un avance significativo en el procesamiento de IA multimodal - en lugar de alimentar manualmente el contenido a través de diferentes modelos, has creado un proceso inteligente que maneja automáticamente todo el flujo de trabajo. El script que construiste monitorea activamente nuevos archivos, los procesa sin problemas a través de tres sofisticados modelos de OpenAI (Whisper, GPT y DALL·E), y organiza los resultados en una colección estructurada de resúmenes, instrucciones creativas e imágenes generadas.
Este tipo de automatización revoluciona el procesamiento de contenido al eliminar pasos manuales y crear un flujo de trabajo continuo y automatizado. Las aplicaciones para este sistema son diversas y potentes, particularmente beneficiosas para:
- Equipos de contenido: Agilizar la creación de contenido multimedia generando automáticamente recursos complementarios a partir de grabaciones de audio
- Creadores individuales: Permitir que los creadores de contenido individuales multipliquen su producción creativa sin esfuerzo manual adicional
- Investigadores: Automatizar la transcripción y visualización de entrevistas, grabaciones de campo y notas de investigación
- Aplicaciones de diario de voz: Convertir diarios hablados en experiencias multimedia enriquecidas con imágenes generadas
- Herramientas educativas: Transformar conferencias y contenido educativo en materiales visuales y textuales atractivos
- Sistemas de documentación basados en IA: Generar automáticamente documentación completa con ayudas visuales a partir de grabaciones de voz
Quizás lo más notable es que has logrado esta sofisticada automatización con solo unos pocos archivos Python. Esto representa una democratización de la tecnología que anteriormente habría requerido un equipo de ingenieros especializados e infraestructura compleja para implementar. Al aprovechar las modernas APIs de IA y prácticas inteligentes de programación, has creado un sistema de automatización creativa de nivel empresarial que puede ser mantenido y modificado por un solo desarrollador.