DALLE3

Generar imágenes con DALL-E 3

DALL-E 3 es el modelo de generación de imágenes de OpenAI que permite crear imágenes de alta calidad a partir de descripciones textuales. A diferencia de versiones anteriores, DALL-E 3 ofrece una mejor comprensión del contexto y genera imágenes más precisas y detalladas según las instrucciones proporcionadas.

Configuración inicial

Para trabajar con DALL-E 3, necesitamos instalar el SDK de OpenAI y configurar nuestro entorno. El SDK detecta automáticamente la clave API desde las variables de entorno:

from openai import OpenAI
import base64

# El cliente se inicializa automáticamente con la API key del entorno
client = OpenAI()

Generación básica de imágenes

La forma más directa de generar imágenes con DALL-E 3 es utilizando la Image API. Esta API está diseñada para casos donde necesitamos generar una sola imagen a partir de un prompt:

from openai import OpenAI
import base64

client = OpenAI()

# Definir el prompt descriptivo
prompt = """
Un gato atigrado gris abrazando a una nutria que lleva una bufanda naranja,
estilo ilustración de libro infantil, colores cálidos y suaves
"""

# Generar la imagen
result = client.images.generate(
    model="dall-e-3",
    prompt=prompt,
    size="1024x1024",
    quality="standard",
    n=1
)

# Obtener los datos de la imagen en base64
image_base64 = result.data[0].b64_json
image_bytes = base64.b64decode(image_base64)

# Guardar la imagen
with open("gato_nutria.png", "wb") as f:
    f.write(image_bytes)

Ejemplo:

Parámetros de configuración

DALL-E 3 ofrece varios parámetros de personalización que nos permiten controlar la calidad y características de las imágenes generadas:

Tamaños disponibles:

# Imagen cuadrada (por defecto)
result = client.images.generate(
    model="dall-e-3",
    prompt="Un paisaje montañoso al atardecer",
    size="1024x1024"
)

# Imagen horizontal
result = client.images.generate(
    model="dall-e-3",
    prompt="Un paisaje montañoso al atardecer",
    size="1792x1024"
)

# Imagen vertical
result = client.images.generate(
    model="dall-e-3",
    prompt="Un rascacielos futurista",
    size="1024x1792"
)

Niveles de calidad:

# Calidad estándar (más rápida y económica)
result = client.images.generate(
    model="dall-e-3",
    prompt="Un robot amigable en un jardín",
    quality="standard"
)

# Alta calidad (más detallada pero más lenta)
result = client.images.generate(
    model="dall-e-3",
    prompt="Un robot amigable en un jardín",
    quality="hd"
)

Optimización de prompts

La calidad del prompt es fundamental para obtener resultados precisos con DALL-E 3. El modelo responde mejor a descripciones detalladas y específicas:

# Prompt básico
prompt_basico = "Un perro"

# Prompt optimizado
prompt_optimizado = """
Un golden retriever adulto sentado en un prado verde,
luz dorada del atardecer, estilo fotografía profesional,
enfoque nítido, fondo ligeramente desenfocado
"""

result = client.images.generate(
    model="dall-e-3",
    prompt=prompt_optimizado,
    size="1024x1024",
    quality="hd"
)

Manejo de respuestas y errores

Es importante implementar un manejo robusto de las respuestas y posibles errores:

from openai import OpenAI
import base64
import os

client = OpenAI()

def generar_imagen(prompt, nombre_archivo="imagen_generada.png"):
    try:
        result = client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size="1024x1024",
            quality="standard"
        )
        
        # Verificar que se generó la imagen
        if result.data and len(result.data) > 0:
            image_data = result.data[0]
            
            # Obtener el prompt revisado por el modelo
            if hasattr(image_data, 'revised_prompt'):
                print(f"Prompt revisado: {image_data.revised_prompt}")
            
            # Guardar la imagen
            image_base64 = image_data.b64_json
            image_bytes = base64.b64decode(image_base64)
            
            with open(nombre_archivo, "wb") as f:
                f.write(image_bytes)
            
            print(f"Imagen guardada como: {nombre_archivo}")
            return True
            
    except Exception as e:
        print(f"Error al generar la imagen: {e}")
        return False

# Uso de la función
exito = generar_imagen(
    "Un café humeante en una mesa de madera, luz matutina suave",
    "cafe_matutino.png"
)

Generación de múltiples variaciones

Aunque DALL-E 3 genera una imagen por solicitud, podemos crear múltiples variaciones ejecutando varias llamadas con ligeras modificaciones en el prompt:

def generar_variaciones(prompt_base, num_variaciones=3):
    variaciones = [
        f"{prompt_base}, estilo realista",
        f"{prompt_base}, estilo artístico",
        f"{prompt_base}, estilo minimalista"
    ]
    
    for i, prompt in enumerate(variaciones):
        try:
            result = client.images.generate(
                model="dall-e-3",
                prompt=prompt,
                size="1024x1024"
            )
            
            image_base64 = result.data[0].b64_json
            image_bytes = base64.b64decode(image_base64)
            
            with open(f"variacion_{i+1}.png", "wb") as f:
                f.write(image_bytes)
                
            print(f"Variación {i+1} generada exitosamente")
            
        except Exception as e:
            print(f"Error en variación {i+1}: {e}")

# Generar variaciones de un concepto
generar_variaciones("Un árbol solitario en una colina")

Consideraciones de rendimiento y costos

DALL-E 3 tiene limitaciones importantes que debemos considerar en nuestras aplicaciones:

import time

def generar_con_reintentos(prompt, max_intentos=3):
    for intento in range(max_intentos):
        try:
            result = client.images.generate(
                model="dall-e-3",
                prompt=prompt,
                size="1024x1024"
            )
            
            return result.data[0].b64_json
            
        except Exception as e:
            print(f"Intento {intento + 1} fallido: {e}")
            if intento < max_intentos - 1:
                # Esperar antes del siguiente intento
                time.sleep(2 ** intento)  # Backoff exponencial
            else:
                raise e

# Uso con manejo de reintentos
try:
    imagen = generar_con_reintentos("Un castillo medieval en las nubes")
    print("Imagen generada exitosamente")
except Exception as e:
    print(f"No se pudo generar la imagen después de varios intentos: {e}")

La velocidad de generación varía según la complejidad del prompt y la calidad solicitada. Las imágenes de alta calidad pueden tardar significativamente más en procesarse, por lo que es recomendable implementar indicadores de progreso en aplicaciones interactivas.