Marigold Bilgisayar Görüşü

Marigold, Bingxin Ke, Anton Obukhov, Shengyu Huang, Nando Metzger, Rodrigo Caye Daudt ve Konrad Schindler tarafından yazılan CVPR 2024 Oral makalesi olan Repurposing Diffusion-Based Image Generators for Monocular Depth Estimation adlı çalışmada önerilmiştir. Temel fikir, Metinden Görsele Latent Difüzyon Modellerinin (LDM) üretken öncülünü geleneksel bilgisayar görüsü görevleri için yeniden kullanmaktır. Bu yaklaşım, yukarıdaki tanıtım görselinde gösterildiği gibi, Stable Diffusion'ın Monocular Depth Estimation için ince ayarlanarak keşfedilmiştir.

Marigold, Marigold: Affordable Adaptation of Diffusion-Based Image Generators for Image Analysis başlıklı takip eden makalede genişletilmiştir. Bu makalenin yazarları Bingxin Ke, Kevin Qu, Tianfu Wang, Nando Metzger, Shengyu Huang, Bo Li, Anton Obukhov ve Konrad Schindler'dir. Bu çalışma, Marigold'u Surface Normals ve Intrinsic Image Decomposition (IID) gibi yeni modaliteleri destekleyecek şekilde genişletmiş, Latent Consistency Models (LCM) için bir eğitim protokolü sunmuş ve High-Resolution (HR) işleme yeteneğini göstermiştir.

Erken Marigold modelleri (v1-0 ve öncesi), en az 10 çıkarım adımıyla en iyi sonuçlar için optimize edilmişti. LCM modelleri, yalnızca 1 ila 4 adımda yüksek kaliteli çıkarım yapılabilmesini sağlamak için daha sonra geliştirildi. v1-1 ve sonraki Marigold modelleri, DDIM zamanlayıcısını kullanarak 1 ila 4 adım gibi az sayıda adımda optimal sonuçlar elde eder.

Kullanılabilir Boru Hatları

Her pipeline, belirli bir bilgisayarla görme görevi için tasarlanmıştır; girdi olarak bir RGB görüntüsü işler ve buna karşılık gelen bir tahmin üretir. Şu anda aşağıdaki bilgisayarla görme görevleri uygulanmıştır:

Mevden Kontroller

Tüm orijinal checkpoint'ler Hugging Face'teki PRS-ETH kuruluşu altında mevcuttur. Bunlar, diffusers pipeline'ları ve yeni model checkpoint'leri eğitmek için de kullanılabilecek orijinal kod tabanı ile birlikte kullanılmak üzere tasarlanmıştır. Aşağıda, 1 ila 4 adımda güvenilir sonuçlar üreten önerilen checkpoint'lerin bir özeti yer almaktadır.

Zamanlayıcılar kılavuzunu inceleyerek zamanlayıcı hızı ve kalitesi arasındaki ödünleşimi nasıl keşfedebileceğinizi öğrenin ve aynı bileşenleri birden çok boru hattına nasıl verimli bir şekilde yükleyebileceğinizi görmek için boru hatları arasında bileşenleri yeniden kullanma bölümüne bakın. Ayrıca, bu boru hattının bellek kullanımını azaltma konusunda daha fazla bilgi edinmek için buradaki [“Bellek kullanımını azaltma”] bölümüne başvurun.

Marigold pipeline'leri, zamanlayıcının model kontrol noktasına gömülü olduğu şekilde tasarlanmış ve test edilmiştir. En uygun çıkarım adım sayısı zamanlayıcıya göre değişir ve tüm durumlar için en iyi sonucu veren evrensel bir değer yoktur. Buna uyum sağlamak için, pipeline'ın __call__ yöntemindeki num_inference_steps parametresinin varsayılan değeri None'dir (bkz. API referansı). Açıkça ayarlanmadığı sürece, bu değer kontrol noktası yapılandırma dosyasındaki (model_index.json) default_denoising_steps alanından devralınır. Bu, pipeline'ın yalnızca image argümanı ile çağrılması durumunda yüksek kaliteli tahminler yapılmasını sağlar.

