IA multimodal

La IA no solo puede hablar, sino también ver imágenes, escuchar sonidos y comprender videos: domina las herramientas y tecnologías multimodales.

Durante mucho tiempo, la IA fue de un solo sentido.

La IA de texto solo puede procesar texto, por ejemplo, hacer que ChatGPT escriba artículos.
La IA de imágenes solo puede procesar imágenes, por ejemplo, hacer que Midjourney dibuje.
La IA de audio solo puede procesar sonido, por ejemplo, hacer que Whisper transcriba voz.

Pero el mundo real es multimodal: al leer vemos ilustraciones, al ver películas hay imagen y sonido, y al comunicarnos con otros debemos observar expresiones y tonos de voz.

La IA multimodal es una IA que puede comprender y generar múltiples tipos de contenido simultáneamente.Esto es como dotar a la IA de ojos, oídos y boca, permitiéndole interactuar con el mundo de una manera más cercana a la humana.

Un ejemplo práctico: le das a la IA una foto de un recibo de compra, y puede reconocer el texto (OCR), entender qué productos se compraron, organizarlos en una tabla y leerlos en voz alta. Eso es una tarea multimodal típica.

¿Qué es la IA multimodal?

Primero aclaremos algunos conceptos básicos.

Unimodal vs. multimodal

La modalidad (modality en inglés) se refiere a la forma en que se presenta la información.

Texto, imágenes, audio y video son todas modalidades diferentes.

Tipo	Descripción	Producto típico
IA unimodal	Solo puede procesar una modalidad.	GPT-3 temprano (solo texto), Stable Diffusion (solo imágenes)
IA multimodal	Puede procesar múltiples modalidades simultáneamente.	GPT-4o、Claude 3、Gemini

El avance clave de la IA multimodal es:puede convertir información de diferentes modalidades a un mismo lenguaje para comprenderla.。

Por ejemplo, si ve una imagen de un "gato", puede convertir la imagen en un vector (un conjunto de números); si ve el carácter "gato", también puede convertirlo en un vector. Estos dos vectores están cerca en el espacio matemático porque representan el mismo concepto.

Los desafíos centrales de la multimodalidad

La multimodalidad suena sencilla, pero en realidad es muy difícil de implementar.

El primer desafío es la "alineación": ¿cómo hacer que el "gato" en la imagen y el "gato" en el texto sean lo mismo para el modelo?
El segundo desafío es la "fusión": cuando se ve simultáneamente una imagen y un texto, ¿cómo combinar su información?
El tercer desafío es la "generación": ¿cómo generar una imagen a partir de una descripción textual, o generar una descripción textual a partir de una imagen?
Afortunadamente, estos problemas se están resolviendo gradualmente. Después de 2024, los principales modelos grandes son casi todos multimodales.

Comprensión de imágenes (Visión)

La comprensión de imágenes consiste en hacer que la IA "vea" y entienda imágenes: describir contenido, reconocer texto, analizar gráficos y detectar detalles.

Los principales modelos grandes ya admiten entrada de imágenes.

Normalmente hay dos formas de uso:

Una es subir directamente el archivo de imagen, por ejemplo, haciendo clic en el ícono de imagen en la versión web de ChatGPT.
La otra es incrustar la imagen en la solicitud API usando codificación Base64, adecuado para llamadas desde programas.

Modelo	Método de entrada de imágenes	Formatos de imagen compatibles
GPT	URL, Base64, subida directa	JPG、PNG、WEBP、GIF
Claude	Base64, subida directa	JPG、PNG、WEBP、GIF
Gemini	Subida directa, Google Drive	JPG、PNG、WEBP

Las tareas de visión comunes incluyen:

Descripción de imagen: ¿qué hay en esta imagen?
OCR: extraer el texto de la imagen.
Análisis de gráficos: ¿qué dice este gráfico de barras?
Detección de detalles: ayúdame a revisar si hay algún problema en este diseño.

Práctica: llamar a la API de GPT-4o Vision con Python

Veamos un ejemplo completo: analizar una imagen con la API.

Ejemplo

# ============================================
# Archivo: ejemplo_vision_demo.py
# Función: analizar imágenes con la API de GPT-4o Vision
# ============================================

import base64
import requests
import os

# Configura la clave de API (reemplázala con tu clave real)
# Dónde obtenerla: https://platform.openai.com/api-keys
OPENAI_API_KEY = "sk-your-api-key-here"
OPENAI_API_URL = "https://api.openai.com/v1/chat/completions"

def encode_image_to_base64(image_path: str) -> str:
"""
Codifica el archivo de imagen local como una cadena Base64
Este es el formato de transmisión requerido por la API
"""
with open(image_path, "rb") as image_file:
# Lee el contenido del archivo binario y codifícalo en Base64
base64_data = base64.b64encode(image_file.read()).decode("utf-8")
return base64_data

