DALLE2

Generar imágenes con DALL-E 2

DALL-E 2 es un modelo especializado de OpenAI para la generación de imágenes que, aunque considerado legacy en comparación con los modelos más recientes como GPT Image, sigue siendo una opción viable para proyectos que requieren un coste reducido y la capacidad de realizar múltiples solicitudes concurrentes.

Este modelo destaca por su capacidad para generar variaciones de imágenes existentes y realizar ediciones mediante máscaras (inpainting), funcionalidades que no están disponibles en todos los modelos más modernos. Su identificador en la API es dall-e-2.

Configuración básica

Para trabajar con DALL-E 2, utilizamos la Image API de OpenAI, que proporciona tres endpoints principales: generaciones, ediciones y variaciones. El SDK de Python detecta automáticamente la clave API desde las variables de entorno:

from openai import OpenAI
import base64

client = OpenAI()

Generación de imágenes desde cero

La funcionalidad más básica de DALL-E 2 es generar imágenes completamente nuevas a partir de descripciones textuales. El modelo interpreta el prompt y crea una imagen que coincida con la descripción proporcionada:

# Generar una imagen con DALL-E 2
result = client.images.generate(
    model="dall-e-2",
    prompt="Un gato atigrado gris abrazando a una nutria con una bufanda naranja",
    size="1024x1024",
    quality="standard",
    n=1
)

# Obtener la imagen en formato 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)

El parámetro n permite generar múltiples imágenes en una sola solicitud, lo que resulta útil cuando necesitas varias opciones para elegir:

# Generar 3 variantes de la misma imagen
result = client.images.generate(
    model="dall-e-2",
    prompt="Un paisaje futurista con edificios flotantes y vehículos voladores",
    size="512x512",
    n=3
)

# Guardar cada imagen generada
for i, image_data in enumerate(result.data):
    image_base64 = image_data.b64_json
    image_bytes = base64.b64decode(image_base64)
    
    with open(f"paisaje_futurista_{i+1}.png", "wb") as f:
        f.write(image_bytes)

Tamaños disponibles

DALL-E 2 soporta tres tamaños específicos de imagen, cada uno optimizado para diferentes casos de uso:

• 256x256: Ideal para prototipos rápidos y pruebas de concepto
• 512x512: Equilibrio entre calidad y velocidad de generación
• 1024x1024: Máxima resolución disponible para resultados detallados

# Ejemplo con diferentes tamaños
tamaños = ["256x256", "512x512", "1024x1024"]

for tamaño in tamaños:
    result = client.images.generate(
        model="dall-e-2",
        prompt="Un robot jardinero cuidando plantas en un invernadero",
        size=tamaño
    )
    
    image_base64 = result.data[0].b64_json
    image_bytes = base64.b64decode(image_base64)
    
    with open(f"robot_jardinero_{tamaño}.png", "wb") as f:
        f.write(image_bytes)

Generación de variaciones

Una característica exclusiva de DALL-E 2 es su capacidad para crear variaciones de una imagen existente. Esta funcionalidad toma una imagen como entrada y genera nuevas versiones manteniendo elementos similares pero con variaciones creativas:

# Generar variaciones de una imagen existente
with open("imagen_original.png", "rb") as image_file:
    result = client.images.create_variation(
        model="dall-e-2",
        image=image_file,
        n=2,
        size="1024x1024"
    )

# Guardar las variaciones
for i, variation in enumerate(result.data):
    image_base64 = variation.b64_json
    image_bytes = base64.b64decode(image_base64)
    
    with open(f"variacion_{i+1}.png", "wb") as f:
        f.write(image_bytes)

Edición con máscaras (Inpainting)

DALL-E 2 permite editar partes específicas de una imagen utilizando una máscara que indica qué áreas deben ser modificadas. La máscara debe ser una imagen PNG con canal alfa, donde las áreas transparentes indican las zonas a editar:

# Editar una imagen usando una máscara
with open("imagen_base.png", "rb") as image_file, \
     open("mascara.png", "rb") as mask_file:
    
    result = client.images.edit(
        model="dall-e-2",
        image=image_file,
        mask=mask_file,
        prompt="Un flamingo rosado nadando en el agua",
        size="1024x1024"
    )

# Guardar la imagen editada
image_base64 = result.data[0].b64_json
image_bytes = base64.b64decode(image_base64)

with open("imagen_editada.png", "wb") as f:
    f.write(image_bytes)

Optimización de prompts

Para obtener mejores resultados con DALL-E 2, es importante estructurar los prompts de manera clara y específica. El modelo responde mejor a descripciones detalladas que incluyan estilo, composición y elementos específicos:

# Prompt básico
prompt_basico = "Un perro"

# Prompt optimizado
prompt_optimizado = """
Un golden retriever adulto corriendo por una playa al atardecer,
con olas suaves en el fondo y arena dorada,
estilo fotográfico realista con iluminación cálida
"""

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

Manejo de errores y limitaciones

Es importante implementar manejo de errores adecuado, especialmente considerando las limitaciones de contenido y las posibles fallas de red:

try:
    result = client.images.generate(
        model="dall-e-2",
        prompt="Un paisaje sereno con montañas y un lago cristalino",
        size="1024x1024"
    )
    
    if result.data:
        image_base64 = result.data[0].b64_json
        image_bytes = base64.b64decode(image_base64)
        
        with open("paisaje_sereno.png", "wb") as f:
            f.write(image_bytes)
        
        print("Imagen generada exitosamente")
    
except Exception as e:
    print(f"Error al generar la imagen: {e}")

Consideraciones de coste

DALL-E 2 utiliza un modelo de precios basado en el número de imágenes generadas y su resolución. Las imágenes de mayor tamaño tienen un coste superior, por lo que es recomendable usar el tamaño mínimo necesario para tu aplicación:

# Función para generar imágenes con control de coste
def generar_imagen_economica(prompt, usar_alta_resolucion=False):
    tamaño = "1024x1024" if usar_alta_resolucion else "512x512"
    
    result = client.images.generate(
        model="dall-e-2",
        prompt=prompt,
        size=tamaño,
        n=1  # Generar solo una imagen para minimizar costes
    )
    
    return result.data[0].b64_json

# Uso de la función
imagen_economica = generar_imagen_economica(
    "Un café humeante en una mesa de madera",
    usar_alta_resolucion=False
)