GPT Image 1

Generar imágenes con gpt-image-1

GPT Image 1 representa la evolución más avanzada en generación de imágenes de OpenAI, combinando las capacidades de un modelo de lenguaje multimodal con técnicas especializadas de síntesis visual. A diferencia de los modelos DALL·E anteriores, GPT Image 1 integra conocimiento del mundo real y ofrece un seguimiento superior de instrucciones complejas.

Este modelo destaca por su capacidad para renderizar texto dentro de las imágenes con mayor precisión y manejar composiciones detalladas que requieren comprensión contextual profunda. La integración nativa con el ecosistema GPT permite workflows más sofisticados y conversacionales.

NOTA: este modelo actualmente requiere verificación de identidad mediante NIF y reconocimiento facial para poder usarlo vía API.

En caso de no tener la identidad verificada dará error:

Configuración inicial

Para trabajar con GPT Image 1, necesitas configurar el cliente de OpenAI. El SDK moderno detecta automáticamente la clave API desde las variables de entorno:

from openai import OpenAI
import base64

client = OpenAI()

La configuración es mínima gracias a la detección automática de credenciales. Solo asegúrate de tener la variable OPENAI_API_KEY configurada en tu sistema.

Generación básica con Image API

La Image API proporciona el método más directo para generar imágenes individuales. Es ideal cuando necesitas crear una imagen específica sin contexto conversacional:

def generar_imagen_basica(prompt):
    """Genera una imagen usando la Image API"""
    result = client.images.generate(
        model="gpt-image-1",
        prompt=prompt
    )
    
    # Decodificar y guardar la imagen
    image_base64 = result.data[0].b64_json
    image_bytes = base64.b64decode(image_base64)
    
    with open("imagen_generada.png", "wb") as f:
        f.write(image_bytes)
    
    return "imagen_generada.png"

# Ejemplo de uso
prompt = """
Un café acogedor con estanterías llenas de libros, 
luz cálida filtrándose por ventanas grandes, 
y una taza de café humeante sobre una mesa de madera
"""

archivo_imagen = generar_imagen_basica(prompt)
print(f"Imagen guardada como: {archivo_imagen}")

Generación avanzada con Responses API

La Responses API ofrece capacidades más sofisticadas, incluyendo generación conversacional y streaming. Esta API es preferible para aplicaciones interactivas:

def generar_con_responses_api(descripcion):
    """Genera imagen usando la Responses API moderna"""
    response = client.responses.create(
        model="gpt-4.1-mini",
        input=descripcion,
        tools=[{"type": "image_generation"}]
    )
    
    # Extraer datos de imagen generada
    image_data = [
        output.result
        for output in response.output
        if output.type == "image_generation_call"
    ]
    
    if image_data:
        image_base64 = image_data[0]
        with open("imagen_responses.png", "wb") as f:
            f.write(base64.b64decode(image_base64))
        return "imagen_responses.png"
    
    return None

# Generar imagen con contexto más rico
descripcion = """
Crea una ilustración estilo acuarela de un jardín japonés 
con un puente de bambú sobre un estanque con carpas koi, 
cerezos en flor y una pagoda al fondo
"""

resultado = generar_con_responses_api(descripcion)

Personalización de parámetros

GPT Image 1 permite personalizar múltiples aspectos de la generación para adaptar el resultado a necesidades específicas:

def generar_imagen_personalizada(prompt, configuracion=None):
    """Genera imagen con parámetros personalizados"""
    config_default = {
        "size": "1024x1024",
        "quality": "high",
        "background": "opaque"
    }
    
    if configuracion:
        config_default.update(configuracion)
    
    result = client.images.generate(
        model="gpt-image-1",
        prompt=prompt,
        **config_default
    )
    
    return result.data[0].b64_json

# Diferentes configuraciones según el uso
configuraciones = {
    "retrato": {"size": "1024x1536", "quality": "high"},
    "paisaje": {"size": "1536x1024", "quality": "medium"},
    "logo": {"background": "transparent", "quality": "high"},
    "rapida": {"quality": "low", "size": "1024x1024"}
}

# Generar logo con fondo transparente
logo_config = configuraciones["logo"]
imagen_logo = generar_imagen_personalizada(
    "Logo minimalista de una montaña con tipografía moderna",
    logo_config
)

Generación múltiple y batch processing

Para generar múltiples imágenes de manera eficiente, puedes usar el parámetro n o procesar lotes de prompts:

