Marigold Vision par ordinateur

Marigold a été proposé dans Repurposing Diffusion-Based Image Generators for Monocular Depth Estimation, un article oral de CVPR 2024 de Bingxin Ke, Anton Obukhov, Shengyu Huang, Nando Metzger, Rodrigo Caye Daudt et Konrad Schindler. L’idée centrale est de réutiliser le prior génératif des modèles de diffusion latente Text-to-Image (LDM) pour des tâches traditionnelles de vision par ordinateur. Cette approche a été explorée en effectuant un fine-tuning de Stable Diffusion pour l'estimation de profondeur monoculaire, comme le montre l’image d’illustration ci-dessus.

Marigold a ensuite été étendu dans l'article de suivi, Marigold: Affordable Adaptation of Diffusion-Based Image Generators for Image Analysis, co-signé par Bingxin Ke, Kevin Qu, Tianfu Wang, Nando Metzger, Shengyu Huang, Bo Li, Anton Obukhov et Konrad Schindler. Ce travail a élargi Marigold pour prendre en charge de nouvelles modalités telles que les Surface Normals et la Intrinsic Image Decomposition (IID), a introduit un protocole d'entraînement pour les Latent Consistency Models (LCM) et a démontré la capacité de traitement en High-Resolution (HR).

Les premiers modèles Marigold (v1-0 et antérieurs) étaient optimisés pour obtenir les meilleurs résultats avec au moins 10 étapes d’inférence. Les modèles LCM ont été développés par la suite pour permettre une inférence de haute qualité en seulement 1 à 4 étapes. Les modèles Marigold v1-1 et ultérieurs utilisent le planificateur DDIM pour obtenir des résultats optimaux en aussi peu que 1 à 4 étapes.

Pipelines disponibles

Chaque pipeline est conçu pour une tâche de vision par ordinateur spécifique, traitant une image RGB en entrée et générant une prédiction correspondante. Actuellement, les tâches de vision par ordinateur suivantes sont implémentées :

Points de contrôle disponibles

Tous les points de contrôle originaux sont disponibles sous l’organisation PRS-ETH sur Hugging Face. Ils sont conçus pour être utilisés avec les pipelines diffusers et le code source original, qui peut également servir à entraîner de nouveaux points de contrôle de modèles. Voici un résumé des points de contrôle recommandés, qui produisent tous des résultats fiables en 1 à 4 étapes.

Pensez à consulter le guide sur les Schedulers pour apprendre à explorer le compromis entre la vitesse et la qualité du scheduler, et à consulter la section réutilisation des composants entre les pipelines pour apprendre à charger efficacement les mêmes composants dans plusieurs pipelines. En outre, pour en savoir plus sur la réduction de l'utilisation de la mémoire de ce pipeline, reportez-vous à la section [“Reduce memory usage”] ici.

Les pipelines Marigold ont été conçus et testés avec le planificateur intégré au point de contrôle du modèle. Le nombre optimal d'étapes d'inférence varie selon le planificateur, sans valeur universelle qui soit la meilleure dans tous les cas. Pour s'adapter à cela, le paramètre num_inference_steps de la méthode __call__ du pipeline a par défaut la valeur None (voir la référence de l'API). Sauf s'il est défini explicitement, il hérite de la valeur du champ default_denoising_steps du fichier de configuration du point de contrôle (model_index.json). Cela garantit des prédictions de haute qualité lors de l'appel du pipeline avec uniquement l'argument image.

Les exemples ci-dessous sont principalement donnés pour la prédiction de profondeur, mais ils peuvent être appliqués de manière universelle à d'autres modalités prises en charge. Nous présentons les prédictions en utilisant la même image d'Albert Einstein générée par Midjourney. Cela facilite la comparaison des visualisations des prédictions entre les différentes modalités et points de contrôle.

Prédiction de la profondeur

Pour obtenir une prédiction de profondeur, chargez le point de contrôle prs-eth/marigold-depth-v1-1 dans MarigoldDepthPipeline, faites passer l’image dans le pipeline, puis enregistrez les prédictions :

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 fonction visualize_depth() applique l’une des cartes de couleurs de matplotlib (Spectral par défaut) pour mapper les valeurs de pixels prédites, issues d’une plage de profondeur monocanal [0, 1], vers une image RGB. Avec la carte de couleurs Spectral, les pixels proches sont peints en rouge et les pixels éloignés en bleu. Le fichier PNG 16 bits stocke les valeurs du canal unique, mappées linéairement de la plage [0, 1] vers [0, 65535]. Ci-dessous figurent les prédictions brutes et visualisées. Les zones plus sombres et plus proches (la moustache) sont plus faciles à distinguer dans la visualisation.

