# Оценка глубины

Наборы данных для оценки глубины используются для обучения модели, приближающей относительное расстояние каждого пикселя изображения от камеры, также известное как глубина. Применение этих наборов данных в основном связано с такими областями, как визуальное машинное восприятие и восприятие в робототехнике. Примеры приложений включают картографирование улиц для беспилотных автомобилей. В этом руководстве показано, как применять преобразования к набору данных для оценки глубины.

Прежде чем начать, убедитесь, что у вас установлены актуальные версии `albumentations`:

```bash
pip install -U albumentations 
```

[Albumentations](https://albumentations.ai/) — это библиотека на Python для выполнения аугментации данных в задачах компьютерного зрения. Она поддерживает различные задачи компьютерного зрения, такие как классификация изображений, обнаружение объектов, сегментация и оценка ключевых точек.

В этом руководстве используется набор данных [NYU Depth V2](https://huggingface.co/datasets/sayakpaul/nyu_depth_v2), состоящий из видеопоследовательностей различных внутренних сцен, записанных камерами RGB и глубины. Набор данных включает сцены из 3 городов и предоставляет изображения вместе с их картами глубины в качестве меток.

Загрузите разделение `train` набора данных и рассмотрите пример:

```py
>>> from datasets import load_dataset

>>> train_dataset = load_dataset("sayakpaul/nyu_depth_v2", split="train")
>>> index = 17
>>> example = train_dataset[index]
>>> example
{'image': <PIL.PngImagePlugin.PngImageFile image mode=RGB size=640x480>,
 'depth_map': <PIL.TiffImagePlugin.TiffImageFile image mode=F size=640x480>}
```

Набор данных содержит два поля:

* `image`: объект изображения PNG в формате PIL с типом данных `uint8`.
* `depth_map`: объект изображения в формате PIL Tiff с типом данных `float32`, представляющий карту глубины изображения.

Здесь карты глубины используют формат TIFF, так как он поддерживает широкий диапазон типов данных, включая данные `float32`. Однако стоит отметить, что форматы JPEG/PNG могут хранить только данные `uint8` или `uint16`. Поэтому, если ваши карты глубины сохранены в формате JPEG/PNG, используйте тип `Image(mode="F")`, чтобы загрузить их как одноканальные `float32`, как обычные карты глубины:

```python
>>> from datasets import Image

>>> train_dataset = train_dataset.cast_column("depth_map", Image(mode="F"))
```

Далее проверьте изображение с помощью:

```py
>>> example["image"]
```

    

Прежде чем рассматривать карту глубины, необходимо сначала преобразовать её тип данных в `uint8` с помощью `.convert('RGB')`, так как PIL не может отображать изображения типа `float32`. Теперь посмотрите на соответствующую карту глубины:

```py
>>> example["depth_map"].convert("RGB")
```

    

Всё чёрное! Чтобы корректно визуализировать карту глубины, нужно добавить в неё цвет. Для этого можно автоматически применить цвет при отображении с помощью `plt.imshow()` или создать цветную карту глубины с помощью `plt.cm`, а затем отобразить её. В этом примере использован второй вариант, так как цветную карту глубины можно сохранить или записать позже. (утилита ниже взята из [репозитория FastDepth](https://github.com/dwofk/fast-depth/blob/master/utils.py)).

```py 
>>> import numpy as np
>>> import matplotlib.pyplot as plt

>>> cmap = plt.cm.viridis

>>> def colored_depthmap(depth, d_min=None, d_max=None):
...     if d_min is None:
...         d_min = np.min(depth)
...     if d_max is None:
...         d_max = np.max(depth)
...     depth_relative = (depth - d_min) / (d_max - d_min)
...     return 255 * cmap(depth_relative)[:,:,:3]

>>> def show_depthmap(depth_map):
...    if not isinstance(depth_map, np.ndarray):
...        depth_map = np.array(depth_map)
...    if depth_map.ndim == 3:
...        depth_map = depth_map.squeeze()

...    d_min = np.min(depth_map)
...    d_max = np.max(depth_map)
...    depth_map = colored_depthmap(depth_map, d_min, d_max)

...    plt.imshow(depth_map.astype("uint8"))
...    plt.axis("off")
...    plt.show()

>>> show_depthmap(example["depth_map"])
```

    

Вы также можете визуализировать несколько различных изображений и соответствующие им карты глубины.

```py
>>> def merge_into_row(input_image, depth_target):
...     if not isinstance(input_image, np.ndarray):
...         input_image = np.array(input_image)
...
...     d_min = np.min(depth_target)
...     d_max = np.max(depth_target)
...     depth_target_col = colored_depthmap(depth_target, d_min, d_max)
...     img_merge = np.hstack([input_image, depth_target_col])
...
...     return img_merge

>>> random_indices = np.random.choice(len(train_dataset), 9).tolist()
>>> plt.figure(figsize=(15, 6))
>>> for i, idx in enumerate(random_indices):
...     example = train_dataset[idx]
...     ax = plt.subplot(3, 3, i + 1)
...     image_viz = merge_into_row(
...         example["image"], example["depth_map"]
...     )
...     plt.imshow(image_viz.astype("uint8"))
...     plt.axis("off")
```

    

Теперь применим некоторые аугментации с помощью `albumentations`. Преобразования аугментации включают:

* Случайное горизонтальное отражение
* Случайное обрезание
* Случайная яркость и контраст
* Случайная гамма-коррекция
* Случайная насыщенность оттенка

```py 
>>> import albumentations as A

>>> crop_size = (448, 576)
>>> transforms = [
...     A.HorizontalFlip(p=0.5),
...     A.RandomCrop(crop_size[0], crop_size[1]),
...     A.RandomBrightnessContrast(),
...     A.RandomGamma(),
...     A.HueSaturationValue()
... ]
```

Кроме того, определите отображение, чтобы лучше отражать целевое имя ключа.

```py 
>>> additional_targets = {"depth": "mask"}
>>> aug = A.Compose(transforms=transforms, additional_targets=additional_targets)
```

Если определён `additional_targets`, вы можете передавать целевые карты глубины в аргумент `depth` функции `aug` вместо `mask`. Вы заметите это изменение в функции `apply_transforms()`, определённой ниже.

Создайте функцию для применения преобразования к изображениям, а также к их картам глубины:

```py 
>>> def apply_transforms(examples):
...     transformed_images, transformed_maps = [], []
...     for image, depth_map in zip(examples["image"], examples["depth_map"]):
...         image, depth_map = np.array(image), np.array(depth_map)
...         transformed = aug(image=image, depth=depth_map)
...         transformed_images.append(transformed["image"])
...         transformed_maps.append(transformed["depth"])
...
...     examples["pixel_values"] = transformed_images
...     examples["labels"] = transformed_maps
...     return examples
```

Используйте функцию [set_transform()](/docs/datasets/v5.2.0/ru/package_reference/main_classes#datasets.Dataset.set_transform), чтобы применять преобразование на лету к батчам набора данных и экономить место на диске:

```py
>>> train_dataset.set_transform(apply_transforms)
```

Вы можете убедиться, что преобразование сработало, обратившись по индексу к `pixel_values` и `labels` примера изображения:

```py
>>> example = train_dataset[index]

>>> plt.imshow(example["pixel_values"])
>>> plt.axis("off")
>>> plt.show()
```

    

Визуализируйте то же преобразование на соответствующей карте глубины изображения:

```py 
>>> show_depthmap(example["labels"])
```

    

Вы также можете визуализировать несколько обучающих выборок, повторно используя предыдущие `random_indices`:

```py 
>>> plt.figure(figsize=(15, 6))

>>> for i, idx in enumerate(random_indices):
...     ax = plt.subplot(3, 3, i + 1)
...     example = train_dataset[idx]
...     image_viz = merge_into_row(
...         example["pixel_values"], example["labels"]
...     )
...     plt.imshow(image_viz.astype("uint8"))
...     plt.axis("off")
```

    

