Transformers 文档

BLOOM

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

BLOOM

概述

BLOOM 模型及其各种版本已通过 BigScience 工作坊 提出。BigScience 受其他开放科学计划的启发,在这些计划中,研究人员共同投入时间和资源,以实现更高的影响力。BLOOM 的架构与 GPT3(用于下一个标记预测的自回归模型)基本相似,但已在 46 种不同的语言和 13 种编程语言上进行了训练。一些较小的模型版本已在同一数据集上进行了训练。BLOOM 提供以下版本

资源

一系列官方 Hugging Face 和社区(由 🌎 表示)资源,可帮助您开始使用 BLOOM。如果您有兴趣提交要在此处包含的资源,请随时打开一个 Pull Request,我们会对其进行审查!该资源理想情况下应展示一些新内容,而不是重复现有的资源。

文本生成

另请参阅

⚡️ 推理

⚙️ 训练

BloomConfig

class transformers.BloomConfig

< >

( vocab_size = 250880 hidden_size = 64 n_layer = 2 n_head = 8 layer_norm_epsilon = 1e-05 initializer_range = 0.02 use_cache = True bos_token_id = 1 eos_token_id = 2 apply_residual_connection_post_layernorm = False hidden_dropout = 0.0 attention_dropout = 0.0 pretraining_tp = 1 slow_but_exact = False **kwargs )

参数

  • vocab_size (int, 可选,默认为 250880) — Bloom 模型的词汇量大小。定义了调用 BloomModel 时传递的 inputs_ids 可以表示的不同标记的最大数量。查看 此讨论 以了解 vocab_size 的定义方式。
  • hidden_size (int, 可选,默认为 64) — 嵌入和隐藏状态的维度。
  • n_layer (int, 可选,默认为 2) — Transformer 编码器中隐藏层的数量。
  • layer_norm_epsilon (float可选,默认为 1e-5) — 层归一化层中使用的 epsilon。
  • initializer_range (float可选,默认为 0.02) — 初始化所有权重矩阵的截断正态分布初始化器的标准差。
  • apply_residual_connection_post_layernorm (bool可选,默认为 False) — 如果启用,则在 Transformer 块中使用隐藏状态的层归一化作为残差
  • hidden_dropout (float可选,默认为 0.1) — 偏置 dropout 上的 dropout 函数的 dropout 率。
  • attention_dropout (float可选,默认为 0.1) — 应用于注意力概率的 dropout 率
  • use_cache (bool可选,默认为 True) — 模型是否应该返回最后的键/值注意力(并非所有模型都使用)。
  • pretraining_tp (int可选,默认为 1) — 实验性功能。使用 Megatron 进行预训练时使用的张量并行秩。请参阅 本文档 以了解更多信息。此值对于确保预训练结果的精确可重复性是必要的。请参阅 此问题。另请注意,仅当 slow_but_exact=True 时才启用此功能。
  • slow_but_exact (bool可选,默认为 False) — 实验性功能。是否使用注意力机制的缓慢但精确的实现。在合并 TP 秩张量时,由于切片操作,在 Megatron 上训练的模型和我们的模型之间结果可能略有不同。请参阅 此问题。获得更准确结果的解决方案是启用此功能。启用此功能会影响推理的计算时间。一旦主模型使用 TP_rank=1 进行了微调,未来可能会解决此问题。

这是用于存储 BloomModel 配置的配置类。它用于根据指定的参数实例化 Bloom 模型,定义模型架构。使用默认值实例化配置将产生与 Bloom 架构 bigscience/bloom 类似的配置。

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

示例

>>> from transformers import BloomConfig, BloomModel

>>> # Initializing a Bloom configuration
>>> configuration = BloomConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = BloomModel(configuration)

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

BloomTokenizerFast

transformers.BloomTokenizerFast

< >

( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' pad_token = '<pad>' add_prefix_space = False clean_up_tokenization_spaces = False **kwargs )

参数

  • vocab_file (str) — 词汇表文件路径。
  • merges_file (str) — 合并文件路径。
  • errors (str, 可选, 默认为 "replace") — 解码字节到 UTF-8 时采用的策略。更多信息请参考 bytes.decode
  • unk_token (str, 可选, 默认为 <|endoftext|>) — 未知词元。不在词汇表中的词元无法转换为 ID,此时将设置为该词元。
  • bos_token (str, 可选, 默认为 <|endoftext|>) — 序列开始词元。
  • eos_token (str, 可选, 默认为 <|endoftext|>) — 序列结束词元。
  • add_prefix_space (bool, 可选, 默认为 False) — 是否在输入的开头添加空格。这使得开头单词的处理方式与其他单词相同。(Bloom 分词器通过前导空格检测单词的开头)。
  • trim_offsets (bool, 可选, 默认为 True) — 后处理步骤是否应修剪偏移量以避免包含空格。

构建一个“快速”Bloom 分词器(由 HuggingFace 的 tokenizers 库支持)。基于字节级字节对编码 (Byte-Pair-Encoding)。

该分词器经过训练,可以将空格视为词元的一部分(有点像 SentencePiece),因此一个单词

的编码方式会根据它是否位于句子的开头(没有空格)而有所不同。

>>> from transformers import BloomTokenizerFast

>>> tokenizer = BloomTokenizerFast.from_pretrained("bigscience/bloom")
>>> tokenizer("Hello world")["input_ids"]
[59414, 8876]

>>> tokenizer(" Hello world")["input_ids"]
[86153, 8876]

可以通过在实例化该分词器时传递 add_prefix_space=True 来避免此行为,但由于模型不是以这种方式进行预训练的,因此可能会导致性能下降。

当与 is_split_into_words=True 一起使用时,需要使用 add_prefix_space=True 实例化此分词器。

此分词器继承自 PreTrainedTokenizerFast,其中包含大多数主要方法。有关这些方法的更多信息,用户应参考此超类。

Pytorch
隐藏 Pytorch 内容

BloomModel

transformers.BloomModel

< >

( config: BloomConfig )

参数

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

基本的 Bloom 模型转换器,输出原始隐藏状态,没有任何特定的头部。

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

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

前向传播

< >

( input_ids: Optional = None past_key_values: Union = None attention_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None cache_position: Optional = None **deprecated_arguments ) transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentionstuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — input_ids_length = 如果 past_key_valuesNone 则为 sequence_length,否则为 past_key_values[0][0].shape[2] (输入过去键值状态的 sequence_length)。词汇表中输入序列标记的索引。

    如果使用 past_key_values,则只应将没有计算其过去的 input_ids 作为 input_ids 传递。

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

    什么是输入 ID?

  • past_key_values (Cachetuple(tuple(torch.FloatTensor)), 可选) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(tuple(torch.FloatTensor)),每个元组都有两个形状为 (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

  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1] 中:

    • 1 表示未掩盖的标记,
    • 0 表示掩盖的标记。

    什么是注意力掩码?

  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads), 可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中:

    • 1 表示未掩盖的头部,
    • 0 表示掩盖的头部。
  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示而不是传递 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 而不是普通元组。
  • cache_position (torch.LongTensor 形状为 (sequence_length)可选) — 描述输入序列令牌在序列中的位置的索引。与 position_ids 相反,此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。

返回

transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentionstuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含根据配置 (BloomConfig) 和输入而变化的各种元素。

  • 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))可选,当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(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)可选,当传递 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=Trueconfig.add_cross_attention=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组(每一层一个)形状为 (batch_size, num_heads, sequence_length, sequence_length)

    解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。

BloomModel 正向方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, BloomModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom-560m")
>>> model = BloomModel.from_pretrained("bigscience/bloom-560m")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

BloomForCausalLM

transformers.BloomForCausalLM

< >

( config: BloomConfig )

参数

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

具有语言建模头的 Bloom 模型转换器(具有与输入嵌入绑定的权重的线性层)。

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

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

前向传播

< >

