diffusers/main/tr/api/pipelines/marigold.md

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 bilgisayarla görü 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, Bingxin Ke, Kevin Qu, Tianfu Wang, Nando Metzger, Shengyu Huang, Bo Li, Anton Obukhov ve Konrad Schindler tarafından kaleme alınan Marigold: Affordable Adaptation of Diffusion-Based Image Generators for Image Analysis başlıklı takip eden makalede genişletilmiştir. 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ı almak üzere optimize edilmişti. LCM modelleri, yüksek kaliteli çıkarımı yalnızca 1 ila 4 adımda mümkün kılmak 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:

Pipeline	Önerilen Model Kontrol Noktaları	Spaces (Etkileşimli Uygulamalar)	Tahmin Edilen Modaliteler
MarigoldDepthPipeline	prs-eth/marigold-depth-v1-1	Derinlik Tahmini	Derinlik, Paralaks
MarigoldNormalsPipeline	prs-eth/marigold-normals-v1-1	Yüzey Normallerinin Tahmini	Yüzey normalleri
MarigoldIntrinsicsPipeline	prs-eth/marigold-iid-appearance-v1-1,prs-eth/marigold-iid-lighting-v1-1	İçsel Görüntü Ayrıştırma	Albedo, Materyaller, Aydınlatma

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.

Kontrol Noktası	Modalite	Yorum
prs-eth/marigold-depth-v1-1	Derinlik	Affine-değişmez derinlik tahmini, her piksele 0 (yakın düzlem) ile 1 (uzak düzlem) arasında bir değer atar; her iki düzlem de çıkarım sırasında model tarafından belirlenir.
prs-eth/marigold-normals-v0-1	Normal	Yüz normali tahminleri, ekran uzayı kamerasında -1 ile 1 aralığında değerlere sahip, birim uzunlukta 3B vektörlerdir.
prs-eth/marigold-iid-appearance-v1-1	İçsel Özellikler	InteriorVerse ayrıştırması, Albedo ve iki BRDF malzeme özelliğinden oluşur: Roughness ve Metallicity.
prs-eth/marigold-iid-lighting-v1-1	İçsel Özellikler	HyperSim'in bir görüntünün $I$ ayrıştırması, Albedo $A$, Diffuse shading $S$ ve Non-diffuse residual $R$ bileşenlerinden oluşur: $I = A*S+R$.

Zamanlayıcı hızı ve kalitesi arasındaki ödünleşimi keşfetmeyi öğrenmek için Zamanlayıcılar kılavuzunu mutlaka inceleyin ve aynı bileşenleri birden fazla boru hattına verimli bir şekilde yüklemenin nasıl yapılacağını öğrenmek 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 ["Bellek kullanımını azaltma"] bölümüne buradan ulaşabilirsiniz.

Marigold pipeline'leri, zamanlayıcının (scheduler) model kontrol noktasına (checkpoint) 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. Bu durumu karşılamak için, pipeline'ın __call__ metodundaki num_inference_steps parametresinin varsayılan değeri None'dir (API referansına bakınız). 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ıyla ç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 tüm modalitelere evrensel olarak uygulanabilir. Tahminleri, Midjourney tarafından üretilen Albert Einstein'ın aynı girdi görselini kullanarak gösteriyoruz. Bu, çeşitli modaliteler ve kontrol noktaları arasında tahmin görselleştirmelerini karşılaştırmayı kolaylaştırır.

  Tüm Marigold hatları için örnek giriş görseli

Derinlik Tahmini

Derinlik tahmini almak için prs-eth/marigold-depth-v1-1 kontrol noktasını MarigoldDepthPipeline içine yükleyin, görüntüyü 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'in 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 daha yakın olan bölgeler (bıyık) görselleştirmede daha kolay ayırt edilebilir.

  Tahmini derinlik (16-bit PNG)





  Tahmini derinlik görselleştirmesi (Spektral)

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 eşler. 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 bakan referans çerçevesindeki yüzey normal vektörüne göre boyanır. Aşağıda görselleştirilmiş tahmin yer almaktadır:

  Tahmin edilen yüzey normalleri görselleştirmesi

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. Omuzlarda yukarı bakan ve büyük bir Y bileşenine sahip 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.

• "Appearance" modeli ayrıca Malzeme özelliklerini de tahmin eder: Roughness ve Metallicity.
• "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 bulunmaktadır. Tüm modaliteler Intrinsic Image Decomposition Space’inde incelenebilir.

  Tahmini albedo ("Görünüm" modeli)





  Tahmini difüz gölgeleme ("Lighting" modeli)

Çı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ımları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 (latent), 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ı (latent spaces) arasında dönüşüm için ayrılmıştır. Marigold'un gizli uzayı (latent space) Stable Diffusion 2.0 ile uyumlu olduğundan, hafif bir SD VAE ikamesi kullanarak çıkarım (inference) 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 kısmını oluşturur. Bunların hızlandırılması, daha verimli bir dikkat (attention) işlemcisi kullanılarak 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ştirildiğinde 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, bir döngü içinde olduğu gibi aynı pipeline örneğinin 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 bir kaba kuvvet yöntemidir. 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 hedeflenirken, num_inference_steps'nin 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ı türüne bağlıdır. Ensemble'ın etkisi özellikle yüzey normallerinde 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")

  Yüzey normalleri, ensemble kullanılmadı





  Ensemble ile yüzey normalleri

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ı gereği, 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, geleneksel uçtan uca yoğun regresyon ağlarıyla karşılaştırıldığında bu açık bir dezavantaj haline gelir:

