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

Variaciones e iteraciones

Lección 5 de 12 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Variaciones e iteraciones
  2. Generar variaciones del mismo concepto
  3. Variaciones modificando el prompt
  4. Iteración refinando el prompt
  5. Canalización automatizada de iteraciones
  6. Comparar variaciones en un catálogo
  7. La disciplina de la iteración

Actualizado el 2 de noviembre de 2026 — Modelos de imagen. gpt-image-1, el modelo para el que se escribió originalmente este curso, fue discontinuado el 23 de octubre de 2026. Además, 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 los ajustes 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 ya no se acepta y se ha eliminado del código. Fuente: Generación de imágenes (OpenAI).

Variaciones e iteraciones

Conseguir la imagen perfecta al primer intento es poco habitual. El trabajo real implica generar variaciones, compararlas y refinar progresivamente el prompt hasta alcanzar el resultado deseado. Esta lección te proporciona las tres herramientas para este método: variación por reejecución, variación mediante modificación del prompt e iteración mediante refinamiento sucesivo.

Generar variaciones del mismo concepto

El método más sencillo consiste en volver a ejecutar la generación con el mismo prompt: GPT Image produce un resultado diferente cada vez. Esto resulta útil al inicio de la exploración, cuando aún no sabes exactamente qué buscas y quieres observar el abanico de interpretaciones posibles de una idea.

from openai import OpenAI
import base64

client = OpenAI()

def generate_variations(prompt: str, n_variations: int, prefix: str):
    """Genera varias variaciones independientes del mismo prompt."""
    paths = []
    for i in range(n_variations):
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=prompt,
            size="1024x1024",
            quality="medium",
        )

        path = f"{prefix}_v{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        paths.append(path)
        print(f"Variación {i+1} guardada: {path}")

    return paths


variations = generate_variations(
    prompt="Ilustración de un robot jardinero regando flores, estilo infantil y colorido",
    n_variations=5,
    prefix="gardener_robot"
)

Variaciones modificando el prompt

El enfoque anterior te deja a merced del azar; este te da control. Fijas un sujeto invariante —en este caso, una taza de café humeante sobre una mesa de madera— y mueves solo una dimensión: el ambiente. Los cinco resultados se vuelven entonces comparables, ya que sabes exactamente qué los distingue. Esta es la diferencia entre cinco intentos y un experimento.

from openai import OpenAI
import base64

client = OpenAI()

base_prompt = "Taza de café humeante sobre una mesa de madera"

moods = [
    "luz suave de mañana, tonos cálidos",
    "ambiente de cafetería parisina, blanco y negro",
    "estilo pop art, colores saturados",
    "minimalismo escandinavo, fondo blanco",
    "atmósfera acogedora de invierno, luces de hadas con bokeh",
]

for i, mood in enumerate(moods):
    prompt = f"{base_prompt}, {mood}"
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="medium",
    )

    path = f"cafe_mood_{i+1}.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    print(f"Ambiente: {mood[:30]}... → {path}")

Iteración refinando el prompt

Cuando el resultado no es satisfactorio, la reacción correcta no es volver a ejecutar con la esperanza de tener más suerte, sino añadir la restricción que falta. La serie siguiente muestra esta progresión en un ejemplo práctico: «Un logotipo para una startup fintech» no le dice nada al modelo; la segunda iteración acota el número de colores y el fondo; la tercera nombra la metáfora visual y la paleta; la cuarta baja hasta los códigos hexadecimales y el grosor del trazo. Con cada pasada, el espacio de resultados posibles se reduce y la reproducibilidad aumenta.

from openai import OpenAI
import base64

client = OpenAI()

iterations = [
    # Iteración 1: prompt base
    "Un logotipo para una startup fintech",

    # Iteración 2: añadiendo restricciones visuales
    "Un logotipo para una startup fintech, diseño minimalista, máximo dos colores, fondo transparente",

    # Iteración 3: precisión de estilo
    (
        "Logotipo minimalista para una startup fintech, icono geométrico abstracto "
        "que evoque crecimiento, paleta azul marino y verde esmeralda, sin texto, estilo vectorial"
    ),

    # Iteración 4: ajustes finos
    (
        "Logotipo minimalista para una startup fintech, icono geométrico abstracto: "
        "dos flechas entrelazadas formando un rombo, azul marino (#1B2A4A) y "
        "verde esmeralda (#2ECC71), trazo fino de 2 px, fondo blanco, renderizado vectorial nítido, centrado"
    ),
]

for i, prompt in enumerate(iterations):
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

    path = f"logo_iteration_{i+1}.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    print(f"Iteración {i+1}: {prompt[:60]}...")
    print(f"  → {path}\n")

Canalización automatizada de iteraciones

