Ir al contenido principal
Español— Elegir un idioma
Menú

Combina la generación de imágenes con otras herramientas de la API

Lección 10 de 12 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Combina la generación de imágenes con otras herramientas de la API
  2. Haz que un modelo de lenguaje escriba el prompt
  3. Ilustra un artículo de extremo a extremo
  4. Describe una imagen para regenerarla de forma diferente
  5. Procesa grandes volúmenes por lotes
  6. Publica directamente en el almacenamiento
  7. Qué mantiene una pipeline en pie

Actualización 2 de noviembre de 2026 — Modelos de imagen. gpt-image-1, el modelo para el que se escribió originalmente este curso, se discontinuó el 23 de octubre de 2026. gpt-image-1.5, gpt-image-1-mini y chatgpt-image-latest se retirarán el 1 de diciembre de 2026. Los ejemplos ahora utilizan gpt-image-2.5-sunburst, que ofrece la mayor precisión para la edición; gpt-image-2.5-flare es más rápido para la generación estándar. Ambos modelos también admiten las configuraciones de calidad xhigh y max. Los modelos GPT Image devuelven siempre las imágenes en base64: el parámetro response_format de los modelos DALL·E anteriores no es compatible y se ha eliminado del código. Fuente: Generación de imágenes (OpenAI).

Combina la generación de imágenes con otras herramientas de la API

De forma aislada, la generación de imágenes es una herramienta artesanal: escribes un prompt y obtienes un archivo. Su verdadero poder surge cuando se convierte en un paso dentro de una cadena automatizada: un modelo de lenguaje que redacta el prompt, un análisis de visión que describe una imagen de referencia o un almacenamiento que publica el resultado. Esta lección te muestra cómo conectar estas piezas.

Haz que un modelo de lenguaje escriba el prompt

Tus usuarios o compañeros no escriben prompts visuales; escriben breves. «Necesito una imagen para un artículo sobre IA en sanidad, futurista pero humana» no contiene composición, iluminación ni paleta. En lugar de pedirles que aprendan el vocabulario de la lección anterior, inserta un modelo de lenguaje para encargarse de la traducción. Asígnale el rol de director de arte en el mensaje de sistema y exígele que produzca las capas específicas del prompt, con instrucciones estrictas de no outputar nada más. De lo contrario, recibirás una explicación educada que luego tendrías que enviar a GPT Image.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Pipeline de dos pasos:
    1. Un LLM genera el prompt visual óptimo
    2. GPT Image crea la imagen
    """
    # Paso 1: Generar el prompt visual con un LLM
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "Eres un director de arte experto. "
                    "Basándote en un brief, genera un prompt detallado para un "
                    "modelo de generación de imágenes. Incluye: sujeto, composición, iluminación, "
                    "estilo, perspectiva, paleta de colores. "
                    "Responde solo con el prompt, sin explicaciones."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

    visual_prompt = completion.choices[0].message.content
    print(f"Prompt generado: {visual_prompt[:100]}...")

    # Paso 2: Generar la imagen
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=visual_prompt,
        size="1536x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Imagen generada: {output}")
    return visual_prompt


prompt = text_to_image(
    "Necesito una imagen para un artículo sobre inteligencia artificial "
    "en sanidad. Futurista pero humana.",
    "ai_health.png"
)

Ilustra un artículo de extremo a extremo

Un artículo de fondo necesita una imagen de portada y una ilustración por sección. Estas imágenes deben parecer cohesivas sin ser idénticas. La función illustrate_article aplica esta lógica reinyectando el estilo en cada prompt y repitiendo el título del artículo cada vez, lo que otorga unidad temática al conjunto completo. Dos detalles para ahorrar costes merecen atención: la portada se genera con calidad high porque todo el mundo la ve y a menudo se comparte, mientras que las ilustraciones de sección se mantienen en medium ya que se muestran más pequeñas y abajo en la página. Para las cinco secciones de este ejemplo sobre IA en reclutamiento, este compromiso reduce la factura sin que el lector note nada.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Genera una ilustración de cabecera + una por sección.
    """
    results = []

    # Imagen de portada
    header_prompt = (
        f"Imagen de portada para un artículo titulado \"{title}\", "
        f"estilo {style}, composición panorámica, "
        "sin texto en la imagen, profesional"
    )

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=header_prompt,
        size="1536x1024",
        quality="high",
    )

    path = f"{output_dir}/header.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    results.append({"type": "header", "path": path})
    print(f"Cabecera: {path}")

    # Ilustraciones de sección
    for i, section in enumerate(sections):
        section_prompt = (
            f"Ilustración para la sección \"{section}\" "
            f"de un artículo sobre \"{title}\", "
            f"estilo {style}, formato rectangular, "
            "ilustración conceptual sin texto"
        )

        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=section_prompt,
            size="1536x1024",
            quality="medium",
        )

        path = f"{output_dir}/section_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        results.append({"type": f"section_{i+1}", "section": section, "path": path})
        print(f"Sección {i+1} ({section[:30]}...) : {path}")

    return results