Giriş videosu



Marigold Depth, giriş video karelerine bağımsız olarak uygulanır

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:

Marigold Depth, giriş video karelerine bağımsız olarak uygulanır



Zorunlu latents başlatmalı Marigold Depth

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

  Girdi görseli





  ControlNet ile uyumlu formatta derinlik





  Derinlik ve istem koşuluna bağlı ControlNet üretimi: "yüksek kaliteli spor motosiklet, şehir fotoğrafı"

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. Yeniden üretilebilirliği sağlamak için rastgelelik tohumu (seed) isteğe bağlı olarak ayarlanabilir. batch_size değerini en üst düzeye çıkarmak, cihaz kullanımını en üst düzeye çıkarır.

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 fazla 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 olacak şekilde belirtin ve output_uncertainty=True ayarlayın. 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")

  Derinlik belirsizliği





  Yüzey normali belirsizliği





  Albedo belirsizliği

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 boğaz bölgesi.
• Albedo belirsizliği, her renk kanalında belirsizliği bağımsız olarak yakaladığı için bir RGB görüntüsü olarak temsil edilir, derinlik ve yüzey normalleri gibi değildir. Ayrıca gölgeli bölgelerde ve süreksizliklerde daha yüksektir.

Marigold Derinlik Tahmin API[[diffusers.MarigoldDepthPipeline]]

diffusers.MarigoldDepthPipeline[[diffusers.MarigoldDepthPipeline]]

diffusers.MarigoldDepthPipeline(unet: UNet2DConditionModel, vae: AutoencoderKL, scheduler: diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_lcm.LCMScheduler, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, prediction_type: str | None = None, scale_invariant: bool | None = True, shift_invariant: bool | None = True, default_denoising_steps: int | None = None, default_processing_resolution: int | None = None)

Kaynak

Parametreler:

unet (UNet2DConditionModel) : Görüntü latentine koşullu olarak derinlik latentini gürültüsüzleştirmek için kullanılan koşullu U-Net.

vae (AutoencoderKL) : Görüntüleri ve tahminleri gizil (latent) temsillere kodlamak ve bu temsillerden çözmek için kullanılan Varyasyonel Oto-Kodlayıcı (VAE) Modeli.

scheduler (DDIMScheduler veya LCMScheduler) : Kodlanmış görüntü latentlerini gürültüden arındırmak için unet ile birlikte kullanılacak bir zamanlayıcı.

text_encoder (CLIPTextModel) : Boş metin gömme için metin kodlayıcı.

tokenizer (CLIPTokenizer) : CLIP işleyicisi.

prediction_type (str, isteğe bağlı) : Modelin yaptığı tahminlerin türü.

scale_invariant (bool, isteğe bağlı) : Tahmin edilen derinlik haritalarının ölçekten bağımsız olup olmadığını belirleyen bir model özelliği. Bu değer model yapılandırmasında ayarlanmalıdır. shift_invariant=True bayrağıyla birlikte kullanıldığında, modele ayrıca "affine-invariant" (afin dönüşümden bağımsız) da denir. Not: Bu değerin üzerine yazılması desteklenmez.

shift_invariant (bool, isteğe bağlı) : Tahmin edilen derinlik haritalarının kaydırma değişmezliği (shift-invariant) olup olmadığını belirleyen bir model özelliği. Bu değer model yapılandırmasında (config) ayarlanmalıdır. scale_invariant=True bayrağıyla birlikte kullanıldığında, modele ayrıca "affine-invariant" (afin değişmez) denir. NOT: Bu değerin üzerine yazılması (override) desteklenmez.

default_denoising_steps (int, isteğe bağlı) : Verilen modelle makul bir kalitede tahmin üretmek için gereken minimum gürültü azaltma difüzyon adımı sayısı. Bu değer model yapılandırmasında ayarlanmalıdır. Pipeline, num_inference_steps açıkça ayarlanmadan çağrıldığında, varsayılan değer kullanılır. Bu, pipeline ile uyumlu çeşitli model türlerinde makul sonuçları sağlamak için gereklidir; örneğin çok kısa gürültü azaltma zamanlamalarına (LCMScheduler) ve tam difüzyon zamanlamalarına (DDIMScheduler) dayanan modeller.

default_processing_resolution (int, isteğe bağlı) : Hattın processing_resolution parametresi için önerilen değer. Bu değer model yapılandırmasında ayarlanmalıdır. Hat, processing_resolution açıkça ayarlanmadan çağrıldığında varsayılan değer kullanılır. Bu, farklı optimal işleme çözünürlüğü değerleriyle eğitilmiş çeşitli model türleriyle makul sonuçları garanti altına almak için gereklidir.

Marigold yöntemi kullanılarak tek göz derinlik tahmini için Pipeline: https://marigoldmonodepth.github.io.

