# DepthPro

## Genel Bakış

DepthPro modeli, Aleksei Bochkovskii, Amaël Delaunoy, Hugo Germain, Marcel Santos, Yichao Zhou, Stephan R. Richter ve Vladlen Koltun tarafından [Depth Pro: Sharp Monocular Metric Depth in Less Than a Second](https://huggingface.co/papers/2410.02073) makalesinde önerilmiştir.

DepthPro, sıfır atış metrik monoküler derinlik tahmini için bir temel modeldir; olağanüstü keskinlik ve ince detaylarla yüksek çözünürlüklü derinlik haritaları üretmek üzere tasarlanmıştır. Çok ölçekli, Vision Transformer (ViT) tabanlı bir mimari kullanır; bu mimaride görüntüler indirgenir, yamalar (patch) halinde bölünür ve paylaşılan bir Dinov2 kodlayıcı ile işlenir. Çıkarılan yama düzeyindeki özellikler birleştirilir, büyütülür ve DPT benzeri bir füzyon aşamasında rafine edilerek hassas derinlik tahmini sağlanır.

Makalenin özeti aşağıdaki gibidir:

*Sıfır atış metrik monoküler derinlik tahmini için bir temel model sunuyoruz. Modelimiz Depth Pro, eşsiz keskinlik ve yüksek frekanslı detaylarla yüksek çözünürlüklü derinlik haritaları sentezler. Tahminler, kamera içsel parametreleri gibi meta verilerin kullanılabilirliğine dayanmadan, mutlak ölçekle metrik niteliktedir. Ayrıca model hızlıdır ve standart bir GPU üzerinde 0,3 saniyede 2,25 megapiksellik bir derinlik haritası üretir. Bu özellikler, yoğun tahmin için verimli çok ölçekli bir görme dönüştürücüsü, yüksek metrik doğruluğu ince sınır izlemeyle birleştirmek üzere gerçek ve sentetik veri kümelerini kullanan bir eğitim protokolü, tahmin edilen derinlik haritalarındaki sınır doğruluğu için özel değerlendirme metrikleri ve tek bir görüntüden en son odak uzaklığı tahmini dahil olmak üzere çeşitli teknik katkılarla mümkün kılınmaktadır. Kapsamlı deneyler, belirli tasarım seçimlerini analiz eder ve Depth Pro'nun önceki çalışmalardan birden fazla boyutta daha iyi performans gösterdiğini kanıtlar.*

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/depth_pro_teaser.png"
alt="drawing" width="600"/>

 DepthPro Çıktıları. Resmi koddan alınmıştır.

Bu model [geetu040](https://github.com/geetu040) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/apple/ml-depth-pro) bulunabilir.

## Kullanım İpuçları

DepthPro modeli, girdi görüntüsünü önce birden fazla ölçekte küçültüp her ölçeklenmiş sürümünü yamalar (patch) halinde bölerek işler. Bu yamalar, paylaşılan bir Vision Transformer (ViT) tabanlı Dinov2 yama kodlayıcısı kullanılarak kodlanırken, tam görüntü ayrı bir görüntü kodlayıcısı tarafından işlenir. Çıkarılan yama özellikleri, özellik haritalarına birleştirilir, büyütülür ve nihai derinlik tahminini üretmek için DPT benzeri bir çözücü (decoder) kullanılarak birleştirilir. Etkinleştirilirse, ek bir Görüş Alanı (FOV) kodlayıcısı, derinlik doğruluğuna yardımcı olmak amacıyla kameranın görüş alanını tahmin etmek için görüntüyü işler.

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

from transformers import DepthProForDepthEstimation, DepthProImageProcessor

url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)

image_processor = DepthProImageProcessor.from_pretrained("apple/DepthPro-hf")
model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", device_map="auto")

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

field_of_view = post_processed_output[0]["field_of_view"]
focal_length = post_processed_output[0]["focal_length"]
depth = post_processed_output[0]["predicted_depth"]
depth = (depth - depth.min()) / depth.max()
depth = depth * 255.
depth = depth.detach().cpu().numpy()
depth = Image.fromarray(depth.astype("uint8"))
```

### Mimari ve Yapılandırma

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/depth_pro_architecture.png"
alt="drawing" width="600"/>

 DepthPro mimarisi. Orijinal makaleden alınmıştır.

`DepthProForDepthEstimation` modeli, girdi görüntüsünü kodlamak için `DepthProEncoder` ve kodlayıcının çıktı özelliklerini birleştirmek için `FeatureFusionStage` kullanır.

`DepthProEncoder` ayrıca iki kodlayıcı kullanır:

- `patch_encoder`
  - Girdi görüntüsü, `scaled_images_ratios` yapılandırmasında belirtildiği üzere birden fazla oranla ölçeklendirilir.
  - Her ölçeklendirilmiş görüntü, `scaled_images_overlap_ratios` tarafından belirlenen örtüşen alanlara sahip, `patch_size` boyutunda daha küçük **patch'lere** bölünür.
  - Bu yamalar **`patch_encoder`** tarafından işlenir
- `image_encoder`
  - Girdi görüntüsü de `patch_size` boyutuna yeniden ölçeklenir ve **`image_encoder`** tarafından işlenir.

Her iki kodlayıcı da sırasıyla `patch_model_config` ve `image_model_config` ile yapılandırılabilir; her ikisi de varsayılan olarak ayrı `Dinov2Model` örneğidir.

Her iki kodlayıcının (`last_hidden_state`) ve **`patch_encoder`**'den seçilen ara durumların (`hidden_states`) çıktıları, derinlik tahmini için `DPT`-tabanlı bir `FeatureFusionStage` ile birleştirilir.

### Görüş Alanı (FOV) Tahmini

Ağ, bir odak uzaklığı tahmin başlığı ile tamamlanır. Küçük bir konvolüsyon başlığı, derinlik tahmin ağından dondurulmuş özellikleri ve ayrı bir ViT görüntü kodlayıcısından görev-özel özellikleri alarak yatay açısal görüş alanını tahmin eder.

`DepthProConfig` içindeki `use_fov_model` parametresi, **FOV tahmininin** etkin olup olmadığını kontrol eder. Varsayılan olarak, bellek ve hesaplama tasarrufu sağlamak için `False` olarak ayarlanır. Etkinleştirildiğinde, **FOV kodlayıcısı**, varsayılan olarak `Dinov2Model` olan `fov_model_config` parametresine göre örneklenir. `use_fov_model` parametresi, `DepthProForDepthEstimation` modeli başlatılırken de geçirilebilir.

Kontrol noktası `apple/DepthPro-hf` içindeki önceden eğitilmiş model, FOV kodlayıcıyı kullanır. FOV kodlayıcı olmadan önceden eğitilmiş modeli kullanmak için, modeli yüklerken `use_fov_model=False` parametresini ayarlayın; bu işlem hesaplama maliyetini azaltır.

```python
from transformers import DepthProForDepthEstimation

model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", use_fov_model=False, device_map="auto")
```

FOV kodlayıcı ile yeni bir model oluşturmak için yapılandırmada `use_fov_model=True` değerini ayarlayın.

```python
from transformers import DepthProConfig, DepthProForDepthEstimation

config = DepthProConfig(use_fov_model=True)
model = DepthProForDepthEstimation(config)
```

Veya modeli başlatırken `use_fov_model=True` değerini ayarlayın; bu, config içindeki değeri geçersiz kılar.

```python
from transformers import DepthProConfig, DepthProForDepthEstimation

config = DepthProConfig()
model = DepthProForDepthEstimation(config, use_fov_model=True)
```

### Ölçekli Nokta Çarpımı Dikkat (SDPA) Kullanımı

PyTorch, `torch.nn.functional` parçası olarak yerel ölçekli nokta çarpımı dikkati (SDPA) operatörünü içerir. Bu fonksiyon, girdilere ve kullanılan donanıma bağlı olarak uygulanabilecek çeşitli uygulamaları kapsar. Daha fazla bilgi için [resmi dokümantasyonu](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) veya [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention) sayfasına bakın.

`torch>=2.1.1` için bir uygulama mevcut olduğunda varsayılan olarak SDPA kullanılır, ancak SDPA'nın kullanılmasını açıkça istemek için `from_pretrained()` içinde `attn_implementation="sdpa"` ayarlayabilirsiniz.

```python
from transformers import DepthProForDepthEstimation

model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", attn_implementation="sdpa", device_map="auto")
```

En iyi hızlanmalar için, modelin yarım hassasiyette (ör. `torch.float16` veya `torch.bfloat16`) yüklenmesini öneririz.

Yerel bir benchmark'ta (A100-40GB, PyTorch 2.3.0, OS Ubuntu 22.04) `float32` ve `google/vit-base-patch16-224` modeliyle, çıkarım sırasında aşağıdaki hızlanmaları gözlemledik.

|   Toplu işlem boyutu |   Ortalama çıkarım süresi (ms), aceleci mod |   Ortalama çıkarım süresi (ms), sdpa modeli |   Hızlandırma, Sdpa / Eager (x) |
|--------------|-------------------------------------------|-------------------------------------------|------------------------------|
|            1 |                                         7 |                                         6 |                      1.17 |
|            2 |                                         8 |                                         6 |                      1.33 |
|            4 |                                         8 |                                         6 |                      1.33 |
|            8 |                                         8 |                                         6 |                      1.33 |

## Kaynaklar

DepthPro ile başlamanıza yardımcı olmak için resmi Hugging Face ve topluluk (🌎 ile belirtilen) kaynaklarının listesi:

- Araştırma Makalesi: [Depth Pro: Sharp Monocular Metric Depth in Less Than a Second](https://huggingface.co/papers/2410.02073)
- Resmî Uygulama: [apple/ml-depth-pro](https://github.com/apple/ml-depth-pro)
- DepthPro Çıkarım Defter Notu: [DepthPro Çıkarımı](https://github.com/qubvel/transformers-notebooks/blob/main/notebooks/DepthPro_inference.ipynb)
- Yüksek Çözünürlük ve Görüntü Segmentasyonu için DepthPro
  - Medium'daki blogu okuyun: [Depth Pro: Beyond Depth](https://medium.com/@raoarmaghanshakir040/depth-pro-beyond-depth-9d822fc557ba)
  - Github'daki kod: [geetu040/depthpro-beyond-depth](https://github.com/geetu040/depthpro-beyond-depth)

Buraya bir kaynak eklemek isterseniz, lütfen bir Pull Request açmaktan çekinmeyin; inceleyeceğiz! Kaynağın, mevcut bir kaynağı tekrarlamak yerine ideal olarak yeni bir şeyi göstermesi beklenir.

## DepthProConfig[[transformers.DepthProConfig]]

#### transformers.DepthProConfig[[transformers.DepthProConfig]]

```python
transformers.DepthProConfig(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, fusion_hidden_size: int = 256, patch_size: int | list[int] | tuple[int, int] = 384, initializer_range: float = 0.02, intermediate_hook_ids: list[int] | tuple[int, ...] = (11, 5), intermediate_feature_dims: list[int] | tuple[int, ...] = (256, 256), scaled_images_ratios: list[int | float] | tuple[int | float, ...] = (0.25, 0.5, 1), scaled_images_overlap_ratios: list[float] | tuple[float, ...] = (0.0, 0.5, 0.25), scaled_images_feature_dims: list[int] | tuple[int, ...] = (1024, 1024, 512), merge_padding_value: int = 3, use_batch_norm_in_fusion_residual: bool = False, use_bias_in_fusion_residual: bool = True, use_fov_model: bool = False, num_fov_head_layers: int = 2, image_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, patch_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, fov_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/depth_pro/configuration_depth_pro.py#L28)

**Parametreler:**

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

patch_size (`Union[int, list[int], tuple[int, int]]`, *isteğe bağlı*, varsayılan `384`) : 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ı.

intermediate_hook_ids (`list[int]`, *isteğe bağlı*, varsayılan `[11, 5]`) : Füzyon için kullanılacak yama kodlayıcısından ara gizli durumların dizinleri.

intermediate_feature_dims (`list[int]`, *isteğe bağlı*, varsayılan `[256, 256]`) : `intermediate_hook_ids` içindeki her ara gizli durum için örnekleme artırma sırasında gizli durum boyutları.

scaled_images_ratios (`list[float]`, *isteğe bağlı*, varsayılan `[0.25, 0.5, 1]`) : Yama kodlayıcısının kullanacağı ölçeklendirilmiş görüntü oranları.

scaled_images_overlap_ratios (`list[float]`, *isteğe bağlı*, varsayılan `[0.0, 0.5, 0.25]`) : `scaled_images_ratios` içindeki her ölçeklendirilmiş görüntü için yamalar arasındaki örtüşme oranları.

scaled_images_feature_dims (`list[int]`, *isteğe bağlı*, varsayılan `[1024, 1024, 512]`) : `scaled_images_ratios` içindeki her ölçeklendirilmiş görüntü için yukarı örneklemeye (upsampling) ait gizli durum boyutları.

merge_padding_value (`int`, *opsiyonel*, varsayılan 3) : Daha küçük yamalar (patches) görüntü boyutuna geri birleştirilirken, bu boyuttaki üst üste binen bölümler kaldırılır.

use_batch_norm_in_fusion_residual (`bool`, *isteğe bağlı*, varsayılan `False`) : Füzyon bloklarındaki ön-aktivasyonlu artımsal birimlerde parti normalizasyonu kullanılıp kullanılmayacağı.

use_bias_in_fusion_residual (`bool`, *isteğe bağlı*, varsayılan `True`) : Füzyon bloklarındaki ön-aktivasyonlu artık birimlerinde sapma (bias) kullanılıp kullanılmayacağı.

use_fov_model (`bool`, *isteğe bağlı*, varsayılan `False`) : Görüş alanını üretmek için `DepthProFovModel`'in kullanılıp kullanılmayacağı.

num_fov_head_layers (`int`, *isteğe bağlı*, varsayılan 2) : `DepthProFovModel` başındaki konvolüsyon katmanlarının sayısı.

image_model_config (`Union[dict[str, Any], PreTrainedConfig]`, *isteğe bağlı*) : [AutoModel](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoModel) API'si kullanılarak yüklenen görüntü kodlayıcı modelinin yapılandırmasıdır. Varsayılan olarak, Dinov2 modeli omurga olarak kullanılır.

patch_model_config (`Union[dict[str, Any], PreTrainedConfig]`, *isteğe bağlı*) : [AutoModel](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoModel) API'si kullanılarak yüklenen yama kodlayıcı (patch encoder) modelinin yapılandırması. Varsayılan olarak, omurga (backbone) olarak Dinov2 modeli kullanılır.

fov_model_config (`Union[dict[str, Any], PreTrainedConfig]`, *isteğe bağlı*) : [AutoModel](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoModel) API'si kullanılarak yüklenen fov encoder modelinin yapılandırması. Varsayılan olarak, Dinov2 modeli omurga (backbone) olarak kullanılır.

Bu, bir DepthProModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Depth Pro modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [apple/DepthPro](https://huggingface.co/apple/DepthPro) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnek:

```python
>>> from transformers import DepthProConfig, DepthProModel

>>> # Initializing a DepthPro apple/DepthPro style configuration
>>> configuration = DepthProConfig()

>>> # Initializing a model (with random weights) from the apple/DepthPro style configuration
>>> model = DepthProModel(configuration)

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

## DepthProImageProcessor[[transformers.DepthProImageProcessor]]

#### transformers.DepthProImageProcessor[[transformers.DepthProImageProcessor]]

```python
transformers.DepthProImageProcessor(**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/depth_pro/image_processing_depth_pro.py#L45)

**Parametreler:**

do_convert_rgb (`bool`, *kwargs*, *isteğe bağlı*) : Görselin RGB'ye dönüştürülüp dönüştürülmeyeceği.

do_resize (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin yeniden boyutlandırılıp boyutlandırılmayacağı.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, varsayılan `{'height' : 1536, 'width': 1536}`): Modelin kabul ettiği maksimum giriş boyutlarını açıklar.

default_to_square (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Boyut bir int ise, yeniden boyutlandırma sırasında varsayılan olarak kare bir görüntü kullanılıp kullanılmayacağını belirtir.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` uygulandıktan sonra çıktı görüntüsünün boyutu.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, varsayılan `2`) : Görsel yeniden boyutlandırılıyorsa kullanılacak yeniden örnekleme filtresi. Bu, `PILImageResampling` enum değerlerinden biri olabilir. Yalnızca `do_resize` `True` olarak ayarlanırsa etkilidir.

do_rescale (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin yeniden ölçeklendirilip ölçeklendirilmeyeceğini belirtir.

rescale_factor (`float`, *kwargs*, *opsiyonel*, varsayılan `0.00392156862745098`) : `do_rescale` `True` olarak ayarlandığında görüntüyü yeniden ölçeklemek için kullanılan yeniden ölçekleme faktörü.

do_normalize (`bool`, *kwargs*, *opsiyonel*, varsayılan `True`) : Görselin normalize edilip edilmeyeceğini belirtir.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*, varsayılan `[0.5, 0.5, 0.5]`) : Normalizasyon için kullanılacak görüntü ortalaması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*, varsayılan `[0.5, 0.5, 0.5]`) : Normalizasyon için kullanılacak görüntü standart sapması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

do_pad (`bool`, *kwargs*, *isteğe bağlı*) : Görselin dolgu (padding) uygulanıp uygulanmayacağını belirtir. Dolgu, ya batch içindeki en büyük boyuta ya da görsel başına sabit bir kare boyuta yapılır. Kesin dolgu stratejisi modele bağlıdır.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Görsellerin doldurulacağı boyut, `{"height": int, "width" int}` biçiminde. Ön işleme için sağlanan herhangi bir görsel boyutundan büyük olmalıdır. `pad_size` sağlanmazsa, görseller partideki en büyük yüksekliğe ve genişliğe doldurulur. Yalnızca `do_pad=True.` olduğunda uygulanır.

do_center_crop (`bool`, *kwargs*, *opsiyonel*) : Görselin merkezden kırpılıp kırpılmayacağını belirtir.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Yalnızca `ChannelDimension.FIRST` desteklenir. Yavaş işleyicilerle uyumluluk için eklendi.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Girdi görüntüsünün kanal boyutu biçimi. Ayarlanmazsa, kanal boyutu biçimi girdi görüntüsünden çıkarılır. Aşağıdakilerden biri olabilir: - `"channels_first"` veya `ChannelDimension.FIRST`: (num_channels, height, width) biçiminde görüntü. - `"channels_last"` veya `ChannelDimension.LAST`: (height, width, num_channels) biçiminde görüntü. - `"none"` veya `ChannelDimension.NONE`: (height, width) biçiminde görüntü.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Videoların işleneceği cihaz. Ayarlanmamışsa, cihaz girdi videolarından çıkarılır.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'` olarak ayarlanırsa yığılmış tensörleri, aksi halde tensör listesi döndürür.

disable_grouping (`bool`, *kwargs*, *opsiyonel*) : Görsellerin boyuta göre gruplandırılmasını devre dışı bırakarak bunların toplu olarak değil, tek tek işlenmesini sağlar. None ise, görseller CPU üzerindeyse True, aksi halde False olarak ayarlanır. Bu seçim, buradaki ayrıntılı açıklamalara dayalı ampirik gözlemlere dayanmaktadır: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opsiyonel*) : Girdideki her görüntü için kullanılacak görüntü jetonlarının sayısı. Geriye dönük uyumluluk için eklendi ancak gelecekteki modellerde bu, bir işlemci özniteliği olarak ayarlanmalıdır. `'pt'` olarak ayarlanırsa yığılmış tensörler döndürür, aksi takdirde tensör listesi döndürür.

disable_grouping (`bool`, *kwargs*, *opsiyonel*) : Görsellerin boyuta göre gruplandırılmasını devre dışı bırakarak bunların toplu olarak değil, tek tek işlenmesini sağlar. None ise, görseller CPU üzerindeyse True, aksi halde False olarak ayarlanır. Bu seçim, buradaki ayrıntılı açıklamalara dayalı ampirik gözlemlere dayanmaktadır: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *opsiyonel*) : Girdideki her görüntü için kullanılacak görüntü jetonlarının sayısı. Geriye dönük uyumluluk için eklendi ancak gelecekteki modellerde bu, bir işlemci özniteliği olarak ayarlanmalıdır. `'pt'` olarak ayarlanırsa yığılmış tensörler döndürür, aksi takdirde tensör listesi döndürür.

disable_grouping (`bool`, *kwargs*, *opsiyonel*) : Görsellerin boyuta göre gruplandırılmasını devre dışı bırakarak bunların toplu olarak değil, tek tek işlenmesini sağlar. None ise, görseller CPU üzerindeyse True, aksi halde False olarak ayarlanır. Bu seçim, buradaki ayrıntılı açıklamalara dayalı ampirik gözlemlere dayanmaktadır: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *isteğe bağlı*) : Girdideki her görüntü için kullanılacak görüntü jetonlarının sayısı. Geriye dönük uyumluluk için eklendi ancak bu, gelecekteki modellerde bir işlemci özniteliği olarak ayarlanmalıdır.

`'pt'` olarak ayarlanırsa yığılmış tensörler döndürür, aksi takdirde tensör listesi döndürür. --

Bir DepthPro görüntü işleyicisi oluşturur.

disable_grouping (`bool`, *kwargs*, *opsiyonel*): Görsellerin boyuta göre gruplandırılmasını devre dışı bırakarak bunların toplu olarak değil, bireysel olarak işlenmesini sağlar. None ise, görseller CPU üzerindeyse True, aksi halde False olarak ayarlanır. Bu seçim, buradaki ayrıntılı açıklamaya dayanan ampirik gözlemlere dayanmaktadır: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opsiyonel*): Girdideki her görsel için kullanılacak görsel jeton sayısı. Geriye dönük uyumluluk için eklendi ancak gelecekteki modellerde bu, bir işlemci özniteliği olarak ayarlanmalıdır.

#### preprocess[[transformers.DepthProImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/image_processing_utils.py#L382)

**Parametreler:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Ön işlenecek görüntü. Piksel değerleri 0 ile 255 arasında değişen tek bir görüntü veya görüntü grubu beklenir. Piksel değerleri 0 ile 1 arasında olan görüntüler geçiriliyorsa `do_rescale=False` olarak ayarlayın.

image_like_kwargs (`dict[str, Any]`, *isteğe bağlı*) : Ek görüntü benzeri girdiler için geliştirici bayrağı; bu girdiler de ön işleme tabi tutulacaktır. Girdileri kwarg olarak geçirmenin çalışmadığı durumlarda kullanın. Örneğin, `preprocess(images, masks=masks)` tercih edilen seçenektir ancak bazı modellerde argüman öncelik sorunlarına yol açar. Bu durumlarda bunun yerine `preprocess(images, image_like_inputs={"masks": masks})` kullanılabilir.

do_convert_rgb (`bool`, *kwargs*, *isteğe bağlı*) : Görselin RGB'ye dönüştürülüp dönüştürülmeyeceği.

do_resize (`bool`, *kwargs*, *isteğe bağlı*) : Görselin yeniden boyutlandırılıp boyutlandırılmayacağı.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Modelin kabul ettiği maksimum giriş boyutlarını açıklar.

default_to_square (`bool`, *kwargs*, *opsiyonel*) : Boyut bir int ise, yeniden boyutlandırma sırasında varsayılan olarak kare bir görsel kullanılıp kullanılmayacağı.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` uygulandıktan sonra çıktı görüntüsünün boyutu.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Görsel yeniden boyutlandırılıyorsa kullanılacak yeniden örnekleme filtresi. Bu, `PILImageResampling` enum değerlerinden biri olabilir. Yalnızca `do_resize` `True` olarak ayarlanırsa etkilidir.

do_rescale (`bool`, *kwargs*, *opsiyonel*) : Görselin yeniden ölçeklendirilip ölçeklendirilmeyeceğini belirtir.

rescale_factor (`float`, *kwargs*, *opsiyonel*) : `do_rescale` `True` olarak ayarlanırsa görüntüyü yeniden ölçeklemek için yeniden ölçekleme çarpanı.

do_normalize (`bool`, *kwargs*, *isteğe bağlı*) : Görüntünün normalize edilip edilmeyeceğini belirtir.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*) : Normalizasyon için kullanılacak görüntü ortalaması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsiyonel*) : Normalizasyon için kullanılacak görüntü standart sapması. Yalnızca `do_normalize` `True` olarak ayarlanırsa etkilidir.

do_pad (`bool`, *kwargs*, *isteğe bağlı*) : Görselin dolgu (padding) uygulanıp uygulanmayacağını belirtir. Dolgu, ya batch içindeki en büyük boyuta ya da görsel başına sabit bir kare boyuta yapılır. Kesin dolgu stratejisi modele bağlıdır.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Görsellerin doldurulacağı boyut, `{"height": int, "width" int}` biçiminde. Ön işleme için sağlanan herhangi bir görsel boyutundan büyük olmalıdır. `pad_size` sağlanmazsa, görseller partideki en büyük yüksekliğe ve genişliğe doldurulur. Yalnızca `do_pad=True.` olduğunda uygulanır.

do_center_crop (`bool`, *kwargs*, *opsiyonel*) : Görselin merkezden kırpılıp kırpılmayacağını belirtir.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Yalnızca `ChannelDimension.FIRST` desteklenir. Yavaş işleyicilerle uyumluluk için eklendi.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *isteğe bağlı*) : Girdi görüntüsünün kanal boyutu biçimi. Ayarlanmazsa, kanal boyutu biçimi girdi görüntüsünden çıkarılır. Aşağıdakilerden biri olabilir: - `"channels_first"` veya `ChannelDimension.FIRST`: (num_channels, height, width) biçiminde görüntü. - `"channels_last"` veya `ChannelDimension.LAST`: (height, width, num_channels) biçiminde görüntü. - `"none"` veya `ChannelDimension.NONE`: (height, width) biçiminde görüntü.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Videoların işleneceği cihaz. Ayarlanmamışsa, cihaz girdi videolarından çıkarılır.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'` olarak ayarlanırsa yığılmış tensörleri, aksi halde tensör listesi döndürür.

disable_grouping (`bool`, *kwargs*, *opsiyonel*) : Görsellerin boyuta göre gruplandırılmasını devre dışı bırakarak bunların toplu olarak değil, tek tek işlenmesini sağlar. None ise, görseller CPU üzerindeyse True, aksi halde False olarak ayarlanır. Bu seçim, buradaki ayrıntılı açıklamalara dayalı ampirik gözlemlere dayanmaktadır: https://github.com/huggingface/transformers/pull/38157

image_seq_length (`int`, *kwargs*, *isteğe bağlı*) : Girdideki her görüntü için kullanılacak görüntü jetonlarının sayısı. Geriye dönük uyumluluk için eklendi ancak bu, gelecekteki modellerde bir işlemci özniteliği olarak ayarlanmalıdır.

**Dönüş:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- __call__ yönteminin döndürdüğü listeler/diziler/tensörler sözlüğü ('pixel_values' vb.).
- **tensor_type** (`Union[None, str, TensorType]`, *isteğe bağlı*) -- Başlatma sırasında PyTorch/Numpy Tensörlerindeki tamsayı listelerini dönüştürmek için burada bir tensor_type verebilirsiniz.

Bir görüntüyü veya bir görüntü grubunu ön işleme tabi tutun.

#### post_process_depth_estimation[[transformers.DepthProImageProcessor.post_process_depth_estimation]]

```python
post_process_depth_estimation(outputs: DepthProDepthEstimatorOutput, target_sizes: transformers.utils.generic.TensorType | list[tuple[int, int]] | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/depth_pro/image_processing_depth_pro.py#L84)

Modelden gelen ham derinlik tahminlerini son işlemeye tabi tutar.

## DepthProModel[[transformers.DepthProModel]]

#### transformers.DepthProModel[[transformers.DepthProModel]]

```python
transformers.DepthProModel(config: DepthProConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/depth_pro/modeling_depth_pro.py#L624)

**Parametreler:**

config ([DepthProConfig](/docs/transformers/v5.23.0/tr/model_doc/depth_pro#transformers.DepthProConfig)) : 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/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın.

Üzerinde herhangi bir özel head olmadan ham hidden-states üreten çıplak Depth Pro Model.

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/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.DepthProModel.forward]]

```python
forward(pixel_values: Tensor, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/depth_pro/modeling_depth_pro.py#L636)

**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 [DepthProImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/depth_pro#transformers.DepthProImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [DepthProImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın (`processor_class`, görüntü işleme için [DepthProImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/depth_pro#transformers.DepthProImageProcessor) kullanır).

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/v5.23.0/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `DepthProOutput` veya `tuple(torch.Tensor)`

Yapılandırmaya ([DepthProConfig](/docs/transformers/v5.23.0/tr/model_doc/depth_pro#transformers.DepthProConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşan bir `DepthProOutput` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda).

[DepthProModel](/docs/transformers/v5.23.0/tr/model_doc/depth_pro#transformers.DepthProModel) 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.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, n_patches_per_batch, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **features** (`Union[torch.Tensor, List[torch.Tensor]]`, *isteğe bağlı*) -- Kodlayıcılardan gelen özellikler. Tek bir özellik veya özellik listesi olabilir.
- **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` (modelin bir 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 bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  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) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

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

Örnekler:

```python
>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, DepthProModel

>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> checkpoint = "apple/DepthPro-hf"
>>> processor = AutoProcessor.from_pretrained(checkpoint)
>>> model = DepthProModel.from_pretrained(checkpoint)

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

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

>>> output.last_hidden_state.shape
torch.Size([1, 35, 577, 1024])
```

## DepthProForDepthEstimation[[transformers.DepthProForDepthEstimation]]

#### transformers.DepthProForDepthEstimation[[transformers.DepthProForDepthEstimation]]

```python
transformers.DepthProForDepthEstimation(config: DepthProConfig, use_fov_model = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/depth_pro/modeling_depth_pro.py#L995)

**Parametreler:**

config ([DepthProConfig](/docs/transformers/v5.23.0/tr/model_doc/depth_pro#transformers.DepthProConfig)) : 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/v5.23.0/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine bakın.

use_fov_model (`bool`, *isteğe bağlı*) : Görüş alanı modelinin kullanılıp kullanılmayacağı.

Üstünde derinlik tahmini kafası (3 konvolüsyonel katmandan oluşan) bulunan DepthPro Modeli.

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/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.DepthProForDepthEstimation.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/v5.23.0/src/transformers/models/depth_pro/modeling_depth_pro.py#L1020)

**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 [DepthProImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/depth_pro#transformers.DepthProImageProcessor) kullanılarak elde edilebilir. Ayrıntılar için [DepthProImageProcessor.__call__()](/docs/transformers/v5.23.0/tr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) bölümüne bakın (`processor_class`, görüntü işleme için [DepthProImageProcessor](/docs/transformers/v5.23.0/tr/model_doc/depth_pro#transformers.DepthProImageProcessor) 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/v5.23.0/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** `DepthProDepthEstimatorOutput` veya `tuple(torch.Tensor)`

`DepthProDepthEstimatorOutput` veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([DepthProConfig](/docs/transformers/v5.23.0/tr/model_doc/depth_pro#transformers.DepthProConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[DepthProForDepthEstimation](/docs/transformers/v5.23.0/tr/model_doc/depth_pro#transformers.DepthProForDepthEstimation) 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)`, *isteğe bağlı*) -- Her piksel için tahmin edilen derinlik.
- **field_of_view** (`torch.Tensor`, şekli `(batch_size,)`, *isteğe bağlı*, `use_fov_model` sağlandığında döndürülür) -- Görüş Alanı Ölçekleyicisi.
- **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` (modelin bir 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 bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  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) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  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, DepthProForDepthEstimation
>>> import torch
>>> 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()))

>>> checkpoint = "apple/DepthPro-hf"
>>> processor = AutoImageProcessor.from_pretrained(checkpoint)
>>> model = DepthProForDepthEstimation.from_pretrained(checkpoint)

>>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
>>> model.to(device)

>>> # prepare image for the model
>>> inputs = processor(images=image, return_tensors="pt").to(device)

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

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

>>> # get the field of view (fov) predictions
>>> field_of_view = post_processed_output[0]["field_of_view"]
>>> focal_length = post_processed_output[0]["focal_length"]

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

