Buckets:
| # Marigold Bilgisayar Görüşü | |
|  | |
| Marigold, [Bingxin Ke](http://www.kebingxin.com/), [Anton Obukhov](https://www.obukhov.ai/), [Shengyu Huang](https://shengyuh.github.io/), [Nando Metzger](https://nandometzger.github.io/), [Rodrigo Caye Daudt](https://rcdaudt.github.io/) ve [Konrad Schindler](https://scholar.google.com/citations?user=FZuNgqIAAAAJ&hl=en) tarafından yazılan CVPR 2024 Oral makalesi olan [Repurposing Diffusion-Based Image Generators for Monocular Depth Estimation](https://huggingface.co/papers/2312.02145) 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](http://www.kebingxin.com/), [Kevin Qu](https://www.linkedin.com/in/kevin-qu-b3417621b/?locale=en_US), [Tianfu Wang](https://tianfwang.github.io/), [Nando Metzger](https://nandometzger.github.io/), [Shengyu Huang](https://shengyuh.github.io/), [Bo Li](https://www.linkedin.com/in/bobboli0202/), [Anton Obukhov](https://www.obukhov.ai/) ve [Konrad Schindler](https://scholar.google.com/citations?user=FZuNgqIAAAAJ&hl=en) tarafından kaleme alınan [Marigold: Affordable Adaptation of Diffusion-Based Image Generators for Image Analysis](https://huggingface.co/papers/2312.02145) 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. | |
| > [!TIP] | |
| > 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_depth.py) | [prs-eth/marigold-depth-v1-1](https://huggingface.co/prs-eth/marigold-depth-v1-1) | [Derinlik Tahmini](https://huggingface.co/spaces/prs-eth/marigold) | [Derinlik](https://en.wikipedia.org/wiki/Depth_map), [Paralaks](https://en.wikipedia.org/wiki/Binocular_disparity) | | |
| | [MarigoldNormalsPipeline](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_normals.py) | [prs-eth/marigold-normals-v1-1](https://huggingface.co/prs-eth/marigold-normals-v1-1) | [Yüzey Normallerinin Tahmini](https://huggingface.co/spaces/prs-eth/marigold-normals) | [Yüzey normalleri](https://en.wikipedia.org/wiki/Normal_mapping) | | |
| | [MarigoldIntrinsicsPipeline](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_intrinsics.py) | [prs-eth/marigold-iid-appearance-v1-1](https://huggingface.co/prs-eth/marigold-iid-appearance-v1-1),[prs-eth/marigold-iid-lighting-v1-1](https://huggingface.co/prs-eth/marigold-iid-lighting-v1-1) | [İçsel Görüntü Ayrıştırma](https://huggingface.co/spaces/prs-eth/marigold-iid) | [Albedo](https://en.wikipedia.org/wiki/Albedo), [Materyaller](https://www.n.aiq3d.com/wiki/roughnessmetalnessao-map), [Aydınlatma](https://en.wikipedia.org/wiki/Diffuse_reflection) | | |
| ## Mevden Kontroller | |
| Tüm orijinal checkpoint'ler Hugging Face'teki [PRS-ETH](https://huggingface.co/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ı](https://github.com/prs-eth/marigold) 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](https://huggingface.co/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](https://huggingface.co/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](https://huggingface.co/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](https://huggingface.co/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$. | | |
| > [!TIP] | |
| > Zamanlayıcı hızı ve kalitesi arasındaki ödünleşimi keşfetmeyi öğrenmek için Zamanlayıcılar [kılavuzunu](../../using-diffusers/schedulers) 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](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) 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](./stable_diffusion/svd#reduce-memory-usage) ulaşabilirsiniz. | |
| > [!WARNING] | |
| > 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](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.MarigoldDepthPipeline) içine yükleyin, görüntüyü boru hattından geçirin ve tahminleri kaydedin: | |
| ```python | |
| 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()](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldImageProcessor.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](https://matplotlib.org/stable/users/explain/colors/colormaps.html) 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](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.MarigoldNormalsPipeline) içine yükleyin, görüntüyü boru hattından geçirin ve tahminleri kaydedin: | |
| ```python | |
| 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()](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldImageProcessor.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: | |
| ```python | |
| 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: | |
| ```python | |
| 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()](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldImageProcessor.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](https://huggingface.co/spaces/prs-eth/marigold-iid) 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: | |
| ```diff | |
| 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](../models/autoencoder_tiny) 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. | |
| ```diff | |
| 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: | |
| ```diff | |
| 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](../../optimization/fp16#torchcompile) 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. | |
| ```diff | |
| 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: | |
| ```diff | |
| 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: | |
| ```python | |
| 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: | |
| ```python | |
| 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. | |
| ```python | |
| 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: | |
| ```python | |
| 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]] | |
| ```python | |
| 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_depth.py#L104) | |
| **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](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.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__]] | |
| ```python | |
| __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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_depth.py#L347) | |
| **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](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldDepthOutput) döndürülüp döndürülmemesi. | |
| **Dönüş:** [MarigoldDepthOutput](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldDepthOutput) veya `tuple` | |
| `return_dict` `True` ise [MarigoldDepthOutput](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.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: | |
| ```py | |
| >>> 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]] | |
| ```python | |
| 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_depth.py#L83) | |
| **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]] | |
| ```python | |
| 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/marigold_image_processing.py#L387) | |
| **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]] | |
| ```python | |
| 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_normals.py#L99) | |
| **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](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.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__]] | |
| ```python | |
| __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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_normals.py#L332) | |
| **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](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldNormalsOutput) döndürülüp döndürülmemesi. | |
| **Dönüş:** [MarigoldNormalsOutput](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldNormalsOutput) veya `tuple` | |
| `return_dict` `True` ise [MarigoldNormalsOutput](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.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: | |
| ```py | |
| >>> 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]] | |
| ```python | |
| 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_normals.py#L78) | |
| **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]] | |
| ```python | |
| 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/marigold_image_processing.py#L486) | |
| **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]] | |
| ```python | |
| 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_intrinsics.py#L120) | |
| **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](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.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__]] | |
| ```python | |
| __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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_intrinsics.py#L359) | |
| **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](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldIntrinsicsOutput) döndürülüp döndürülmediğini belirtir. | |
| **Dönüş:** [MarigoldIntrinsicsOutput](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.MarigoldIntrinsicsOutput) veya `tuple` | |
| `return_dict` `True` ise [MarigoldIntrinsicsOutput](/docs/diffusers/main/tr/api/pipelines/marigold#diffusers.pipelines.marigold.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: | |
| ```py | |
| >>> 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") | |
| ``` | |
| ```py | |
| >>> 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]] | |
| ```python | |
| 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/pipeline_marigold_intrinsics.py#L96) | |
| **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]] | |
| ```python | |
| 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/marigold/marigold_image_processing.py#L542) | |
| **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. | |
Xet Storage Details
- Size:
- 68.3 kB
- Xet hash:
- e64416043f5a78cff283ae225c6d91d05eaccffd4188a5130c14fba5aeb833a7
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.