Bu model DiffusionPipeline sınıfından devralır. Kütüphanenin tüm pipeline'lar için uyguladığı genel yöntemler (indirme veya kaydetme, belirli bir cihazda çalıştırma vb.) için üst sınıf belgelendirmesine bakın.

call[[diffusers.MarigoldDepthPipeline.call]]

__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], num_inference_steps: int | None = None, ensemble_size: int = 1, processing_resolution: int | None = None, match_input_resolution: bool = True, resample_method_input: str = 'bilinear', resample_method_output: str = 'bilinear', batch_size: int = 1, ensembling_kwargs: dict[str, typing.Any] | None = None, latents: typing.Union[torch.Tensor, list[torch.Tensor], NoneType] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str = 'np', output_uncertainty: bool = False, output_latent: bool = False, return_dict: bool = True)

Kaynak

Parametreler:

image (PIL.Image.Image, np.ndarray, torch.Tensor, list[PIL.Image.Image], list[np.ndarray]), : list[torch.Tensor]: Derinlik tahmini görevi için girdi olarak kullanılan bir veya birden fazla girdi görüntüsü. Diziler ve tensörler için beklenen değer aralığı [0, 1] arasındadır. Dört boyutlu bir dizi veya tensör sağlayarak bir görüntü partisi geçmek mümkündür. Ayrıca, iki veya üç boyutlu dizi veya tensörlerden oluşan bir görüntü listesi de geçirilebilir. Bu son durumda, listenin tüm öğelerinin aynı genişliğe ve yüksekliğe sahip olması gerekir.

num_inference_steps (int, isteğe bağlı, varsayılan None) : Çıkarım sırasında gürültü azaltma difüzyon adımlarının sayısı. Varsayılan değer None otomatik seçimle sonuçlanır.

ensemble_size (int, varsayılan 1) : Ensemble tahmin sayısı. Daha yüksek değerler ölçülebilir iyileşmelere ve görsel bozulmalara yol açar.

processing_resolution (int, isteğe bağlı, varsayılan None) : Etkili işleme çözünürlüğü. 0 olarak ayarlandığında, daha büyük giriş görüntü boyutuna eşitlenir. Bu, daha keskin tahminler üretir ancak genel bağlamın tamamen kaybedilmesine de yol açabilir. Varsayılan değer None, model yapılandırmasındaki optimal değere çözümlenir.

match_input_resolution (bool, isteğe bağlı, varsayılan True) : Etkinleştirildiğinde, çıktı tahmini giriş boyutlarıyla eşleşecek şekilde yeniden boyutlandırılır. Devre dışı bırakıldığında, çıktının daha uzun kenarı processing_resolution değerine eşit olur.

resample_method_input (str, isteğe bağlı, varsayılan "bilinear") : Girdi görüntülerini processing_resolution boyutuna yeniden boyutlandırmak için kullanılan yeniden örnekleme yöntemi. Kabul edilen değerler şunlardır: "nearest", "nearest-exact", "bilinear", "bicubic" veya "area".

resample_method_output (str, isteğe bağlı, varsayılan "bilinear") : Çıktı tahminlerini girdi çözünürlüğüyle eşleştirmek için yeniden boyutlandırmada kullanılan yeniden örnekleme yöntemi. Kabul edilen değerler "nearest", "nearest-exact", "bilinear", "bicubic" veya "area"'dır.

batch_size (int, isteğe bağlı, varsayılan 1) : Batch boyutu; yalnızca ensemble_size ayarlanırken veya bir görüntü tensörü geçirilirken önemlidir.

ensembling_kwargs (dict, isteğe bağlı, varsayılan None) : Hassas ensemble kontrolü için argümanlar içeren ek sözlük. Aşağıdaki seçenekler kullanılabilir: - reduction (str, isteğe bağlı, varsayılan "median"): Her piksel konumunda uygulanan ensemble işlevini tanımlar; "median" veya "mean" olabilir. - regularizer_strength (float, isteğe bağlı, varsayılan 0.02): Hizalanmış tahminleri 0'dan 1'e birim aralığına çeken düzenleyicinin gücü. - max_iter (int, isteğe bağlı, varsayılan 2): Hizalama çözücüsü adımlarının maksimum sayısı. scipy.optimize.minimize işlevine, options argümanına bakın. - tol (float, isteğe bağlı, varsayılan 1e-3): Hizalama çözücüsü toleransı. Tolerans değerine ulaşıldığında çözücü durur. - max_res (int, isteğe bağlı, varsayılan None): Hizalamanın gerçekleştirildiği çözünürlük; None, processing_resolution ile eşleşir.

latents (torch.Tensor veya list[torch.Tensor], isteğe bağlı, varsayılan None) : Rastgele başlatmanın yerini alacak gizli gürültü tensörleri. Bunlar, önceki fonksiyon çağrısının çıktısından alınabilir.

generator (torch.Generator veya list[torch.Generator], isteğe bağlı, varsayılan None) : Yeniden üretilebilirliği sağlamak için rastgele sayı üreteci nesnesi.

output_type (str, isteğe bağlı, varsayılan "np") : Çıktının prediction ve isteğe bağlı uncertainty alanları için tercih edilen biçim. Kabul edilen değerler: "np" (numpy dizisi) veya "pt" (torch tensörü).

