Transformers 文档
Jamba
并获得增强的文档体验
开始使用
该模型于 2024 年 3 月 28 日在 HF papers 上发布，并于 2024 年 4 月 18 日贡献给 Hugging Face Transformers。
Jamba
Jamba 是一种混合 Transformer-Mamba 专家混合（MoE）语言模型，其总参数量从 52B 到 398B 不等。该模型旨在结合两个模型系列的优势，即 Transformer 模型的高性能，以及 Mamba 等状态空间模型（SSM）的高效性和更长上下文（256K token）处理能力。
Jamba 的架构采用块层（blocks-and-layers）设计，使 Jamba 能够成功地将 Transformer 和 Mamba 架构完全集成在一起。每个 Jamba 块包含一个注意力层或一个 Mamba 层，随后是一个多层感知机（MLP），总比例为每八层中有一层 Transformer 层。MoE 层被混合在其中以提高模型容量。
您可以在 AI21 组织下找到所有原始的 Jamba 检查点（checkpoints）。
点击右侧边栏中的 Jamba 模型，查看更多关于如何将 Jamba 应用于不同语言任务的示例。
下面的示例演示了如何使用 Pipeline、AutoModel 以及命令行来生成文本。
# install optimized Mamba implementations
# !pip install mamba-ssm causal-conv1d>=1.2.0
from transformers import pipeline
pipeline = pipeline(
task="text-generation",
model="ai21labs/AI21-Jamba-Mini-1.6",
device=0
)
pipeline("Plants create energy through a process known as")量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。
下面的示例使用 bitsandbytes 仅将权重压缩为 8 位。
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(load_in_8bit=True,
llm_int8_skip_modules=["mamba"])
# a device map to distribute the model evenly across 8 GPUs
device_map = {'model.embed_tokens': 0, 'model.layers.0': 0, 'model.layers.1': 0, 'model.layers.2': 0, 'model.layers.3': 0, 'model.layers.4': 0, 'model.layers.5': 0, 'model.layers.6': 0, 'model.layers.7': 0, 'model.layers.8': 0, 'model.layers.9': 1, 'model.layers.10': 1, 'model.layers.11': 1, 'model.layers.12': 1, 'model.layers.13': 1, 'model.layers.14': 1, 'model.layers.15': 1, 'model.layers.16': 1, 'model.layers.17': 1, 'model.layers.18': 2, 'model.layers.19': 2, 'model.layers.20': 2, 'model.layers.21': 2, 'model.layers.22': 2, 'model.layers.23': 2, 'model.layers.24': 2, 'model.layers.25': 2, 'model.layers.26': 2, 'model.layers.27': 3, 'model.layers.28': 3, 'model.layers.29': 3, 'model.layers.30': 3, 'model.layers.31': 3, 'model.layers.32': 3, 'model.layers.33': 3, 'model.layers.34': 3, 'model.layers.35': 3, 'model.layers.36': 4, 'model.layers.37': 4, 'model.layers.38': 4, 'model.layers.39': 4, 'model.layers.40': 4, 'model.layers.41': 4, 'model.layers.42': 4, 'model.layers.43': 4, 'model.layers.44': 4, 'model.layers.45': 5, 'model.layers.46': 5, 'model.layers.47': 5, 'model.layers.48': 5, 'model.layers.49': 5, 'model.layers.50': 5, 'model.layers.51': 5, 'model.layers.52': 5, 'model.layers.53': 5, 'model.layers.54': 6, 'model.layers.55': 6, 'model.layers.56': 6, 'model.layers.57': 6, 'model.layers.58': 6, 'model.layers.59': 6, 'model.layers.60': 6, 'model.layers.61': 6, 'model.layers.62': 6, 'model.layers.63': 7, 'model.layers.64': 7, 'model.layers.65': 7, 'model.layers.66': 7, 'model.layers.67': 7, 'model.layers.68': 7, 'model.layers.69': 7, 'model.layers.70': 7, 'model.layers.71': 7, 'model.final_layernorm': 7, 'lm_head': 7}
model = AutoModelForCausalLM.from_pretrained("ai21labs/AI21-Jamba-Large-1.6",
attn_implementation="flash_attention_2",
quantization_config=quantization_config,
device_map=device_map)
tokenizer = AutoTokenizer.from_pretrained("ai21labs/AI21-Jamba-Large-1.6")
messages = [
{"role": "system", "content": "You are an ancient oracle who speaks in cryptic but wise phrases, always hinting at deeper meanings."},
{"role": "user", "content": "Hello!"},
]
input_ids = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors='pt').to(model.device)
outputs = model.generate(input_ids, max_new_tokens=216)
# Decode the output
conversation = tokenizer.decode(outputs[0], skip_special_tokens=True)
# Split the conversation to get only the assistant's response
assistant_response = conversation.split(messages[-1]['content'])[1].strip()
print(assistant_response)
# Output: Seek and you shall find. The path is winding, but the journey is enlightening. What wisdom do you seek from the ancient echoes?注意事项
请勿量化 Mamba 块，以防止模型性能下降。
不建议在没有优化 Mamba 内核的情况下使用 Mamba，因为这会导致显著的延迟增加。如果您仍想在没有内核的情况下使用 Mamba，请在 from_pretrained() 中设置
use_mamba_kernels=False。import torch from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained("ai21labs/AI21-Jamba-1.5-Large", use_mamba_kernels=False, device_map="auto")
JambaConfig
class transformers.JambaConfig
< 源代码 >( transformers_version: str | None = None architectures: list[str] | None = None output_hidden_states: bool | None = False return_dict: bool | None = True dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None chunk_size_feed_forward: int = 0 is_encoder_decoder: bool = False id2label: dict[int, str] | dict[str, str] | None = None label2id: dict[str, int] | dict[str, str] | None = None problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None vocab_size: int = 65536 tie_word_embeddings: bool = False hidden_size: int = 4096 intermediate_size: int = 14336 num_hidden_layers: int = 32 num_attention_heads: int = 32 num_key_value_heads: int = 8 hidden_act: str = 'silu' initializer_range: float = 0.02 rms_norm_eps: float = 1e-06 use_cache: bool = True output_router_logits: bool = False router_aux_loss_coef: float = 0.001 pad_token_id: int | None = 0 bos_token_id: int | None = 1 eos_token_id: int | list[int] | None = 2 max_position_embeddings: int = 262144 attention_dropout: float | int = 0.0 num_experts_per_tok: int = 2 num_experts: int = 16 expert_layer_period: int = 2 expert_layer_offset: int = 1 attn_layer_period: int = 8 attn_layer_offset: int = 4 use_mamba_kernels: bool = True mamba_d_state: int = 16 mamba_d_conv: int = 4 mamba_expand: int = 2 mamba_dt_rank: int | str = 'auto' mamba_conv_bias: bool = True mamba_proj_bias: bool = False )
参数
- vocab_size (
int, 可选, 默认为65536) — 模型的词汇表大小。定义了input_ids可以表示的不同 token 的数量。 - tie_word_embeddings (
bool, 可选, 默认为False) — 是否根据模型的tied_weights_keys映射来绑定权重嵌入。 - hidden_size (
int, 可选, 默认为4096) — 隐藏表示的维度。 - intermediate_size (
int, 可选, 默认为14336) — MLP 表示的维度。 - num_hidden_layers (
int, 可选, 默认为32) — Transformer 解码器中的隐藏层数量。 - num_attention_heads (
int, 可选, 默认为32) — Transformer 解码器中每个注意力层的注意力头数量。 - num_key_value_heads (
int, 可选, 默认为8) — 这是用于实现分组查询注意力（Grouped Query Attention）的 key_value 头数量。如果num_key_value_heads=num_attention_heads，模型将使用多头注意力（MHA）；如果num_key_value_heads=1，模型将使用多查询注意力（MQA）；否则使用 GQA。在将多头检查点转换为 GQA 检查点时，每个组的键（key）和值（value）头应通过对该组内的所有原始头进行平均池化来构建。更多详情，请查看 这篇论文。如果未指定，将默认为num_attention_heads。 - hidden_act (
str, 可选, 默认为silu) — 解码器中的非线性激活函数（函数或字符串）。例如："gelu","relu","silu"等。 - initializer_range (
float, 可选, 默认为0.02) — 用于初始化所有权重矩阵的截断正态初始化器（truncated_normal_initializer）的标准差。 - rms_norm_eps (
float, 可选, 默认为1e-06) — 用于 RMS 归一化层的 epsilon 值。 - use_cache (
bool, 可选, 默认为True) — 模型是否应该返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True或模型为仅解码器生成模型时相关。 - output_router_logits (
bool, 可选, 默认为False) — 模型是否应该返回路由逻辑（router logits）。启用此功能还将允许模型输出辅助损失，包括负载均衡损失和路由 z-损失。 - router_aux_loss_coef (
float, 可选, 默认为0.001) — 辅助负载均衡损失系数。用于惩罚 MoE 模型中不均匀的专家路由。 - pad_token_id (
int, 可选, 默认为0) — 词汇表中用于填充（padding）的 token ID。 - bos_token_id (
int, 可选, 默认为1) — 词汇表中用于流开始（beginning-of-stream）的 token ID。 - eos_token_id (
Union[int, list[int]], 可选, 默认为2) — 词汇表中用于流结束（end-of-stream）的 token ID。 - max_position_embeddings (
int, 可选, 默认为262144) — 此模型可能使用的最大序列长度。 - attention_dropout (
Union[float, int], 可选, 默认为0.0) — 注意力概率的 dropout 比率。 - num_experts_per_tok (
int, 可选, 默认为2) — 每个 token 要路由到的专家数量。这是 token 选择路由的 top-k 值。 - num_experts (
int, 可选, 默认为16) — MoE 层中已路由专家的数量。 - expert_layer_period (
int, 可选, 默认为 2) — 每隔这么多层，我们将设置一个专家层。 - expert_layer_offset (
int, optional, defaults to 1) — 包含专家 MLP 层的第一个层索引 - attn_layer_period (
int, optional, defaults to 8) — 每隔这么多层，会出现一个常规注意力（vanilla attention）层 - attn_layer_offset (
int, optional, defaults to 4) — 包含常规注意力 MLP 层的第一个层索引 - use_mamba_kernels (
bool, optional, defaults toTrue) — 指示是否使用快速 Mamba 内核的标志。仅在安装了mamba-ssm和causal-conv1d，且 Mamba 模块在 CUDA 设备上运行时才可用。如果设置为True但内核不可用，将引发 ValueError - mamba_d_state (
int, optional, defaults to16) — Mamba 层中 SSM 状态（潜在状态维度）的大小。 - mamba_d_conv (
int, optional, defaults to4) — Mamba 卷积核的大小 - mamba_expand (
int, optional, defaults to2) — 用于确定 Mamba 中间大小的扩展因子（相对于 hidden_size） - mamba_dt_rank (
Union[int,str], optional, defaults to"auto") — Mamba 离散化投影矩阵的秩。"auto"表示默认为math.ceil(self.hidden_size / 16) - mamba_conv_bias (
bool, optional, defaults toTrue) — 指示是否在 Mamba 混合块的卷积层中使用偏置的标志。 - mamba_proj_bias (
bool, optional, defaults toFalse) — 指示是否在 Mamba 混合块的输入和输出投影（[“in_proj”, “out_proj”]）中使用偏置的标志
这是用于存储 JambaModel 配置的配置类。它根据指定的参数实例化 Jamba 模型，从而定义模型架构。使用默认值实例化配置将产生与 ai21labs/Jamba-v0.1 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。阅读 PreTrainedConfig 的文档以获取更多信息。
JambaModel
class transformers.JambaModel
< 源码 >( config: JambaConfig )
参数
- config (JambaConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
纯 Jamba 模型，输出原始隐藏状态，顶部没有任何特定头部。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None position_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None use_cache: bool | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → MoeModelOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充（Padding）将被忽略。索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]。 - past_key_values (
~cache_utils.Cache，可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包含当use_cache=True或config.use_cache=True时模型在先前解码阶段返回的past_key_values。仅允许使用 Cache 实例作为输入，请参阅我们的 kv 缓存指南。如果没有传递
past_key_values，将默认初始化 DynamicCache。模型将输出与作为输入馈送的缓存格式相同的缓存。
如果使用
past_key_values，用户应仅输入未处理的input_ids（那些其过去键值状态未提供给此模型的输入），其形状为(batch_size, unprocessed_length)，而不是形状为(batch_size, sequence_length)的所有input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传入嵌入表示，而不是传递input_ids。如果您想比模型内部的嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联向量，这很有用。 - use_cache (
bool，可选) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
返回
MoeModelOutputWithPast 或 tuple(torch.FloatTensor)
一个 MoeModelOutputWithPast 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（JambaConfig）和输入，包含各种元素。
JambaModel 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
last_hidden_state (
torch.FloatTensor, 形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。past_key_values (
Cache，*可选*，当传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if
config.is_encoder_decoder=Truein the cross-attention blocks) that can be used (seepast_key_valuesinput) to speed up sequential decoding.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 后的注意力权重，用于计算自注意力头中的加权平均值。
router_logits (
tuple(torch.FloatTensor), 可选, 当传递output_router_probs=True且config.add_router_probs=True时，或config.output_router_probs=True时返回) — 形状为(batch_size, sequence_length, num_experts)的torch.FloatTensor元组（每一层一个）。由 MoE 路由器计算的原始路由器对数（softmax 后），这些术语用于计算专家混合模型的辅助损失。
JambaForCausalLM
class transformers.JambaForCausalLM
< 源码 >( config: JambaConfig )
参数
- config (JambaConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
用于因果语言建模的 Jamba 模型。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None position_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None output_router_logits: bool | None = None logits_to_keep: int | torch.Tensor = 0 **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → MoeCausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充（Padding）将被忽略。索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]。 - past_key_values (
~cache_utils.Cache，可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包含当use_cache=True或config.use_cache=True时模型在先前解码阶段返回的past_key_values。仅允许使用 Cache 实例作为输入，请参阅我们的 kv 缓存指南。如果没有传递
past_key_values，将默认初始化 DynamicCache。模型将输出与作为输入馈送的缓存格式相同的缓存。
如果使用
past_key_values，用户应仅输入未处理的input_ids（那些其过去键值状态未提供给此模型的输入），其形状为(batch_size, unprocessed_length)，而不是形状为(batch_size, sequence_length)的所有input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选参数，用于直接传入嵌入表示，而不是传入input_ids。如果你想比模型内部的嵌入查找矩阵更精确地控制如何将input_ids索引转换为相关向量，此参数非常有用。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]范围内或为 -100（参见input_ids文档字符串）。索引设置为-100的 token 将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]范围内的 token 进行计算。 - use_cache (
bool，可选) — 如果设置为True，则会返回past_key_values键值状态，可用于加速解码（参见past_key_values）。 - output_router_logits (
bool，可选) — 是否返回所有路由器的逻辑值 (logits)。它们对于计算路由器损失很有用，在推理期间不应返回。 - logits_to_keep (
Union[int, torch.Tensor]，可选，默认为0) — 如果是int，则计算最后logits_to_keep个 token 的逻辑值。如果为0，则计算所有input_ids的逻辑值（特殊情况）。生成时仅需要最后一个 token 的逻辑值，仅为该 token 计算可以节省内存，这对于长序列或大词汇量的情况非常显著。如果是torch.Tensor，则必须是对应于序列长度维度中要保留的索引的一维张量。这在使用打包张量格式（batch 和序列长度使用单一维度）时非常有用。
返回
MoeCausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一个 MoeCausalLMOutputWithPast 对象或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False 时），根据配置（JambaConfig）和输入包含不同的元素。
JambaForCausalLM 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
loss (
torch.FloatTensor形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个 token 预测）。logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。aux_loss (
torch.FloatTensor，可选，当提供labels时返回) — 稀疏模块的辅助损失。router_logits (
tuple(torch.FloatTensor), 可选, 当传递output_router_probs=True且config.add_router_probs=True时，或config.output_router_probs=True时返回) — 形状为(batch_size, sequence_length, num_experts)的torch.FloatTensor元组（每一层一个）。由 MoE 路由器计算的原始路由器对数（softmax 后），这些术语用于计算专家混合模型的辅助损失。
past_key_values (
Cache，*可选*，当传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见
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 后的注意力权重，用于计算自注意力头中的加权平均值。
示例
>>> from transformers import AutoTokenizer, JambaForCausalLM
>>> model = JambaForCausalLM.from_pretrained("ai21labs/Jamba-v0.1")
>>> tokenizer = AutoTokenizer.from_pretrained("ai21labs/Jamba-v0.1")
>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."JambaForSequenceClassification
forward
< 源码 >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None position_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → SequenceClassifierOutputWithPast or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 输入序列 token 在词汇表中的索引。默认情况下，填充 (padding) 将被忽略。索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值选自[0, 1]：- 1 表示未掩码的 token，
- 0 表示被掩码的 token。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]。 - past_key_values (
~cache_utils.Cache，可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括当use_cache=True或config.use_cache=True时模型在解码的前一阶段返回的past_key_values。仅允许输入 Cache 实例，请参阅我们的 kv 缓存指南。如果不传入
past_key_values，默认将初始化 DynamicCache。模型将输出与作为输入传入的格式相同的缓存格式。
如果使用
past_key_values，用户只需输入形状为(batch_size, unprocessed_length)的未处理input_ids（即其过去键值状态未提供给此模型的那些 input_ids），而无需输入形状为(batch_size, sequence_length)的所有input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选参数，用于直接传入嵌入表示，而不是传入input_ids。如果你想比模型内部的嵌入查找矩阵更精确地控制如何将input_ids索引转换为相关向量，此参数非常有用。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]范围内或为 -100（参见input_ids文档字符串）。索引设置为-100的 token 将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]范围内的 token 进行计算。 - use_cache (
bool，可选) — 如果设置为True，则会返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
返回
SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
一个 SequenceClassifierOutputWithPast 或 torch.FloatTensor 元组（如果传入了 return_dict=False 或当 config.return_dict=False 时），根据配置（None）和输入，其包含不同的元素。
The GenericForSequenceClassification forward method, overrides the __call__ special method.
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
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=True或config.use_cache=True时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见
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 后的注意力权重，用于计算自注意力头中的加权平均值。