Aşağıdaki örnekler büyük ölçüde derinlik tahmini için verilmiştir, ancak desteklenen diğer modalitelere de evrensel olarak uygulanabilir. Tahminleri, Midjourney tarafından üretilen Albert Einstein'ın aynı girdi görselini kullanarak gösteriyoruz. Bu, tahminlerin görselleştirmelerini çeşitli modaliteler ve kontrol noktaları arasında karşılaştırmayı kolaylaştırır.

Derinlik Tahmini

Derinlik tahmini almak için prs-eth/marigold-depth-v1-1 kontrol noktasını MarigoldDepthPipeline içine yükleyin, görseli boru hattından geçirin ve tahminleri kaydedin:

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

visualize_depth() fonksiyonu, tek kanallı [0, 1] derinlik aralığındaki tahmini piksel değerlerini bir RGB görüntüsüne dönüştürmek için matplotlib’ın renk haritalarından birini (varsayılan olarak Spectral) uygular. Spectral renk haritasında yakın derinliğe sahip pikseller kırmızı, uzak pikseller ise mavi olarak boyanır. 16 bitlik PNG dosyası, [0, 1] aralığından [0, 65535] aralığına doğrusal olarak eşlenen tek kanallı değerleri saklar. Aşağıda ham ve görselleştirilmiş tahminler yer almaktadır. Daha koyu ve yakın alanlar (bıyık) görselleştirmede daha kolay ayırt edilebilir.

Yüzey Normalleri Tahmini

prs-eth/marigold-normals-v1-1 kontrol noktasını MarigoldNormalsPipeline içine yükleyin, görüntüyü boru hattından geçirin ve tahminleri kaydedin:

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

visualize_normals(), [-1, 1] aralığında piksel değerlerine sahip üç boyutlu tahmini bir RGB görüntüsüne dönüştürür. Görselleştirme işlevi, görselleştirmenin referans çerçevesi için diğer seçimlerle uyumlu hale getirilmesini sağlamak üzere yüzey normal eksenlerini ters çevirmeyi destekler. Kavramsal olarak, her piksel; X ekseni sağa, Y ekseni yukarı ve Z ekseni izleyiciye baktığı referans çerçevesindeki yüzey normal vektörüne göre boyanır. Aşağıda görselleştirilmiş tahmin yer almaktadır:

Bu örnekte, burun ucu neredeyse kesinlikle yüzeyde, yüzey normal vektörü doğrudan izleyiciye bakan bir noktaya sahiptir; bu da koordinatlarının [0, 0, 1] olduğu anlamına gelir. Bu vektör, mor-mavi renge karşılık gelen RGB [128, 128, 255] değerine eşlenir. Benzer şekilde, görüntünün sağ kısmındaki yanakta bir yüzey normalinin büyük bir X bileşeni vardır ve bu, kırmızı tonunu artırır. Yukarıya doğru, büyük bir Y bileşeniyle işaret eden omuz noktaları yeşil rengi öne çıkarır.

İçsel Görüntü Ayrıştırma

Marigold, İçsel Görüntü Ayrıştırması (IID) için iki model sunar: “Appearance” ve “Lighting”. Her model, sırasıyla InteriorVerse ve Hypersim etiketlerinden türetilen Albedo haritaları üretir.

• “Görünüm” modeli ayrıca Malzeme özelliklerini de tahmin eder: Pürüzlülük ve Metaliklik.
• “Lighting” modeli, Diffuse Shading ve Non-diffuse Residual üretir.

İşte “Appearance” modelinin yaptığı tahminleri kaydeden örnek kod:

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

“Lighting” modelinin yaptığı tahminleri gösteren bir başka örnek:

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