output_uncertainty (bool, isteğe bağlı, varsayılan False) : Etkinleştirildiğinde, ensemble_size argümanı 2'den büyük bir değere ayarlanmışsa, çıktının uncertainty alanı öngörü belirsizliği haritasını içerir.

output_latent (bool, isteğe bağlı, varsayılan False) : Etkinleştirildiğinde, çıktının latent alanı, ensemble içindeki tahminlere karşılık gelen latent kodları içerir. Bu kodlar kaydedilebilir, değiştirilebilir ve latents argümanı ile sonraki çağrılarda kullanılabilir.

return_dict (bool, isteğe bağlı, varsayılan True) : Düz bir tuple yerine MarigoldDepthOutput döndürülüp döndürülmemesi.

Dönüş: MarigoldDepthOutput veya tuple

return_dict True ise MarigoldDepthOutput döndürülür, aksi halde ilk öğesi tahmin, ikinci öğesi belirsizlik (veya None) ve üçüncü öğesi latent (veya None) olan bir tuple döndürülür.

pipeline çağrıldığında tetiklenen işlev.

Örnekler:

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

diffusers.pipelines.marigold.MarigoldDepthOutput[[diffusers.pipelines.marigold.MarigoldDepthOutput]]

diffusers.pipelines.marigold.MarigoldDepthOutput(prediction: typing.Union[numpy.ndarray, torch.Tensor], uncertainty: typing.Union[NoneType, numpy.ndarray, torch.Tensor], latent: typing.Optional[torch.Tensor])

Kaynak

Parametreler:

prediction (np.ndarray, torch.Tensor) : [0, 1] aralığında değerlere sahip tahmini derinlik haritaları. torch.Tensor için şekil numimages × 1 × height × width, np.ndarray için ise numimages × height × width × 1'dir.

uncertainty (None, np.ndarray, torch.Tensor) : Ensemble'dan hesaplanan belirsizlik haritaları, değerler [0, 1] aralığındadır. torch.Tensor için şekil numimages × 1 × height × width, np.ndarray için ise numimages × height × width × 1'dir.

latent (None, torch.Tensor) : Tahminlere karşılık gelen, pipeline'ın latents argümanıyla uyumlu latent özellikler. Şekil numimages * numensemble × 4 × latentheight × latentwidth'dir.

Marigold tek gözlü derinlik tahmini hattı için çıktı sınıfı.

diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_depth[[diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_depth]]

diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_depth(depth: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], val_min: float = 0.0, val_max: float = 1.0, color_map: str = 'Spectral')

Kaynak

Parametreler:

depth (PIL.Image.Image | np.ndarray | torch.Tensor | list[PIL.Image.Image, list[np.ndarray], : list[torch.Tensor]]): Derinlik haritaları.

val_min (float, isteğe bağlı, varsayılan 0.0) : Görselleştirilen derinlik aralığının minimum değeri.

val_max (float, isteğe bağlı, varsayılan 1.0) : Görselleştirilen derinlik aralığının maksimum değeri.

color_map (str, isteğe bağlı, varsayılan "Spectral") : Tek kanallı derinlik tahminini renkli temsiline dönüştürmek için kullanılan renk haritası.

MarigoldDepthPipeline öngörüleri gibi derinlik haritalarını görselleştirir.

Dönüş: derinlik haritalarının görselleştirmesi içeren list[PIL.Image.Image].

Marigold Normals Tahmin API'si[[diffusers.MarigoldNormalsPipeline]]

diffusers.MarigoldNormalsPipeline[[diffusers.MarigoldNormalsPipeline]]

diffusers.MarigoldNormalsPipeline(unet: UNet2DConditionModel, vae: AutoencoderKL, scheduler: diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_lcm.LCMScheduler, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, prediction_type: str | None = None, use_full_z_range: bool | None = True, default_denoising_steps: int | None = None, default_processing_resolution: int | None = None)

Kaynak

Parametreler:

unet (UNet2DConditionModel) : Görüntü latentine koşullu olarak, normal latentini gürültüden arındırmak için kullanılan koşullu U-Net.

vae (AutoencoderKL) : Görüntüleri ve tahminleri gizil (latent) temsillere kodlamak ve bu temsillerden çözmek için kullanılan Varyasyonel Oto-Kodlayıcı (VAE) Modeli.

scheduler (DDIMScheduler veya LCMScheduler) : Kodlanmış görüntü latentlerini gürültüden arındırmak için unet ile birlikte kullanılacak bir zamanlayıcı.

text_encoder (CLIPTextModel) : Boş metin gömme için metin kodlayıcı.

tokenizer (CLIPTokenizer) : CLIP işleyicisi.

prediction_type (str, isteğe bağlı) : Modelin yaptığı tahminlerin türü.

use_full_z_range (bool, isteğe bağlı) : Bu modelin öngördüğü normal vektörlerin, Z boyutunun tam aralığını mı yoksa yalnızca pozitif yarısını mı kullandığını belirtir.

