Transformers 文档

Falcon

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

PyTorch FlashAttention SDPA

Falcon

Falcon 是一个大型语言模型家族,提供 7B、40B 和 180B 参数的预训练和指令微调变体。该模型侧重于在性能、数据和硬件三个方面扩展预训练规模。Falcon 使用多组注意力机制(multigroup attention)显著减少推理内存需求,并采用旋转位置嵌入(RoPE)。这些模型在 RefinedWeb 上进行预训练,这是一个高质量且去重后的 5T 词元(token)数据集。

你可以在 Falcon 合集中找到所有原始的 Falcon checkpoints。

点击右侧边栏中的 Falcon 模型,查看更多关于如何将 Falcon 应用于不同语言任务的示例。

以下示例演示了如何使用 PipelineAutoModel 以及从命令行生成文本。

流水线
自动模型
Transformers CLI
import torch
from transformers import pipeline

pipeline = pipeline(
    task="text-generation",
    model="tiiuae/falcon-7b-instruct",
    torch_dtype=torch.bfloat16,
    device=0
)
pipeline(
    "Write a short poem about coding",
    max_length=100,
    do_sample=True,
    temperature=0.7
)

量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端,请参阅量化概述。

以下示例使用 bitsandbytes 仅将权重量化为 4 位。

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
)

tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-7b")
model = AutoModelForCausalLM.from_pretrained(
    "tiiuae/falcon-7b",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    quantization_config=quantization_config,
)

