Transformers 4.37 中文文档（六十八）（2）

Transformers 4.37 中文文档（六十八）（1）https://developer.aliyun.com/article/1564091

GLPNModel

class transformers.GLPNModel

< source >

( config )
• 1

参数

• config（GLPNConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。

裸的 GLPN 编码器（Mix-Transformer）输出原始隐藏状态，没有特定的顶部头。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( pixel_values: FloatTensor output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)
• 1

参数

• pixel_values（形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor）— 像素值。默认情况下将忽略填充。可以使用 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（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。
  
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出的一个+每个层的输出一个）。
  模型在每个层的输出处的隐藏状态加上可选的初始嵌入输出。
  
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
  

GLPNModel 的前向方法，覆盖__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoImageProcessor, GLPNModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> 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]
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

GLPNForDepthEstimation

class transformers.GLPNForDepthEstimation

<来源>

( config )
• 1

参数

• config（GLPNConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

GLPN 模型变换器，顶部带有轻量级深度估计头，例如适用于 KITTI、NYUv2。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

前进

<来源>

( pixel_values: FloatTensor labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.DepthEstimatorOutput or tuple(torch.FloatTensor)
• 1

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 GLPNImageProcessor.call()。
  
• output_attentions（可选，布尔值）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
  
• output_hidden_states（可选，布尔值）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
  
• return_dict（可选，布尔值）- 是否返回 ModelOutput 而不是普通元组。
  
• labels（形状为(batch_size, height, width)的torch.FloatTensor，可选）- 用于计算损失的地面真实深度估计图。
  

返回

transformers.modeling_outputs.DepthEstimatorOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.DepthEstimatorOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置（GLPNConfig）和输入的不同元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 分类（如果 config.num_labels==1 则为回归）损失。
  
• predicted_depth（形状为(batch_size, height, width)的torch.FloatTensor）- 每个像素的预测深度。
  
• hidden_states（可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。
  模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
  
• attentions（可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor元组（每层一个）。
  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
  

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)
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31

ImageGPT

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/imagegpt

概述

ImageGPT 模型是由 Mark Chen、Alec Radford、Rewon Child、Jeffrey Wu、Heewoo Jun、David Luan、Ilya Sutskever 在像素生成预训练中提出的。ImageGPT（iGPT）是一个类似于 GPT-2 的模型，训练用于预测下一个像素值，从而实现无条件和有条件的图像生成。

论文摘要如下：

受到自然语言无监督表示学习进展的启发，我们研究类似的模型是否可以学习对图像有用的表示。我们训练一个序列  Transformer，自回归地预测像素，而不考虑 2D 输入结构的知识。尽管在没有标签的低分辨率 ImageNet 上训练，我们发现一个  GPT-2 规模的模型通过线性探测、微调和低数据分类来衡量，学习到了强大的图像表示。在 CIFAR-10 上，我们通过线性探测实现了  96.3%的准确率，超过了监督的 Wide ResNet，并且通过完全微调实现了 99.0%的准确率，与顶级监督预训练模型相匹敌。当用  VQVAE 编码替换像素时，我们在 ImageNet 上也与自监督基准竞争，通过线性探测我们的特征实现了 69.0%的 top-1 准确率。

方法概述。摘自原始论文。

该模型由nielsr贡献，基于此问题。原始代码可以在这里找到。

使用提示

• ImageGPT 与 GPT-2 几乎完全相同，唯一的区别是使用了不同的激活函数（即“quick gelu”），并且层归一化层不对输入进行均值中心化。ImageGPT 也没有绑定输入和输出嵌入。
  
• 由于  Transformer 的注意机制的时间和内存需求与序列长度的平方成比例增长，作者在较小的输入分辨率（如 32x32 和  64x64）上预训练了 ImageGPT。然而，将一个 32x32x3=3072 个令牌的序列从 0…255 输入到 Transformer  仍然是不可行的。因此，作者对（R,G,B）像素值应用了 k=512 的 k 均值聚类。这样，我们只有一个长度为 32*32 = 1024  的序列，但现在是 0…511 范围内的整数。因此，我们在缩短序列长度的同时增加了嵌入矩阵的大小。换句话说，ImageGPT 的词汇大小为  512，再加上一个特殊的“句子开头”（SOS）令牌，用于每个序列的开头。可以使用 ImageGPTImageProcessor  来为模型准备图像。
  
• 尽管 ImageGPT  完全无监督预训练（即不使用任何标签），但它生成了相当有效的图像特征，可用于下游任务，如图像分类。作者表明，网络中间的特征最有效，并且可以直接用作训练线性模型（例如  sklearn logistic 回归模型）。这也被称为“线性探测”。通过首先将图像通过模型转发，然后指定output_hidden_states=True，然后在任何您喜欢的层上对隐藏状态进行平均池化，可以轻松获取特征。
  
