diffusers/controlnet-depth-sdxl-1.0-mid

diffusers

Texto a imagen

ControlNet de profundidad para Stable Diffusion XL 1.0, entrenado con condicionamiento por mapas de profundidad sobre la base `stabilityai/stable-diffusion-xl-base-1.0`. El checkpoint es experimental, usa una arquitectura ControlNet más pequeña inicializada desde el UNet de SDXL y es unas 5 veces más ligero que el checkpoint XL ControlNet original. Está pensado para generación texto-a-imagen guiada por estructura espacial o profundidad de una imagen de entrada.

Como usar

Instalación básica con Diffusers:
pip install -U diffusers transformers accelerate

Carga mínima del ControlNet con SDXL:
from diffusers import ControlNetModel, StableDiffusionControlNetPipeline

controlnet = ControlNetModel.from_pretrained("diffusers/controlnet-depth-sdxl-1.0-mid")
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet=controlnet
)

Ejemplo completo con estimación de profundidad y generación:
pip install accelerate transformers safetensors diffusers

import torch
import numpy as np
from PIL import Image
from transformers import DPTFeatureExtractor, DPTForDepthEstimation
from diffusers import ControlNetModel, StableDiffusionXLControlNetPipeline, AutoencoderKL
from diffusers.utils import load_image

depth_estimator = DPTForDepthEstimation.from_pretrained("Intel/dpt-hybrid-midas").to("cuda")
feature_extractor = DPTFeatureExtractor.from_pretrained("Intel/dpt-hybrid-midas")

controlnet = ControlNetModel.from_pretrained(
    "diffusers/controlnet-depth-sdxl-1.0-mid",
    variant="fp16",
    use_safetensors=True,
    torch_dtype=torch.float16,
).to("cuda")

vae = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16).to("cuda")

pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet=controlnet,
    vae=vae,
    variant="fp16",
    use_safetensors=True,
    torch_dtype=torch.float16,
).to("cuda")
pipe.enable_model_cpu_offload()

def get_depth_map(image):
    image = feature_extractor(images=image, return_tensors="pt").pixel_values.to("cuda")
    with torch.no_grad(), torch.autocast("cuda"):
        depth_map = depth_estimator(image).predicted_depth

    depth_map = torch.nn.functional.interpolate(
        depth_map.unsqueeze(1),
        size=(1024, 1024),
        mode="bicubic",
        align_corners=False,
    )
    depth_min = torch.amin(depth_map, dim=[1, 2, 3], keepdim=True)
    depth_max = torch.amax(depth_map, dim=[1, 2, 3], keepdim=True)
    depth_map = (depth_map - depth_min) / (depth_max - depth_min)
    image = torch.cat([depth_map] * 3, dim=1)
    image = image.permute(0, 2, 3, 1).cpu().numpy()[0]
    image = Image.fromarray((image * 255.0).clip(0, 255).astype(np.uint8))
    return image

prompt = "stormtrooper lecture, photorealistic"
image = load_image("https://huggingface.co/lllyasviel/sd-controlnet-depth/resolve/main/images/stormtrooper.png")
controlnet_conditioning_scale = 0.5

depth_image = get_depth_map(image)
images = pipe(
    prompt,
    image=depth_image,
    num_inference_steps=30,
    controlnet_conditioning_scale=controlnet_conditioning_scale,
).images

images[0].save("stormtrooper_grid.png")

Funcionalidades

Condicionamiento por profundidad para controlar la composición y geometría en generación con SDXL.
Checkpoint más pequeño que el ControlNet XL original, orientado a menor peso de modelo.
Compatible con Diffusers, Safetensors y ejecución en FP16.
Entrenado sin destilación, con un ControlNet más pequeño inicializado desde el UNet de SDXL.
Funciona bien en muchas imágenes de condicionamiento, aunque los checkpoints más grandes pueden rendir mejor en condicionamientos complejos.
Permite ajustar `controlnet_conditioning_scale` y `guidance_scale` para mejorar la calidad o la adherencia al mapa de profundidad.

Casos de uso

Generar imágenes con SDXL manteniendo la estructura de profundidad de una imagen de referencia.
Transformar escenas, personajes u objetos conservando su distribución espacial aproximada.
Crear composiciones fotorealistas guiadas por mapas de profundidad generados con DPT/MiDaS.
Experimentar con ControlNet ligero para SDXL en flujos locales con Diffusers.
Prototipar pipelines texto-a-imagen donde el prompt define el estilo o sujeto y la profundidad define la geometría.