Her iki model de farklı ayrıştırma türlerini desteklerken aynı iş akışını paylaşır. Kesin ayrıştırma parametrelendirmesi (ör. sRGB ile doğrusal uzay) pipe.target_properties sözlüğünde saklanır ve bu sözlük visualize_intrinsics() fonksiyonuna aktarılır.

Aşağıda, tahmini ayrıştırma çıktıları sergileyen bazı örnekler yer almaktadır. Tüm modaliteler Intrinsic Image Decomposition Uzayında incelenebilir.

Çıkarım hızını artırma

Yukarıdaki hızlı başlangıç kod parçacıkları, kalite ve hız için zaten optimize edilmiştir; checkpoint yüklenir, ağırlıkların ve hesaplamaların fp16 varyantı kullanılır ve varsayılan sayıda (4) gürültü azaltma difüzyon adımı gerçekleştirilir. Tahmin kalitesinden ödün vererek çıkarımı hızlandırmanın ilk adımı, gürültü azaltma difüzyon adım sayısını minimuma indirmektir:

  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)

Bu değişiklik ile pipe çağrısı RTX 3090 GPU üzerinde 280ms içinde tamamlanır. İçeride, girdi görüntüsü önce Stable Diffusion VAE kodlayıcısı kullanılarak kodlanır, ardından U-Net tarafından tek bir gürültü azaltma adımı gerçekleştirilir. Son olarak, tahmin gizli değişkeni, VAE çözücü ile piksel uzayına çözülür. Bu kurulumda, üç modül çağrısından ikisi, LDM'nin piksel ve gizli uzayları arasında dönüşüm için ayrılmıştır. Marigold'un gizli uzayı Stable Diffusion 2.0 ile uyumlu olduğundan, SD VAE'nin hafif bir ikamesi kullanılarak çıkarım 3x'ten fazla hızlandırılabilir ve RTX 3090 üzerinde çağrı süresi 85ms'e düşürülebilir. Hafif bir VAE kullanmanın, tahminlerin görsel kalitesini hafifçe azaltabileceğini unutmayın.

  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)

Şimdiye kadar difüzyon adım sayısını ve model bileşenlerini optimize ettik. Kendi-dikkat (self-attention) işlemleri, hesaplamaların önemli bir bölümünü oluşturur. Bunları hızlandırmak, daha verimli bir dikkat (attention) işlemcisi kullanarak sağlanabilir:

  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)

Son olarak, Optimizations bölümünde önerildiği üzere, hedef donanıma bağlı olarak torch.compile etkinleştirilerek performans daha da artırılabilir. Ancak derleme, ilk pipeline çağrısı sırasında önemli bir ek yük oluşturur; bu nedenle, aynı pipeline örneğinin bir döngü içinde olduğu gibi tekrar tekrar çağrıldığı durumlarda faydalıdır.

  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)

Hassasiyeti Maksimize Etme ve Ensemble

Marigold pipeline'leri, farklı rastgele latentlerden gelen birden çok tahmini birleştiren yerleşik bir ensemble mekanizmasına sahiptir. Bu, difüzyonun üretken doğasından yararlanarak tahminlerin hassasiyetini artırmak için kullanılan kaba kuvvet (brute-force) bir yöntemdir. Ensemble yolu, ensemble_size argümanı 3'e eşit veya daha büyük bir değere ayarlandığında otomatik olarak etkinleştirilir. Maksimum hassasiyet hedefleniyorsa, num_inference_steps'in ensemble_size ile eş zamanlı olarak ayarlanması mantıklıdır. Önerilen değerler checkpoint'ler arasında değişmekle birlikte, esas olarak zamanlayıcı (scheduler) türüne bağlıdır. Ensemble'ın etkisi özellikle yüzey normallerinde (surface normals) belirgin şekilde görülür:

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

Görüldüğü üzere, saç gibi ince taneli yapıların olduğu tüm alanlarda tahminler daha muhafazakâr ve ortalama olarak daha doğru hale geldi. Bu tür bir sonuç, 3B yeniden oluşturma gibi hassasiyete duyarlı aşağı akış görevleri için daha uygundur.

