# Depth Anything

[Depth Anything](https://huggingface.co/papers/2401.10891), monoküler derinlik tahmini (MDE) için bir temel model olarak tasarlanmıştır. Veri setini geliştirmek amacıyla etiketli ve ~62M etiketsiz görüntü üzerinde birlikte eğitilir. Mevcut zengin anlamsal önceliklerini devralmak için bir görüntü kodlayıcı olarak önceden eğitilmiş bir [DINOv2](./dinov2) modeli ve çözücü olarak [DPT](./dpt) kullanır. Sahte etiketler oluşturmak için etiketsiz görüntüler üzerinde bir öğretmen modeli eğitilir. Öğrenci modeli, sahte etiketlerin ve etiketli görüntülerin bir kombinasyonunda eğitilir. Öğrenci modelinin performansını artırmak için, öğrenci modelinin görüntüden daha fazla görsel bilgi öğrenmesini sağlamak amacıyla etiketsiz görüntülere güçlü bozulmalar eklenir.

Tüm orijinal Depth Anything checkpoint'lerini [Depth Anything](https://huggingface.co/collections/LiheYoung/depth-anything-release-65b317de04eec72abf6b55aa) koleksiyonunda bulabilirsiniz.

> [!TIP]
> Farklı görü görevlerine Depth Anything uygulamanın daha fazla örneği için sağ kenar çubuğundaki Depth Anything modellerine tıklayın.

Aşağıdaki örnek, [Pipeline](/docs/transformers/main/tr/main_classes/pipelines#transformers.Pipeline) veya [AutoModel](/docs/transformers/main/tr/model_doc/auto#transformers.AutoModel) sınıfı ile derinlik haritası elde etmenin nasıl yapılacağını göstermektedir.

```python
from transformers import pipeline

pipe = pipeline(task="depth-estimation", model="LiheYoung/depth-anything-base-hf", device=0)
pipe("http://images.cocodataset.org/val2017/000000039769.jpg")["depth"]
```

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForDepthEstimation

image_processor = AutoImageProcessor.from_pretrained("LiheYoung/depth-anything-base-hf")
model = AutoModelForDepthEstimation.from_pretrained("LiheYoung/depth-anything-base-hf", device_map="auto")
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
inputs = image_processor(images=image, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

post_processed_output = image_processor.post_process_depth_estimation(
    outputs,
    target_sizes=[(image.height, image.width)],
)
predicted_depth = post_processed_output[0]["predicted_depth"]
depth = (predicted_depth - predicted_depth.min()) / (predicted_depth.max() - predicted_depth.min())
depth = depth.detach().cpu().numpy() * 255
Image.fromarray(depth.astype("uint8"))
```

## Notlar

- [DepthAnythingV2](./depth_anything_v2), Haziran 2024'te yayımlanmıştır, Depth Anything ile aynı mimariyi kullanır ve tüm kod örnekleri ile mevcut iş akışlarıyla uyumludur. Çok daha ince ve sağlam derinlik tahminleri elde etmek için sentetik veri ve daha büyük kapasiteli bir öğretmen modeli kullanır.

## DepthAnythingConfig[[transformers.DepthAnythingConfig]]

#### transformers.DepthAnythingConfig[[transformers.DepthAnythingConfig]]

```python
transformers.DepthAnythingConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, patch_size: int | list[int] | tuple[int, int] = 14, initializer_range: float = 0.02, reassemble_hidden_size: int = 384, reassemble_factors: list[int | float] | tuple[int | float, ...] = (4, 2, 1, 0.5), neck_hidden_sizes: list[int] | tuple[int, ...] = (48, 96, 192, 384), fusion_hidden_size: int = 64, head_in_index: int = -1, head_hidden_size: int = 32, depth_estimation_type: str = 'relative', max_depth: int | None = 1)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_anything/configuration_depth_anything.py#L25)

**Parametreler:**

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Omurga modelinin yapılandırması.

patch_size (`Union[int, list[int], tuple[int, int]]`, *isteğe bağlı*, varsayılan `14`) : Her yamanın boyutu (çözünürlüğü).

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

reassemble_hidden_size (`int`, *isteğe bağlı*, varsayılan 384) : Yeniden birleştirme katmanlarının giriş kanal sayısı.

reassemble_factors (`list[int]`, *isteğe bağlı*, varsayılan `[4, 2, 1, 0.5]`) : Yeniden birleştirme katmanlarının yukarı/aşağı örneklemeye faktörleri.

neck_hidden_sizes (`list[str]`, *isteğe bağlı*, varsayılan `[48, 96, 192, 384]`) : Omurganın (backbone) özellik haritaları için projeksiyon yapılacak gizli boyutlar.

fusion_hidden_size (`int`, *isteğe bağlı*, varsayılan 64) : Füzyondan önceki kanal sayısı.

head_in_index (`int`, *isteğe bağlı*, varsayılan -1) : Derinlik tahmini başlığında kullanılacak özelliklerin indeksi.

head_hidden_size (`int`, *isteğe bağlı*, varsayılan 32) : Derinlik tahmin başlığının ikinci konvolüsyonundaki çıktı kanalı sayısı.

depth_estimation_type (`str`, *isteğe bağlı*, varsayılan `"relative"`) : Kullanılacak derinlik tahmini türü. `["relative", "metric"]` değerlerinden biri olabilir.

max_depth (`float`, *isteğe bağlı*) : "metric" derinlik tahmini başlığı için kullanılacak maksimum derinlik. İç mekan modelleri için 20, dış mekan modelleri için 80 kullanılmalıdır. "relative" derinlik tahmininde bu değer yok sayılır.

Bu, bir Depth AnythingModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Depth Anything modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [LiheYoung/depth-anything-small-hf](https://huggingface.co/LiheYoung/depth-anything-small-hf) yapılandırmasına benzer bir yapılandırma üretir.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import DepthAnythingConfig, DepthAnythingForDepthEstimation

>>> # Initializing a DepthAnything small style configuration
>>> configuration = DepthAnythingConfig()

>>> # Initializing a model from the DepthAnything small style configuration
>>> model = DepthAnythingForDepthEstimation(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## DepthAnythingForDepthEstimation[[transformers.DepthAnythingForDepthEstimation]]

#### transformers.DepthAnythingForDepthEstimation[[transformers.DepthAnythingForDepthEstimation]]

```python
transformers.DepthAnythingForDepthEstimation(config: DepthAnythingConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_anything/modeling_depth_anything.py#L316)

**Parametreler:**

config ([DepthAnythingConfig](/docs/transformers/main/tr/model_doc/depth_anything#transformers.DepthAnythingConfig)) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

Üstünde derinlik tahmini kafası (3 konvolüsyonel katmandan oluşan) bulunan Depth Anything Model'i, örneğin KITTI, NYUv2 için.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

#### forward[[transformers.DepthAnythingForDepthEstimation.forward]]

```python
forward(pixel_values: Tensor, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_anything/modeling_depth_anything.py#L327)

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri [DPTImageProcessor](/docs/transformers/main/tr/model_doc/dpt#transformers.DPTImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [DPTImageProcessor.__call__()](/docs/transformers/main/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın (`processor_class`, görüntüleri işlemek için [DPTImageProcessor](/docs/transformers/main/tr/model_doc/dpt#transformers.DPTImageProcessor) kullanır).

labels (`torch.LongTensor`, şekli `(batch_size, height, width)`, *isteğe bağlı*) : Kayıp (loss) hesaplamak için kullanılan gerçek derinlik tahmin haritaları.

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** [DepthEstimatorOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) veya `tuple(torch.Tensor)`

[DepthEstimatorOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.DepthEstimatorOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([DepthAnythingConfig](/docs/transformers/main/tr/model_doc/depth_anything#transformers.DepthAnythingConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[DepthAnythingForDepthEstimation](/docs/transformers/main/tr/model_doc/depth_anything#transformers.DepthAnythingForDepthEstimation) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Sınıflandırma (config.num_labels==1 ise regresyon) kaybı.
- **predicted_depth** (`torch.Tensor`, şekli `(batch_size, height, width)`) -- Her piksel için tahmin edilen derinlik.
- **hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren ve `(batch_size, num_channels, height, width)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, patch_size, sequence_length)`.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnekler:
```python
>>> from transformers import AutoImageProcessor, AutoModelForDepthEstimation
>>> import torch
>>> import numpy as np
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("LiheYoung/depth-anything-small-hf")
>>> model = AutoModelForDepthEstimation.from_pretrained("LiheYoung/depth-anything-small-hf")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # interpolate to original size
>>> post_processed_output = image_processor.post_process_depth_estimation(
...     outputs,
...     target_sizes=[(image.height, image.width)],
... )

>>> # visualize the prediction
>>> predicted_depth = post_processed_output[0]["predicted_depth"]
>>> depth = predicted_depth * 255 / predicted_depth.max()
>>> depth = depth.detach().cpu().numpy()
>>> depth = Image.fromarray(depth.astype("uint8"))
```