default_denoising_steps (int, isteğe bağlı) : Verilen modelle makul bir kalitede tahmin üretmek için gereken minimum gürültü azaltma difüzyon adımı sayısı. Bu değer model yapılandırmasında ayarlanmalıdır. Pipeline, num_inference_steps açıkça ayarlanmadan çağrıldığında, varsayılan değer kullanılır. Bu, pipeline ile uyumlu çeşitli model türlerinde makul sonuçları sağlamak için gereklidir; örneğin çok kısa gürültü azaltma zamanlamalarına (LCMScheduler) ve tam difüzyon zamanlamalarına (DDIMScheduler) dayanan modeller.

default_processing_resolution (int, isteğe bağlı) : Hattın processing_resolution parametresi için önerilen değer. Bu değer model yapılandırmasında ayarlanmalıdır. Hat, processing_resolution açıkça ayarlanmadan çağrıldığında varsayılan değer kullanılır. Bu, farklı optimal işleme çözünürlüğü değerleriyle eğitilmiş çeşitli model türleriyle makul sonuçları garanti altına almak için gereklidir.

Marigold yöntemi kullanılarak tek gözlü normal tahmini için pipeline: https://marigoldmonodepth.github.io.

Bu model DiffusionPipeline sınıfından devralır. Kütüphanenin tüm pipeline'lar için uyguladığı genel yöntemler (indirme veya kaydetme, belirli bir cihazda çalıştırma vb.) için üst sınıf belgelendirmesine bakın.

call[[diffusers.MarigoldNormalsPipeline.call]]

__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], num_inference_steps: int | None = None, ensemble_size: int = 1, processing_resolution: int | None = None, match_input_resolution: bool = True, resample_method_input: str = 'bilinear', resample_method_output: str = 'bilinear', batch_size: int = 1, ensembling_kwargs: dict[str, typing.Any] | None = None, latents: typing.Union[torch.Tensor, list[torch.Tensor], NoneType] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str = 'np', output_uncertainty: bool = False, output_latent: bool = False, return_dict: bool = True)

Kaynak

Parametreler:

image (PIL.Image.Image, np.ndarray, torch.Tensor, list[PIL.Image.Image], list[np.ndarray]), : list[torch.Tensor]: Normaller tahmini görevi için girdi olarak kullanılan bir veya daha fazla girdi görüntüsü. Diziler ve tensörler için beklenen değer aralığı [0, 1] arasındadır. Dört boyutlu bir dizi veya tensör sağlayarak bir görüntü partisi geçmek mümkündür. Ayrıca, iki veya üç boyutlu dizi veya tensörlerden oluşan bir görüntü listesi de geçirilebilir. Bu son durumda, listenin tüm öğelerinin aynı genişliğe ve yüksekliğe sahip olması gerekir.

num_inference_steps (int, isteğe bağlı, varsayılan None) : Çıkarım sırasında gürültü azaltma difüzyon adımlarının sayısı. Varsayılan değer None otomatik seçimle sonuçlanır.

ensemble_size (int, varsayılan 1) : Ensemble tahmin sayısı. Daha yüksek değerler ölçülebilir iyileşmelere ve görsel bozulmalara yol açar.

processing_resolution (int, isteğe bağlı, varsayılan None) : Etkili işleme çözünürlüğü. 0 olarak ayarlandığında, daha büyük giriş görüntü boyutuna eşitlenir. Bu, daha keskin tahminler üretir ancak genel bağlamın tamamen kaybedilmesine de yol açabilir. Varsayılan değer None, model yapılandırmasındaki optimal değere çözümlenir.

match_input_resolution (bool, isteğe bağlı, varsayılan True) : Etkinleştirildiğinde, çıktı tahmini giriş boyutlarıyla eşleşecek şekilde yeniden boyutlandırılır. Devre dışı bırakıldığında, çıktının daha uzun kenarı processing_resolution değerine eşit olur.

resample_method_input (str, isteğe bağlı, varsayılan "bilinear") : Girdi görüntülerini processing_resolution boyutuna yeniden boyutlandırmak için kullanılan yeniden örnekleme yöntemi. Kabul edilen değerler şunlardır: "nearest", "nearest-exact", "bilinear", "bicubic" veya "area".

resample_method_output (str, isteğe bağlı, varsayılan "bilinear") : Çıktı tahminlerini girdi çözünürlüğüyle eşleştirmek için yeniden boyutlandırmada kullanılan yeniden örnekleme yöntemi. Kabul edilen değerler "nearest", "nearest-exact", "bilinear", "bicubic" veya "area"'dır.

batch_size (int, isteğe bağlı, varsayılan 1) : Batch boyutu; yalnızca ensemble_size ayarlanırken veya bir görüntü tensörü geçirilirken önemlidir.

ensembling_kwargs (dict, isteğe bağlı, varsayılan None) : Hassas ensemble kontrolü için argümanlar içeren ek sözlük. Kullanılabilir seçenekler şunlardır: - reduction (str, isteğe bağlı, varsayılan "closest"): Her piksel konumunda uygulanan ensemble işlevini tanımlar, "closest" veya "mean" olabilir.

latents (torch.Tensor, isteğe bağlı, varsayılan None) : Rastgele başlatmanın yerini alacak gizli gürültü tensörleri. Bunlar, önceki fonksiyon çağrısının çıktısından alınabilir.

