Hugging Face's logo

Transformers 文档

GIT

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

GIT

概述

GIT 模型由 Jianfeng Wang, Zhengyuan Yang, Xiaowei Hu, Linjie Li, Kevin Lin, Zhe Gan, Zicheng Liu, Ce Liu, Lijuan Wang 在 GIT: A Generative Image-to-text Transformer for Vision and Language 中提出。GIT 是一种仅解码器的 Transformer，它利用 CLIP 的视觉编码器来根据视觉输入（除了文本）调节模型。该模型在图像描述和视觉问答基准测试中获得了最先进的结果。

论文的摘要如下：

在本文中，我们设计和训练了一个生成式图像到文本转换器 GIT，以统一视觉语言任务，例如图像/视频描述和问题回答。虽然生成模型在预训练和微调之间提供了Consistent的网络架构，但现有工作通常包含复杂的结构（单/多模态编码器/解码器），并依赖于外部模块，例如对象检测器/标注器和光学字符识别（OCR）。在 GIT 中，我们将架构简化为一个图像编码器和一个文本解码器，置于单个语言建模任务下。我们还扩大了预训练数据和模型大小，以提高模型性能。我们的 GIT 没有花哨的功能，在 12 个具有挑战性的基准测试中以大幅优势确立了新的最先进水平。例如，我们的模型首次在 TextCaps 上超越了人类的表现（CIDEr 中为 138.2 对 125.5）。此外，我们提出了一种新的基于生成的图像分类和场景文本识别方案，在标准基准测试中取得了不错的性能。

drawing GIT 架构。取自原始论文。

此模型由 nielsr 贡献。原始代码可以在这里找到。

使用技巧

  • GIT 的实现方式与 GPT-2 非常相似，唯一的区别是该模型还以 pixel_values 为条件。

资源

官方 Hugging Face 和社区（🌎 表示）资源列表，可帮助您开始使用 GIT。

如果您有兴趣提交资源以包含在此处，请随时打开拉取请求，我们将对其进行审核。理想情况下，该资源应展示一些新的内容，而不是重复现有资源。

GitVisionConfig

class transformers.GitVisionConfig

< >

( hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 num_channels = 3 image_size = 224 patch_size = 16 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 **kwargs )