• 或者，可以在下游数据集上进一步微调整个模型，类似于 BERT。为此，可以使用 ImageGPTForImageClassification。
  
• ImageGPT 有不同的大小：有 ImageGPT-small、ImageGPT-medium 和 ImageGPT-large。作者还训练了一个 XL 变体，但他们没有发布。大小上的差异总结在以下表中：
  

资源

一个官方的 Hugging Face 和社区（由🌎表示）资源列表，帮助您开始使用 ImageGPT。

图像分类

• ImageGPT 的演示笔记本可以在这里找到。
  
• ImageGPTForImageClassification 由这个示例脚本和笔记本支持。
  
• 另请参阅：图像分类任务指南
  

如果您有兴趣提交资源以包含在这里，请随时打开一个 Pull Request，我们将进行审核！资源应该展示一些新东西，而不是重复现有资源。

ImageGPTConfig

class transformers.ImageGPTConfig

<来源>

( vocab_size = 513 n_positions = 1024 n_embd = 512 n_layer = 24 n_head = 8 n_inner = None activation_function = 'quick_gelu' resid_pdrop = 0.1 embd_pdrop = 0.1 attn_pdrop = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 scale_attn_weights = True use_cache = True tie_word_embeddings = False scale_attn_by_inverse_layer_idx = False reorder_and_upcast_attn = False **kwargs )
• 1

参数

• vocab_size (int，可选，默认为 512) — GPT-2 模型的词汇大小。定义了在调用 ImageGPTModel 或TFImageGPTModel时可以表示的不同令牌数量。
  
• n_positions (int，可选，默认为 32*32) — 此模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。
  
• n_embd (int，可选，默认为 512) — 嵌入和隐藏状态的维度。
  
• n_layer (int，可选，默认为 24) — Transformer 编码器中的隐藏层数。
  
• n_head (int，可选，默认为 8) — Transformer 编码器中每个注意力层的注意力头数。
  
• n_inner (int，可选，默认为 None) — 内部前馈层的维度。None将将其设置为 n_embd 的 4 倍。
  
• activation_function (str，可选，默认为"quick_gelu") — 激活函数（可以是 src/transformers/activations.py 中定义的激活函数之一）。默认为"quick_gelu"。
  