Estimation des normales de surface

Chargez le point de contrôle prs-eth/marigold-normals-v1-1 dans MarigoldNormalsPipeline, passez l’image dans le pipeline et enregistrez les prédictions :

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 fonction visualize_normals() convertit la prédiction tridimensionnelle, dont les valeurs de pixels sont comprises dans l'intervalle [-1, 1], en une image RGB. La fonction de visualisation permet d'inverser les axes des normales de surface afin de rendre la visualisation compatible avec d'autres choix de repère. Conceptuellement, chaque pixel est coloré en fonction du vecteur normale de surface dans le repère, où l'axe X pointe vers la droite, l'axe Y pointe vers le haut et l'axe Z pointe vers l'observateur. Voici la prédiction visualisée :

Dans cet exemple, la pointe du nez a presque certainement un point sur la surface, dont le vecteur normal pointe directement vers l’observateur, ce qui signifie que ses coordonnées sont [0, 0, 1]. Ce vecteur correspond à la valeur RGB [128, 128, 255], qui correspond à la couleur bleu-violet. De même, une normale de surface sur la joue dans la partie droite de l’image a une grande composante X, ce qui augmente la teinte rouge. Les points sur les épaules pointant vers le haut avec une grande Y favorisent la couleur verte.

Décomposition d'image intrinsèque

Marigold fournit deux modèles pour la décomposition d'image intrinsèque (IID) : « Appearance » et « Lighting ». Chaque modèle produit des cartes d'albédo, dérivées respectivement des annotations d'InteriorVerse et de Hypersim.

• Le modèle « Appearance » estime également les propriétés de matériau : Roughness et Metallicity.
• Le modèle « Lighting » génère l'ombrage diffus et le résidu non diffus.

Voici le code d’exemple qui enregistre les prédictions effectuées par le modèle « 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")

Un autre exemple illustrant les prédictions effectuées par le modèle « 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")

Les deux modèles partagent le même pipeline tout en prenant en charge différents types de décomposition. La paramétrisation exacte de la décomposition (par exemple, espace sRGB vs. espace linéaire) est stockée dans le dictionnaire pipe.target_properties, qui est transmis à la fonction visualize_intrinsics().

Voici quelques exemples illustrant les sorties de décomposition prédites. Toutes les modalités peuvent être examinées dans l’espace Intrinsic Image Decomposition.

Accélérer l'inférence

Les extraits de démarrage rapide ci-dessus sont déjà optimisés pour la qualité et la vitesse : ils chargent le point de contrôle, utilisent la variante fp16 des poids et des calculs, et effectuent le nombre par défaut (4) d'étapes de débruitage par diffusion. La première étape pour accélérer l'inférence, au détriment de la qualité de la prédiction, consiste à réduire les étapes de débruitage par diffusion au minimum :

  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)

Avec ce changement, l’appel pipe s’achève en 280 ms sur un GPU RTX 3090. En interne, l’image d’entrée est d’abord encodée à l’aide de l’encodeur VAE de Stable Diffusion, puis une seule étape de débruitage est effectuée par le U-Net. Enfin, le latent de prédiction est décodé par le décodeur VAE dans l’espace des pixels. Dans cette configuration, deux des trois appels de modules sont consacrés à la conversion entre les espaces pixel et latent du LDM. Puisque l’espace latent de Marigold est compatible avec Stable Diffusion 2.0, l’inférence peut être accélérée de plus de 3x, réduisant le temps d’appel à 85 ms sur un RTX 3090, en utilisant un remplacement léger du VAE SD. Notez que l’utilisation d’un VAE léger peut légèrement réduire la qualité visuelle des prédictions.

  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)

Jusqu'à présent, nous avons optimisé le nombre d'étapes de diffusion et les composants du modèle. Les opérations d'auto-attention représentent une part importante des calculs. Les accélérer peut se faire en utilisant un processeur d'attention plus efficace :

  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)

Enfin, comme suggéré dans Optimizations, l’activation de torch.compile peut améliorer encore les performances, selon le matériel cible. Cependant, la compilation entraîne un surcoût important lors de la première invocation du pipeline, ce qui n’est avantageux que lorsque la même instance de pipeline est appelée de manière répétée, par exemple dans une boucle.

  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)

