GLPN
这是一个最近推出的模型，因此 API 还没有经过广泛测试。将来可能存在一些错误或细微的破坏性变更需要修复。如果您发现奇怪的地方，请提交Github Issue。
概述
GLPN 模型由 Doyeon Kim、Woonghyun Ga、Pyungwhan Ahn、Donggyu Joo、Sehwan Chun 和 Junmo Kim 在具有垂直切割深度的单目深度估计的全局局部路径网络中提出。GLPN 将SegFormer 的分层混合 Transformer 与轻量级解码器相结合，用于单目深度估计。所提出的解码器在计算复杂度明显降低的情况下，表现出比以前提出的解码器更好的性能。
论文的摘要如下：
从单张图像中进行深度估计是一项重要任务，可以应用于计算机视觉的各个领域，随着卷积神经网络的发展，这项任务发展迅速。本文提出了一种单目深度估计的新结构和训练策略，以进一步提高网络的预测精度。我们部署了分层 Transformer 编码器来捕获和传递全局上下文，并设计了一个轻量级但功能强大的解码器来生成估计的深度图，同时考虑局部连通性。通过使用我们提出的选择性特征融合模块在多尺度局部特征和全局解码流之间构建连接路径，网络可以整合两种表示并恢复精细细节。此外，所提出的解码器在计算复杂度明显降低的情况下，表现出比以前提出的解码器更好的性能。此外，我们通过利用深度估计中的一个重要观察结果来改进深度特定的增强方法，以增强模型。我们的网络在具有挑战性的深度数据集 NYU Depth V2 上取得了最先进的性能。已经进行了大量的实验来验证并表明所提出的方法的有效性。最后，我们的模型表现出比其他比较模型更好的泛化能力和鲁棒性。
该方法的总结。摘自原始论文。该模型由nielsr 贡献。原始代码可以在这里找到here.
资源
以下列出了官方的 Hugging Face 和社区（由 🌎 表示）资源，以帮助您开始使用 GLPN。
- 有关GLPNForDepthEstimation 的演示笔记本可以在这里找到here.
- 单目深度估计任务指南
GLPNConfig
class transformers.GLPNConfig
< 源代码 >( num_channels = 3 num_encoder_blocks = 4 depths = [2, 2, 2, 2] sr_ratios = [8, 4, 2, 1] hidden_sizes = [32, 64, 160, 256] patch_sizes = [7, 3, 3, 3] strides = [4, 2, 2, 2] num_attention_heads = [1, 2, 5, 8] mlp_ratios = [4, 4, 4, 4] hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 drop_path_rate = 0.1 layer_norm_eps = 1e-06 decoder_hidden_size = 64 max_depth = 10 head_in_index = -1 **kwargs )
参数
- num_channels (
int, 可选，默认值为 3) — 输入通道数。 - num_encoder_blocks (
int, 可选，默认值为 4) — 编码器块的数量（即混合 Transformer 编码器中的阶段）。 - depths (
List[int], 可选，默认值为[2, 2, 2, 2]) — 每个编码器块中的层数。 - sr_ratios (
List[int], 可选，默认值为[8, 4, 2, 1]) — 每个编码器块中的序列缩减比率。 - hidden_sizes (
List[int], 可选, 默认值为[32, 64, 160, 256]) — 每个编码器块的维度。 - patch_sizes (
List[int], 可选, 默认值为[7, 3, 3, 3]) — 每个编码器块之前的补丁大小。 - strides (
List[int], 可选, 默认值为[4, 2, 2, 2]) — 每个编码器块之前的步长。 - num_attention_heads (
List[int], 可选, 默认值为[1, 2, 5, 8]) — Transformer 编码器中每个块的每个注意力层中的注意力头数。 - mlp_ratios (
List[int], 可选, 默认值为[4, 4, 4, 4]) — 编码器块中 Mix FFNs 的隐藏层大小与输入层大小的比率。 - hidden_act (
str或function, 可选, 默认值为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。 如果是字符串，则支持"gelu"、"relu"、"selu"和"gelu_new"。 - hidden_dropout_prob (
float, 可选, 默认值为 0.0) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。 - attention_probs_dropout_prob (
float, 可选, 默认值为 0.0) — 注意力概率的丢弃率。 - initializer_range (
float, 可选, 默认值为 0.02) — 初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - drop_path_rate (
float, 可选, 默认值为 0.1) — 用于 Transformer 编码器块的随机深度的丢弃概率。 - max_depth (
int, 可选, 默认值为 10) — 解码器的最大深度。 - head_in_index (
int, 可选, 默认值为 -1) — 用于头部的特征索引。
这是一个配置类，用于存储 GLPNModel 的配置。它用于根据指定的参数实例化 GLPN 模型，定义模型架构。使用默认值实例化配置将产生与 GLPN vinvino02/glpn-kitti 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 中的文档以获取更多信息。
示例
>>> from transformers import GLPNModel, GLPNConfig
>>> # Initializing a GLPN vinvino02/glpn-kitti style configuration
>>> configuration = GLPNConfig()
>>> # Initializing a model from the vinvino02/glpn-kitti style configuration
>>> model = GLPNModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configGLPNFeatureExtractor
预处理图像或图像批次。
GLPNImageProcessor
类 transformers.GLPNImageProcessor
< 源代码 >( do_resize: bool = True size_divisor: int = 32 resample = <Resampling.BILINEAR: 2> do_rescale: bool = True **kwargs )
构造 GLPN 图像处理器。
preprocess
< source >( images: Union do_resize: Optional = None size_divisor: Optional = None resample = None do_rescale: Optional = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None )
参数
- images (
PIL.Image.Image或TensorType或List[np.ndarray]或List[TensorType]) — 要预处理的图像。 预计单个或一批图像的像素值范围为 0 到 255。 如果传递像素值在 0 到 1 之间的图像，请设置do_normalize=False。 - do_resize (
bool, 可选, 默认值为self.do_resize) — 是否调整输入大小，使 (高度，宽度) 尺寸是size_divisor的倍数。 - size_divisor (
int, 可选, 默认值为self.size_divisor) — 当do_resize为True时，图像将被调整大小，使其高度和宽度向下舍入到最接近的size_divisor倍数。 - resample (
PIL.Image重采样过滤器, 可选, 默认值为self.resample) — 如果调整图像大小，则要使用的PIL.Image重采样过滤器，例如PILImageResampling.BILINEAR。 仅当do_resize设置为True时才有效。 - do_rescale (
bool, 可选, 默认值为self.do_rescale) — 是否应用缩放因子（使像素值在 0. 和 1. 之间）。 - return_tensors (
str或TensorType, 可选) — 要返回的张量类型。 可以是以下之一：None: 返回一个np.ndarray列表。TensorType.TENSORFLOW或'tf': 返回一批类型为tf.Tensor的数据。TensorType.PYTORCH或'pt': 返回一批类型为torch.Tensor的数据。TensorType.NUMPY或'np': 返回一批类型为np.ndarray的数据。TensorType.JAX或'jax': 返回一批类型为jax.numpy.ndarray的数据。
- 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)。
预处理给定的图像。
GLPNModel
class transformers.GLPNModel
< 源码 >( config )
参数
- config (GLPNConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。
GLPN 编码器 (Mix-Transformer) 的基本形式，输出原始隐藏状态，没有任何特定头部。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以了解与一般使用和行为相关的所有事项。
forward
< 源码 >( pixel_values: FloatTensor output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。如果提供，默认情况下将忽略填充。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 GLPNImageProcessor.call() 。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包括根据配置 (GLPNConfig) 和输入的不同元素。
-
last_hidden_state (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递了output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（一个用于嵌入的输出，如果模型具有嵌入层，+ 一个用于每一层的输出）形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递了output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个）形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均。
The GLPNModel 正向方法，覆盖了 __call__ 特殊方法。
虽然正向传递的配方需要在此函数内定义，但之后应该调用 Module 实例而不是这个函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoImageProcessor, GLPNModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("vinvino02/glpn-kitti")
>>> model = GLPNModel.from_pretrained("vinvino02/glpn-kitti")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 512, 15, 20]GLPNForDepthEstimation
class transformers.GLPNForDepthEstimation
< 源代码 >( config )
参数
- config (GLPNConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。
GLPN 模型转换器，在顶部具有轻量级深度估计头，例如用于 KITTI、NYUv2。此模型是 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 or tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下将忽略填充，如果您提供它。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 GLPNImageProcessor.call()。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。 - labels (
torch.FloatTensor形状为(batch_size, height, width), 可选) — 用于计算损失的深度估计真值图。
返回
transformers.modeling_outputs.DepthEstimatorOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.DepthEstimatorOutput 或一个 torch.FloatTensor 元组 (如果传递 return_dict=False 或当 config.return_dict=False 时)，包含根据配置 (GLPNConfig) 和输入而不同的各种元素。
-
loss (
torch.FloatTensor形状为(1,), 可选, 当提供labels时返回) — 分类 (或回归，如果 config.num_labels==1) 损失。 -
predicted_depth (
torch.FloatTensor形状为(batch_size, height, width)) — 每个像素的预测深度。 -
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 后的注意力权重，用于计算自注意力头中的加权平均。
The GLPNForDepthEstimation 前向方法，重写了 __call__ 特殊方法。
虽然正向传递的配方需要在此函数内定义，但之后应该调用 Module 实例而不是这个函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoImageProcessor, GLPNForDepthEstimation
>>> 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("vinvino02/glpn-kitti")
>>> model = GLPNForDepthEstimation.from_pretrained("vinvino02/glpn-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)