Marigold Computer Vision

Marigold se propuso en Repurposing Diffusion-Based Image Generators for Monocular Depth Estimation, un artículo Oral de CVPR 2024 de Bingxin Ke, Anton Obukhov, Shengyu Huang, Nando Metzger, Rodrigo Caye Daudt y Konrad Schindler. La idea central es reutilizar el prior generativo de los Modelos de Difusión Latente de Texto a Imagen (LDM) para tareas tradicionales de visión por computadora. Este enfoque se exploró mediante el ajuste fino de Stable Diffusion para Monocular Depth Estimation, como se muestra en la imagen de arriba.

Marigold se amplió posteriormente en el artículo de seguimiento, Marigold: Affordable Adaptation of Diffusion-Based Image Generators for Image Analysis, autoría de Bingxin Ke, Kevin Qu, Tianfu Wang, Nando Metzger, Shengyu Huang, Bo Li, Anton Obukhov y Konrad Schindler. Este trabajo expandió Marigold para soportar nuevas modalidades como Surface Normals y Intrinsic Image Decomposition (IID), introdujo un protocolo de entrenamiento para Latent Consistency Models (LCM) y demostró la capacidad de procesamiento en High-Resolution (HR).

Los modelos de Marigold iniciales (v1-0 y anteriores) estaban optimizados para obtener los mejores resultados con al menos 10 pasos de inferencia. Los modelos LCM se desarrollaron posteriormente para permitir una inferencia de alta calidad en solo 1 a 4 pasos. Los modelos de Marigold v1-1 y posteriores utilizan el programador DDIM para lograr resultados óptimos en tan solo 1 a 4 pasos.

Pipelines disponibles

Cada pipeline está diseñado para una tarea específica de visión por computadora, procesa una imagen RGB de entrada y genera una predicción correspondiente. Actualmente, se han implementado las siguientes tareas de visión por computadora:

Puntos de control disponibles

Todos los puntos de control originales están disponibles bajo la organización PRS-ETH en Hugging Face. Están diseñados para su uso con pipelines de diffusers y el original codebase, que también puede utilizarse para entrenar nuevos puntos de control de modelos. A continuación se presenta un resumen de los puntos de control recomendados, todos los cuales producen resultados fiables con 1 a 4 pasos.

Asegúrate de consultar la guía de Schedulers para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección reuse components across pipelines para aprender a cargar de forma eficiente los mismos componentes en varios pipelines. Además, para saber más sobre cómo reducir el uso de memoria de este pipeline, consulta la sección [“Reduce memory usage”] aquí.

Los pipelines de Marigold se diseñaron y probaron con el scheduler integrado en el checkpoint del modelo. El número óptimo de pasos de inferencia varía según el scheduler, y no existe un valor universal que funcione mejor en todos los casos. Para adaptarse a esto, el parámetro num_inference_steps en el método __call__ del pipeline tiene un valor predeterminado de None (consulte la referencia de la API). A menos que se establezca explícitamente, hereda el valor del campo default_denoising_steps en el archivo de configuración del checkpoint (model_index.json). Esto garantiza predicciones de alta calidad al invocar el pipeline solo con el argumento image.

Los ejemplos a continuación se presentan principalmente para la predicción de profundidad, pero pueden aplicarse universalmente a otras modalidades admitidas. Mostramos las predicciones utilizando la misma imagen de entrada de Albert Einstein generada por Midjourney. Esto facilita la comparación de las visualizaciones de las predicciones entre las distintas modalidades y puntos de control.

Predicción de profundidad

Para obtener una predicción de profundidad, carga el punto de control prs-eth/marigold-depth-v1-1 en MarigoldDepthPipeline, pasa la imagen por el pipeline y guarda las predicciones:

import diffusers
import torch