参数

  • hidden_size (int, 可选，默认为 768) — 编码器层和池化层的维度。
  • intermediate_size (int, 可选，默认为 3072) — Transformer 编码器中“中间”（即，前馈）层的维度。
  • num_hidden_layers (int, 可选，默认为 12) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, 可选，默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
  • image_size (int, 可选，默认为 224) — 每张图片的大小（分辨率）。
  • patch_size (int, 可选，默认为 16) — 每个图像块的大小（分辨率）。
  • hidden_act (str 或 function, 可选，默认为 "quick_gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu", "relu", "selu" 和 "gelu_new" "quick_gelu"。
  • layer_norm_eps (float, 可选，默认为 1e-5) — 层归一化层使用的 epsilon 值。
  • attention_dropout (float, 可选，默认为 0.0) — 注意力概率的 dropout 比率。
  • initializer_range (float, 可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。

这是用于存储 GitVisionModel 配置的配置类。它用于根据指定的参数实例化 GIT 视觉编码器，从而定义模型架构。使用默认值实例化配置将产生与 GIT microsoft/git-base 架构的视觉编码器类似的配置。

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

示例

>>> from transformers import GitVisionConfig, GitVisionModel

>>> # Initializing a GitVisionConfig with microsoft/git-base style configuration
>>> configuration = GitVisionConfig()

>>> # Initializing a GitVisionModel (with random weights) from the microsoft/git-base style configuration
>>> model = GitVisionModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

GitVisionModel

class transformers.GitVisionModel

< >

( config: GitVisionConfig )

参数

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

CLIP 中的视觉模型，用于 GIT，顶部没有任何头或投影。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与一般用法和行为相关的所有事项。

forward

< >

( pixel_values: Optional = None 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 获得。详见 CLIPImageProcessor.call()。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。 详见返回张量下的 attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的 hidden_states。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通的元组。

Returns

transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

A transformers.modeling_outputs.BaseModelOutput 或 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.git.configuration_git.GitVisionConfig'>) 和输入。

  • last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。

  • hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型具有嵌入层，则为嵌入层的输出 + 每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出以及可选的初始嵌入输出处的隐藏状态。

  • attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

GitVisionModel forward 方法，覆盖了 __call__ 特殊方法。

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

Examples

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, GitVisionModel

>>> processor = AutoProcessor.from_pretrained("microsoft/git-base")
>>> model = GitVisionModel.from_pretrained("microsoft/git-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state

GitConfig

class transformers.GitConfig

< >

( vision_config = None vocab_size = 30522 hidden_size = 768 num_hidden_layers = 6 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 1024 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' use_cache = True tie_word_embeddings = False bos_token_id = 101 eos_token_id = 102 num_image_with_embedding = None **kwargs )

参数

  • vision_config (dict, optional) — 用于初始化 GitVisionConfig 的配置选项字典。
  • vocab_size (int, optional, defaults to 30522) — GIT 模型的词汇表大小。 定义了调用 GitModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
  • hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。
  • num_hidden_layers (int, optional, defaults to 6) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。
  • intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”层（通常称为前馈层）的维度。
  • hidden_act (str 或 Callable, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。 如果是字符串，则支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
  • hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
  • max_position_embeddings (int, optional, defaults to 1024) — 此模型可能使用的最大序列长度。 通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。
  • initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon 值。
  • position_embedding_type (str, optional, defaults to "absolute") — 位置嵌入的类型。 选择 "absolute"、"relative_key"、"relative_key_query" 之一。 对于位置嵌入，请使用 "absolute"。 有关 "relative_key" 的更多信息，请参阅 Self-Attention with Relative Position Representations (Shaw et al.)。 有关 "relative_key_query" 的更多信息，请参阅 Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的方法 4 。
  • use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
  • num_image_with_embedding (int, optional) — 要添加的时间嵌入的数量，以防模型用于视频字幕/VQA。

这是用于存储 GitModel 配置的配置类。 它用于根据指定的参数实例化 GIT 模型，定义模型架构。 使用默认值实例化配置将产生与 GIT microsoft/git-base 架构类似的配置。

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

Examples

>>> from transformers import GitConfig, GitModel

>>> # Initializing a GIT microsoft/git-base style configuration
>>> configuration = GitConfig()

>>> # Initializing a model (with random weights) from the microsoft/git-base style configuration
>>> model = GitModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

GitProcessor

class transformers.GitProcessor

< >

( image_processor tokenizer )

参数

构建一个 GIT 处理器，它将 CLIP 图像处理器和 BERT 分词器包装到单个处理器中。

GitProcessor 提供 CLIPImageProcessor 和 BertTokenizerFast 的所有功能。 有关更多信息，请参阅 call() 和 decode()。

__call__

< >

( images: Union = None text: Union = None audio = None videos = None **kwargs: Unpack ) → BatchFeature

参数

  • images (PIL.Image.Image, np.ndarray, torch.Tensor, List[PIL.Image.Image], List[np.ndarray], List[torch.Tensor]) — 要准备的图像或图像批次。每张图像可以是 PIL 图像、NumPy 数组或 PyTorch 张量。支持通道优先和通道在后格式。
  • text (TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput], optional) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）形式提供，则必须设置 is_split_into_words=True （以消除与序列批次的歧义）。
  • return_tensors (str 或 TensorType, optional) — 如果设置，将返回特定框架的张量。可接受的值为：

    • 'tf'：返回 TensorFlow tf.constant 对象。
    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 NumPy np.ndarray 对象。
    • 'jax'：返回 JAX jnp.ndarray 对象。

Returns

BatchFeature

一个包含以下字段的 BatchFeature

  • input_ids — 要馈送到模型的 token id 列表。当 text 不是 None 时返回。
  • attention_mask — 指定模型应关注哪些 token 的索引列表（当 return_attention_mask=True 或如果 “attention_mask” 在 self.model_input_names 中，且 text 不是 None 时）。
  • pixel_values — 要馈送到模型的像素值。当 images 不是 None 时返回。

准备模型的一个或多个序列和图像的主要方法。如果 text 不是 None，此方法将 text 和 kwargs 参数转发到 BertTokenizerFast 的 call() 以编码文本。要准备图像，如果 images 不是 None，此方法将 images 和 kwrags 参数转发到 CLIPImageProcessor 的 call()。有关更多信息，请参阅上述两种方法的 doctsring。

GitModel

class transformers.GitModel

< >

( config )

参数

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

裸 GIT 模型转换器，由 CLIP 图像编码器和文本解码器组成，输出原始隐藏状态，顶部没有任何特定的 head。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与一般用法和行为相关的所有事项。

forward

< >

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None pixel_values: Optional = None head_mask: Optional = None inputs_embeds: Optional = None past_key_values: Union = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

参数

  • input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor) — 词汇表中输入序列 token 的索引。

    索引可以使用 AutoTokenizer 获得。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详细信息。

    什么是输入 ID？

  • attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor, optional) — 避免对 padding token 索引执行 attention 的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示 token 未被掩盖，
    • 0 表示 token 被掩盖。

    什么是 attention 掩码？

  • position_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, optional) — 每个输入序列 token 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 ID？

  • pixel_values (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素值。像素值可以使用 AutoImageProcessor 获得。 请参阅 CLIPImageProcessor.call() 了解详细信息。
  • head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.FloatTensor, optional) — 用于使 self-attention 模块的选定 head 无效的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示 head 未被掩盖，
    • 0 表示 head 被掩盖。
  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更灵活地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
  • past_key_values (Cache 或 tuple(tuple(torch.FloatTensor)), optional) — 预先计算的隐藏状态（self-attention 块和 cross-attention 块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

    允许两种格式：

    • Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组具有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量。这也称为旧版缓存格式。

    模型将输出与作为输入馈送的缓存格式相同的格式。如果未传递 past_key_values，则将返回旧版缓存格式。

    如果使用 past_key_values，则用户可以选择仅输入形状为 (batch_size, 1) 的最后一个 input_ids（那些没有将其过去的键值状态提供给此模型的 input_ids），而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • output_attentions (bool, optional) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  • use_cache (bool, optional) — 如果设置为 True，则返回 past_key_values 键值状态，并可用于加速解码（请参阅 past_key_values）。

Returns

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或 torch.FloatTensor 的元组（如果传递 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (GitConfig) 和输入。

  • last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。

  • pooler_output (形状为 (batch_size, hidden_size) 的 torch.FloatTensor) — 序列的第一个 token（分类 token）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理后。 例如，对于 BERT 系列模型，这返回通过线性层和 tanh 激活函数处理后的分类 token。线性层权重从预训练期间的下一句预测（分类）目标中训练而来。

  • hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型具有嵌入层，则为嵌入层的输出 + 每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出以及可选的初始嵌入输出处的隐藏状态。

  • attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

GitModel forward 方法，覆盖了 __call__ 特殊方法。

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

Examples

>>> from transformers import AutoProcessor, AutoModel
>>> import requests
>>> from PIL import Image

>>> processor = AutoProcessor.from_pretrained("microsoft/git-base")
>>> model = AutoModel.from_pretrained("microsoft/git-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> text = "this is an image of two cats"

>>> inputs = processor(images=image, text=text, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state

GitForCausalLM

class transformers.GitForCausalLM

< >

( config )

参数

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

GIT 模型，顶部带有一个用于自回归语言建模的 language modeling head。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与一般用法和行为相关的所有事项。

forward

< >

( input_ids: 可选 = None attention_mask: 可选 = None position_ids: 可选 = None pixel_values: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None labels: 可选 = None past_key_values: 联合类型 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

    可以使用 AutoTokenizer 获取索引。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以获取详细信息。

    什么是输入 IDs？

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。 掩码值在 [0, 1] 中选择：

    • 1 表示 tokens 未被掩盖，
    • 0 表示 tokens 被掩盖。

    什么是 attention 掩码？

  • position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs？

  • pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。 像素值可以使用 AutoImageProcessor 获取。 请参阅 CLIPImageProcessor.call() 以获取详细信息。
  • head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于置空 self-attention 模块中选定 head 的掩码。 掩码值在 [0, 1] 中选择：

    • 1 表示 head 未被掩盖，
    • 0 表示 head 被掩盖。
  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
  • past_key_values (Cache 或 tuple(tuple(torch.FloatTensor))，可选) — 预先计算的隐藏状态（self-attention 模块和 cross-attention 模块中的键和值），可用于加速顺序解码。 这通常包括在解码的先前阶段由模型返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

    允许两种格式：

    • Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组具有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。 这也称为旧版缓存格式。

    模型将输出与作为输入馈送的缓存格式相同的格式。 如果未传递 past_key_values，则将返回旧版缓存格式。

    如果使用 past_key_values，则用户可以选择仅输入最后 input_ids（那些没有将其过去键值状态提供给此模型的）形状为 (batch_size, 1) 而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
  • labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算从左到右语言建模损失（下一个单词预测）的标签。 索引应为 [-100, 0, ..., config.vocab_size]（参见 input_ids 文档字符串） 索引设置为 -100 的 Tokens 将被忽略（掩盖），损失仅针对标签为 n [0, ..., config.vocab_size] 的 tokens 计算
  • use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，并且可以用于加速解码（请参阅 past_key_values）。

Returns

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

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (GitConfig) 和输入。

  • loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 语言建模损失（用于下一个 token 预测）。

  • logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模 head 的预测分数（SoftMax 之前每个词汇表 token 的分数）。

  • past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组具有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量）

    包含预先计算的隐藏状态（self-attention 模块中的键和值），可以用于（参见 past_key_values 输入）加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型具有嵌入层，则为嵌入层的输出 + 每层输出一个)，形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出以及可选的初始嵌入输出处的隐藏状态。

  • attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个)，形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

GitForCausalLM 前向传播方法，覆盖了 __call__ 特殊方法。

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

Examples

图像字幕示例

>>> from transformers import AutoProcessor, AutoModelForCausalLM
>>> import requests
>>> from PIL import Image

>>> processor = AutoProcessor.from_pretrained("microsoft/git-base-coco")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-base-coco")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> pixel_values = processor(images=image, return_tensors="pt").pixel_values

>>> generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
>>> generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print(generated_caption)
two cats sleeping on a pink blanket next to remotes.

视觉问答 (VQA) 示例

>>> from transformers import AutoProcessor, AutoModelForCausalLM
>>> from huggingface_hub import hf_hub_download
>>> from PIL import Image

>>> processor = AutoProcessor.from_pretrained("microsoft/git-base-textvqa")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-base-textvqa")

>>> file_path = hf_hub_download(repo_id="nielsr/textvqa-sample", filename="bus.png", repo_type="dataset")
>>> image = Image.open(file_path).convert("RGB")

>>> pixel_values = processor(images=image, return_tensors="pt").pixel_values

>>> question = "what does the front of the bus say at the top?"

>>> input_ids = processor(text=question, add_special_tokens=False).input_ids
>>> input_ids = [processor.tokenizer.cls_token_id] + input_ids
>>> input_ids = torch.tensor(input_ids).unsqueeze(0)

>>> generated_ids = model.generate(pixel_values=pixel_values, input_ids=input_ids, max_length=50)
>>> print(processor.batch_decode(generated_ids, skip_special_tokens=True))
['what does the front of the bus say at the top? special']

视频字幕示例

>>> import av
>>> import numpy as np
>>> from PIL import Image
>>> from huggingface_hub import hf_hub_download
>>> from transformers import AutoProcessor, AutoModelForCausalLM

>>> processor = AutoProcessor.from_pretrained("microsoft/git-base-vatex")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-base-vatex")

>>> # set seed for reproducability
>>> np.random.seed(45)


>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`List[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])


>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`List[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices


>>> # load video
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)

>>> # sample frames
>>> num_frames = model.config.num_image_with_embedding
>>> indices = sample_frame_indices(
...     clip_len=num_frames, frame_sample_rate=4, seg_len=container.streams.video[0].frames
... )
>>> frames = read_video_pyav(container, indices)

>>> pixel_values = processor(images=list(frames), return_tensors="pt").pixel_values

>>> generated_ids = model.generate(pixel_values=pixel_values, max_length=50)

>>> print("Generated caption:", processor.batch_decode(generated_ids, skip_special_tokens=True))
Generated caption: ['a woman is sitting at a table and she is talking about the food she is holding.']
< > 在 GitHub 上更新

←FLAVA Grounding DINO→