def analyze_image_with_gpt4o(
image_path: str,
prompt: str = "Describe detalladamente el contenido de esta imagen",
model: str = "gpt-4o"
) -> str:
"""
Analizar imágenes con la API de GPT-4o Vision

Parámetros:
image_path: ruta del archivo de imagen local (por ejemplo, "ejemplo_test.jpg")
prompt: la pregunta que quieres hacer o la tarea que quieres que la IA realice
model: nombre del modelo a usar (por defecto gpt-4o)

Retorno:
Texto con el resultado del análisis de la IA
"""
# Paso 1: codifica la imagen en Base64
base64_image = encode_image_to_base64(image_path)

# Paso 2: construye el encabezado de la solicitud
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {OPENAI_API_KEY}"
}

# Paso 3: construye el cuerpo de la solicitud
# Nota: el contenido de la imagen se transmite a través del campo image_url, con el formato "data:image/jpeg;base64,..."
payload = {
"model": model,
"messages": [
{
"role": "user",
"content": [
# La primera parte es el mensaje de texto
{"type": "text", "text": prompt},
# La segunda parte es la imagen
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}"
}
}
]
}
],
"max_tokens": 1000 # Controla la longitud de la salida para evitar costos excesivos
}

# Paso 4: envía la solicitud a la API
print(f"Analizando imagen: {image_path} ...")
response = requests.post(OPENAI_API_URL, headers=headers, json=payload)

# Paso 5: procesa la respuesta
if response.status_code == 200:
result = response.json()
# Extrae la respuesta de la IA
answer = result["choices"][0]["message"]["content"]
return answer
else:
# Imprime los detalles si ocurre un error
error_msg = f"Solicitud fallida: {response.status_code} - {response.text}"
print(error_msg)
return error_msg

def extract_text_from_image(image_path: str) -> str:
"""
Especializado en OCR: extraer el texto de la imagen
"""
prompt = """
Extrae todo el contenido de texto de esta imagen.
Requisitos:
1. Reproduce el texto con precisión, sin omitir nada
2. Mantén los párrafos y el formato originales
3. Si hay tablas, muéstralas en formato de tabla
4. Si no hay texto en la imagen, indícalo
Esta es la prueba de OCR del tutorial de EJEMPLO.
"""
return analyze_image_with_gpt4o(image_path, prompt)

def analyze_chart(image_path: str) -> str:
"""
Especializado en análisis de gráficos
"""
prompt = """
Analiza este gráfico.
Responde las siguientes preguntas:
1. ¿Qué tipo de gráfico es (barras, líneas, circular, etc.)?
2. ¿Cuál es el título del gráfico y el significado de los ejes?
3. ¿Cuál es la información principal que transmite el gráfico?
4. ¿Hay alguna tendencia o anomalía notable?
Esta es la prueba de análisis de gráficos del tutorial de EJEMPLO.
"""
return analyze_image_with_gpt4o(image_path, prompt)

# ============================================
# Programa principal: demuestra diferentes tareas de análisis visual
# ============================================

if __name__ == "__main__":
# Supongamos que tenemos una imagen de prueba (necesitas preparar una imagen real)
# Puede ser: foto de producto, captura de pantalla, foto de documento, gráfico, etc.
test_image = "ejemplo_test_image.jpg"

# Comprueba si la imagen existe
if not os.path.exists(test_image):
print(f"Aviso: prepara una imagen, nómbrala {test_image} y colócala en el directorio actual")
print("O modifica la ruta de la imagen en el código")
else:
# Tarea 1: descripción general de la imagen
print("\n" + "="*50)
print("Tarea 1: descripción de la imagen")
print("="*50)
result1 = analyze_image_with_gpt4o(
test_image,
"Describe esta imagen detalladamente, incluidos el sujeto, el fondo, los colores, la composición, etc."
)
print(result1)

# Tarea 2: extracción de texto OCR
print("\n" + "="*50)
print("Tarea 2: Extracción de texto OCR")
print("="*50)
result2 = extract_text_from_image(test_image)
print(result2)

# Tarea 3: Análisis de gráficos (si la imagen es un gráfico)
print("\n" + "="*50)
print("Tarea 3: Análisis de gráficos")
print("="*50)
result3 = analyze_chart(test_image)
print(result3)

print("\n" + "="*50)
print("¡Demostración del tutorial EJEMPLO completada!")
print("="*50)

Antes de ejecutar este programa, necesitas:

1. Instalar dependencias:pip install requests
2. Preparar una imagen de prueba, nómbralaejemplo_test_image.jpg
3. Reemplaza la clave API por la tuya propia

Aviso de costos: GPT-4o Vision se cobra según el tamaño de la imagen. Una imagen de 1024x1024 cuesta aproximadamente 0.00765 USD. Las imágenes pequeñas son más baratas. Para depurar, se recomienda usar imágenes de baja resolución; para uso formal, usa alta definición.

Generación de imágenes a partir de texto (Text-to-Image)

La generación de imagen a partir de texto consiste en que la IA genere imágenes según una descripción textual; es otro campo de aplicación multimodal muy maduro.

Introducción a los principios de los modelos de difusión

Las herramientas actuales de generación de imagen a partir de texto utilizan básicamente la tecnología de modelo de difusión (Diffusion Model).

