ZoeDepth
概述
ZoeDepth 模型在 ZoeDepth: Zero-shot Transfer by Combining Relative and Metric Depth 中提出，作者是 Shariq Farooq Bhat、Reiner Birkl、Diana Wofk、Peter Wonka、Matthias Müller。ZoeDepth 扩展了用于度量（也称为绝对）深度估计的 DPT 框架。ZoeDepth 在 12 个数据集上使用相对深度进行预训练，并在两个领域（NYU 和 KITTI）上使用度量深度进行微调。轻量级头部与称为度量 bins 模块的新型 bin 调整设计一起用于每个领域。在推理过程中，每个输入图像都使用潜在分类器自动路由到相应的头部。
该论文的摘要如下：
本文探讨了从单张图像进行深度估计的问题。现有工作要么侧重于不考虑度量尺度的泛化性能，即相对深度估计，要么侧重于特定数据集上的最先进结果，即度量深度估计。我们提出了第一种结合了这两个方面的方法，从而产生了一个在保持度量尺度的同时具有出色泛化性能的模型。我们的旗舰模型 ZoeD-M12-NK 在 12 个数据集上使用相对深度进行预训练，并在两个数据集上使用度量深度进行微调。我们为每个领域使用带有新型 bin 调整设计的轻量级头部，称为度量 bins 模块。在推理过程中，每个输入图像都使用潜在分类器自动路由到相应的头部。我们的框架允许根据用于相对深度预训练和度量微调的数据集进行多种配置。在没有预训练的情况下，我们已经可以显着提高 NYU Depth v2 室内数据集上的最先进水平 (SOTA)。在十二个数据集上进行预训练，并在 NYU Depth v2 室内数据集上进行微调，我们可以进一步提高 SOTA，相对绝对误差 (REL) 总共提高了 21%。最后，ZoeD-M12-NK 是第一个可以在多个数据集（NYU Depth v2 和 KITTI）上联合训练而性能没有显着下降的模型，并且在室内和室外领域的八个未见数据集上实现了前所未有的零样本泛化性能。
ZoeDepth 架构。取自原始论文。 使用技巧
- ZoeDepth 是一个绝对（也称为度量）深度估计模型，与 DPT（相对深度估计模型）不同。这意味着 ZoeDepth 能够以米等度量单位估计深度。
使用 ZoeDepth 执行推理的最简单方法是利用 pipeline API
from transformers import pipeline
from PIL import Image
import requests
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
pipe = pipeline(task="depth-estimation", model="Intel/zoedepth-nyu-kitti")
result = pipe(image)
depth = result["depth"]或者，也可以使用以下类执行推理
from transformers import AutoImageProcessor, ZoeDepthForDepthEstimation
import torch
import numpy as np
from PIL import Image
import requests
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
image_processor = AutoImageProcessor.from_pretrained("Intel/zoedepth-nyu-kitti")
model = ZoeDepthForDepthEstimation.from_pretrained("Intel/zoedepth-nyu-kitti")
# prepare image for the model
inputs = image_processor(images=image, return_tensors="pt")
with torch.no_grad():
outputs = model(**inputs)
predicted_depth = outputs.predicted_depth
# interpolate to original size
prediction = torch.nn.functional.interpolate(
predicted_depth.unsqueeze(1),
size=image.size[::-1],
mode="bicubic",
align_corners=False,
)
# visualize the prediction
output = prediction.squeeze().cpu().numpy()
formatted = (output * 255 / np.max(output)).astype("uint8")
depth = Image.fromarray(formatted)资源
Hugging Face 官方和社区（标有 🌎）资源列表，可帮助您开始使用 ZoeDepth。
- 有关使用 ZoeDepth 模型进行推理的演示 notebook 可以在这里找到。 🌎
ZoeDepthConfig
class transformers.ZoeDepthConfig
< 源代码 >( backbone_config = None backbone = None use_pretrained_backbone = False backbone_kwargs = None hidden_act = 'gelu' initializer_range = 0.02 batch_norm_eps = 1e-05 readout_type = 'project' reassemble_factors = [4, 2, 1, 0.5] neck_hidden_sizes = [96, 192, 384, 768] fusion_hidden_size = 256 head_in_index = -1 use_batch_norm_in_fusion_residual = False use_bias_in_fusion_residual = None num_relative_features = 32 add_projection = False bottleneck_features = 256 num_attractors = [16, 8, 4, 1] bin_embedding_dim = 128 attractor_alpha = 1000 attractor_gamma = 2 attractor_kind = 'mean' min_temp = 0.0212 max_temp = 50.0 bin_centers_type = 'softplus' bin_configurations = [{'n_bins': 64, 'min_depth': 0.001, 'max_depth': 10.0}] num_patch_transformer_layers = None patch_transformer_hidden_size = None patch_transformer_intermediate_size = None patch_transformer_num_attention_heads = None **kwargs )
参数
- backbone_config (
Union[Dict[str, Any], PretrainedConfig], 可选, 默认为BeitConfig()) — 主干模型的配置。 - backbone (
str, 可选) — 当backbone_config为None时，要使用的主干名称。如果use_pretrained_backbone为True，这将从 timm 或 transformers 库加载相应的预训练权重。如果use_pretrained_backbone为False，这将加载主干的配置并使用它来初始化具有随机权重的主干。 - use_pretrained_backbone (
bool, 可选, 默认为False) — 是否对主干使用预训练权重。 - backbone_kwargs (
dict, 可选) — 从检查点加载时要传递给 AutoBackbone 的关键字参数，例如{'out_indices': (0, 1, 2, 3)}。如果设置了backbone_config，则无法指定。 - hidden_act (
str或function, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"selu"和"gelu_new"。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 - batch_norm_eps (
float, 可选, 默认为 1e-05) — 批归一化层使用的 epsilon 值。 - readout_type (
str, 可选, 默认为"project") — 处理 ViT backbone 中间隐藏状态的 readout token (CLS token) 时使用的 readout 类型。 可以是 ["ignore","add","project"] 之一。- “ignore” 简单地忽略 CLS token。
- “add” 通过添加表示，将来自 CLS token 的信息传递给所有其他 token。
- “project” 通过在将表示投影到原始特征维度 D 之前，将 readout 连接到所有其他 token，从而将信息传递给其他 token，使用线性层，然后是非线性 GELU。
- reassemble_factors (
List[int], 可选, 默认为[4, 2, 1, 0.5]) — 重组层的上/下采样因子。 - neck_hidden_sizes (
List[str], 可选, 默认为[96, 192, 384, 768]) — backbone 的特征图要投影到的隐藏大小。 - fusion_hidden_size (
int, 可选, 默认为 256) — 融合之前的通道数。 - head_in_index (
int, 可选, 默认为 -1) — 在 head 中使用的特征的索引。 - use_batch_norm_in_fusion_residual (
bool, 可选, 默认为False) — 是否在融合块的预激活残差单元中使用批归一化。 - use_bias_in_fusion_residual (
bool, 可选, 默认为True) — 是否在融合块的预激活残差单元中使用偏置。 - num_relative_features (
int, 可选, 默认为 32) — 在相对深度估计 head 中使用的特征数量。 - add_projection (
bool, 可选, 默认为False) — 是否在深度估计 head 之前添加投影层。 - bottleneck_features (
int, 可选, 默认为 256) — bottleneck 层中的特征数量。 - num_attractors (
List[int], *可选*, 默认为[16, 8, 4, 1]`) — 每个阶段中使用的 attractor 的数量。 - bin_embedding_dim (
int, 可选, 默认为 128) — bin embeddings 的维度。 - attractor_alpha (
int, 可选, 默认为 1000) — 在 attractor 中使用的 alpha 值。 - attractor_gamma (
int, 可选, 默认为 2) — 在 attractor 中使用的 gamma 值。 - attractor_kind (
str, 可选, 默认为"mean") — 要使用的 attractor 的种类。 可以是 ["mean","sum"] 之一。 - min_temp (
float, 可选, 默认为 0.0212) — 要考虑的最小温度值。 - max_temp (
float, 可选, 默认为 50.0) — 要考虑的最大温度值。 - bin_centers_type (
str, 可选, 默认为"softplus") — 用于 bin 中心激活类型。 可以是 “normed” 或 “softplus”。 对于 “normed” bin 中心，应用线性归一化技巧。 这会导致有界的 bin 中心。 对于 “softplus”，使用 softplus 激活，因此是无界的。 - bin_configurations (
List[dict], 可选, 默认为[{'n_bins' -- 64, 'min_depth': 0.001, 'max_depth': 10.0}]): 每个 bin head 的配置。 每个配置应包含以下键：- name (
str): bin head 的名称 - 仅在多个 bin 配置的情况下需要。 n_bins(int): 要使用的 bin 的数量。min_depth(float): 要考虑的最小深度值。max_depth(float): 要考虑的最大深度值。 如果仅传递单个配置，则模型将使用具有指定配置的单个 head。 如果传递多个配置，则模型将使用具有指定配置的多个 head。
- name (
- num_patch_transformer_layers (
int, 可选) — 在 patch transformer 中使用的 transformer 层数。 仅在多个 bin 配置的情况下使用。 - patch_transformer_hidden_size (
int, 可选) — 在 patch transformer 中使用的隐藏大小。 仅在多个 bin 配置的情况下使用。 - patch_transformer_intermediate_size (
int, 可选) — 在 patch transformer 中使用的中间大小。 仅在多个 bin 配置的情况下使用。 - patch_transformer_num_attention_heads (
int, 可选) — 在 patch transformer 中使用的 attention heads 的数量。 仅在多个 bin 配置的情况下使用。
这是用于存储 ZoeDepthForDepthEstimation 配置的配置类。 它用于根据指定的参数实例化 ZoeDepth 模型，定义模型架构。 使用默认值实例化配置将产生与 ZoeDepth Intel/zoedepth-nyu 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。 请阅读 PretrainedConfig 的文档以获取更多信息。
示例
>>> from transformers import ZoeDepthConfig, ZoeDepthForDepthEstimation
>>> # Initializing a ZoeDepth zoedepth-large style configuration
>>> configuration = ZoeDepthConfig()
>>> # Initializing a model from the zoedepth-large style configuration
>>> model = ZoeDepthForDepthEstimation(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configZoeDepthImageProcessor
class transformers.ZoeDepthImageProcessor
< source >( do_pad: bool = True do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> keep_aspect_ratio: bool = True ensure_multiple_of: int = 32 **kwargs )
参数
- do_pad (
bool, 可选, 默认为True) — 是否应用 padding 到输入。 - do_rescale (
bool, 可选, 默认为True) — 是否通过指定的比例rescale_factor重新缩放图像。 可以被preprocess中的do_rescale覆盖。 - rescale_factor (
int或float, 可选, 默认为1/255) — 如果重新缩放图像，则使用的缩放因子。 可以被preprocess中的rescale_factor覆盖。 - do_normalize (
bool, 可选, 默认为True) — 是否对图像进行归一化处理。可以被preprocess方法中的do_normalize参数覆盖。 - image_mean (
float或List[float], 可选, 默认为IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化，则使用的均值。这可以是浮点数或浮点数列表，列表的长度应等于图像通道数。可以被preprocess方法中的image_mean参数覆盖。 - image_std (
float或List[float], 可选, 默认为IMAGENET_STANDARD_STD) — 如果对图像进行归一化，则使用的标准差。这可以是浮点数或浮点数列表，列表的长度应等于图像通道数。可以被preprocess方法中的image_std参数覆盖。 - do_resize (
bool, 可选, 默认为True) — 是否调整图像的 (高度, 宽度) 尺寸。可以被preprocess中的do_resize覆盖。 - size (
Dict[str, int]可选, 默认为{"height" -- 384, "width": 512}): 调整大小后图像的尺寸。调整大小后图像的尺寸。如果keep_aspect_ratio为True，则图像会通过选择高度和宽度缩放因子中较小的一个，并将其用于两个维度来进行调整大小。如果还设置了ensure_multiple_of，则图像将进一步调整大小，使其尺寸为该值的倍数。可以被preprocess中的size覆盖。 - resample (
PILImageResampling, 可选, 默认为Resampling.BILINEAR) — 定义调整图像大小时使用的重采样滤波器。可以被preprocess中的resample覆盖。 - keep_aspect_ratio (
bool, 可选, 默认为True) — 如果为True，则图像会通过选择高度和宽度缩放因子中较小的一个，并将其用于两个维度来进行调整大小。这确保了图像在尽可能少地缩小的情况下，仍然能够适应所需的输出尺寸。如果还设置了ensure_multiple_of，则图像将进一步调整大小，使其尺寸为该值的倍数，方法是将高度和宽度向下取整到最接近该值的倍数。可以被preprocess中的keep_aspect_ratio覆盖。 - ensure_multiple_of (
int, 可选, 默认为 32) — 如果do_resize为True，则图像将被调整为该值倍数的尺寸。通过将高度和宽度向下取整到最接近该值的倍数来实现。无论是否将
keep_aspect_ratio设置为True均可工作。可以被preprocess中的ensure_multiple_of覆盖。
构建 ZoeDepth 图像处理器。
preprocess
< source >( images: Union do_pad: bool = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None do_resize: bool = None size: int = None keep_aspect_ratio: bool = None ensure_multiple_of: int = None resample: Resampling = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None )
参数
- images (
ImageInput) — 要预处理的图像。 接受像素值范围为 0 到 255 的单张或批量图像。 如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。 - do_pad (
bool, 可选, 默认为self.do_pad) — 是否对输入图像进行填充。 - do_rescale (
bool, 可选, 默认为self.do_rescale) — 是否将图像值重新缩放到 [0 - 1] 之间。 - rescale_factor (
float, 可选, 默认为self.rescale_factor) — 如果do_rescale设置为True，则用于重新缩放图像的缩放因子。 - do_normalize (
bool, 可选, 默认为self.do_normalize) — 是否对图像进行归一化处理。 - image_mean (
float或List[float], 可选, 默认为self.image_mean) — 图像均值。 - image_std (
float或List[float], 可选, 默认为self.image_std) — 图像标准差。 - do_resize (
bool, 可选, 默认为self.do_resize) — 是否调整图像大小。 - size (
Dict[str, int], 可选, 默认为self.size) — 调整大小后图像的尺寸。如果keep_aspect_ratio为True，则图像会通过选择高度和宽度缩放因子中较小的一个，并将其用于两个维度来进行调整大小。如果还设置了ensure_multiple_of，则图像将进一步调整大小，使其尺寸为该值的倍数。 - keep_aspect_ratio (
bool, 可选, 默认为self.keep_aspect_ratio) — 如果为True且do_resize=True，则图像会通过选择高度和宽度缩放因子中较小的一个，并将其用于两个维度来进行调整大小。这确保了图像在尽可能少地缩小的情况下，仍然能够适应所需的输出尺寸。如果还设置了ensure_multiple_of，则图像将进一步调整大小，使其尺寸为该值的倍数，方法是将高度和宽度向下取整到最接近该值的倍数。 - ensure_multiple_of (
int, 可选, 默认为self.ensure_multiple_of) — 如果do_resize为True，则图像将被调整为该值倍数的尺寸。通过将高度和宽度向下取整到最接近该值的倍数来实现。无论是否将
keep_aspect_ratio设置为True均可工作。可以被preprocess中的ensure_multiple_of覆盖。 - resample (
int, 可选, 默认为self.resample) — 调整图像大小时使用的重采样滤波器。 这可以是枚举类型PILImageResampling中的一个值。 仅在do_resize设置为True时有效。 - return_tensors (
str或TensorType, 可选) — 返回张量的类型。 可以是以下之一：- Unset: 返回
np.ndarray列表。 TensorType.TENSORFLOW或'tf': 返回tf.Tensor类型的批次。TensorType.PYTORCH或'pt': 返回torch.Tensor类型的批次。TensorType.NUMPY或'np': 返回np.ndarray类型的批次。TensorType.JAX或'jax': 返回jax.numpy.ndarray类型的批次。
- Unset: 返回
- data_format (
ChannelDimension或str, 可选, 默认为ChannelDimension.FIRST) — 输出图像的通道维度格式。 可以是以下之一：ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
- input_data_format (
ChannelDimension或str, 可选) — 输入图像的通道维度格式。 如果未设置，则通道维度格式将从输入图像推断。 可以是以下之一："channels_first"或ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。"none"或ChannelDimension.NONE: 图像格式为 (height, width)。
预处理单张或批量图像。
ZoeDepthForDepthEstimation
class transformers.ZoeDepthForDepthEstimation
< 源文件 >( config )
参数
- config (ViTConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
ZoeDepth 模型，顶部带有一个或多个度量深度估计头。
此模型是 PyTorch torch.nn.Module 子类。 可以将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与通用用法和行为相关的所有事项。
forward (前向传播)
< 源文件 >( pixel_values: FloatTensor labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.DepthEstimatorOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。 像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 DPTImageProcessor.call()。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (形状为
(batch_size, height, width)的torch.LongTensor, 可选) — 用于计算损失的地面实况深度估计图。
返回值
transformers.modeling_outputs.DepthEstimatorOutput 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.DepthEstimatorOutput 或 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (ZoeDepthConfig) 和输入。
-
loss (形状为
(1,)的torch.FloatTensor, 可选, 当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 -
predicted_depth (形状为
(batch_size, height, width)的torch.FloatTensor) — 每个像素的预测深度。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出提供一个，+ 为每层的输出提供一个），形状为(batch_size, num_channels, height, width)。模型在每层输出端的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, patch_size, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
ZoeDepthForDepthEstimation 前向传播方法，覆盖了 __call__ 特殊方法。
尽管前向传播的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoImageProcessor, ZoeDepthForDepthEstimation
>>> import torch
>>> import numpy as np
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("Intel/zoedepth-nyu-kitti")
>>> model = ZoeDepthForDepthEstimation.from_pretrained("Intel/zoedepth-nyu-kitti")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
... predicted_depth = outputs.predicted_depth
>>> # interpolate to original size
>>> prediction = torch.nn.functional.interpolate(
... predicted_depth.unsqueeze(1),
... size=image.size[::-1],
... mode="bicubic",
... align_corners=False,
... )
>>> # visualize the prediction
>>> output = prediction.squeeze().cpu().numpy()
>>> formatted = (output * 255 / np.max(output)).astype("uint8")
>>> depth = Image.fromarray(formatted)