inputs = tokenizer("In quantum physics, entanglement means", return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

注意事项

  • 如果你正在从旧的自定义代码 checkpoint 升级,请记得使用位于 Falcon 模型目录中的转换脚本将其转换为官方 Transformers 格式,以获得更好的稳定性和性能。

    python convert_custom_code_checkpoint.py --checkpoint_dir my_model

FalconConfig

class transformers.FalconConfig

< >

( vocab_size = 65024 hidden_size = 4544 num_hidden_layers = 32 num_attention_heads = 71 num_ln_in_parallel_attn = None layer_norm_epsilon = 1e-05 initializer_range = 0.02 use_cache = True hidden_dropout = 0.0 attention_dropout = 0.0 num_kv_heads = None alibi = False new_decoder_architecture = False multi_query = True parallel_attn = True bias = False max_position_embeddings = 2048 rope_theta = 10000.0 rope_scaling = None bos_token_id = 11 eos_token_id = 11 ffn_hidden_size = None activation = 'gelu' **kwargs )

参数

  • vocab_size (int可选,默认为 65024) — Falcon 模型的词汇表大小。定义了在调用 FalconModel 时,`inputs_ids` 参数可以表示的不同词元的数量。
  • hidden_size (int可选,默认为 4544) — 隐藏表示的维度。
  • num_hidden_layers (int可选,默认为 32) — Transformer 解码器中的隐藏层数量。
  • num_attention_heads (int可选,默认为 71) — Transformer 编码器中每个注意力层的注意力头数量。
  • num_ln_in_parallel_attn (int可选) — 在使用并行注意力时,如果需要为 MLP 和注意力输出使用单独的层归一化,则设置为 2,否则为 1。
  • layer_norm_epsilon (float可选,默认为 1e-05) — 层归一化层使用的 epsilon 值。
  • initializer_range (float可选,默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • use_cache (bool可选,默认为 `True`) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。仅在 `config.is_decoder=True` 时相关。
  • hidden_dropout (float可选,默认为 0.0) — MLP 层的 dropout 概率。
  • attention_dropout (float可选,默认为 0.0) — 注意力层的 dropout 概率。
  • num_kv_heads (int可选) — 每个注意力层要使用的键值(key-value)头的数量。如果未设置,则默认为与 `num_attention_heads` 相同的值。
  • alibi (bool可选,默认为 `False`) — 是否在自注意力期间使用 ALiBi 位置偏差。
  • new_decoder_architecture (bool可选,默认为 `False`) — 是否使用新的(Falcon-40B)解码器架构。如果为 `True`,则忽略 `multi_query` 和 `parallel_attn` 参数,因为新的解码器总是使用并行注意力。
  • multi_query (bool可选,默认为 `True`) — 是否在解码器中使用多查询注意力(multi-query attention)。当 `new_decoder_architecture` 为 `True` 时忽略此参数。
  • parallel_attn (bool可选,默认为 `True`) — 是否与前馈层并行计算注意力。如果为 False,它们将按顺序计算,如同原始的 Transformer 架构。当 `new_decoder_architecture` 为 `True` 时忽略此参数。
  • bias (bool可选,默认为 `False`) — 是否在线性层上使用偏置。
  • max_position_embeddings (int可选,默认为 2048) — 当 `alibi` 为 `False` 时,该模型可能使用的最大序列长度。预训练的 Falcon 模型(使用 RoPE)支持最多 2048 个词元。
  • rope_theta (float可选,默认为 10000.0) — RoPE 嵌入的基周期。
  • rope_scaling (`Dict`,*可选*) — 包含 RoPE 嵌入缩放配置的字典。注意:如果你应用了新的 RoPE 类型,并期望模型能处理更长的 `max_position_embeddings`,我们建议你相应地更新此值。预期内容:`rope_type` (`str`):要使用的 RoPE 子变体。可以是 ['default', 'linear', 'dynamic', 'yarn', 'longrope', 'llama3'] 中的一种,其中 'default' 是原始的 RoPE 实现。`factor` (`float`,*可选*):用于除 'default' 外的所有 RoPE 类型。应用于 RoPE 嵌入的缩放因子。在大多数缩放类型中,`factor` 为 x 将使模型能够处理长度为 x * 原始最大预训练长度的序列。`original_max_position_embeddings` (`int`,*可选*):用于 'dynamic'、'longrope' 和 'llama3'。预训练期间使用的原始最大位置嵌入。`attention_factor` (`float`,*可选*):用于 'yarn' 和 'longrope'。应用于注意力计算的缩放因子。如果未指定,则默认为实现推荐的值,使用 `factor` 字段推断建议值。`beta_fast` (`float`,*可选*):仅用于 'yarn'。设置线性斜坡函数中外推(仅限)边界的参数。如果未指定,则默认为 32。`beta_slow` (`float`,*可选*):仅用于 'yarn'。设置线性斜坡函数中插值(仅限)边界的参数。如果未指定,则默认为 1。`short_factor` (`list[float]`,*可选*):仅用于 'longrope'。应用于短上下文(< `original_max_position_embeddings`)的缩放因子。必须是与隐藏大小除以注意力头数再除以 2 长度相同的数字列表。`long_factor` (`list[float]`,*可选*):仅用于 'longrope'。应用于长上下文(> `original_max_position_embeddings`)的缩放因子。必须是与隐藏大小除以注意力头数再除以 2 长度相同的数字列表。`low_freq_factor` (`float`,*可选*):仅用于 'llama3'。应用于 RoPE 低频分量的缩放因子。`high_freq_factor` (`float`,*可选*):仅用于 'llama3'。应用于 RoPE 高频分量的缩放因子。
  • bos_token_id (int可选,默认为 11) — “序列开始”词元的 ID。
  • eos_token_id (int可选,默认为 11) — “序列结束”词元的 ID。
  • ffn_hidden_size (int可选) — Transformer 解码器中前馈层的隐藏大小。默认为隐藏维度的 4 倍。
  • activation (str可选,默认为 `"gelu"`) — 前馈层中使用的激活函数。

这是一个配置类,用于存储 FalconModel 的配置。它用于根据指定的参数实例化一个 Falcon 模型,定义模型架构。使用默认值实例化一个配置将产生与 tiiuae/falcon-7b 架构类似的配置。

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

示例

>>> from transformers import FalconModel, FalconConfig

>>> # Initializing a small (2-layer) Falcon configuration
>>> configuration = FalconConfig(num_hidden_layers=2)

>>> # Initializing a model from the small configuration
>>> model = FalconModel(configuration)

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

FalconModel

class transformers.FalconModel

< >

( config: FalconConfig )

参数

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

裸 Falcon 模型,输出原始的隐藏状态,顶部没有任何特定的头(head)。

该模型继承自 PreTrainedModel。请查阅超类文档,了解该库为所有模型实现的通用方法(如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, tuple[tuple[torch.Tensor, torch.Tensor], ...], NoneType] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None ) transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentionstuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, input_ids_length)) — 如果 past_key_valuesNone,则 input_ids_length = 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 (Union[~cache_utils.Cache, tuple[tuple[torch.Tensor, torch.Tensor], ...], NoneType]) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速序列解码。这通常包括模型在解码的先前阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

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

    模型将输出与输入相同的缓存格式。如果未传递 past_key_values,将返回旧版缓存格式。

    如果使用 past_key_values,用户可以选择只输入最后的 input_ids(那些没有向该模型提供其过去键值状态的 ID),形状为 (batch_size, 1),而不是所有形状为 (batch_size, sequence_length)input_ids

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 掩码,用于避免在填充令牌索引上执行注意力。掩码值选自 [0, 1]

    • 1 表示令牌未被屏蔽
    • 0 表示令牌被屏蔽

    什么是注意力掩码?

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

    什么是位置 ID?

  • head_mask (torch.LongTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自 [0, 1]

    • 1 表示头未被屏蔽
    • 0 表示头被屏蔽
  • inputs_embeds (torch.LongTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,你可以选择直接传递嵌入表示,而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵有更多控制权来将 input_ids 索引转换为相关向量,这将非常有用。
  • 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),根据配置(FalconConfig)和输入包含各种元素。

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

    如果使用了 past_key_values,则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values (Cache可选,在传递 use_cache=Trueconfig.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息,请参阅我们的 kv 缓存指南

    包含预先计算的隐藏状态(自注意力块中的键和值,如果 config.is_encoder_decoder=True,则还包括交叉注意力块中的键和值),可用于(参见 past_key_values 输入)加速序列解码。

  • hidden_states (tuple(torch.FloatTensor)可选,在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则一个是嵌入层的输出,加上每个层的输出),形状为 (batch_size, sequence_length, hidden_size)

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

  • attentions (tuple(torch.FloatTensor)可选,在传递 output_attentions=Trueconfig.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=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

FalconModel 的前向方法会覆盖 __call__ 特殊方法。

尽管前向传递的流程需要在此函数内定义,但之后应调用 Module 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默忽略它们。

FalconForCausalLM

class transformers.FalconForCausalLM

< >

( config: FalconConfig )

参数

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

带有一个语言建模头(与输入嵌入权重绑定的线性层)的 Falcon 模型 Transformer。

该模型继承自 PreTrainedModel。请查阅超类文档,了解该库为所有模型实现的通用方法(如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, tuple[tuple[torch.Tensor, torch.Tensor], ...], NoneType] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs ) transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, input_ids_length)) — 如果 past_key_valuesNone,则 input_ids_length = 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 (Union[~cache_utils.Cache, tuple[tuple[torch.Tensor, torch.Tensor], ...], NoneType]) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速序列解码。这通常包括模型在解码的先前阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

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

    模型将输出与输入相同的缓存格式。如果未传递 past_key_values,将返回旧版缓存格式。

    如果使用 past_key_values,用户可以选择只输入最后的 input_ids(那些没有向该模型提供其过去键值状态的 ID),形状为 (batch_size, 1),而不是所有形状为 (batch_size, sequence_length)input_ids

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 掩码,用于避免在填充令牌索引上执行注意力。掩码值选自 [0, 1]

    • 1 表示令牌未被屏蔽
    • 0 表示令牌被屏蔽

    什么是注意力掩码?

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

    什么是位置 ID?

  • head_mask (torch.Tensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自 [0, 1]

    • 1 表示头未被屏蔽
    • 0 表示头被屏蔽
  • inputs_embeds (torch.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,你可以选择直接传递嵌入表示,而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵有更多控制权来将 input_ids 索引转换为相关向量,这将非常有用。
  • labels (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 语言建模的标签。请注意,标签在模型内部被移动,即你可以设置 labels = input_ids。索引选自 [-100, 0, ..., config.vocab_size]。所有设置为 -100 的标签都会被忽略(屏蔽),损失仅对 [0, ..., config.vocab_size] 中的标签计算。
  • 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 相反,此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。
  • logits_to_keep (Union[int, torch.Tensor],默认为 0) — 如果是 int,则为最后的 logits_to_keep 个令牌计算 logits。如果是 0,则为所有 input_ids 计算 logits(特殊情况)。生成时只需要最后一个令牌的 logits,只为该令牌计算可以节省内存,这对于长序列或大词汇表来说非常重要。如果是 torch.Tensor,则必须是一维的,对应于序列长度维度中要保留的索引。这在使用打包张量格式(批处理和序列长度使用单一维度)时非常有用。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

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

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

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

  • hidden_states (tuple(torch.FloatTensor)可选,在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则一个是嵌入层的输出,加上每个层的输出),形状为 (batch_size, sequence_length, hidden_size)

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

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

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

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

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

  • past_key_values (Cache可选,在传递 use_cache=Trueconfig.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息,请参阅我们的 kv 缓存指南

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

FalconForCausalLM 的前向方法会覆盖 __call__ 特殊方法。

尽管前向传递的流程需要在此函数内定义,但之后应调用 Module 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默忽略它们。

示例

FalconForSequenceClassification

class transformers.FalconForSequenceClassification

< >

( config: FalconConfig )

参数

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

带有一个序列分类头(线性层)的 Falcon 模型 Transformer。

FalconForSequenceClassification 使用最后一个令牌进行分类,与其他因果模型(如 GPT-1)一样。

由于它在最后一个令牌上进行分类,因此需要知道最后一个令牌的位置。如果配置中定义了 pad_token_id,它会找到每行中不是填充令牌的最后一个令牌。如果没有定义 pad_token_id,它会简单地取批处理中每行的最后一个值。当传递 inputs_embeds 而不是 input_ids 时,它无法猜测填充令牌,因此它会做同样的操作(取批处理中每行的最后一个值)。

该模型继承自 PreTrainedModel。请查阅超类文档,了解该库为所有模型实现的通用方法(如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor, torch.Tensor], ...]] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_outputs.SequenceClassifierOutputWithPasttuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, input_ids_length)) — 如果 past_key_valuesNone,则 input_ids_length = 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 (tuple[tuple[torch.Tensor, torch.Tensor, ...]]可选) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速序列解码。这通常包括模型在解码的先前阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

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

    模型将输出与输入相同的缓存格式。如果未传递 past_key_values,将返回旧版缓存格式。

    如果使用 past_key_values,用户可以选择只输入最后的 input_ids(那些没有向该模型提供其过去键值状态的 ID),形状为 (batch_size, 1),而不是所有形状为 (batch_size, sequence_length)input_ids

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 掩码,用于避免在填充令牌索引上执行注意力。掩码值选自 [0, 1]

    • 1 表示令牌未被屏蔽
    • 0 表示令牌被屏蔽

    什么是注意力掩码?

  • head_mask (torch.Tensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自 [0, 1]

    • 1 表示头未被屏蔽
    • 0 表示头被屏蔽
  • inputs_embeds (torch.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,你可以选择直接传递嵌入表示,而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵有更多控制权来将 input_ids 索引转换为相关向量,这将非常有用。
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1,则计算回归损失(均方损失),如果 config.num_labels > 1,则计算分类损失(交叉熵)。
  • use_cache (bool可选) — 如果设置为 True,将返回 past_key_values 键值状态,可用于加速解码(参见 past_key_values)。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_outputs.SequenceClassifierOutputWithPasttuple(torch.FloatTensor)

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

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

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

  • past_key_values (Cache可选,在传递 use_cache=Trueconfig.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息,请参阅我们的 kv 缓存指南

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

  • hidden_states (tuple(torch.FloatTensor)可选,在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则一个是嵌入层的输出,加上每个层的输出),形状为 (batch_size, sequence_length, hidden_size)

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

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

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

FalconForSequenceClassification 的前向方法会覆盖 __call__ 特殊方法。

尽管前向传递的流程需要在此函数内定义,但之后应调用 Module 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默忽略它们。

单标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, FalconForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-7b")
>>> model = FalconForSequenceClassification.from_pretrained("tiiuae/falcon-7b")

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

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

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # 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 = FalconForSequenceClassification.from_pretrained("tiiuae/falcon-7b", num_labels=num_labels)

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

多标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, FalconForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-7b")
>>> model = FalconForSequenceClassification.from_pretrained("tiiuae/falcon-7b", 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 = FalconForSequenceClassification.from_pretrained(
...     "tiiuae/falcon-7b", 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

FalconForTokenClassification

class transformers.FalconForTokenClassification

< >

( config: FalconConfig )

参数

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

带有一个令牌分类头(在隐藏状态输出之上加一个线性层)的 Falcon Transformer,例如用于命名实体识别(NER)任务。

该模型继承自 PreTrainedModel。请查阅超类文档,了解该库为所有模型实现的通用方法(如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor, torch.Tensor], ...]] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) 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] (输入 past key value 状态的 sequence_length)。词汇表中输入序列词元的索引。

    如果使用了 `past_key_values`,则只有那些尚未计算其过去值的 `input_ids` 才应作为 `input_ids` 传递。

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

    什么是输入 ID?

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

    允许两种格式:

    • Cache 实例,请参阅我们的 kv cache 指南
    • 长度为 `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`(那些没有为其提供过去键值状态的 `input_ids`),形状为 `(batch_size, 1)`,而不是所有形状为 `(batch_size, sequence_length)` 的 `input_ids`。

  • attention_mask (torch.Tensor,形状为 `(batch_size, sequence_length)`,可选) — 用于避免在填充词元索引上执行注意力的掩码。掩码值选自 `[0, 1]`:

    • 1 表示词元未被掩码
    • 0 表示词元被掩码

    什么是注意力掩码?

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

    • 1 表示头未被掩码
    • 0 表示头被掩码
  • inputs_embeds (torch.Tensor,形状为 `(batch_size, sequence_length, hidden_size)`,可选) — 可选地,你可以选择直接传递嵌入表示,而不是传递 `input_ids`。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 `input_ids` 索引转换为相关向量,这会很有用。
  • labels (torch.LongTensor,形状为 `(batch_size,)`,可选) — 用于计算序列分类/回归损失的标签。索引应在 `[0, ..., config.num_labels - 1]` 范围内。如果 `config.num_labels == 1`,则计算回归损失(均方损失);如果 `config.num_labels > 1`,则计算分类损失(交叉熵)。
  • use_cache (bool, 可选) — 如果设置为 `True`,则返回 `past_key_values` 键值状态,并可用于加速解码(参见 `past_key_values`)。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量下的 `attentions`。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的 `hidden_states`。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

返回

transformers.modeling_outputs.TokenClassifierOutputtuple(torch.FloatTensor)

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

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

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

  • hidden_states (tuple(torch.FloatTensor)可选,在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则一个是嵌入层的输出,加上每个层的输出),形状为 (batch_size, sequence_length, hidden_size)

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

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

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

FalconForTokenClassification 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传递的流程需要在此函数内定义,但之后应调用 Module 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默忽略它们。

示例

>>> from transformers import AutoTokenizer, FalconForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-7b")
>>> model = FalconForTokenClassification.from_pretrained("tiiuae/falcon-7b")

>>> 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]]
>>> predicted_tokens_classes
...

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