Para entender su funcionamiento de forma sencilla:

Fase de entrenamiento: se muestra al modelo una imagen nítida y luego se le añade ruido poco a poco hasta convertirla en una imagen caótica llena de estática. El modelo aprende a convertir la imagen caótica en una nítida paso a paso.
Fase de generación: se le da al modelo una imagen de ruido aleatorio y, según la indicación de texto, va eliminando el ruido paso a paso hasta generar una imagen nítida que coincida con la descripción.

Este proceso normalmente requiere de 20 a 50 pasos, por lo que generar una imagen tarda unos segundos.

Técnicas avanzadas de uso de Midjourney

Midjourney es una de las herramientas de generación de imagen a partir de texto más populares actualmente; se usa a través de Discord.

Un prompt de alta calidad suele incluir estos elementos:

Descripción del sujeto: "un gato con sombrero"
Estilo: "estilo Hayao Miyazaki", "pintura al óleo", "render 3D"
Iluminación: "luz natural", "luz cinematográfica", "neón ciberpunk"
Composición: "primer plano", "gran angular", "vista aérea"
Calidad de imagen: "8K", "detalle ultraalto", "nivel fotográfico"

Parámetros	Descripción	Ejemplo
--ar	Establecer relación de aspecto	--ar 16:9 (video), --ar 3:4 (móvil)
--v	Especificar versión del modelo	--v 6.0 (última versión)
--s	Grado de estilización (0-1000)	--s 750 (fuerte sentido artístico)
--q	Calidad de renderizado (0.25-2)	--q 2 (mayor calidad, más lento)
--iw	Peso de la imagen de referencia	--iw 1.5 (más parecido a la imagen de referencia)

Implementación local de Stable Diffusion

Si quieres un control total, puedes ejecutar Stable Diffusion localmente:https://github.com/compvis/stable-diffusion。

La herramienta más utilizada es la WebUI de Automatic1111.

Los pasos son aproximadamente:

1. Instalar Python 3.10
2. Descargar Stable Diffusion WebUI
3. Descargar el archivo del modelo (formato .safetensors)
4. Ejecutar webui.bat (Windows) o webui.sh (Mac/Linux)

Las ventajas de la implementación local son: la generación no cuesta dinero, no hay restricciones de contenido, se puede ajustar el estilo con LoRA y se puede controlar la composición con precisión con ControlNet.

Las desventajas son: se necesita una tarjeta gráfica con al menos 6GB de memoria de video y la configuración es algo complicada.

Práctica: generar imágenes con la API de DALL·E 3

Si quieres una forma sencilla de generar imágenes mediante API, DALL·E 3 es una buena opción.

Ejemplo

# ============================================
# Archivo: ejemplo_dalle3_demo.py
# Función: generar imágenes con la API de DALL·E 3
# ============================================

import requests
import os
from datetime import datetime

# Configurar la clave API (reemplázala con tu clave real)
OPENAI_API_KEY = "sk-your-api-key-here"
DALLE3_API_URL = "https://api.openai.com/v1/images/generations"

def generate_image_with_dalle3(
prompt: str,
size: str = "1024x1024",
quality: str = "standard",
style: str = "vivid",
save_dir: str = "ejemplo_generated_images"
) -> dict:
"""
Generar imágenes con la API de DALL·E 3

Descripción de parámetros:
prompt: descripción de texto, cuanto más detallada, mejor
size: tamaño de la imagen
Opciones: 1024x1024, 1024x1792 (vertical), 1792x1024 (horizontal)
quality: calidad de la imagen
Opciones: standard (estándar), hd (alta definición, más caro)
style: estilo
Opciones: vivid (vívido, más artístico), natural (natural, más realista)
save_dir: directorio donde se guardan las imágenes

Devuelve:
Un diccionario con la URL de la imagen y la ruta de guardado
"""
# Paso 1: preparar el encabezado de la solicitud
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {OPENAI_API_KEY}"
}

# Paso 2: preparar el cuerpo de la solicitud
payload = {
"model": "dall-e-3",
"prompt": prompt,
"n": 1, # DALL·E 3 solo puede generar 1 imagen a la vez
"size": size,
"quality": quality,
"style": style
}

# Paso 3: enviar la solicitud
print(f"Generando imagen, prompt: {prompt[:50]}...")
response = requests.post(DALLE3_API_URL, headers=headers, json=payload)

# Paso 4: procesar la respuesta
if response.status_code == 200:
result = response.json()
image_url = result["data"][0]["url"]
revised_prompt = result["data"][0].get("revised_prompt", prompt)

print(f"Prompt optimizado automáticamente por DALL·E 3: {revised_prompt}")

# Paso 5: descargar y guardar la imagen
if not os.path.exists(save_dir):
os.makedirs(save_dir)

# Generar nombre de archivo con marca de tiempo
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"ejemplo_dalle3_{timestamp}.png"
filepath = os.path.join(save_dir, filename)

# Descargar imagen
image_response = requests.get(image_url)
if image_response.status_code == 200:
with open(filepath, "wb") as f:
f.write(image_response.content)
print(f"Imagen guardada en: {filepath}")