En un proyecto algo más largo, la memoria humana no basta: tras quince imágenes, ya no sabes qué prompt produjo qué resultado. La siguiente canalización estructura el trabajo en rondas, genera varias variantes por ronda, nombra los archivos de forma rastreable y mantiene el historial completo de los prompts en un archivo JSON. Este archivo de historial es lo que hace valiosa la configuración: te permite retroceder y capitalizar de un proyecto a otro.

from openai import OpenAI
import base64
import json

client = OpenAI()

def iteration_pipeline(brief: str, n_rounds: int = 3, n_per_round: int = 3):
    """
    Canalización de iteración: genera varias variantes por ronda,
    mantiene un historial de prompts y resultados.
    """
    history = []
    current_prompt = brief

    for round_num in range(1, n_rounds + 1):
        print(f"\n{'='*50}")
        print(f"RONDA {round_num} — Prompt: {current_prompt[:80]}...")
        print(f"{'='*50}")

        round_images = []
        for i in range(n_per_round):
            response = client.images.generate(
                model="gpt-image-2.5-sunburst",
                prompt=current_prompt,
                size="1024x1024",
                quality="medium",
            )

            path = f"pipeline_r{round_num}_v{i+1}.png"
            data = base64.b64decode(response.data[0].b64_json)
            with open(path, "wb") as f:
                f.write(data)
            round_images.append(path)
            print(f"  Variante {i+1}: {path}")

        history.append({
            "round": round_num,
            "prompt": current_prompt,
            "images": round_images
        })

        # Refinar el prompt para la siguiente ronda
        if round_num < n_rounds:
            current_prompt += ", más detalles, mejor composición"

    # Guardar el historial
    with open("pipeline_history.json", "w") as f:
        json.dump(history, f, indent=2, ensure_ascii=False)

    print(f"\nHistorial guardado: pipeline_history.json")
    return history


iteration_pipeline(
    brief="Ilustración de una librería independiente vista desde fuera, tarde de otoño, estilo Ghibli",
    n_rounds=3,
    n_per_round=3
)

Abrir nueve PNG uno a uno en un visor no permite ninguna comparación seria. En su lugar, genera una página HTML que los muestre uno al lado del otro, con las imágenes codificadas en base64 para que el archivo sea autónomo y pueda compartirse tal cual con un cliente o director de arte.

import base64
from pathlib import Path
from glob import glob

def generate_catalog(images: list[str], title: str, output: str = "catalog.html"):
    """Crea una página HTML con todas las imágenes una al lado de la otra."""
    html_parts = [
        '<!DOCTYPE html><html><head><meta charset="utf-8">',
        f'<title>{title}</title>',
        '<style>',
        'body { background: #111; color: #fff; font-family: sans-serif; padding: 2rem; }',
        '.grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 1rem; }',
        '.card { background: #222; border-radius: 8px; overflow: hidden; }',
        '.card img { width: 100%; display: block; }',
        '.card p { padding: 0.5rem 1rem; font-size: 0.85rem; color: #aaa; }',
        '</style></head><body>',
        f'<h1>{title}</h1><div class="grid">',
    ]

    for img_path in images:
        with open(img_path, "rb") as f:
            b64 = base64.b64encode(f.read()).decode()
        html_parts.append(f'<div class="card">')
        html_parts.append(f'<img src="data:image/png;base64,{b64}" />')
        html_parts.append(f'<p>{Path(img_path).name}</p></div>')

    html_parts.append('</div></body></html>')

    with open(output, "w") as f:
        f.write("\n".join(html_parts))
    print(f"Catálogo generado: {output}")


images = sorted(glob("pipeline_r*_v*.png"))
generate_catalog(images, "Variaciones — Librería Ghibli")

La disciplina de la iteración

Unos pocos principios separan la iteración productiva del costoso ensayo y error. Cambia solo un parámetro cada vez; de lo contrario, nunca sabrás cuál mejoró el resultado. Mantén un historial de tus prompts y renderizados, como hace la canalización anterior, para capitalizar en lugar de empezar de cero en cada proyecto. Trabaja con quality: low durante toda la fase de exploración y cambia a high solo para el renderizado final, o pagarás un precio desorbitado por imágenes que acabarás descartando. Cuando simplemente busques diversidad rápida, prefiere una única llamada con el parámetro n frente a un bucle de solicitudes. Por último, nombra tus archivos de forma descriptiva: es un detalle trivial el primer día, pero decisivo tras doscientas imágenes.

Aplica ahora esta secuencia completa a un tema de tu elección —logotipo, ilustración o fotografía de producto—. Genera tres variantes con un prompt inicial, refina ese prompt a la luz de los resultados, genera tres nuevas variantes y, finalmente, produce el catálogo HTML comparativo de las seis imágenes.