Variaciones e iteraciones
En esta página
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-miniychatgpt-image-latestse retirarán el 1 de diciembre de 2026. Los ejemplos ahora utilizangpt-image-2.5-sunburst, que ofrece la mayor precisión para la edición;gpt-image-2.5-flarees más rápido para la generación estándar. Ambos modelos también admiten los ajustes de calidadxhighymax. Los modelos GPT Image devuelven siempre las imágenes en base64: el parámetroresponse_formatde 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
)
Comparar variaciones en un catálogo
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.