generator (torch.Generator veya list[torch.Generator], isteğe bağlı, varsayılan None) : Yeniden üretilebilirliği sağlamak için rastgele sayı üreteci nesnesi.

output_type (str, isteğe bağlı, varsayılan "np") : Çıktının prediction ve isteğe bağlı uncertainty alanları için tercih edilen biçim. Kabul edilen değerler: "np" (numpy dizisi) veya "pt" (torch tensörü).

output_uncertainty (bool, isteğe bağlı, varsayılan False) : Etkinleştirildiğinde, ensemble_size argümanı 2'den büyük bir değere ayarlanmışsa, çıktının uncertainty alanı öngörü belirsizliği haritasını içerir.

output_latent (bool, isteğe bağlı, varsayılan False) : Etkinleştirildiğinde, çıktının latent alanı, ensemble içindeki tahminlere karşılık gelen latent kodları içerir. Bu kodlar kaydedilebilir, değiştirilebilir ve latents argümanı ile sonraki çağrılarda kullanılabilir.

return_dict (bool, isteğe bağlı, varsayılan True) : Düz bir tuple yerine MarigoldNormalsOutput döndürülüp döndürülmemesi.

Dönüş: MarigoldNormalsOutput veya tuple

return_dict True ise MarigoldNormalsOutput döndürülür, aksi takdirde ilk öğesi tahmin, ikinci öğesi belirsizlik (veya None) ve üçüncü öğesi latent (veya None) olan bir tuple döndürülür.

pipeline çağrıldığında tetiklenen işlev.

Örnekler:

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

diffusers.pipelines.marigold.MarigoldNormalsOutput[[diffusers.pipelines.marigold.MarigoldNormalsOutput]]

diffusers.pipelines.marigold.MarigoldNormalsOutput(prediction: typing.Union[numpy.ndarray, torch.Tensor], uncertainty: typing.Union[NoneType, numpy.ndarray, torch.Tensor], latent: typing.Optional[torch.Tensor])

Kaynak

Parametreler:

prediction (np.ndarray, torch.Tensor) : [-1, 1] aralığında değerlere sahip tahmini normaller. torch.Tensor için şekil numimages × 3 × height × width, np.ndarray için ise numimages × height × width × 3'tür.

uncertainty (None, np.ndarray, torch.Tensor) : Ensemble'dan hesaplanan belirsizlik haritaları, değerler [0, 1] aralığındadır. torch.Tensor için şekil numimages × 1 × height × width, np.ndarray için ise numimages × height × width × 1'dir.

latent (None, torch.Tensor) : Tahminlere karşılık gelen, pipeline'ın latents argümanıyla uyumlu latent özellikler. Şekil numimages * numensemble × 4 × latentheight × latentwidth'dir.

Marigold tek gözlü normal tahmin hattı için çıktı sınıfı.

diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_normals[[diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_normals]]

diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_normals(normals: typing.Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor]], flip_x: bool = False, flip_y: bool = False, flip_z: bool = False)

Kaynak

Parametreler:

normals (np.ndarray | torch.Tensor | list[np.ndarray, list[torch.Tensor]]) : Yüzey normalleri.

flip_x (bool, isteğe bağlı, varsayılan False) : Normaller referans çerçevesinin X eksenini tersine çevirir. Varsayılan yön sağdır.

flip_y (bool, isteğe bağlı, varsayılan False) : Normaller referans çerçevesinin Y eksenini tersine çevirir. Varsayılan yön yukarıdır.

flip_z (bool, isteğe bağlı, varsayılan False) : Normaller referans çerçevesinin Z eksenini tersine çevirir. Varsayılan yön, gözlemciye bakmaktadır.

MarigoldNormalsPipeline öngörüleri gibi yüzey normallerini görselleştirir.

Dönüş: Yüzey normalleri görselleştirmesi içeren list[PIL.Image.Image].

Marigold İçsel Görüntü Ayrıştırma API[[diffusers.MarigoldIntrinsicsPipeline]]

diffusers.MarigoldIntrinsicsPipeline[[diffusers.MarigoldIntrinsicsPipeline]]

diffusers.MarigoldIntrinsicsPipeline(unet: UNet2DConditionModel, vae: AutoencoderKL, scheduler: diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_lcm.LCMScheduler, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, prediction_type: str | None = None, target_properties: dict[str, typing.Any] | None = None, default_denoising_steps: int | None = None, default_processing_resolution: int | None = None)

Kaynak

Parametreler:

unet (UNet2DConditionModel) : Hedef latentleri, görüntü latentine koşullu olarak gürültüden arındırmak için kullanılan koşullu U-Net.

vae (AutoencoderKL) : Görüntüleri ve tahminleri gizil (latent) temsillere kodlamak ve bu temsillerden çözmek için kullanılan Varyasyonel Oto-Kodlayıcı (VAE) Modeli.

scheduler (DDIMScheduler veya LCMScheduler) : Kodlanmış görüntü latentlerini gürültüden arındırmak için unet ile birlikte kullanılacak bir zamanlayıcı.