return {
"image_url": image_url,
"filepath": filepath,
"revised_prompt": revised_prompt
}
else:
error_msg = f"Solicitud fallida: {response.status_code} - {response.text}"
print(error_msg)
return {"error": error_msg}

def generate_ejemplo_logo_demo():
"""Demostración: generar un logotipo estilo EJEMPLO"""
prompt = """
A cute and friendly robot mascot for EJEMPLO tutorial website.
Blue and green color scheme, modern flat design, white background.
The robot looks helpful and intelligent, with big friendly eyes.
Simple, clean, suitable for a tech education brand.
"""
# Los prompts en chino también funcionan; DALL·E 3 admite varios idiomas
prompt = """
Diseña una mascota robot linda y amigable para el sitio web de tutoriales EJEMPLO.
Tonalidad verde azulada, diseño plano moderno, fondo blanco.
El robot parece servicial e inteligente, con grandes ojos amigables.
Sencillo y limpio, adecuado para una marca de educación tecnológica.
"""
return generate_image_with_dalle3(
prompt=prompt,
size="1024x1024",
quality="hd",
style="vivid"
)

def generate_book_cover_demo():
"""Demostración: generar portada de libro"""
prompt = """
Book cover design for "AI Tutorial for Beginners".
Modern minimalist style, deep blue and purple gradient background.
The title text is elegant and readable.
Subtle tech elements: floating geometric shapes, faint circuit patterns.
Professional, trustworthy, suitable for a programming book.
"""
return generate_image_with_dalle3(
prompt=prompt,
size="1024x1792", # Versión vertical
quality="hd",
style="natural"
)

def generate_banner_demo():
"""Demostración: generar imagen de banner publicitario"""
prompt = """
Web banner design for a coding tutorial website (EJEMPLO).
16:9 wide format. Modern gradient background from teal to blue.
Clean layout with space for text.
Abstract tech elements: floating code snippets, subtle grid lines.
Professional and inviting.
"""
return generate_image_with_dalle3(
prompt=prompt,
size="1792x1024", # Versión horizontal
quality="standard",
style="vivid"
)

# ============================================
# Programa principal: demostrar diferentes tareas de generación
# ============================================

if __name__ == "__main__":
print("="*60)
print("Demostración de generación de imágenes con EJEMPLO DALL·E 3")
print("="*60)

# Tarea 1: generar logotipo
print("\n[Tarea 1] Generando logotipo ...")
result1 = generate_ejemplo_logo_demo()

# Tarea 2: generar portada de libro
print("\n[Tarea 2] Generando portada de libro ...")
result2 = generate_book_cover_demo()

# Tarea 3: generar banner
print("\n[Tarea 3] Generando banner ...")
result3 = generate_banner_demo()

print("\n" + "="*60)
print("¡Todas las tareas completadas! Revisa el directorio ejemplo_generated_images")
print("="*60)

Las características de DALL·E 3 son: fuerte capacidad de comprensión, no distorsiona manos y rostros, y buen efecto en la generación de texto.

Pero también tiene limitaciones: solo puede generar 1 imagen a la vez, no se puede controlar el estilo con precisión y no se puede ajustar finamente como en Stable Diffusion.

Aviso de derechos de autor: el consenso actual es que, en las imágenes generadas por IA, quien redacta el prompt posee el derecho de uso, pero no los derechos de autor (porque la oficina de derechos de autor exige creación humana). Para uso comercial, se recomienda revisar los términos de uso de la herramienta.

IA de video

La IA de video se divide en dos categorías: generación de video y comprensión de video.

En comparación con las imágenes, el video es técnicamente más difícil, porque combina "tiempo + espacio"; hay que garantizar que cada fotograma sea coherente y los movimientos naturales.

Comparación de herramientas de generación de video con IA

2024 fue el año inaugural del video con IA; varias empresas lanzaron productos de generación de video.