illustrate_article(
    title="5 formas en que la IA está transformando el reclutamiento",
    sections=[
        "Cribado automático de CV",
        "Entrevistas en vídeo analizadas por IA",
        "Emparejamiento inteligente candidato-puesto",
        "Reducción del sesgo en el reclutamiento",
        "Incorporación personalizada",
    ],
    style="Ilustración isométrica 3D, tonos azules y violetas",
    output_dir="."
)

Describe una imagen para regenerarla de forma diferente

¿Cómo consigues una versión invernal de un paisaje de verano cuando solo tienes el archivo, sin máscara y sin herramientas de edición? Pasa por el lenguaje. La visión del modelo analiza la imagen y produce una descripción lo suficientemente precisa para servir como prompt de reconstrucción: sujeto, composición, iluminación, colores, estilo, perspectiva, estado de ánimo. Luego concatenas tu instrucción de modificación a esta descripción. El modelo de generación recibe un prompt de texto completo donde solo ha cambiado la estación, y obtienes una imagen coherente con la original en lugar de algo unrelated. Esta es también la forma más fiable de reproducir la identidad visual de una imagen de referencia que no puedes editar directamente.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analiza una imagen con GPT Vision
    2. Genera una variante basada en el análisis
    """
    # Paso 1: Analizar la imagen
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    analysis = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Describe esta imagen en detalle para que un modelo "
                            "de generación de imágenes pueda reproducirla fielmente. "
                            "Incluye: sujeto, composición, iluminación, colores, estilo, "
                            "perspectiva, estado de ánimo. Sé muy preciso."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

    description = analysis.choices[0].message.content
    print(f"Análisis: {description[:150]}...")

    # Paso 2: Generar una variante modificada
    variant_prompt = f"{description}. Modificación solicitada: {instruction}"

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=variant_prompt,
        size="1024x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Variante generada: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Cambia la estación de verano a invierno, con nieve en los tejados y los árboles",
    "winter_landscape.png"
)

Procesa grandes volúmenes por lotes

Generar cinco visuales de producto en serie lleva minutos; generar quinientos secuencialmente lleva toda la noche y falla ante el primer tropiezo de red. La configuración siguiente resuelve ambos problemas. Cada tarea es un diccionario autónomo que lleva su ID, prompt, archivo de salida y configuración. La función worker envuelve la llamada en un bloque try que devuelve un estado en lugar de colapsar todo el lote: una generación rechazada no tumba a las otras cuatrocientas noventa y nueve. El ThreadPoolExecutor paraleliza entonces la ejecución, pero con un max_workers deliberadamente bajo —tres en este ejemplo— porque el cuello de botella no es tu máquina, son las cuotas de la API. El informe final cuenta éxitos y fallos para que sepas qué reintentar.

from openai import OpenAI
import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

client = OpenAI()

def generate_one_image(task: dict) -> dict:
    """Genera una única imagen a partir de una tarea."""
    try:
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=task["prompt"],
            size=task.get("size", "1024x1024"),
            quality=task.get("quality", "medium"),
        )

        data = base64.b64decode(response.data[0].b64_json)
        with open(task["output"], "wb") as f:
            f.write(data)

        return {"id": task["id"], "status": "ok", "path": task["output"]}

    except Exception as e:
        return {"id": task["id"], "status": "error", "error": str(e)}


def batch_generation(tasks: list[dict], max_parallel: int = 3):
    """Ejecuta un lote de generaciones con paralelismo controlado."""
    results = []

    with ThreadPoolExecutor(max_workers=max_parallel) as executor:
        futures = {
            executor.submit(generate_one_image, task): task
            for task in tasks
        }

        for future in as_completed(futures):
            result = future.result()
            results.append(result)
            status = result["status"]
            print(f"  [{status}] {result['id']}")

    # Informe
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nFinalizado: {ok} ok, {errors} errores de {len(tasks)} tareas")

    return results


# Define un lote de tareas
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"Foto de producto e-commerce: {product}, fondo blanco, estudio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "reloj de oro rosa",
        "gafas de sol de aviador",
        "pulsera de cuero trenzado",
        "anillo de solitario con diamante",
        "collar de perlas cultivadas",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Publica directamente en el almacenamiento

Escribir el PNG en el disco de la máquina que ejecuta el script solo tiene sentido en desarrollo. En producción, la imagen debe aterrizar donde tu sitio la vaya a buscar, y hacer un desvío por el sistema de archivos local se convierte en un punto de fallo innecesario. El formato b64_json se adapta bien a esta eliminación: los bytes decodificados se envuelven en un objeto BytesIO y se empujan directamente al bucket, con un ContentType explícito —sin el cual los navegadores ofrecerían una descarga en lugar de mostrar la imagen—. La función devuelve la URL pública, que es lo que tu CMS necesita realmente.

from openai import OpenAI
import base64
import boto3
from io import BytesIO

client = OpenAI()

def generate_and_store_s3(prompt: str, bucket: str, key: str):
    """Genera una imagen y la sube directamente a S3."""
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

    image_data = base64.b64decode(response.data[0].b64_json)

    s3 = boto3.client("s3")
    s3.upload_fileobj(
        BytesIO(image_data),
        bucket,
        key,
        ExtraArgs={"ContentType": "image/png"}
    )

    url = f"https://{bucket}.s3.amazonaws.com/{key}"
    print(f"Imagen almacenada en S3: {url}")
    return url


# Ejemplo
url = generate_and_store_s3(
    "Icono de aplicación móvil: libro abierto con estrellas, diseño plano",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Qué mantiene una pipeline en pie

Las cinco pipelines de esta lección comparten la misma higiene de construcción. Cada paso hace una cosa, lo que te permite reemplazar la escritura del prompt o el almacenamiento sin tocar el resto. Cada paso gestiona sus propios errores; de lo contrario, un rechazo de moderación en medio de un lote tumba toda la cadena: eso es exactamente lo que previene el try en generate_one_image. El paralelismo se mantiene estrangulado para respetar los límites de tasa, y en este punto, la precaución cuesta menos que la recuperación tras una prohibición temporal.

Quedan dos hábitos menos visibles pero igual de decisivos. Registra los prompts realmente enviados, especialmente cuando los escribe un modelo de lenguaje: sin este registro, una imagen que te encanta se vuelve irreproducible en la segunda ejecución. Y almacena en caché los resultados siempre que el mismo prompt pueda volver, algo que la siguiente lección formaliza en un sistema completo.

Ahora ensambla tu propia cadena completa: toma un título de artículo como entrada, pide a un modelo de lenguaje tres descripciones de visuales relevantes, genera las tres imágenes en paralelo y produce un JSON resumen que enlace cada prompt con su archivo. Tendrás entonces todo lo necesario para ilustrar un blog entero sin intervención manual.