text_encoder (CLIPTextModel) : Boş metin gömme için metin kodlayıcı.

tokenizer (CLIPTokenizer) : CLIP işleyicisi.

prediction_type (str, isteğe bağlı) : Modelin yaptığı tahminlerin türü.

target_properties (dict[str, Any], isteğe bağlı) : target_names gibi tahmin edilen modalitelerin özellikleri; tahmin edilen modalitelerin sayısını, sırasını ve adlarını tanımlamak için kullanılan list[str] ve tahminlerin yorumlanması için gerekebilecek diğer tüm meta veriler.

default_denoising_steps (int, isteğe bağlı) : Verilen modelle makul bir kalitede tahmin üretmek için gereken minimum gürültü azaltma difüzyon adımı sayısı. Bu değer model yapılandırmasında ayarlanmalıdır. Pipeline, num_inference_steps açıkça ayarlanmadan çağrıldığında, varsayılan değer kullanılır. Bu, pipeline ile uyumlu çeşitli model türlerinde makul sonuçları sağlamak için gereklidir; örneğin çok kısa gürültü azaltma zamanlamalarına (LCMScheduler) ve tam difüzyon zamanlamalarına (DDIMScheduler) dayanan modeller.

default_processing_resolution (int, isteğe bağlı) : Hattın processing_resolution parametresi için önerilen değer. Bu değer model yapılandırmasında ayarlanmalıdır. Hat, processing_resolution açıkça ayarlanmadan çağrıldığında varsayılan değer kullanılır. Bu, farklı optimal işleme çözünürlüğü değerleriyle eğitilmiş çeşitli model türleriyle makul sonuçları garanti altına almak için gereklidir.

Marigold yöntemi kullanılarak Intrinsic Image Decomposition (IID) için Pipeline: https://marigoldcomputervision.github.io.

Bu model DiffusionPipeline sınıfından devralır. Kütüphanenin tüm pipeline'lar için uyguladığı genel yöntemler (indirme veya kaydetme, belirli bir cihazda çalıştırma vb.) için üst sınıf belgelendirmesine bakın.

call[[diffusers.MarigoldIntrinsicsPipeline.call]]

__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], num_inference_steps: int | None = None, ensemble_size: int = 1, processing_resolution: int | None = None, match_input_resolution: bool = True, resample_method_input: str = 'bilinear', resample_method_output: str = 'bilinear', batch_size: int = 1, ensembling_kwargs: dict[str, typing.Any] | None = None, latents: typing.Union[torch.Tensor, list[torch.Tensor], NoneType] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str = 'np', output_uncertainty: bool = False, output_latent: bool = False, return_dict: bool = True)

Kaynak

Parametreler:

image (PIL.Image.Image, np.ndarray, torch.Tensor, list[PIL.Image.Image], list[np.ndarray]), : list[torch.Tensor]: İçsel ayrıştırma görevi için girdi olarak kullanılan bir veya daha fazla girdi görüntüsü. Diziler ve tensörler için beklenen değer aralığı [0, 1] arasındadır. Dört boyutlu bir dizi veya tensör sağlayarak bir görüntü partisi geçmek mümkündür. Ayrıca, iki veya üç boyutlu dizi veya tensörlerden oluşan bir görüntü listesi de geçirilebilir. Bu son durumda, listenin tüm öğelerinin aynı genişliğe ve yüksekliğe sahip olması gerekir.

num_inference_steps (int, isteğe bağlı, varsayılan None) : Çıkarım sırasında gürültü azaltma difüzyon adımlarının sayısı. Varsayılan değer None otomatik seçimle sonuçlanır.

ensemble_size (int, varsayılan 1) : Ensemble tahmin sayısı. Daha yüksek değerler ölçülebilir iyileşmelere ve görsel bozulmalara yol açar.

processing_resolution (int, isteğe bağlı, varsayılan None) : Etkili işleme çözünürlüğü. 0 olarak ayarlandığında, daha büyük giriş görüntü boyutuna eşitlenir. Bu, daha keskin tahminler üretir ancak genel bağlamın tamamen kaybedilmesine de yol açabilir. Varsayılan değer None, model yapılandırmasındaki optimal değere çözümlenir.

match_input_resolution (bool, isteğe bağlı, varsayılan True) : Etkinleştirildiğinde, çıktı tahmini giriş boyutlarıyla eşleşecek şekilde yeniden boyutlandırılır. Devre dışı bırakıldığında, çıktının daha uzun kenarı processing_resolution değerine eşit olur.

resample_method_input (str, isteğe bağlı, varsayılan "bilinear") : Girdi görüntülerini processing_resolution boyutuna yeniden boyutlandırmak için kullanılan yeniden örnekleme yöntemi. Kabul edilen değerler şunlardır: "nearest", "nearest-exact", "bilinear", "bicubic" veya "area".

resample_method_output (str, isteğe bağlı, varsayılan "bilinear") : Çıktı tahminlerini girdi çözünürlüğüyle eşleştirmek için yeniden boyutlandırmada kullanılan yeniden örnekleme yöntemi. Kabul edilen değerler "nearest", "nearest-exact", "bilinear", "bicubic" veya "area"'dır.