• resid_pdrop (float，可选，默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的丢失概率。
  
• embd_pdrop (int，可选，默认为 0.1) — 嵌入的丢失比率。
  
• attn_pdrop (float，可选，默认为 0.1) — 注意力的丢失比率。
  
• layer_norm_epsilon (float，可选，默认为 1e-5) — 在层归一化层中使用的 epsilon。
  
• initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• scale_attn_weights (bool，可选，默认为True) — 通过除以 sqrt(hidden_size)来缩放注意力权重。
  
• use_cache (bool, 可选, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
  
• scale_attn_by_inverse_layer_idx (bool, 可选, 默认为False) — 是否额外按1 / layer_idx + 1缩放注意力权重。
  
• reorder_and_upcast_attn (bool, 可选, 默认为False) — 是否在计算注意力（点积）之前缩放键（K），并在使用混合精度训练时将注意力点积/softmax 向上转换为 float()。
  

这是配置类，用于存储 ImageGPTModel 或TFImageGPTModel的配置。根据指定的参数实例化一个 GPT-2 模型，定义模型架构。使用默认值实例化配置将产生类似于 ImageGPT openai/imagegpt-small架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import ImageGPTConfig, ImageGPTModel
>>> # Initializing a ImageGPT configuration
>>> configuration = ImageGPTConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = ImageGPTModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

ImageGPTFeatureExtractor

class transformers.ImageGPTFeatureExtractor

<来源>

( *args **kwargs )
• 1

__call__

<来源>

( images **kwargs )
• 1

预处理一张图像或一批图像。

ImageGPTImageProcessor

class transformers.ImageGPTImageProcessor

<来源>

( clusters: Union = None do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_normalize: bool = True do_color_quantize: bool = True **kwargs )
• 1

参数

• clusters (np.ndarray或List[List[int]], 可选) — 在颜色量化时要使用的颜色簇，形状为(n_clusters, 3)。可以被preprocess中的clusters覆盖。
  
• do_resize (bool, 可选, 默认为True) — 是否将图像的尺寸调整为(size["height"], size["width"])。可以被preprocess中的do_resize覆盖。
  
• size (Dict[str, int] 可选, 默认为{"height" -- 256, "width": 256}): 调整大小后的图像尺寸。可以被preprocess中的size覆盖。
  
• resample (PILImageResampling, 可选, 默认为Resampling.BILINEAR) — 如果调整图像大小，要使用的重采样滤波器。可以被preprocess中的resample覆盖。
  
• do_normalize (bool, 可选, 默认为True) — 是否将图像像素值归一化为[-1, 1]之间。可以被preprocess中的do_normalize覆盖。
  
• do_color_quantize (bool, 可选, 默认为True) — 是否对图像进行颜色量化。可以被preprocess中的do_color_quantize覆盖。
  

构建一个 ImageGPT 图像处理器。此图像处理器可用于将图像调整为较小分辨率（如 32x32 或 64x64），对其进行归一化，最后进行颜色量化，以获得“像素值”（颜色簇）序列。

preprocess

<来源>

( images: Union do_resize: bool = None size: Dict = None resample: Resampling = None do_normalize: bool = None do_color_quantize: Optional = None clusters: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )
• 1

参数

• images (ImageInput) — 要预处理的图像。期望像素值从 0 到 255 的单个图像或图像批次。如果传入像素值在 0 到 1 之间的图像，请设置do_normalize=False。
  
• do_resize (bool, 可选, 默认为self.do_resize) — 是否调整图像大小。
  
• size (Dict[str, int], 可选, 默认为self.size) — 调整大小后的图像尺寸。
  
• resample (int，可选，默认为 self.resample) — 如果调整图像大小，则要使用的重采样滤波器。可以是枚举 PILImageResampling 中的一个，仅在 do_resize 设置为 True 时有效。
  
• do_normalize (bool，可选，默认为 self.do_normalize) — 是否对图像进行归一化
  
• do_color_quantize (bool，可选，默认为 self.do_color_quantize) — 是否对图像进行颜色量化。
  
• clusters (np.ndarray 或 List[List[int]]，可选，默认为 self.clusters) — 用于对图像进行量化的聚类，形状为 (n_clusters, 3)。仅在 do_color_quantize 设置为 True 时有效。
  
• return_tensors (str 或 TensorType，可选) — 返回的张量类型。可以是以下之一：

• 未设置: 返回一个 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: 图像格式为 (通道数, 高度, 宽度)。
  
• ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。仅在 do_color_quantize 设置为 False 时有效。
  

• input_data_format (ChannelDimension 或 str，可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：

• "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (通道数, 高度, 宽度)。
  
• "channels_last" 或 ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。
  
• "none" 或 ChannelDimension.NONE: 图像格式为 (高度, 宽度)。
  

预处理图像或图像批次。

ImageGPTModel

class transformers.ImageGPTModel

< source >

( config: ImageGPTConfig )
• 1

参数

• config (ImageGPTConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。

裸的 ImageGPT 模型变压器，输出没有特定头部的原始隐藏状态。

该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

该模型还是一个 PyTorch torch.nn.Module 子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

< source >

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs: Any ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)
• 1

参数

• input_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor） — 如果 past_key_values 为 None，则 input_ids_length = sequence_length，否则为 past_key_values[0][0].shape[-2]（输入过去关键值状态的序列长度）。词汇表中输入序列标记的索引。
  如果使用了 past_key_values，则只应将未计算其过去的 input_ids 作为 input_ids 传递。
  可以使用 AutoImageProcessor 获取索引。有关详细信息，请参见 ImageGPTImageProcessor.call()。
  
• past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）- 包含由模型计算的预先计算的隐藏状态（注意力块中的键和值），可以用于加速顺序解码。将过去给定给该模型的input_ids不应作为input_ids传递，因为它们已经被计算过。
  
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

• 1 表示未被masked的标记，
  
• 0 表示被masked的标记。
  

• 什么是 attention masks？
  
• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

• 0 对应于句子 A标记，
  
• 1 对应于句子 B标记。
  

• 什么是 token type IDs？
  
• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
  什么是 position IDs？
  
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

• 1 表示头部未被masked，
  
• 0 表示头部是masked。
  

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
  如果使用past_key_values，则可以选择仅输入最后的inputs_embeds（请参见past_key_values）。
  
• use_cache（bool，可选）- 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参见past_key_values）。
  
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量下的attentions。
  
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量下的hidden_states。
  
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。
  
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于语言建模的标签。请注意，模型内部的标签已经被移位，即您可以设置labels = input_ids。索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都被忽略（被masked），损失仅计算标签在[0, ..., config.vocab_size]中的情况。
  

返回

transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（ImageGPTConfig）和输入的各种元素。

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出的隐藏状态序列。
  如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
  
• past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。
  包含预先计算的隐藏状态（自注意力块中的键和值，以及在交叉注意力块中可选地使用config.is_encoder_decoder=True）可用于加速顺序解码（查看past_key_values输入）。
  
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出）。
  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  
• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
  
• cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True和config.add_cross_attention=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
  

ImageGPTModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoImageProcessor, ImageGPTModel
>>> 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("openai/imagegpt-small")
>>> model = ImageGPTModel.from_pretrained("openai/imagegpt-small")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

Transformers 4.37 中文文档（六十八）（3）