Control de calidad, estilo y resolución
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, quedó obsoleto 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 admiten ahora los niveles de calidadxhighymax. Los modelos GPT Image devuelven siempre las imágenes en formato base64: el parámetroresponse_formatque utilizaban los modelos DALL·E anteriores ya no se acepta y se ha eliminado del código. Fuente: Generación de imágenes (OpenAI).
Control de calidad, estilo y resolución
GPT Image ofrece varias palancas para ajustar tu resultado, pero no todas funcionan de la misma manera. La calidad y la resolución son parámetros explícitos de la API que afectan al coste y al tiempo de generación. El estilo, sin embargo, se controla exclusivamente mediante el prompt. Entender esta distinción te evita buscar opciones inexistentes y te ayuda a optimizar la relación calidad-coste en cada generación.
Niveles de calidad
El parámetro quality impacta directamente en el nivel de detalle y en el tiempo de generación. La mejor forma de apreciar la diferencia es probarlo con un sujeto exigente, como un bodegón con iluminación Rembrandt, donde los gradientes y las texturas son críticos, en lugar de con un gráfico plano donde las diferencias serían invisibles.
import base64
from openai import OpenAI
client = OpenAI()
qualities = ["low", "medium", "high"]
for q in qualities:
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt="Still life with exotic fruits on a marble table, Rembrandt lighting",
size="1024x1024",
quality=q
)
with open(f"quality_{q}.png", "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
print(f"Quality {q}: quality_{q}.png")
| Calidad | Detalles | Tiempo | Coste | Uso recomendado |
|---|---|---|---|---|
low | Básico | Rápido | Económico | Borradores, pruebas, prototipado |
medium | Bueno | Moderado | Intermedio | Redes sociales, presentaciones |
high | Máximo | Más lento | Premium | Impresión, publicidad, portafolios |
Resoluciones disponibles
Hay disponibles tres relaciones de aspecto, cada una adaptada a casos de uso específicos: cuadrada 1024×1024 para redes sociales y avatares, vertical 1024×1536 para historias, pósteres y pantallas móviles, y horizontal 1536×1024 para banners, cabeceras y presentaciones. Genera siempre directamente en tu formato objetivo. Recortar afterwards desperdicia píxeles por los que has pagado y rompe la composición que el modelo construyó para ese encuadre concreto.
import base64
from openai import OpenAI
client = OpenAI()
resolutions = {
"1024x1024": "Cuadrada — ideal para redes sociales y avatares",
"1024x1536": "Vertical — historias, pósteres, móvil",
"1536x1024": "Horizontal — banners, cabeceras, presentaciones",
}
for size, description in resolutions.items():
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt="Panoramic view of a futuristic city at dusk, neon lights and skyscrapers",
size=size,
quality="medium"
)
with open(f"city_{size}.png", "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
print(f"{size} ({description}) → city_{size}.png")
Control del estilo mediante el prompt
El estilo no es un parámetro explícito de la API; lo controlas enteramente a través del prompt. La técnica más fiable es especificar un medio preciso con su propio vocabulario. «Fotografía profesional, Nikon D850, f/2.8» no solo solicita una foto, sino que exige una profundidad de campo y un renderizado óptico específicos. «Arte de píxeles retro de 16 bits, paleta limitada» impone una restricción de resolución que el modelo respetará. El siguiente bucle aplica cinco medios diferentes al mismo sujeto, haciendo que las diferencias sean inmediatamente visibles.
import base64
mediums = [
"professional photography, Nikon D850, f/2.8",
"oil painting on canvas, impressionist style",
"flat design vector illustration, pastel colors",
"architectural technical drawing, cross-section view",
"retro 16-bit pixel art, limited palette",
]
for medium in mediums:
prompt = f"A typical Parisian café with outdoor seating, {medium}"
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="medium"
)
filename = f"cafe_{mediums.index(medium) + 1}.png"
with open(filename, "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
print(f"{medium[:40]}... → {filename}")
La iluminación es tu segunda palanca y, a menudo, la más potente: puede transformar radicalmente la misma escena. Un retrato de una artesana ceramista en su taller se convierte en una toma documental sobria bajo una iluminación de estudio de tres puntos, en una imagen publicitaria con luz de hora dorada o en un póster de cine con claroscuro al estilo de Caravaggio. El sujeto no ha cambiado ni una palabra; solo ha variado la atmósfera.
import base64
lightings = [
"three-point studio lighting, neutral white background",
"natural golden hour light",
"cyberpunk neon lighting, pink and blue",
"dramatic Caravaggio-style chiaroscuro",
"diffuse rainy day light, gray tones",
]
for lighting in lightings:
prompt = f"Portrait of a ceramic artisan in her workshop, {lighting}"
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1536",
quality="high"
)
filename = f"artisan_{lightings.index(lighting) + 1}.png"
with open(filename, "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
print(f"Lighting: {lighting} → {filename}")
Función de utilidad para la generación
Repetir las mismas seis líneas en cada llamada resulta rápidamente tedioso y propenso a errores. Envuelve tus preferencias predeterminadas en una función reutilizable que también gestione el almacenamiento en disco y la adición de sufijos a los archivos cuando solicites múltiples imágenes.
from openai import OpenAI
import base64
from pathlib import Path
client = OpenAI()
def generate_image(
prompt: str,
output_path: str,
size: str = "1024x1024",
quality: str = "medium",
n: int = 1
) -> list[str]:
"""
Genera una o más imágenes y las guarda localmente.
Devuelve una lista de rutas de archivo creadas.
"""
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
n=n,
size=size,
quality=quality,
)
paths = []
for i, image in enumerate(response.data):
if n > 1:
path = Path(output_path).stem + f"_{i+1}" + Path(output_path).suffix
else:
path = output_path
data = base64.b64decode(image.b64_json)
with open(path, "wb") as f:
f.write(data)
paths.append(path)
print(f"Saved: {path}")
return paths
# Uso
generate_image(
prompt="Premium packaging for matcha tea, minimalist Japanese design",
output_path="matcha_packaging.png",
size="1024x1024",
quality="high"
)
Elige la combinación adecuada
Tú decides ambos parámetros conjuntamente en función de tu medio objetivo. La siguiente tabla resume los escenarios más comunes.
| Contexto | Resolución | Calidad |
|---|---|---|
| Prototipado rápido | 1024×1024 | low |
| Publicación en Instagram / LinkedIn | 1024×1024 | medium |
| Historia vertical / Reel | 1024×1536 | medium |
| Banner web / cabecera | 1536×1024 | medium |
| Póster impreso A3+ | 1024×1536 | high |
| Portafolio creativo / libro | 1024×1024 | high |
| Pruebas de prompts por lotes | 1024×1024 | low |
En producción, no copies manualmente esta tabla en cada script. Tradúcela a lógica de configuración y deja que tu código elija en función del contexto declarado. Obtienes una única fuente de verdad y, si más adelante decides que tus publicaciones en redes sociales deben usar calidad high, solo necesitas cambiar una línea.
def generate_for_context(prompt: str, context: str, output: str):
"""Adapta automáticamente la calidad y la resolución al contexto."""
configs = {
"prototype": {"size": "1024x1024", "quality": "low"},
"social_media": {"size": "1024x1024", "quality": "medium"},
"story": {"size": "1024x1536", "quality": "medium"},
"banner": {"size": "1536x1024", "quality": "medium"},
"print": {"size": "1024x1536", "quality": "high"},
}
config = configs.get(context, configs["social_media"])
return generate_image(
prompt=prompt,
output_path=output,
**config
)
# Generar la misma imagen para diferentes medios
generate_for_context(
"Corsen AI logo on dark background, premium tech style",
"social_media",
"logo_social.png"
)
Para formar tu propio criterio sobre estos ajustes, genera tú mismo la matriz completa: escribe un script que tome un único prompt y produzca las nueve combinaciones de calidad × resolución, guarde cada archivo con un nombre explícito como image_low_1024x1024.png y muestre una tabla resumen. Pronto sabrás a simple vista cuándo medium es suficiente.