FalconForQuestionAnswering

class transformers.FalconForQuestionAnswering

< >

( config )

参数

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

Falcon Transformer,顶部带有一个用于抽取式问答任务(如SQuAD)的跨度分类头(在隐藏状态输出之上有一个线性层,用于计算 `span start logits` 和 `span end logits`)。

该模型继承自 PreTrainedModel。请查阅超类文档,了解该库为所有模型实现的通用方法(如下载或保存、调整输入嵌入大小、修剪头等)。

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_outputs.QuestionAnsweringModelOutputtuple(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] (输入 past key value 状态的 sequence_length)。词汇表中输入序列词元的索引。

    如果使用了 `past_key_values`,则只有那些尚未计算其过去值的 `input_ids` 才应作为 `input_ids` 传递。

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

    什么是输入 ID?

  • 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` 索引转换为相关向量,这会很有用。
  • start_positions (torch.LongTensor,形状为 `(batch_size,)`,可选) — 标记的跨度开始位置(索引)的标签,用于计算词元分类损失。位置被限制在序列长度(`sequence_length`)内。序列之外的位置在计算损失时将不被考虑。
  • end_positions (torch.LongTensor,形状为 `(batch_size,)`,可选) — 标记的跨度结束位置(索引)的标签,用于计算词元分类损失。位置被限制在序列长度(`sequence_length`)内。序列之外的位置在计算损失时将不被考虑。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量下的 `attentions`。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的 `hidden_states`。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

返回

transformers.modeling_outputs.QuestionAnsweringModelOutputtuple(torch.FloatTensor)

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

  • loss (torch.FloatTensor of shape (1,), 可选, 当提供 labels 时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。

  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围起始分数(SoftMax 之前)。

  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围结束分数(SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor)可选,在传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则一个是嵌入层的输出,加上每个层的输出),形状为 (batch_size, sequence_length, hidden_size)

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

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

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

FalconForQuestionAnswering 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传递的流程需要在此函数内定义,但之后应调用 Module 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默忽略它们。

示例

>>> from transformers import AutoTokenizer, FalconForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-7b")
>>> model = FalconForQuestionAnswering.from_pretrained("tiiuae/falcon-7b")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
< > 在 GitHub 上更新