Herramienta	Desarrollador	Características	Duración típica
Sora	OpenAI	Detalles de imagen y comprensión de escenas espaciales líderes en la industria, física realista; aún no está completamente abierto a pruebas públicas.	Hasta 60 segundos
Runway Gen-4	Runway	Plataforma integral de creación que integra generación de video a partir de texto/imagen, edición posterior con IA, pincel de movimiento y efectos VFX; la opción preferida de creadores profesionales en el extranjero.	10-20 segundos
Kling (Keling AI)	Kuaishou	Excelente adaptación a prompts en chino, movimientos de personajes fluidos, estabilidad del personaje entre tomas, buena relación calidad-precio en China, admite unión de múltiples segmentos narrativos.	5-30 segundos, hasta 2 minutos por segmento
Pika	Pika Labs	Gran expresividad en estilos anime e ilustración cinematográfica, personajes consistentes, admite repintado de estilo de video y interpolación de fotogramas.	5-10 segundos
Veo	Google	Iluminación y movimiento de cámara de nivel cinematográfico, narrativa estable en planos largos, renderizado físico natural; aún no se ha lanzado públicamente.	Más de 60 segundos
Jiemeng AI (Seedance)	ByteDance	Integración profunda con el ecosistema de Jianying/Douyin, semántica china precisa, sincronización de audio, imagen y labios, admite guiones gráficos automáticos a partir de un script.	5-15 segundos, uniendo múltiples segmentos en un video
Tongyi Wanxiang Video	Academia Damo de Alibaba	Modelo base de código abierto, interacción multiagente estable, admite generación de texto en imágenes, se puede implementar e inferir de forma local.	2–15 segundos
Hailuo AI (Hailuo)	MiniMax Xiyu	Generación ligera y ultrarrápida, ideal para convertir pósters en vídeos cortos dinámicos y material efímero para redes sociales; destaca especialmente en estilo anime.	4–10 segundos
Luma Dream Machine	Luma AI	Simulación de dinámica física de primer nivel; los efectos de agua, fuego, telas y explosiones se ven reales; movimiento de cámara de nivel cinematográfico.	5–12 segundos
Zhiying	Tencent	Orientado a edición con IA y vídeos con avatares digitales; gran cantidad de plantillas de vídeo corto; subtítulos, doblaje y recorte de fondo en un solo lugar; umbral bajo para uso comercial.	Duración ilimitada; los segmentos generados por IA duran de 5 a 15 segundos.
Haiyi AI	Haiyi Technology	Admite salida de alta tasa de fotogramas de 4K/60fps, generación de vídeo a partir de múltiples imágenes conectadas, incluye un flujo de trabajo completo de creación; la cuota gratuita limitada es generosa.	Duración máxima de 30 segundos por clip

El vídeo con IA todavía está en una etapa temprana:

Ventajas: rapidez creativa, bajo coste y capacidad de lograr efectos muy difíciles de conseguir en rodajes reales.
Desventajas: duración limitada, los detalles tienden a degradarse y las leyes físicas a veces fallan (por ejemplo, objetos que se atraviesan, dedos mal contados).
Escenarios adecuados: demostración de conceptos, material para vídeos cortos, anuncios de comercio electrónico, animaciones para juegos.
Escenarios no adecuados: largometrajes que requieren control preciso, noticias serias, pruebas legales.

Comprensión y resumen de video

Además de generar vídeo, la IA también puede entenderlo.

Tareas comunes de comprensión de vídeo:

Resumen de vídeo: "¿De qué trata este vídeo? Resúmelo en 3 frases".
Búsqueda de contenido: "Encuentra el fragmento donde alguien anda en bicicleta".
Preguntas y respuestas: "¿Qué dijo la tercera persona en el vídeo?"

La ruta técnica suele ser: extraer fotogramas del vídeo (por ejemplo, 1 fotograma por segundo), luego usar un modelo de visión para revisar los fotogramas uno a uno y finalmente integrar la información.

Tendencias futuras

La dirección del vídeo con IA es clara:

Más largo: de 10 segundos a 1 minuto, y luego a 10 minutos.
Más controlable: poder controlar con precisión cada toma mediante un guion gráfico.
Más consistente: que el mismo personaje se mantenga coherente en distintas tomas.
Más práctico: de parecer impresionante a resolver problemas reales.
Se puede esperar que, en unos años, todos puedan crear obras de vídeo con IA con calidad cinematográfica.

IA de audio y voz

La IA de audio incluye principalmente: voz a texto (ASR), texto a voz (TTS) y generación de música.

Es un campo ya bastante maduro.

Conversión de voz a texto (API Whisper)

Whisper es el modelo de reconocimiento de voz de código abierto de OpenAI; funciona muy bien y admite 99 idiomas.

Ejemplo

# ============================================
# Archivo: ejemplo_whisper_demo.py
# Función: transcribir audio con la API Whisper
# ============================================

import requests
import os

# Configurar la clave de API
OPENAI_API_KEY = "sk-your-api-key-here"
WHISPER_API_URL = "https://api.openai.com/v1/audio/transcriptions"

def transcribe_audio_with_whisper(
audio_path: str,
language: str = "zh", # zh=chino, en=inglés; si se deja vacío, se detecta automáticamente
prompt: str = "", # Opcional: proporcionar pistas de terminología para mejorar la precisión
temperature: float = 0.0
) -> dict:
"""
Transcribir un archivo de audio con la API Whisper

Parámetros:
audio_path: ruta del archivo de audio (admite mp3, wav, m4a, etc.)
language: código de idioma (opcional; si no se especifica, se detecta automáticamente)
Códigos comunes: zh (chino), en (inglés), ja (japonés)
prompt: texto de aviso (opcional; escribe aquí posibles términos técnicos o nombres propios)
temperature: temperatura de muestreo (0.0 es lo más determinista, 1.0 es más variado)

Devuelve:
Un diccionario con el texto transcrito
"""
# Paso 1: comprobar si el archivo existe
if not os.path.exists(audio_path):
return {"error": f"El archivo no existe: {audio_path}"}

# Paso 2: preparar las cabeceras de la solicitud
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}