pipe = diffusers.MarigoldDepthPipeline.from_pretrained(
    "prs-eth/marigold-depth-v1-1", variant="fp16", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"

image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")

depth = pipe(image)

vis = pipe.image_processor.visualize_depth(depth.prediction)
vis[0].save("einstein_depth.png")

depth_16bit = pipe.image_processor.export_depth_to_16bit_png(depth.prediction)
depth_16bit[0].save("einstein_depth_16bit.png")

La función visualize_depth() aplica uno de los colormaps de matplotlib (Spectral por defecto) para mapear los valores de píxel predichos de un rango de profundidad de un solo canal [0, 1] a una imagen RGB. Con el colormap Spectral, los píxeles con profundidad cercana se pintan de rojo y los píxeles lejanos, de azul. El archivo PNG de 16 bits almacena los valores de un solo canal mapeados linealmente desde el rango [0, 1] hasta [0, 65535]. A continuación se muestran las predicciones en bruto y las visualizadas. Las áreas más oscuras y cercanas (bigote) son más fáciles de distinguir en la visualización.

Estimación de normales de superficie

Carga el punto de control prs-eth/marigold-normals-v1-1 en MarigoldNormalsPipeline, procesa la imagen a través de la tubería y guarda las predicciones:

import diffusers
import torch

pipe = diffusers.MarigoldNormalsPipeline.from_pretrained(
    "prs-eth/marigold-normals-v1-1", variant="fp16", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"

image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")

normals = pipe(image)

vis = pipe.image_processor.visualize_normals(normals.prediction)
vis[0].save("einstein_normals.png")

La función visualize_normals() mapea la predicción tridimensional, con valores de píxeles en el rango [-1, 1], a una imagen RGB. La función de visualización admite la inversión de los ejes de las normales de la superficie para hacer que la visualización sea compatible con otras elecciones del sistema de referencia. Conceptualmente, cada píxel se pinta según el vector de la normal de la superficie en el sistema de referencia, donde el eje X apunta a la derecha, el eje Y apunta hacia arriba y el eje Z apunta hacia el espectador. A continuación se muestra la predicción visualizada:

En este ejemplo, la punta de la nariz casi con seguridad tiene un punto en la superficie en el que el vector normal de la superficie apunta directamente hacia el espectador, lo que significa que sus coordenadas son [0, 0, 1]. Este vector se mapea al RGB [128, 128, 255], que corresponde al color violeta-azulado. De manera similar, una normal de superficie en la mejilla de la parte derecha de la imagen tiene un componente X grande, lo que aumenta el tono rojo. Los puntos en los hombros que apuntan hacia arriba con un Y grande promueven el color verde.

Descomposición de imagen intrínseca

Marigold ofrece dos modelos para la Descomposición de Imágenes Intrínsecas (IID): “Appearance” y “Lighting”. Cada modelo produce mapas de Albedo, derivados de las anotaciones de InteriorVerse y Hypersim, respectivamente.

• El modelo “Appearance” también estima las propiedades de Material: Roughness y Metallicity.
• El modelo “Lighting” genera Diffuse Shading y Non-diffuse Residual.

A continuación se muestra el código de ejemplo que guarda las predicciones realizadas por el modelo “Appearance”:

import diffusers
import torch

pipe = diffusers.MarigoldIntrinsicsPipeline.from_pretrained(
    "prs-eth/marigold-iid-appearance-v1-1", variant="fp16", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"

image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")

intrinsics = pipe(image)

vis = pipe.image_processor.visualize_intrinsics(intrinsics.prediction, pipe.target_properties)
vis[0]["albedo"].save("einstein_albedo.png")
vis[0]["roughness"].save("einstein_roughness.png")
vis[0]["metallicity"].save("einstein_metallicity.png")

Otro ejemplo que muestra las predicciones realizadas por el modelo “Lighting”:

import diffusers
import torch

pipe = diffusers.MarigoldIntrinsicsPipeline.from_pretrained(
    "prs-eth/marigold-iid-lighting-v1-1", variant="fp16", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"

image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")

intrinsics = pipe(image)

vis = pipe.image_processor.visualize_intrinsics(intrinsics.prediction, pipe.target_properties)
vis[0]["albedo"].save("einstein_albedo.png")
vis[0]["shading"].save("einstein_shading.png")
vis[0]["residual"].save("einstein_residual.png")

Ambos modelos comparten el mismo pipeline mientras admiten diferentes tipos de descomposición. La parametrización exacta de la descomposición (p. ej., espacio sRGB vs. espacio lineal) se almacena en el diccionario pipe.target_properties, que se pasa a la función visualize_intrinsics().

A continuación se muestran algunos ejemplos que ilustran las salidas de descomposición predichas. Todas las modalidades pueden inspeccionarse en el Espacio Intrinsic Image Decomposition.

Acelerar la inferencia

Los fragmentos de inicio rápido anteriores ya están optimizados para calidad y velocidad: cargan el punto de control, utilizan la variante fp16 de pesos y cómputo, y ejecutan el número predeterminado (4) de pasos de difusión de desruido. El primer paso para acelerar la inferencia, a costa de la calidad de la predicción, es reducir los pasos de difusión de desruido al mínimo:

  import diffusers
  import torch

  pipe = diffusers.MarigoldDepthPipeline.from_pretrained(
      "prs-eth/marigold-depth-v1-1", variant="fp16", dtype=torch.float16
  ).to("cuda")  # or "mps", "xpu", "cpu"

  image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")
  
- depth = pipe(image)
+ depth = pipe(image, num_inference_steps=1)

Con este cambio, la llamada pipe se completa en 280 ms en una GPU RTX 3090. Internamente, la imagen de entrada se codifica primero con el codificador VAE de Stable Diffusion, seguido de un único paso de desruido realizado por la U-Net. Finalmente, el latente de predicción se decodifica con el decodificador VAE al espacio de píxeles. En esta configuración, dos de las tres llamadas a módulos están dedicadas a convertir entre los espacios de píxeles y latentes del LDM. Dado que el espacio latente de Marigold es compatible con Stable Diffusion 2.0, la inferencia puede acelerarse más de 3 veces, reduciendo el tiempo de llamada a 85 ms en una RTX 3090, mediante el uso de un sustituto ligero del VAE de SD. Tenga en cuenta que el uso de un VAE ligero puede reducir ligeramente la calidad visual de las predicciones.

  import diffusers
  import torch

  pipe = diffusers.MarigoldDepthPipeline.from_pretrained(
      "prs-eth/marigold-depth-v1-1", variant="fp16", dtype=torch.float16
  ).to("cuda")  # or "mps", "xpu", "cpu"

+ pipe.vae = diffusers.AutoencoderTiny.from_pretrained(
+     "madebyollin/taesd", dtype=torch.float16
+ ).cuda()

  image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")

  depth = pipe(image, num_inference_steps=1)

Hasta ahora, hemos optimizado el número de pasos de difusión y los componentes del modelo. Las operaciones de autoatención representan una parte significativa de los cálculos. Pueden acelerarse utilizando un procesador de atención más eficiente:

  import diffusers
  import torch
+ from diffusers.models.attention_processor import AttnProcessor2_0

  pipe = diffusers.MarigoldDepthPipeline.from_pretrained(
      "prs-eth/marigold-depth-v1-1", variant="fp16", dtype=torch.float16
  ).to("cuda")  # or "mps", "xpu", "cpu"

+ pipe.vae.set_attn_processor(AttnProcessor2_0()) 
+ pipe.unet.set_attn_processor(AttnProcessor2_0())

  image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")

  depth = pipe(image, num_inference_steps=1)

Por último, tal como se sugiere en Optimizations, habilitar torch.compile puede mejorar aún más el rendimiento dependiendo del hardware objetivo. Sin embargo, la compilación implica un sobrecoste significativo durante la primera invocación del pipeline, por lo que solo resulta beneficioso cuando la misma instancia del pipeline se llama repetidamente, como dentro de un bucle.

  import diffusers
  import torch
  from diffusers.models.attention_processor import AttnProcessor2_0

  pipe = diffusers.MarigoldDepthPipeline.from_pretrained(
      "prs-eth/marigold-depth-v1-1", variant="fp16", dtype=torch.float16
  ).to("cuda")  # or "mps", "xpu", "cpu"

  pipe.vae.set_attn_processor(AttnProcessor2_0()) 
  pipe.unet.set_attn_processor(AttnProcessor2_0())

+ pipe.vae = torch.compile(pipe.vae, mode="reduce-overhead", fullgraph=True)
+ pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)

  image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")

  depth = pipe(image, num_inference_steps=1)

Maximizar la precisión y el ensembling

Los pipelines de Marigold tienen un mecanismo de ensembling integrado que combina múltiples predicciones a partir de diferentes latentes aleatorios. Esta es una forma de fuerza bruta de mejorar la precisión de las predicciones, aprovechando la naturaleza generativa de la difusión. La ruta de ensembling se activa automáticamente cuando el argumento ensemble_size se establece en un valor mayor o igual que 3. Cuando se busca la máxima precisión, tiene sentido ajustar num_inference_steps simultáneamente con ensemble_size. Los valores recomendados varían entre puntos de control, pero dependen principalmente del tipo de programador. El efecto del ensembling se aprecia especialmente bien con las normales de superficie:

  import diffusers

  pipe = diffusers.MarigoldNormalsPipeline.from_pretrained("prs-eth/marigold-normals-v1-1").to("cuda")  # or "mps", "xpu", "cpu"

  image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")

- depth = pipe(image)
+ depth = pipe(image, num_inference_steps=10, ensemble_size=5)

  vis = pipe.image_processor.visualize_normals(depth.prediction)
  vis[0].save("einstein_normals.png")

Como se puede observar, todas las áreas con estructuras de grano fino, como el cabello, obtuvieron predicciones más conservadoras y, en promedio, más correctas. Tal resultado es más adecuado para tareas posteriores sensibles a la precisión, como la reconstrucción 3D.

Procesamiento de video cuadro a cuadro con consistencia temporal

Debido a la naturaleza generativa de Marigold, cada predicción es única y está definida por el ruido aleatorio muestreado para la inicialización latente. Esto se convierte en un inconveniente evidente en comparación con las redes de regresión densa de extremo a extremo tradicionales, como se ilustra en los siguientes videos:

Para abordar este problema, es posible pasar el argumento latents a los pipelines, lo que define el punto de partida de la difusión. Empíricamente, encontramos que una combinación convexa del mismo ruido latente de punto de partida y el latente correspondiente a la predicción del fotograma anterior produce resultados suficientemente suaves, tal como se implementa en el fragmento de código a continuación:

import imageio
import diffusers
import torch
from diffusers.models.attention_processor import AttnProcessor2_0
from PIL import Image
from tqdm import tqdm

device = "cuda"  # or "mps", "xpu", "cpu"
path_in = "https://huggingface.co/spaces/prs-eth/marigold-lcm/resolve/c7adb5427947d2680944f898cd91d386bf0d4924/files/video/obama.mp4"
path_out = "obama_depth.gif"

pipe = diffusers.MarigoldDepthPipeline.from_pretrained(
    "prs-eth/marigold-depth-v1-1", variant="fp16", dtype=torch.float16
).to(device)
pipe.vae = diffusers.AutoencoderTiny.from_pretrained(
    "madebyollin/taesd", dtype=torch.float16
).to(device)
pipe.unet.set_attn_processor(AttnProcessor2_0())
pipe.vae = torch.compile(pipe.vae, mode="reduce-overhead", fullgraph=True)
pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
pipe.set_progress_bar_config(disable=True)

with imageio.get_reader(path_in) as reader:
    size = reader.get_meta_data()['size']
    last_frame_latent = None
    latent_common = torch.randn(
        (1, 4, 768 * size[1] // (8 * max(size)), 768 * size[0] // (8 * max(size)))
    ).to(device=device, dtype=torch.float16)

    out = []
    for frame_id, frame in tqdm(enumerate(reader), desc="Processing Video"):
        frame = Image.fromarray(frame)
        latents = latent_common
        if last_frame_latent is not None:
            latents = 0.9 * latents + 0.1 * last_frame_latent

        depth = pipe(
            frame,
            num_inference_steps=1,
            match_input_resolution=False, 
            latents=latents, 
            output_latent=True,
        )
        last_frame_latent = depth.latent
        out.append(pipe.image_processor.visualize_depth(depth.prediction)[0])

    diffusers.utils.export_to_gif(out, path_out, fps=reader.get_meta_data()['fps'])

Aquí, el proceso de difusión comienza desde el latente calculado dado. La pipeline establece output_latent=True para acceder a out.latent y calcula su contribución a la inicialización del latente del siguiente fotograma. El resultado es mucho más estable ahora:

Marigold para ControlNet

Una aplicación muy común para la predicción de profundidad con modelos de difusión se da en conjunto con ControlNet. La nitidez de la profundidad desempeña un papel crucial para obtener resultados de alta calidad con ControlNet. Como se observa en las comparaciones con otros métodos anteriores, Marigold destaca en esa tarea. El fragmento de código a continuación demuestra cómo cargar una imagen, calcular la profundidad y pasarla a ControlNet en un formato compatible:

import torch
import diffusers

device = "cuda"  # or "mps", "xpu", "cpu"
generator = torch.Generator(device=device).manual_seed(2024)
image = diffusers.utils.load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/controlnet_depth_source.png"
)

pipe = diffusers.MarigoldDepthPipeline.from_pretrained(
    "prs-eth/marigold-depth-v1-1", dtype=torch.float16, variant="fp16"
).to(device)

depth_image = pipe(image, generator=generator).prediction
depth_image = pipe.image_processor.visualize_depth(depth_image, color_map="binary")
depth_image[0].save("motorcycle_controlnet_depth.png")

controlnet = diffusers.ControlNetModel.from_pretrained(
    "diffusers/controlnet-depth-sdxl-1.0", dtype=torch.float16, variant="fp16"
).to(device)
pipe = diffusers.StableDiffusionXLControlNetPipeline.from_pretrained(
    "SG161222/RealVisXL_V4.0", dtype=torch.float16, variant="fp16", controlnet=controlnet
).to(device)
pipe.scheduler = diffusers.DPMSolverMultistepScheduler.from_config(pipe.scheduler.config, use_karras_sigmas=True)

controlnet_out = pipe(
    prompt="high quality photo of a sports bike, city",
    negative_prompt="",
    guidance_scale=6.5,
    num_inference_steps=25,
    image=depth_image,
    controlnet_conditioning_scale=0.7,
    control_guidance_end=0.7,
    generator=generator,
).images
controlnet_out[0].save("motorcycle_controlnet_out.png")

Evaluación cuantitativa

Para evaluar Marigold de forma cuantitativa en tablas de clasificación y conjuntos de datos estándar (como NYU, KITTI y otros), siga el protocolo de evaluación descrito en el artículo: cargue el modelo de precisión completa fp32 y use los valores adecuados para num_inference_steps y ensemble_size. Opcionalmente, fije la semilla de aleatoriedad para garantizar la reproducibilidad. Maximizar batch_size proporcionará la máxima utilización del dispositivo.

import diffusers
import torch

device = "cuda"  # or "mps", "xpu", "cpu"
seed = 2024

generator = torch.Generator(device=device).manual_seed(seed)
pipe = diffusers.MarigoldDepthPipeline.from_pretrained("prs-eth/marigold-depth-v1-1").to(device)

image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")

depth = pipe(
    image, 
    num_inference_steps=4,  # set according to the evaluation protocol from the paper
    ensemble_size=10,       # set according to the evaluation protocol from the paper
    generator=generator,
)

# evaluate metrics

Uso de la incertidumbre predictiva

El mecanismo de ensembling integrado en las pipelines de Marigold combina múltiples predicciones obtenidas a partir de diferentes latentes aleatorios. Como efecto secundario, puede utilizarse para cuantificar la incertidumbre epistémica (del modelo); basta con especificar ensemble_size mayor o igual que 3 y establecer output_uncertainty=True. La incertidumbre resultante estará disponible en el campo uncertainty de la salida. Puede visualizarse de la siguiente manera:

import diffusers
import torch

pipe = diffusers.MarigoldDepthPipeline.from_pretrained(
    "prs-eth/marigold-depth-v1-1", variant="fp16", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"

image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")

depth = pipe(
	image,
	ensemble_size=10,  # any number >= 3
	output_uncertainty=True,
)

uncertainty = pipe.image_processor.visualize_uncertainty(depth.uncertainty)
uncertainty[0].save("einstein_depth_uncertainty.png")

La interpretación de la incertidumbre es sencilla: los valores más altos (blanco) corresponden a píxeles donde el modelo tiene dificultades para hacer predicciones consistentes.

• El modelo de profundidad presenta la mayor incertidumbre en las discontinuidades, donde la profundidad de los objetos cambia de forma abrupta.
• El modelo de normales de superficie tiene menos confianza en estructuras de gran detalle, como el cabello, y en regiones oscuras, como el área del cuello.
• La incertidumbre del albedo se representa como una imagen RGB, ya que captura la incertidumbre de forma independiente para cada canal de color, a diferencia de la profundidad y las normales de superficie. También es mayor en las regiones sombreadas y en las discontinuidades.

API de predicción de profundidad de Marigold

>>> import diffusers
>>> import torch

>>> pipe = diffusers.MarigoldDepthPipeline.from_pretrained(
...     "prs-eth/marigold-depth-v1-1", variant="fp16", torch_dtype=torch.float16
... ).to("cuda")

>>> image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")
>>> depth = pipe(image)

>>> vis = pipe.image_processor.visualize_depth(depth.prediction)
>>> vis[0].save("einstein_depth.png")

>>> depth_16bit = pipe.image_processor.export_depth_to_16bit_png(depth.prediction)
>>> depth_16bit[0].save("einstein_depth_16bit.png")

API de estimación de normales de Marigold

>>> import diffusers
>>> import torch

>>> pipe = diffusers.MarigoldNormalsPipeline.from_pretrained(
...     "prs-eth/marigold-normals-v1-1", variant="fp16", torch_dtype=torch.float16
... ).to("cuda")

>>> image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")
>>> normals = pipe(image)

>>> vis = pipe.image_processor.visualize_normals(normals.prediction)
>>> vis[0].save("einstein_normals.png")

API de descomposición de imagen intrínseca de Marigold

>>> import diffusers
>>> import torch

>>> pipe = diffusers.MarigoldIntrinsicsPipeline.from_pretrained(
...     "prs-eth/marigold-iid-appearance-v1-1", variant="fp16", torch_dtype=torch.float16
... ).to("cuda")

>>> image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")
>>> intrinsics = pipe(image)

>>> vis = pipe.image_processor.visualize_intrinsics(intrinsics.prediction, pipe.target_properties)
>>> vis[0]["albedo"].save("einstein_albedo.png")
>>> vis[0]["roughness"].save("einstein_roughness.png")
>>> vis[0]["metallicity"].save("einstein_metallicity.png")

>>> import diffusers
>>> import torch

>>> pipe = diffusers.MarigoldIntrinsicsPipeline.from_pretrained(
...     "prs-eth/marigold-iid-lighting-v1-1", variant="fp16", torch_dtype=torch.float16
... ).to("cuda")

>>> image = diffusers.utils.load_image("https://marigoldmonodepth.github.io/images/einstein.jpg")
>>> intrinsics = pipe(image)

>>> vis = pipe.image_processor.visualize_intrinsics(intrinsics.prediction, pipe.target_properties)
>>> vis[0]["albedo"].save("einstein_albedo.png")
>>> vis[0]["shading"].save("einstein_shading.png")
>>> vis[0]["residual"].save("einstein_residual.png")