Maximiser la précision et le regroupement

Les pipelines Marigold disposent d'un mécanisme d'ensembling intégré qui combine plusieurs prédictions issues de différents latents aléatoires. Il s'agit d'une méthode par la force brute pour améliorer la précision des prédictions, en tirant parti de la nature générative de la diffusion. Le chemin d'ensembling est activé automatiquement lorsque l'argument ensemble_size est défini à une valeur supérieure ou égale à 3. Lorsque l'on vise une précision maximale, il est judicieux d'ajuster num_inference_steps simultanément à ensemble_size. Les valeurs recommandées varient selon les points de contrôle, mais dépendent principalement du type de planificateur. L'effet de l'ensembling est particulièrement bien visible avec les normales de surface :

  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")

Comme on peut le constater, toutes les zones présentant des structures fines, comme les cheveux, ont obtenu des prédictions plus conservatrices et, en moyenne, plus correctes. Un tel résultat est plus adapté aux tâches en aval sensibles à la précision, telles que la reconstruction 3D.

Traitement vidéo image par image avec cohérence temporelle

En raison de la nature générative de Marigold, chaque prédiction est unique et définie par le bruit aléatoire échantillonné pour l’initialisation latente. Cela constitue un inconvénient évident par rapport aux réseaux de régression dense de bout en bout traditionnels, comme l’illustrent les vidéos suivantes :

Pour résoudre ce problème, il est possible de passer l'argument latents aux pipelines, ce qui définit le point de départ de la diffusion. Empiriquement, nous avons constaté qu'une combinaison convexe du bruit latent correspondant au point de départ et du latent correspondant à la prédiction de la frame précédente donne des résultats suffisamment lisses, comme implémenté dans l'extrait de code ci-dessous :

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'])

Ici, le processus de diffusion démarre à partir du latent calculé fourni. Le pipeline définit output_latent=True pour accéder à out.latent et calcule sa contribution à l’initialisation du latent de la frame suivante. Le résultat est désormais beaucoup plus stable :

Marigold pour ControlNet

Une application très courante de la prédiction de profondeur avec des modèles de diffusion est son utilisation conjointe avec ControlNet. La netteté de la profondeur joue un rôle crucial pour obtenir des résultats de haute qualité avec ControlNet. Comme le montrent les comparaisons avec d'autres méthodes ci-dessus, Marigold excelle dans cette tâche. L'extrait de code ci-dessous montre comment charger une image, calculer la profondeur et la transmettre à ControlNet dans un format 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")

Évaluation quantitative

Pour évaluer Marigold de manière quantitative sur des classements et des jeux de données de référence standard (tels que NYU, KITTI et d'autres), suivez le protocole d'évaluation décrit dans l'article : chargez le modèle en précision complète fp32 et utilisez des valeurs appropriées pour num_inference_steps et ensemble_size. Faites éventuellement un tirage aléatoire (seed) pour garantir la reproductibilité. Maximiser batch_size permettra d'obtenir une utilisation maximale de l'appareil.

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

Utilisation de l'incertitude prédictive

Le mécanisme d'ensembling intégré aux pipelines Marigold combine plusieurs prédictions obtenues à partir de différents latents aléatoires. En conséquence, il peut être utilisé pour quantifier l'incertitude épistémique (du modèle) ; il suffit de spécifier ensemble_size supérieur ou égal à 3 et de définir output_uncertainty=True. L'incertitude résultante sera disponible dans le champ uncertainty de la sortie. Elle peut être visualisée comme suit :

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")

L'interprétation de l'incertitude est simple : les valeurs élevées (blanc) correspondent aux pixels pour lesquels le modèle a du mal à produire des prédictions cohérentes.

• Le modèle de profondeur présente l'incertitude la plus élevée autour des discontinuités, là où la profondeur des objets change brusquement.
• Le modèle de normales de surface est le moins fiable pour les structures fines comme les cheveux et pour les zones sombres telles que le col.
• L'incertitude de l'albédo est représentée sous forme d'image RVB, car elle capture l'incertitude de manière indépendante pour chaque canal de couleur, contrairement à la profondeur et aux normales de surface. Elle est également plus élevée dans les zones ombragées et aux discontinuités.

API de prédiction de profondeur 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 d'estimation des normales 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 décomposition d'image intrinsèque 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")