# Paso 3: preparar el cuerpo de la solicitud (nota: el audio debe usar el formato multipart/form-data)
files = {
"file": open(audio_path, "rb")
}
data = {
"model": "whisper-1",
"temperature": temperature
}
if language:
data["language"] = language
if prompt:
data["prompt"] = prompt

# Paso 4: enviar la solicitud
print(f"Transcribiendo audio: {audio_path} ...")
response = requests.post(WHISPER_API_URL, headers=headers, files=files, data=data)

# Paso 5: cerrar el archivo
files["file"].close()

# Paso 6: procesar la respuesta
if response.status_code == 200:
result = response.json()
text = result["text"]
print(f"Transcripción completada, {len(text)} caracteres en total")
return {
"text": text,
"language": language
}
else:
error_msg = f"Solicitud fallida: {response.status_code} - {response.text}"
print(error_msg)
return {"error": error_msg}

def transcribe_with_timestamps(audio_path: str) -> dict:
"""
Transcripción con marcas de tiempo (usando el formato verbose_json)
"""
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
files = {"file": open(audio_path, "rb")}
data = {
"model": "whisper-1",
"response_format": "verbose_json", # Devuelve información detallada, incluidas las marcas de tiempo
"timestamp_granularities": ["segment", "word"] # Admite marcas de tiempo por segmento y por palabra
}

response = requests.post(WHISPER_API_URL, headers=headers, files=files, data=data)
files["file"].close()

if response.status_code == 200:
result = response.json()
return result
else:
return {"error": response.text}

def translate_audio_to_english(audio_path: str) -> dict:
"""
Traducir audio de cualquier idioma a texto en inglés
"""
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
files = {"file": open(audio_path, "rb")}
data = {
"model": "whisper-1",
"task": "translate" # Indicación especial: tarea de traducción
}

response = requests.post("https://api.openai.com/v1/audio/translations",
headers=headers, files=files, data=data)
files["file"].close()

if response.status_code == 200:
return response.json()
else:
return {"error": response.text}

def ejemplo_meeting_minutes_demo(audio_path: str) -> str:
"""
Caso práctico: generar actas de reunión
Paso 1: transcribir la grabación con Whisper
Paso 2: organizar las actas con GPT-4o
"""
# Primero, transcribir
print("Primer paso: transcribir la grabación de la reunión...")
transcribe_result = transcribe_audio_with_whisper(
audio_path,
language="zh",
prompt="Esta es una reunión del equipo técnico de EJEMPLO, donde se discuten desarrollo de productos, avances, soluciones técnicas, etc."
)

if "error" in transcribe_result:
return transcribe_result["error"]

transcript = transcribe_result["text"]

# Luego, organizar (aquí simplificado; en un proyecto real puedes llamar a la API de GPT-4o)
print("Segundo paso: redactar las actas de la reunión...")
# Aquí, para la demostración, se devuelve directamente el texto transcrito
# En un proyecto real, puedes enviar el transcript a GPT-4o para que lo organice
return transcript

# ============================================
# Programa principal
# ============================================

if __name__ == "__main__":
# Preparar un archivo de audio de prueba
test_audio = "ejemplo_test_audio.mp3"

if not os.path.exists(test_audio):
print(f"Consejo: prepara un archivo de audio y nómbralo {test_audio}")
print("O graba un audio con el móvil y guárdalo en formato mp3")
else:
# Tarea 1: transcripción simple
print("\n" + "="*50)
print("Tarea 1: transcripción simple")
print("="*50)
result1 = transcribe_audio_with_whisper(test_audio, language="zh")
if "text" in result1:
print("Resultado de la transcripción:")
print(result1["text"])

# Tarea 2: transcripción con marcas de tiempo
print("\n" + "="*50)
print("Tarea 2: transcripción con marcas de tiempo")
print("="*50)
result2 = transcribe_with_timestamps(test_audio)
if "segments" in result2:
print("Información de segmentos:")
for seg in result2["segments"][:3]: # Mostrar solo las primeras 3 secciones
start = round(seg["start"], 2)
end = round(seg["end"], 2)
text = seg["text"]
print(f"[{start}-{end}] {text}")

print("\n" + "="*50)
print("¡Demostración de EJEMPLO Whisper completada!")
print("="*50)

Las ventajas de Whisper son: buen soporte multilingüe, tolerancia a distintos acentos y puntuación automática.

Casos de uso típicos: transcripción de grabaciones de reuniones, generación de subtítulos de vídeos, transcripción de podcasts y diarios de voz.

Conversión de texto a voz (TTS)

Texto a voz consiste en hacer que la IA "lea" un texto.

OpenAI también ofrece una API de TTS con múltiples estilos de voz.

Otras herramientas TTS: ElevenLabs (la más parecida a una voz humana), Azure TTS (nivel comercial), Edge TTS (gratuita), Coqui (código abierto).

Generación de música (Suno, Udio)

La generación de música también ha logrado avances importantes.

Suno y Udio son dos productos representativos: introduces la letra y la descripción del estilo, y generan una canción completa, con voz y acompañamiento.

Límites de sus capacidades:

