Estimasi kedalaman

Dataset estimasi kedalaman digunakan untuk melatih model agar dapat memperkirakan jarak relatif setiap piksel dalam sebuah gambar dari kamera, yang juga dikenal sebagai kedalaman. Aplikasi yang didukung oleh dataset ini terutama berada di bidang seperti persepsi mesin visual dan persepsi dalam robotika. Contoh aplikasi termasuk pemetaan jalan untuk mobil otonom. Panduan ini akan menunjukkan cara menerapkan transformasi pada dataset estimasi kedalaman.

Sebelum Anda memulai, pastikan Anda memiliki versi terbaru dari albumentations yang terinstal:

pip install -U albumentations

Albumentations adalah pustaka Python untuk melakukan augmentasi data untuk computer vision. Pustaka ini mendukung berbagai tugas computer vision seperti klasifikasi gambar, deteksi objek, segmentasi, dan estimasi keypoint.

Panduan ini menggunakan dataset NYU Depth V2 yang terdiri dari urutan video dari berbagai adegan dalam ruangan, yang direkam oleh kamera RGB dan kedalaman. Dataset ini terdiri dari adegan dari 3 kota dan menyediakan gambar beserta peta kedalaman mereka sebagai label.

Muat split train dari dataset dan lihat contohnya:

>>> 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>}

Dataset memiliki dua field:

image: objek gambar PNG PIL dengan tipe data uint8.
depth_map: objek gambar PIL Tiff dengan tipe data float32 yang merupakan peta kedalaman dari gambar tersebut.

Di sini, peta kedalaman menggunakan format TIFF karena format ini mendukung berbagai jenis data, termasuk data float32. Namun, perlu dicatat bahwa format JPEG/PNG hanya dapat menyimpan data uint8 atau uint16. Oleh karena itu, jika Anda memiliki peta kedalaman yang disimpan sebagai JPEG/PNG, gunakan tipe Image(mode="F") untuk memuatnya sebagai float32 satu saluran seperti peta kedalaman normal:

>>> from datasets import Image

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

Selanjutnya, lihat gambar dengan:

>>> example["image"]

Sebelum kita melihat peta kedalaman, kita perlu terlebih dahulu mengubah tipe datanya menjadi uint8 menggunakan .convert('RGB') karena PIL tidak dapat menampilkan gambar float32. Sekarang perhatikan peta kedalaman yang bersesuaian:

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

Semuanya hitam! Anda perlu menambahkan beberapa warna ke peta kedalaman untuk memvisualisasikannya dengan benar. Untuk melakukannya, kita bisa menerapkan warna secara otomatis saat menampilkan menggunakan plt.imshow() atau membuat peta kedalaman berwarna menggunakan plt.cm lalu menampilkannya. Pada contoh ini, kami menggunakan yang kedua, karena kita dapat menyimpan/menulis peta kedalaman berwarna tersebut nanti. (utilitas di bawah ini diambil dari FastDepth repository).

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

Anda juga dapat memvisualisasikan beberapa gambar yang berbeda beserta peta kedalaman yang bersesuaian.

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

Sekarang terapkan beberapa augmentasi dengan albumentations. Transformasi augmentasi meliputi:

Pembalikan horizontal acak
Pemotongan acak
Kecerahan dan kontras acak
Koreksi gamma acak
Jenuh warna acak

>>> 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()
... ]

Selain itu, definisikan pemetaan untuk lebih mencerminkan nama kunci target.

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

Dengan additional_targets yang didefinisikan, Anda dapat meneruskan peta kedalaman target ke argumen depth dari aug alih-alih mask. Anda akan melihat perubahan ini pada fungsi apply_transforms() yang didefinisikan di bawah.

Buat fungsi untuk menerapkan transformasi pada gambar serta peta kedalaman mereka:

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

Gunakan fungsi set_transform() untuk menerapkan transformasi secara langsung pada batch dataset guna mengurangi penggunaan ruang disk:

>>> train_dataset.set_transform(apply_transforms)

Anda dapat memverifikasi bahwa transformasi berhasil dengan mengindeks ke dalam pixel_values dan labels dari gambar contoh:

>>> example = train_dataset[index]

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

Visualisasikan transformasi yang sama pada peta kedalaman yang sesuai dari gambar:

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

Anda juga dapat memvisualisasikan beberapa sampel pelatihan dengan menggunakan ulang random_indices sebelumnya:

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

Update on GitHub

Datasets

Estimasi kedalaman