( input_ids: Optional = None past_key_values: Union = None attention_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None cache_position: Optional = None **deprecated_arguments ) transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — input_ids_length = 如果 past_key_valuesNone 则为 sequence_length,否则为 past_key_values[0][0].shape[2] (输入过去键值状态的 sequence_length)。词汇表中输入序列标记的索引。

    如果使用 past_key_values,则仅应将尚未计算其过去的 input_ids 作为 input_ids 传递。

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

    什么是输入 ID?

  • past_key_values (Cachetuple(tuple(torch.FloatTensor)), 可选) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包含模型在解码的先前阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(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(那些没有为此模型提供其过去键值状态的),而不是形状为 (batch_size, sequence_length) 的所有 input_ids

  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1] 中:

    • 1 表示未掩码的标记,
    • 0 表示掩码的标记。

    什么是注意力掩码?

  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads), 可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中:

    • 1 表示头部未掩码
    • 0 表示头部掩码
  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 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 而不是普通元组。
  • cache_position (torch.LongTensor 形状为 (sequence_length)可选) — 描述输入序列令牌在序列中的位置的索引。与 position_ids 相反,此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。
  • labels (torch.LongTensor 形状为 (batch_size, sequence_length)可选) — 用于语言建模的标签。请注意,标签在模型内部已移位,即您可以设置 labels = input_ids。索引在 [-100, 0, ..., config.vocab_size] 中选择。所有设置为 -100 的标签都将被忽略(屏蔽),损失仅针对 [0, ..., config.vocab_size] 中的标签计算。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含取决于配置 (BloomConfig) 和输入的各种元素。

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

  • logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

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

    注意力 Softmax 之后的交叉注意力权重,用于计算交叉注意力头中的加权平均值。

  • past_key_values (tuple(tuple(torch.FloatTensor))可选,当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstorch.FloatTensor 元组,每个元组包含自注意力和交叉注意力层的缓存键值状态(如果模型用于编码器-解码器设置)。仅当 config.is_decoder = True 时才相关。

    包含预计算的隐藏状态(注意力块中的键和值),可用于(请参阅 past_key_values 输入)加速顺序解码。

BloomForCausalLM 正向方法,覆盖 __call__ 特殊方法。

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

示例

>>> import torch
>>> from transformers import AutoTokenizer, BloomForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom-560m")
>>> model = BloomForCausalLM.from_pretrained("bigscience/bloom-560m")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

BloomForSequenceClassification

transformers.BloomForSequenceClassification

< >

( config: BloomConfig )

参数

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

带有序列分类头的 Bloom 模型转换器(线性层)。

BloomForSequenceClassification 使用最后一个 token 进行分类,就像其他因果模型(例如 GPT-1)一样。

由于它对最后一个 token 进行分类,因此需要知道最后一个 token 的位置。如果在配置中定义了 pad_token_id,则它会在每一行中找到最后一个非填充 token。如果未定义 pad_token_id,则它仅获取批次中每一行的最后一个值。由于它无法在传递 inputs_embeds 而不是 input_ids 时猜测填充 token,因此它执行相同的操作(获取批次中每一行的最后一个值)。

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

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

前向传播

< >

( input_ids: Optional = None past_key_values: Union = None attention_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **deprecated_arguments ) transformers.modeling_outputs.SequenceClassifierOutputWithPasttuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — input_ids_length = 如果 past_key_valuesNone 则为 sequence_length,否则为 past_key_values[0][0].shape[2](输入过去键值状态的 sequence_length)。词汇表中输入序列 token 的索引。

    如果使用 past_key_values,则应仅将未计算其过去的 input_ids 作为 input_ids 传递。

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

    什么是输入 ID?

  • past_key_values (Cachetuple(tuple(torch.FloatTensor))可选) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(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(那些未将其过去键值状态提供给此模型的)而不是形状为 (batch_size, sequence_length) 的所有 input_ids

  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length)可选) — 用于避免对填充 token 索引执行注意力的掩码。在 [0, 1] 中选择掩码值:

    • 1 表示未掩盖的 token,
    • 0 表示已掩盖的 token。

    什么是注意力掩码?

  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定 head 无效的掩码。在 [0, 1] 中选择掩码值:

    • 1 表示未掩盖的 head,
    • 0 表示已掩盖的 head。
  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 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 而不是普通元组。
  • cache_position (torch.LongTensor 形状为 (sequence_length)可选) — 表示输入序列标记在序列中的位置的索引。与 position_ids 相反,此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。
  • labels (torch.LongTensor 形状为 (batch_size,)可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1,则计算回归损失(均方误差损失),如果 config.num_labels > 1,则计算分类损失(交叉熵)。

返回

transformers.modeling_outputs.SequenceClassifierOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutputWithPast 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含取决于配置(BloomConfig)和输入的各种元素。

  • loss (torch.FloatTensor 形状为 (1,)可选,在提供 labels 时返回) — 分类(或如果 config.num_labels==1 则为回归)损失。

  • logits (torch.FloatTensor 形状为 (batch_size, config.num_labels)) — 分类(或如果 config.num_labels==1 则为回归)分数(在 SoftMax 之前)。

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

    包含预计算的隐藏状态(自注意力块中的键和值),可用于(参见 past_key_values 输入)加速顺序解码。

  • 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

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

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

单标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, BloomForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom-560m")
>>> model = BloomForSequenceClassification.from_pretrained("bigscience/bloom-560m")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = BloomForSequenceClassification.from_pretrained("bigscience/bloom-560m", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, BloomForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom-560m")
>>> model = BloomForSequenceClassification.from_pretrained("bigscience/bloom-560m", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = BloomForSequenceClassification.from_pretrained(
...     "bigscience/bloom-560m", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

BloomForTokenClassification

transformers.BloomForTokenClassification

< >

( config: BloomConfig )

参数

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

在顶部具有标记分类头的 Bloom 模型(隐藏状态输出顶部的线性层),例如用于命名实体识别 (NER) 任务。

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

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

前向传播

< >

( input_ids: Optional = None past_key_values: Union = None attention_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **deprecated_arguments ) transformers.modeling_outputs.TokenClassifierOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — input_ids_length = sequence_length 如果 past_key_valuesNone,否则为 past_key_values[0][0].shape[2] (输入过去键值状态的 sequence_length)。词汇表中输入序列标记的索引。

    如果使用 past_key_values,则仅应将尚未计算其过去的 input_ids 作为 input_ids 传递。

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

    什么是输入 ID?

  • past_key_values (Cachetuple(tuple(torch.FloatTensor))可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(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

  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length)可选) — 用于避免对填充标记索引执行注意力的掩码。在 [0, 1] 中选择掩码值:

    • 1 表示未掩盖的标记,
    • 0 表示掩盖的标记。

    什么是注意力掩码?

  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部无效的掩码。在 [0, 1] 中选择掩码值:

    • 1 表示头部未掩盖
    • 0 表示头部掩盖
  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 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 而不是普通元组。
  • cache_position (torch.LongTensor 形状为 (sequence_length), 可选) — 描述输入序列标记在序列中的位置的索引。与position_ids相反,此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。
  • labels (torch.LongTensor 形状为 (batch_size,), 可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1,则计算回归损失(均方误差损失),如果config.num_labels > 1,则计算分类损失(交叉熵)。

返回

transformers.modeling_outputs.TokenClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个torch.FloatTensor的元组(如果传递了return_dict=False或当config.return_dict=False时),包含取决于配置(BloomConfig)和输入的各种元素。

  • loss (torch.FloatTensor 形状为 (1,), 可选, 当提供labels时返回) — 分类损失。

  • logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.num_labels)) — 分类分数(在SoftMax之前)。

  • 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

BloomForTokenClassification 的前向方法,覆盖了__call__特殊方法。

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

示例

>>> from transformers import AutoTokenizer, BloomForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom-560m")
>>> model = BloomForTokenClassification.from_pretrained("bigscience/bloom-560m")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

BloomForQuestionAnswering

transformers.BloomForQuestionAnswering

< >

( config )

参数

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

BLOOM 模型转换器,顶部带有跨度分类头部,用于提取式问答任务,例如 SQuAD(在隐藏状态输出之上添加线性层以计算跨度开始 logits跨度结束 logits)。

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

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

前向传播

< >

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — input_ids_length = 如果 past_key_valuesNone 则为 sequence_length,否则为 past_key_values[0][0].shape[2] (输入过去键值状态的 sequence_length)。词汇表中输入序列标记的索引。

    如果使用 past_key_values,则只应将尚未计算其过去的 input_ids 作为 input_ids 传递。

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

    什么是输入 ID?

  • past_key_values (Cachetuple(tuple(torch.FloatTensor))可选) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组都有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为传统缓存格式。

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

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

  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length)可选) — 用于避免对填充标记索引执行注意力的掩码。在 [0, 1] 中选择掩码值:

    • 1 表示未屏蔽的标记,
    • 0 表示屏蔽的标记。

    什么是注意力掩码?

  • head_mask (torch.FloatTensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头部无效的掩码。在 [0, 1] 中选择掩码值:

    • 1 表示头部未屏蔽
    • 0 表示头部屏蔽
  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示而不是传递 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 而不是一个普通元组。
  • cache_position (torch.LongTensor 形状为(sequence_length), 可选) — 表示输入序列标记在序列中的位置的索引。与position_ids相反,此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。
  • start_positions (torch.LongTensor 形状为(batch_size,), 可选) — 用于计算标记分类损失的标记跨度的起始位置(索引)的标签。位置被限制在序列长度(sequence_length)内。序列之外的位置不会被考虑用于计算损失。
  • end_positions (torch.LongTensor 形状为(batch_size,), 可选) — 用于计算标记分类损失的标记跨度的结束位置(索引)的标签。位置被限制在序列长度(sequence_length)内。序列之外的位置不会被考虑用于计算损失。

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

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

JAX
隐藏 JAX 内容

FlaxBloomModel

transformers.FlaxBloomModel

< >

( config: BloomConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

  • config (BloomConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看from_pretrained() 方法以加载模型权重。
  • dtype (jax.numpy.dtype, 可选,默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32jax.numpy.float16(在GPU上)和jax.numpy.bfloat16(在TPU上)。

    这可以用于启用混合精度训练或在GPU或TPU上的半精度推理。如果指定,所有计算都将使用给定的dtype执行。

    请注意,这仅指定计算的dtype,不会影响模型参数的dtype。

    如果希望更改模型参数的dtype,请参见to_fp16()to_bf16()

基本的 Bloom 模型转换器,输出原始隐藏状态,没有任何特定的头部。

此模型继承自FlaxPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入的大小、修剪 head 等)。

此模型也是一个 Flax Linen flax.nn.Module 的子类。将其作为常规的 Flax 模块使用,并参考 Flax 文档以了解所有与一般用法和行为相关的事项。

最后,此模型支持 JAX 的固有特性,例如:

__call__

< >

( input_ids attention_mask = None past_key_values: dict = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (numpy.ndarray 形状为 (batch_size, input_ids_length)) — input_ids_length = sequence_length。词汇表中输入序列标记的索引。

    可以使用 BloomTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 ID?

  • attention_mask (numpy.ndarray 形状为 (batch_size, sequence_length)可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1] 中:

    • 1 表示未被掩盖的标记,
    • 0 表示被掩盖的标记。

    什么是注意力掩码?

  • past_key_values (Dict[str, np.ndarray]可选,由 init_cache 返回或在传递先前的 past_key_values 时返回) — 预计算隐藏状态的字典(注意力块中的键和值),可用于快速自回归解码。预计算的键和值隐藏状态的形状为 [batch_size, max_length]
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputtuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputtorch.FloatTensor 的元组(如果传递了 return_dict=Falseconfig.return_dict=False),包含取决于配置 (BloomConfig) 和输入的各种元素。

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

  • hidden_states (tuple(jnp.ndarray)可选,在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — jnp.ndarray 的元组(一个用于嵌入的输出,一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

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

  • attentions (tuple(jnp.ndarray)可选,在传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

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

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

示例

>>> from transformers import AutoTokenizer, FlaxBloomModel

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom")
>>> model = FlaxBloomModel.from_pretrained("bigscience/bloom")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

FlaxBloomForCausalLM

transformers.FlaxBloomForCausalLM

< >

( config: BloomConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

  • config (BloomConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
  • dtype (jax.numpy.dtype, 可选,默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32jax.numpy.float16(在 GPU 上)和 jax.numpy.bfloat16(在 TPU 上)。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定,所有计算都将使用给定的 dtype 执行。

    注意,这仅指定计算的数据类型,不影响模型参数的数据类型。

    如果希望更改模型参数的数据类型,请参阅 to_fp16()to_bf16()

具有语言建模头的 Bloom 模型转换器(具有与输入嵌入绑定的权重的线性层)。

此模型继承自FlaxPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入的大小、修剪 head 等)。

此模型也是一个 Flax Linen flax.nn.Module 的子类。将其作为常规的 Flax 模块使用,并参考 Flax 文档以了解所有与一般用法和行为相关的事项。

最后,此模型支持 JAX 的固有特性,例如:

__call__

< >

( input_ids attention_mask = None past_key_values: dict = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.modeling_flax_outputs.FlaxMaskedLMOutputtuple(torch.FloatTensor)

参数

  • input_ids (numpy.ndarray 形状为 (batch_size, input_ids_length)) — input_ids_length = sequence_length。词汇表中输入序列标记的索引。

    可以使用 BloomTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 ID?

  • attention_mask (numpy.ndarray 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择在 [0, 1] 中:

    • 1 表示未掩码的标记,
    • 0 表示掩码的标记。

    什么是注意力掩码?

  • past_key_values (Dict[str, np.ndarray], 可选,由 init_cache 返回或在传递以前的 past_key_values 时返回) — 预计算隐藏状态的字典(注意力块中的键和值),可用于快速自回归解码。预计算的键和值隐藏状态的形状为 [batch_size, max_length]
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxMaskedLMOutputtuple(torch.FloatTensor)

transformers.modeling_flax_outputs.FlaxMaskedLMOutputtorch.FloatTensor 的元组(如果传递了return_dict=False或当config.return_dict=False时),包含根据配置 (BloomConfig) 和输入而变化的各种元素。

  • logits (jnp.ndarray 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • hidden_states (tuple(jnp.ndarray)可选,在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — jnp.ndarray 的元组(一个用于嵌入的输出,一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

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

  • attentions (tuple(jnp.ndarray)可选,在传递 output_attentions=Trueconfig.output_attentions=True 时返回) — jnp.ndarray 的元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

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

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

示例

>>> from transformers import AutoTokenizer, FlaxBloomForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom")
>>> model = FlaxBloomForCausalLM.from_pretrained("bigscience/bloom")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
>>> outputs = model(**inputs)

>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]
< > 在 GitHub 上更新