Pueden hacer: generar música de fondo, crear demos de canciones y probar estilos rápidamente.
No pueden hacer bien: copiar exactamente una canción existente, controlar con precisión cada nota o realizar una postproducción profesional.
En cuanto a derechos de autor: las condiciones varían según la herramienta; compruébalas antes de usar contenido con fines comerciales.

Introducción a la arquitectura de los modelos multimodales

Conocer un poco de los principios te ayuda a usar mejor las herramientas.

CLIP: la base de la alineación imagen-texto

CLIP (Contrastive Language-Image Pre-training) es un modelo publicado por OpenAI en 2021.

Su idea es muy simple: observar imágenes y texto a la vez y aprender a relacionarlos.

Durante el entrenamiento, se proporciona al modelo un conjunto de pares deimagen + descripciónpara que aprenda a:

1. Convertir imágenes en vectores
2. Convertir texto en vectores
3. Hacer que los vectores de pares emparejados estén lo más cercanos posible y los de pares no emparejados lo más lejos posible

La importancia de CLIP radica en:demuestra que la "comprensión intermodal" es viable。

Modelos posteriores como Stable Diffusion y GPT-4o se inspiraron en CLIP.

LLaVA: LLM multimodal de código abierto

LLaVA (Large Language and Vision Assistant) es un modelo multimodal de código abierto.

Su arquitectura es muy clara:

Un codificador visual (por ejemplo, ViT), que se encarga de ver la imagen
Un gran modelo de lenguaje (por ejemplo, LLaMA), que se encarga de hablar
Una capa de proyección, que convierte los vectores de imagen a un formato que el modelo de lenguaje pueda entender

El entrenamiento se realiza en dos pasos:

Primer paso: preentrenamiento de alineación, para que el codificador visual y el modelo de lenguaje hablen el mismo idioma
Segundo paso: ajuste con instrucciones, entrenando con datos de imagen-pregunta-respuesta para que aprenda a responder siguiendo instrucciones

LLaVA es un buen punto de partida para aprender tecnología multimodal: código abierto, arquitectura clara y buenos resultados.

Práctica: creación de una herramienta de análisis de imágenes

Integramos los conocimientos anteriores para crear una herramienta práctica de análisis de imágenes.

Ejemplo

# ============================================
# Archivo: ejemplo_image_analyzer.py
# Función: una herramienta completa de análisis de imágenes multimodales
# ============================================

import base64
import requests
import os
import json
from datetime import datetime
from typing import Optional, Dict, Any

class EjemploImageAnalyzer:
"""
Analizador de imágenes EJEMPLO: una clase de herramienta multimodal encapsulada
"""

def __init__(self, api_key: str, base_url: str = "https://api.openai.com/v1"):
"""
Inicializar el analizador

Parámetros:
api_key: clave de API de OpenAI
base_url: dirección de la API (proxy configurable)
"""
self.api_key = api_key
self.base_url = base_url
self.headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {api_key}"
}

def _encode_image(self, image_path: str) -> str:
"""Codificar la imagen como Base64"""
with open(image_path, "rb") as f:
return base64.b64encode(f.read()).decode("utf-8")

def _call_vision_api(
self,
image_path: str,
prompt: str,
model: str = "gpt-4o",
max_tokens: int = 2000
) -> Optional[str]:
"""Método interno: llamar a la API de visión"""
base64_image = self._encode_image(image_path)

payload = {
"model": model,
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}
}
]
}
],
"max_tokens": max_tokens
}

url = f"{self.base_url}/chat/completions"
response = requests.post(url, headers=self.headers, json=payload)

if response.status_code == 200:
return response.json()["choices"][0]["message"]["content"]
else:
print(f"Error de API: {response.status_code} - {response.text}")
return None

def describe(self, image_path: str) -> Optional[str]:
"""Describir detalladamente el contenido de la imagen"""
prompt = """
Describe esta imagen en detalle, incluyendo:
1. Contenido principal (qué personas/objetos hay)
2. Entorno de fondo
3. Colores y luz
4. Ambiente general
Responde en chino, con una estructura clara.
"""
return self._call_vision_api(image_path, prompt)

def extract_text(self, image_path: str) -> Optional[str]:
"""Extraer todo el texto de la imagen (OCR)"""
prompt = """
Extrae todo el contenido de texto de esta imagen.
Requisitos:
1. Reproducir con precisión, sin omitir nada
2. Mantener la estructura de párrafos original
3. Si es una tabla, salida en formato de tabla Markdown
4. Si no hay texto, indica claramente "No hay texto reconocible en la imagen"
"""
return self._call_vision_api(image_path, prompt)

def analyze_ui(self, image_path: str) -> Optional[str]:
"""Analizar el diseño de UI (captura de pantalla)"""
prompt = """
Analiza este diseño de UI:
1. ¿Qué tipo de interfaz es (APP, página web, miniprograma, etc.)?
2. ¿Cuáles son los principales módulos funcionales de la interfaz?
3. ¿Cómo es el estilo de diseño (colores, disposición, tipografía)?
4. ¿Qué se puede mejorar?
Responde en chino, enumerando los puntos.
"""
return self._call_vision_api(image_path, prompt)