batch_size (int, isteğe bağlı, varsayılan 1) : Batch boyutu; yalnızca ensemble_size ayarlanırken veya bir görüntü tensörü geçirilirken önemlidir.

ensembling_kwargs (dict, isteğe bağlı, varsayılan None) : Hassas ensemble kontrolü için argümanlar içeren ek sözlük. Aşağıdaki seçenekler kullanılabilir: - reduction (str, isteğe bağlı, varsayılan "median"): Her piksel konumunda uygulanan ensemble işlevini tanımlar, "median" veya "mean" olabilir.

latents (torch.Tensor, isteğe bağlı, varsayılan None) : Rastgele başlatmanın yerini alacak gizli gürültü tensörleri. Bunlar, önceki fonksiyon çağrısının çıktısından alınabilir.

generator (torch.Generator veya list[torch.Generator], isteğe bağlı, varsayılan None) : Yeniden üretilebilirliği sağlamak için rastgele sayı üreteci nesnesi.

output_type (str, isteğe bağlı, varsayılan "np") : Çıktının prediction ve isteğe bağlı uncertainty alanları için tercih edilen biçim. Kabul edilen değerler: "np" (numpy dizisi) veya "pt" (torch tensörü).

output_uncertainty (bool, isteğe bağlı, varsayılan False) : Etkinleştirildiğinde, ensemble_size argümanı 2'den büyük bir değere ayarlanmışsa, çıktının uncertainty alanı öngörü belirsizliği haritasını içerir.

output_latent (bool, isteğe bağlı, varsayılan False) : Etkinleştirildiğinde, çıktının latent alanı, ensemble içindeki tahminlere karşılık gelen latent kodları içerir. Bu kodlar kaydedilebilir, değiştirilebilir ve latents argümanı ile sonraki çağrılarda kullanılabilir.

return_dict (bool, isteğe bağlı, varsayılan True) : Düz bir tuple yerine MarigoldIntrinsicsOutput döndürülüp döndürülmediğini belirtir.

Dönüş: MarigoldIntrinsicsOutput veya tuple

return_dict True ise MarigoldIntrinsicsOutput döndürülür, aksi halde ilk öğesi tahmin, ikinci öğesi belirsizlik (veya None) ve üçüncü öğesi latent (veya None) olan bir tuple döndürülür.

pipeline çağrıldığında tetiklenen işlev.

Örnekler:

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

diffusers.pipelines.marigold.MarigoldIntrinsicsOutput[[diffusers.pipelines.marigold.MarigoldIntrinsicsOutput]]

diffusers.pipelines.marigold.MarigoldIntrinsicsOutput(prediction: typing.Union[numpy.ndarray, torch.Tensor], uncertainty: typing.Union[NoneType, numpy.ndarray, torch.Tensor], latent: typing.Optional[torch.Tensor])

Kaynak

Parametreler:

prediction (np.ndarray, torch.Tensor) : [0, 1] aralığında değerlere sahip tahmin edilen görüntü içsel parametreleri. torch.Tensor için şekil (numimages * numtargets) × 3 × height × width, np.ndarray için ise (numimages * numtargets) × height × width × 3 şeklindedir; burada numtargets, içsel görüntü ayrıştırmasının tahmin edilen hedef modalitelerinin sayısına karşılık gelir.

uncertainty (None, np.ndarray, torch.Tensor) : Ensemble'dan hesaplanan belirsizlik haritaları, değerler [0, 1] aralığındadır. torch.Tensor için şekil (numimages * numtargets) × 3 × height × width, np.ndarray için ise (numimages * numtargets) × height × width × 3'tür.

latent (None, torch.Tensor) : Tahminlere karşılık gelen, pipeline'ın latents argümanıyla uyumlu latent özellikler. Şekil (numimages * numensemble) × (numtargets * 4) × latentheight × latentwidth'dir.

Marigold Intrinsic Image Decomposition hattı için çıktı sınıfı.

diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_intrinsics[[diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_intrinsics]]

diffusers.pipelines.marigold.MarigoldImageProcessor.visualize_intrinsics(prediction: typing.Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor]], target_properties: dict, color_map: str | dict[str, str] = 'binary')

Kaynak

Parametreler:

prediction (np.ndarray | torch.Tensor | list[np.ndarray, list[torch.Tensor]]) : İçsel görüntü ayrıştırması.

target_properties (dict[str, Any]) : Ayrıştırma özellikleri. Beklenen girdiler: target_names: list[str] ve anahtarları prediction_space: str, sub_target_names: list[str | Null] (eksik modaliteler için null olmak üzere 3 girdi içermelidir), up_to_scale: bool olan bir sözlük; her hedef ve alt hedef için bir tane.

color_map (str | dict[str, str], isteğe bağlı, varsayılan "Spectral") : Tek kanallı tahminleri renkli temsillere dönüştürmek için kullanılan renk haritası. Bir sözlük geçirildiğinde, her modalite kendi renk haritasıyla renklendirilebilir.

MarigoldIntrinsicsPipeline öngörüleri gibi içsel görüntü ayrıştırmasını görselleştirir.

Dönüş: list[dict[str, PIL.Image.Image]] ile içsel görüntü ayrıştırma görselleştirmesi.