def generar_variaciones(prompt_base, cantidad=3):
    """Genera múltiples variaciones de un prompt"""
    result = client.images.generate(
        model="gpt-image-1",
        prompt=prompt_base,
        n=cantidad
    )
    
    imagenes = []
    for i, imagen_data in enumerate(result.data):
        nombre_archivo = f"variacion_{i+1}.png"
        image_bytes = base64.b64decode(imagen_data.b64_json)
        
        with open(nombre_archivo, "wb") as f:
            f.write(image_bytes)
        
        imagenes.append(nombre_archivo)
    
    return imagenes

# Generar variaciones de un concepto
prompt_variaciones = "Un robot amigable ayudando en una cocina moderna"
archivos_generados = generar_variaciones(prompt_variaciones, 4)

print(f"Generadas {len(archivos_generados)} variaciones:")
for archivo in archivos_generados:
    print(f"- {archivo}")

Optimización de prompts para GPT Image 1

La calidad del prompt influye significativamente en el resultado. GPT Image 1 responde bien a descripciones estructuradas y específicas:

def construir_prompt_estructurado(elementos):
    """Construye un prompt optimizado para GPT Image 1"""
    template = """
    Estilo: {estilo}
    Sujeto principal: {sujeto}
    Ambiente: {ambiente}
    Iluminación: {iluminacion}
    Colores dominantes: {colores}
    Detalles específicos: {detalles}
    """
    
    return template.format(**elementos)

# Ejemplo de prompt estructurado
elementos_imagen = {
    "estilo": "Fotografía profesional de producto",
    "sujeto": "Reloj de pulsera elegante",
    "ambiente": "Superficie de mármol blanco con reflejos suaves",
    "iluminacion": "Luz natural difusa desde la izquierda",
    "colores": "Tonos neutros con acentos dorados",
    "detalles": "Enfoque nítido en la esfera, correa de cuero visible"
}

prompt_optimizado = construir_prompt_estructurado(elementos_imagen)
imagen_producto = generar_imagen_basica(prompt_optimizado)

Manejo de errores y validación

Implementar manejo robusto de errores es esencial para aplicaciones en producción:

import time
from openai import OpenAI, OpenAIError

def generar_con_reintentos(prompt, max_intentos=3):
    """Genera imagen con manejo de errores y reintentos"""
    for intento in range(max_intentos):
        try:
            result = client.images.generate(
                model="gpt-image-1",
                prompt=prompt
            )
            
            # Validar que se recibió la imagen
            if result.data and result.data[0].b64_json:
                return result.data[0].b64_json
            else:
                raise ValueError("No se recibieron datos de imagen")
                
        except OpenAIError as e:
            print(f"Error de OpenAI (intento {intento + 1}): {e}")
            if intento < max_intentos - 1:
                time.sleep(2 ** intento)  # Backoff exponencial
            else:
                raise
        
        except Exception as e:
            print(f"Error inesperado: {e}")
            raise

# Uso con manejo de errores
try:
    imagen_segura = generar_con_reintentos(
        "Una biblioteca futurista con hologramas flotantes"
    )
    print("Imagen generada exitosamente")
except Exception as e:
    print(f"Falló la generación después de todos los intentos: {e}")

Integración con flujos de trabajo

GPT Image 1 se integra naturalmente en pipelines de procesamiento más complejos:

def pipeline_generacion_completo(concepto, formatos_salida):
    """Pipeline completo de generación con múltiples formatos"""
    resultados = {}
    
    # Configuraciones para diferentes formatos
    configs = {
        "web": {"size": "1024x1024", "quality": "medium"},
        "print": {"size": "1536x1024", "quality": "high"},
        "thumbnail": {"size": "1024x1024", "quality": "low"}
    }
    
    for formato in formatos_salida:
        if formato in configs:
            try:
                imagen_b64 = generar_imagen_personalizada(
                    concepto, 
                    configs[formato]
                )
                
                nombre_archivo = f"{concepto[:20]}_{formato}.png"
                with open(nombre_archivo, "wb") as f:
                    f.write(base64.b64decode(imagen_b64))
                
                resultados[formato] = nombre_archivo
                
            except Exception as e:
                print(f"Error generando formato {formato}: {e}")
                resultados[formato] = None
    
    return resultados

# Generar múltiples formatos de una vez
concepto = "Diseño de interfaz móvil minimalista"
formatos = ["web", "print", "thumbnail"]
archivos_generados = pipeline_generacion_completo(concepto, formatos)

for formato, archivo in archivos_generados.items():
    if archivo:
        print(f"✓ {formato}: {archivo}")
    else:
        print(f"✗ {formato}: Error en generación")