def analyze_product(self, image_path: str) -> Optional[str]:
"""Analizar la imagen del producto y generar texto de comercio electrónico"""
prompt = """
Analiza esta imagen de producto y genera un texto de comercio electrónico.
El texto debe incluir:
1. Nombre y tipo del producto
2. Características de apariencia (color, material, diseño)
3. Una breve recomendación atractiva (30-50 caracteres)
Responde en chino, con un tono amable y positivo.
"""
return self._call_vision_api(image_path, prompt)

def classify(self, image_path: str, categories: list = None) -> Optional[str]:
"""Clasificar la imagen"""
if categories is None:
categories = [
"Foto de personas", "Foto de paisaje", "Foto de comida", "Foto de producto",
"Diseño/captura de pantalla", "Documento/tabla", "Gráfico/visualización de datos", "Otro"
]
cat_list = "、".join(categories)
prompt = f"""
Determina a qué categoría pertenece esta imagen.
Categorías disponibles: {cat_list}
Devuelve solo el nombre de la categoría que mejor coincida, sin otro texto.
"""
return self._call_vision_api(image_path, prompt)

def full_analysis(self, image_path: str, output_dir: str = "ejemplo_analysis") -> Dict[str, Any]:
"""
Análisis completo: generar un informe de análisis detallado

Devolver un diccionario con todos los resultados del análisis
"""
print(f"Comenzando a analizar la imagen: {image_path}")

# Primero clasificar
print("[1/5] Clasificando...")
category = self.classify(image_path) or "Desconocido"

# Descripción
print("[2/5] Describiendo...")
description = self.describe(image_path) or ""

# Extraer texto
print("[3/5] Realizando OCR...")
text = self.extract_text(image_path) or ""

# Análisis específico según la categoría
print("[4/5] Realizando análisis específico...")
special_analysis = ""
if "Diseño" in category or "Captura de pantalla" in category:
special_analysis = self.analyze_ui(image_path) or ""
elif "Producto" in category or "Artículo" in category:
special_analysis = self.analyze_product(image_path) or ""

# Guardar informe
print("[5/5] Generando informe...")
if not os.path.exists(output_dir):
os.makedirs(output_dir)

timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
report = {
"image_file": os.path.basename(image_path),
"analysis_time": datetime.now().isoformat(),
"category": category,
"description": description,
"extracted_text": text,
"special_analysis": special_analysis
}

# Guardar JSON
json_path = os.path.join(output_dir, f"report_{timestamp}.json")
with open(json_path, "w", encoding="utf-8") as f:
json.dump(report, f, ensure_ascii=False, indent=2)

# Guardar texto legible
txt_path = os.path.join(output_dir, f"report_{timestamp}.txt")
with open(txt_path, "w", encoding="utf-8") as f:
f.write("="*60 + "\n")
f.write("Informe de análisis de imágenes EJEMPLO\n")
f.write("="*60 + "\n\n")
f.write(f"Imagen: {report['image_file']}\n")
f.write(f"Hora: {report['analysis_time']}\n")
f.write(f"Categoría: {report['category']}\n\n")
f.write("-"*60 + "\n")
f.write("Descripción de la imagen:\n")
f.write("-"*60 + "\n")
f.write(report["description"] + "\n\n")
f.write("-"*60 + "\n")
f.write("Texto extraído:\n")
f.write("-"*60 + "\n")
f.write(report["extracted_text"] + "\n\n")
if report["special_analysis"]:
f.write("-"*60 + "\n")
f.write("Análisis específico:\n")
f.write("-"*60 + "\n")
f.write(report["special_analysis"] + "\n")

print(f"¡Análisis completado! Informe guardado en: {output_dir}")
return report

# ============================================
# Ejemplo de uso
# ============================================

def main():
# Configura tu clave de API
api_key = "sk-your-api-key-here"

# Crear analizador
analyzer = EjemploImageAnalyzer(api_key)

# Ruta de la imagen a analizar
image_path = "ejemplo_test_image.jpg"

if not os.path.exists(image_path):
print(f"Prepara primero la imagen: {image_path}")
return

# Método 1: usar una función por separado
print("\nMétodo 1: usar la función OCR por separado")
print("-"*40)
text = analyzer.extract_text(image_path)
if text:
print("Texto extraído:")
print(text)

# Método 2: análisis completo
print("\nMétodo 2: análisis completo")
print("-"*40)
report = analyzer.full_analysis(image_path)
print(f"Resultado de clasificación: {report['category']}")
print(f"Informe guardado")

if __name__ == "__main__":
main()

Esta herramienta encapsula funciones comunes de análisis de imágenes y se puede usar directamente en proyectos.

Puedes ampliarlo según tus necesidades:

Añadir más escenarios de análisis (por ejemplo, imágenes médicas, inspección industrial, análisis de problemas educativos)
Añadir una interfaz web sencilla (con Flask o Gradio)
Compatibilidad con procesamiento por lotes de imágenes en carpetas
Guardar los resultados en una base de datos

Otras extensiones