Zamansal Tutarlılıkla Kare Kare Video İşleme

Marigold’ün üretken doğası nedeniyle, her tahmin benzersizdir ve gizli başlatma için örneklenen rastgele gürültü tarafından tanımlanır. Aşağıdaki videolarda da gösterildiği üzere, bu durum geleneksel uçtan uca yoğun regresyon ağlarına kıyasla açık bir dezavantaj haline gelir:

Bu sorunu çözmek için, difüzyonun başlangıç noktasını tanımlayan latents argümanını pipeline'lara iletmek mümkündür. Deneysel olarak, aynı başlangıç noktası gürültü latentinin ve bir önceki kare tahminine karşılık gelen latentin konveks kombinasyonunun, aşağıdaki kod parçasında uygulandığı gibi yeterince pürüzsüz sonuçlar verdiğini tespit ettik:

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

Burada difüzyon süreci, verilen hesaplanmış latentten başlar. Pipeline, out.latent'e erişmek için output_latent=True ayarını yapar ve bir sonraki kareye ait latent başlatma işlemine katkısını hesaplar. Sonuç artık çok daha kararlıdır:

ControlNet için Marigold

Derinlik tahmini için difüzyon modellerinin çok yaygın bir uygulaması, ControlNet ile birlikte gelir. Derinlik netliği, ControlNet'ten yüksek kaliteli sonuçlar elde etmede kritik bir rol oynar. Yukarıdaki diğer yöntemlerle karşılaştırmalarda görüldüğü üzere, Marigold bu görevde üstün bir performans sergiler. Aşağıdaki kod parçası, bir görüntünün nasıl yükleneceğini, derinliğin nasıl hesaplanacağını ve ControlNet'e uyumlu bir formatta nasıl geçirileceğini göstermektedir:

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

Nicel Değerlendirme

Marigold'u standart lider tablolarında ve test setlerinde (NYU, KITTI ve diğer veri setleri gibi) nicel olarak değerlendirmek için, makalede belirtilen değerlendirme protokolünü izleyin: tam hassasiyetli fp32 modeli yükleyin ve num_inference_steps ile ensemble_size için uygun değerleri kullanın. İsteğe bağlı olarak, yeniden üretilebilirliği sağlamak için rastgelelik tohumu (seed) ayarlayın. batch_size değerini en üst düzeye çıkarmak, maksimum cihaz kullanımını sağlar.

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

Tahmine Dayalı Belirsizlik Kullanma

Marigold pipeline'lerine yerleştirilmiş ensemble mekanizması, farklı rastgele latentlerden elde edilen birden çok tahmini birleştirir. Yan etki olarak, epistemik (model) belirsizliğini nicelendirmek için kullanılabilir; bunun için ensemble_size değerini 3'e eşit veya daha büyük bir değere ayarlayıp output_uncertainty=True olarak belirlemeniz yeterlidir. Sonuçta elde edilen belirsizlik, çıktının uncertainty alanında kullanılabilir hale gelir. Aşağıdaki gibi görselleştirilebilir:

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

Belirsizliğin yorumlanması kolaydır: daha yüksek değerler (beyaz), modelin tutarlı tahminler yapmekte zorlandığı piksellere karşılık gelir.

• Derinlik modeli, nesne derinliğinin ani olarak değiştiği kesintilerin etrafında en yüksek belirsizliği gösterir.
• Yüzey normal modeli, saç gibi ince yapılar ve yakalık bölgesi gibi karanlık alanlarda en az güvenlidir.
• Albedo belirsizliği, derinlik ve yüzey normallerinin aksine, her renk kanalında bağımsız olarak belirsizliği yakaladığı için bir RGB görüntüsü olarak temsil edilir. Gölge bölgelerde ve süreksizliklerde de daha yüksektir.

Marigold Derinlik Tahmin API

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

Marigold Normals Tahmin API'si

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

Marigold İçsel Görüntü Ayrıştırma API

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