# DepthPro ## Обзор Модель DepthPro была предложена в статье [Depth Pro: Sharp Monocular Metric Depth in Less Than a Second](https://huggingface.co/papers/2410.02073) авторами Aleksei Bochkovskii, Amaël Delaunoy, Hugo Germain, Marcel Santos, Yichao Zhou, Stephan R. Richter, Vladlen Koltun. DepthPro — это базовая модель для оценки метрической монокулярной глубины в режиме zero-shot, предназначенная для генерации карт глубины высокого разрешения с высокой чёткостью и детализацией. В ней используется архитектура на основе мультимасштабного Vision Transformer (ViT), в которой изображения уменьшаются, разбиваются на патчи и обрабатываются с помощью общего энкодера Dinov2. Извлечённые патч-уровневые признаки объединяются, увеличиваются и уточняются на этапе слияния, аналогичном DPT, что обеспечивает точную оценку глубины. Аннотация из статьи следующая: *Мы представляем базовую модель для оценки метрической монокулярной глубины в режиме zero-shot. Наша модель, Depth Pro, синтезирует карты глубины высокого разрешения с непревзойдённой чёткостью и высокочастотными деталями. Прогнозы являются метрическими, с абсолютным масштабом, и не зависят от наличия метаданных, таких как внутренние параметры камеры. При этом модель работает быстро: на стандартном GPU она генерирует карту глубины разрешением 2,25 мегапикселя за 0,3 секунды. Эти характеристики обеспечиваются рядом технических решений, включая эффективный мультимасштабный vision transformer для плотного прогнозирования, протокол обучения, сочетающий реальные и синтетические наборы данных для достижения высокой метрической точности и точного отслеживания границ, специализированные метрики оценки для точности границ в оценённых картах глубины, а также оценку фокусного расстояния по одному изображению, соответствующую современному уровню. Обширные эксперименты анализируют конкретные проектные решения и демонстрируют, что Depth Pro превосходит предыдущие работы по нескольким параметрам.* drawing Выходы DepthPro. Взято из официального кода. Эта модель была предоставлена пользователем [geetu040](https://github.com/geetu040). Исходный код можно найти [здесь](https://github.com/apple/ml-depth-pro). ## Советы по использованию Модель DepthPro обрабатывает входное изображение, сначала уменьшая его разрешение в нескольких масштабах и разбивая каждую масштабированную версию на патчи. Затем эти патчи кодируются с помощью общего патч-энкодера на основе Vision Transformer (ViT) — Dinov2, в то время как полное изображение обрабатывается отдельным энкодером изображений. Извлечённые признаки патчей объединяются в карты признаков, масштабируются вверх и сшиваются с помощью декодера, похожего на DPT, для генерации окончательной оценки глубины. Если включено, дополнительный энкодер поля зрения (FOV) обрабатывает изображение для оценки поля зрения камеры, что способствует повышению точности оценки глубины. ```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")) ``` ### Архитектура и конфигурация drawing Архитектура DepthPro. Взято из оригинальной статьи. Модель `DepthProForDepthEstimation` использует `DepthProEncoder` для кодирования входного изображения и `FeatureFusionStage` для слияния выходных признаков, полученных от энкодера. Класс `DepthProEncoder` дополнительно использует два энкодера: - `patch_encoder` - Входное изображение масштабируется с несколькими коэффициентами, как указано в конфигурации `scaled_images_ratios`. - Каждое масштабированное изображение разбивается на более мелкие **патчи** размера `patch_size`, при этом области перекрытия определяются параметром `scaled_images_overlap_ratios`. - Эти патчи обрабатываются **`patch_encoder`** - `image_encoder` - Входное изображение также масштабируется до `patch_size` и обрабатывается с помощью **`image_encoder`** Оба этих кодировщика можно настроить с помощью `patch_model_config` и `image_model_config` соответственно; по умолчанию оба являются отдельными экземплярами `Dinov2Model`. Выходы обоих энкодеров (`last_hidden_state`) и выбранные промежуточные состояния (`hidden_states`) из **`patch_encoder`** объединяются с помощью `FeatureFusionStage` на базе `DPT` для оценки глубины. ### Предсказание поля зрения (FOV) Сеть дополняется головкой для оценки фокусного расстояния. Небольшая свёрточная головка принимает замороженные признаки из сети оценки глубины и признаки, специфичные для задачи, из отдельного ViT-кодировщика изображений, чтобы предсказать горизонтальное угловое поле обзора. Параметр `use_fov_model` в `DepthProConfig` управляет тем, включена ли **прогнозирование FOV**. По умолчанию он установлен в значение `False` для экономии памяти и вычислительных ресурсов. При включении **FOV-энкодер** инициализируется на основе параметра `fov_model_config`, значением по умолчанию для которого является `Dinov2Model`. Параметр `use_fov_model` также можно передать при инициализации модели `DepthProForDepthEstimation`. Предобученная модель в контрольной точке `apple/DepthPro-hf` использует кодировщик FOV. Чтобы использовать предобученную модель без кодировщика FOV, установите `use_fov_model=False` при загрузке модели, что позволит сэкономить вычислительные ресурсы. ```python from transformers import DepthProForDepthEstimation model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", use_fov_model=False, device_map="auto") ``` Чтобы создать новую модель с кодировщиком FOV, установите `use_fov_model=True` в конфигурации. ```python from transformers import DepthProConfig, DepthProForDepthEstimation config = DepthProConfig(use_fov_model=True) model = DepthProForDepthEstimation(config) ``` Или установите `use_fov_model=True` при инициализации модели, что переопределяет значение в конфигурации. ```python from transformers import DepthProConfig, DepthProForDepthEstimation config = DepthProConfig() model = DepthProForDepthEstimation(config, use_fov_model=True) ``` ### Использование масштабированного внимания на основе скалярного произведения (SDPA) PyTorch включает в себя нативный оператор масштабированного внимания на основе скалярного произведения (SDPA) в составе `torch.nn.functional`. Эта функция объединяет несколько реализаций, которые могут применяться в зависимости от входных данных и используемого оборудования. Подробнее см. в [официальной документации](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) или на странице [GPU Inference](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention). SDPA используется по умолчанию для `torch>=2.1.1`, когда доступна соответствующая реализация, но вы также можете установить `attn_implementation="sdpa"` в `from_pretrained()`, чтобы явно запросить использование SDPA. ```python from transformers import DepthProForDepthEstimation model = DepthProForDepthEstimation.from_pretrained("apple/DepthPro-hf", attn_implementation="sdpa", device_map="auto") ``` Для достижения максимального ускорения мы рекомендуем загружать модель в половинной точности (например, `torch.float16` или `torch.bfloat16`). На локальном бенчмарке (A100-40GB, PyTorch 2.3.0, ОС Ubuntu 22.04) с `float32` и моделью `google/vit-base-patch16-224` мы наблюдали следующее ускорение при инференсе. | Размер пакета | Среднее время вывода (мс), режим eager | Среднее время инференса (мс), модель sdpa | Ускорение, Sdpa / Eager (x) | |--------------|-------------------------------------------|-------------------------------------------|------------------------------| | 1 | 7 | 6 | 1.17 | | 2 | 8 | 6 | 1.33 | | 4 | 8 | 6 | 1.33 | | 8 | 8 | 6 | 1.33 | ## Ресурсы Список официальных ресурсов Hugging Face и сообщества (отмечены 🌎), которые помогут вам начать работу с DepthPro: - Научная статья: [Depth Pro: Sharp Monocular Metric Depth in Less Than a Second](https://huggingface.co/papers/2410.02073) - Официальная реализация: [apple/ml-depth-pro](https://github.com/apple/ml-depth-pro) - Ноутбук для инференса DepthPro: [DepthPro Inference](https://github.com/qubvel/transformers-notebooks/blob/main/notebooks/DepthPro_inference.ipynb) - DepthPro для суперразрешения и сегментации изображений - Читать блог на Medium: [Depth Pro: Beyond Depth](https://medium.com/@raoarmaghanshakir040/depth-pro-beyond-depth-9d822fc557ba) - Код на Github: [geetu040/depthpro-beyond-depth](https://github.com/geetu040/depthpro-beyond-depth) Если вы хотите предложить ресурс для включения в этот раздел, пожалуйста, создайте Pull Request, и мы его рассмотрим! В идеале ресурс должен демонстрировать что-то новое, а не дублировать существующие материалы. ## 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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/configuration_depth_pro.py#L28) **Параметры:** fusion_hidden_size (`int`, *необязательный*, по умолчанию 256) : Количество каналов до слияния. patch_size (`Union[int, list[int], tuple[int, int]]`, *необязательный*, по умолчанию `384`) : Размер (разрешение) каждого патча. initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов. intermediate_hook_ids (`list[int]`, *optional*, по умолчанию `[11, 5]`) : Индексы промежуточных скрытых состояний из патч-энкодера, используемые для слияния. intermediate_feature_dims (`list[int]`, *необязательный*, по умолчанию `[256, 256]`) : Размеры скрытых состояний при увеличении разрешения для каждого промежуточного скрытого состояния в `intermediate_hook_ids`. scaled_images_ratios (`list[float]`, *необязательный*, по умолчанию `[0.25, 0.5, 1]`) : Коэффициенты масштабирования изображений, используемые кодировщиком патчей. scaled_images_overlap_ratios (`list[float]`, *необязательный*, по умолчанию `[0.0, 0.5, 0.25]`) : Коэффициенты перекрытия между патчами для каждого масштабированного изображения в `scaled_images_ratios`. scaled_images_feature_dims (`list[int]`, *необязательный*, по умолчанию `[1024, 1024, 512]`) : Размеры скрытых состояний при апсэмплинге для каждого масштабированного изображения в `scaled_images_ratios`. merge_padding_value (`int`, *optional*, по умолчанию 3) : При объединении небольших патчей обратно в размер изображения удаляются перекрывающиеся секции этого размера. use_batch_norm_in_fusion_residual (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли пакетную нормализацию в pre-activate остаточных блоках блоков слияния. use_bias_in_fusion_residual (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли смещение (bias) в предактивирующих остаточных блоках блоков слияния. use_fov_model (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли `DepthProFovModel` для генерации поля зрения. num_fov_head_layers (`int`, *необязательный*, по умолчанию 2) : Количество свёрточных слоёв в головной части `DepthProFovModel`. image_model_config (`Union[dict[str, Any], PreTrainedConfig]`, *необязательный*) : Конфигурация модели кодировщика изображений, которая загружается с помощью API [AutoModel](/docs/transformers/main/ru/model_doc/auto#transformers.AutoModel). По умолчанию в качестве базовой модели используется Dinov2. patch_model_config (`Union[dict[str, Any], PreTrainedConfig]`, *необязательный*) : Конфигурация модели patch-энкодера, которая загружается с помощью API [AutoModel](/docs/transformers/main/ru/model_doc/auto#transformers.AutoModel). По умолчанию в качестве backbone используется модель Dinov2. fov_model_config (`Union[dict[str, Any], PreTrainedConfig]`, *необязательный*) : Конфигурация модели fov encoder, которая загружается с помощью API [AutoModel](/docs/transformers/main/ru/model_doc/auto#transformers.AutoModel). По умолчанию в качестве backbone используется модель Dinov2. Это класс конфигурации для хранения настроек модели DepthProModel. Он используется для создания модели Depth Pro в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [apple/DepthPro](https://huggingface.co/apple/DepthPro) Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig). Пример: ```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: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/image_processing_depth_pro.py#L45) **Параметры:** do_convert_rgb (`bool`, *kwargs*, *необязательный*) : Преобразовать ли изображение в RGB. do_resize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли изменять размер изображения. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, по умолчанию `{'height' : 1536, 'width': 1536}`): описывает максимальные размеры входных данных для модели. default_to_square (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Использовать ли квадратное изображение по умолчанию при изменении размера, если size является int. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер выходного изображения после применения `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, по умолчанию `2`) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Действует только если `do_resize` установлено в `True`. do_rescale (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли масштабировать изображение. rescale_factor (`float`, *kwargs*, *optional*, по умолчанию `0.00392156862745098`) : Коэффициент масштабирования для изменения масштаба изображения, если `do_rescale` установлен в `True`. do_normalize (`bool`, *kwargs*, *optional*, по умолчанию `True`) : Нужно ли нормализовать изображение. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.5, 0.5, 0.5]`) : Средние значения изображения для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, по умолчанию `[0.5, 0.5, 0.5]`) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`. do_pad (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Конкретная стратегия выравнивания зависит от модели. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер в формате `{"height": int, "width" int}`, до которого следует дополнить изображения. Должен быть больше любого размера изображения, переданного для предобработки. Если `pad_size` не указан, изображения будут дополнены до наибольшей высоты и ширины в батче. Применяется только при `do_pad=True.` do_center_crop (`bool`, *kwargs*, *optional*) : Центрировать ли изображение при обрезке. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Устройство для обработки видео. Если не задано, устройство определяется на основе входных видео. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Возвращает стопку тензоров, если установлено значение `'pt'`, иначе возвращает список тензоров. disable_grouping (`bool`, *kwargs*, *optional*) : Указывает, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, подробно описанных здесь: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *optional*) : Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора. Если установлено значение `'pt'`, возвращает стопку тензоров, иначе — список тензоров. disable_grouping (`bool`, *kwargs*, *optional*) : Указывает, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, подробно описанных здесь: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *необязательный*) : Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора. Возвращает стекированные тензоры, если установлено значение `'pt'`, иначе возвращает список тензоров. -- Создаёт процессор изображений DepthPro. disable_grouping (`bool`, *kwargs*, *optional*): Определяет, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, подробности здесь: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *optional*): Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора. #### 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: *) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382) **Параметры:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Изображение для предобработки. Ожидается одно изображение или пакет изображений со значениями пикселей в диапазоне от 0 до 255. Если передаются изображения со значениями пикселей в диапазоне от 0 до 1, установите `do_rescale=False`. image_like_kwargs (`dict[str, Any]`, *необязательный*) : Флаг разработчика для дополнительных изображений и похожих на них входных данных, которые также будут предобработаны. Используйте этот параметр только в том случае, если передача входных данных через kwarg не работает. Например, `preprocess(images, masks=masks)` — предпочтительный вариант, но для некоторых моделей он приводит к проблемам с приоритетом аргументов. В таких случаях можно использовать `preprocess(images, image_like_inputs={"masks": masks})`. do_convert_rgb (`bool`, *kwargs*, *необязательный*) : Преобразовать ли изображение в RGB. do_resize (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли изменить размер изображения. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Описывает максимальные размеры входных данных для модели. default_to_square (`bool`, *kwargs*, *необязательный*) : Указывает, следует ли по умолчанию использовать квадратное изображение при изменении размера, если size задан как int. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер выходного изображения после применения `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Фильтр ресемплинга, используемый при изменении размера изображения. Может быть одним из значений перечисления `PILImageResampling`. Действует только при установке `do_resize` в `True`. do_rescale (`bool`, *kwargs*, *необязательный*) : Нужно ли масштабировать изображение. rescale_factor (`float`, *kwargs*, *optional*) : Коэффициент масштабирования для изменения размера изображения, если `do_rescale` установлен в `True`. do_normalize (`bool`, *kwargs*, *необязательный*) : Нужно ли нормализовать изображение. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Среднее значение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : Стандартное отклонение изображения, используемое для нормализации. Влияет только в том случае, если `do_normalize` установлено в `True`. do_pad (`bool`, *kwargs*, *необязательный*) : Указывает, нужно ли выравнивать изображение. Выравнивание выполняется либо до максимального размера в батче, либо до фиксированного квадратного размера для каждого изображения. Конкретная стратегия выравнивания зависит от модели. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Размер в формате `{"height": int, "width" int}`, до которого следует дополнить изображения. Должен быть больше любого размера изображения, переданного для предобработки. Если `pad_size` не указан, изображения будут дополнены до наибольшей высоты и ширины в батче. Применяется только при `do_pad=True.` do_center_crop (`bool`, *kwargs*, *optional*) : Центрировать ли изображение при обрезке. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *необязательный*) : Поддерживается только `ChannelDimension.FIRST`. Добавлено для совместимости с медленными процессорами. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *optional*) : Формат размерности каналов для входного изображения. Если не задано, формат размерности каналов определяется по входному изображению. Может быть одним из: - `"channels_first"` или `ChannelDimension.FIRST`: изображение в формате (num_channels, height, width). - `"channels_last"` или `ChannelDimension.LAST`: изображение в формате (height, width, num_channels). - `"none"` или `ChannelDimension.NONE`: изображение в формате (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Устройство для обработки видео. Если не задано, устройство определяется на основе входных видео. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Возвращает стопку тензоров, если установлено значение `'pt'`, иначе возвращает список тензоров. disable_grouping (`bool`, *kwargs*, *optional*) : Указывает, следует ли отключить группировку изображений по размеру для их индивидуальной обработки, а не пачками. Если значение равно None, оно будет установлено в True, если изображения находятся на CPU, и в False в противном случае. Этот выбор основан на эмпирических наблюдениях, подробно описанных здесь: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *необязательный*) : Количество токенов изображения, используемых для каждого изображения во входных данных. Добавлено для обратной совместимости, но в будущих моделях это значение следует задавать как атрибут процессора. **Возвращает:** `~image_processing_base.BatchFeature` - **data** (`dict`) — Словарь списков/массивов/тензоров, возвращаемый методом __call__ ('pixel_values' и т. д.). - **tensor_type** (`Union[None, str, TensorType]`, *необязательный*) -- Здесь можно указать tensor_type, чтобы при инициализации преобразовать списки целых чисел в тензоры PyTorch/Numpy. Предобработка изображения или пакета изображений. #### 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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/image_processing_depth_pro.py#L84) Выполняет постобработку сырых предсказаний глубины, полученных от модели. ## DepthProModel[[transformers.DepthProModel]] #### transformers.DepthProModel[[transformers.DepthProModel]] ```python transformers.DepthProModel(config: DepthProConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/modeling_depth_pro.py#L624) **Параметры:** config ([DepthProConfig](/docs/transformers/main/ru/model_doc/depth_pro#transformers.DepthProConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Depth Pro без дополнительных слоёв, выводящая «сырые» скрытые состояния. Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### 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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/modeling_depth_pro.py#L636) **Параметры:** pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [DepthProImageProcessor](/docs/transformers/main/ru/model_doc/depth_pro#transformers.DepthProImageProcessor). Подробности см. в [DepthProImageProcessor.__call__()](/docs/transformers/main/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) (`processor_class` использует [DepthProImageProcessor](/docs/transformers/main/ru/model_doc/depth_pro#transformers.DepthProImageProcessor) для обработки изображений). output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** `DepthProOutput` или `tuple(torch.Tensor)` Объект `DepthProOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([DepthProConfig](/docs/transformers/main/ru/model_doc/depth_pro#transformers.DepthProConfig)) и входных данных. Метод forward модели [DepthProModel](/docs/transformers/main/ru/model_doc/depth_pro#transformers.DepthProModel) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, n_patches_per_batch, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели. - **features** (`Union[torch.Tensor, List[torch.Tensor]]`, *необязательный*) -- Признаки из энкодеров. Может быть одним признаком или списком признаков. - **hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Примеры: ```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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/modeling_depth_pro.py#L995) **Параметры:** config ([DepthProConfig](/docs/transformers/main/ru/model_doc/depth_pro#transformers.DepthProConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. use_fov_model (`bool`, *необязательный*) : Использовать ли модель поля зрения. Модель DepthPro с головкой для оценки глубины (состоящей из 3 свёрточных слоёв). Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### 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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/depth_pro/modeling_depth_pro.py#L1020) **Параметры:** pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью [DepthProImageProcessor](/docs/transformers/main/ru/model_doc/depth_pro#transformers.DepthProImageProcessor). Подробности см. в [DepthProImageProcessor.__call__()](/docs/transformers/main/ru/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) (`processor_class` использует [DepthProImageProcessor](/docs/transformers/main/ru/model_doc/depth_pro#transformers.DepthProImageProcessor) для обработки изображений). labels (`torch.LongTensor` формы `(batch_size, height, width)`, *необязательный*) : Карты истинной глубины для вычисления функции потерь. output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** `DepthProDepthEstimatorOutput` или `tuple(torch.Tensor)` Объект `DepthProDepthEstimatorOutput` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([DepthProConfig](/docs/transformers/main/ru/model_doc/depth_pro#transformers.DepthProConfig)) и входных данных. Метод forward класса [DepthProForDepthEstimation](/docs/transformers/main/ru/model_doc/depth_pro#transformers.DepthProForDepthEstimation) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации (или регрессии, если config.num_labels==1). - **predicted_depth** (`torch.Tensor` формы `(batch_size, height, width)`, *необязательный*) -- Предсказанная глубина для каждого пикселя. - **field_of_view** (`torch.Tensor` формы `(batch_size,)`, *необязательный*, возвращается, если задан `use_fov_model`) -- Масштабатор поля зрения. - **hidden_states** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple[torch.Tensor, ...]`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Примеры: ```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")) ```