Transformers 文档
Jamba
并获得增强的文档体验
开始使用
此模型于 2024-03-28 发布，并于 2024-04-18 添加到 Hugging Face Transformers。
Jamba
Jamba 是一种混合 Transformer-Mamba 专家混合（MoE）语言模型，总参数量从 52B 到 398B 不等。该模型旨在结合两种模型系列的优点，即 Transformer 模型的性能以及状态空间模型（SSM）如 Mamba 的效率和更长的上下文（256K 个 token）。
Jamba 的架构采用块和层的处理方法，允许 Jamba 成功地将 Transformer 和 Mamba 架构集成在一起。每个 Jamba 块包含一个注意力层或 Mamba 层，后跟一个多层感知器（MLP），总体比例是每八个总层中有一个 Transformer 层。通过混合专家层（MoE）来提高模型容量。
您可以在 AI21 组织下找到所有原始 Jamba 检查点。
点击右侧边栏的 Jamba 模型，了解更多将 Jamba 应用于不同语言任务的示例。
以下示例展示了如何使用 Pipeline、AutoModel 和命令行生成文本。
# install optimized Mamba implementations
# !pip install mamba-ssm causal-conv1d>=1.2.0
import torch
from transformers import pipeline
pipeline = pipeline(
task="text-generation",
model="ai21labs/AI21-Jamba-Mini-1.6",
dtype=torch.float16,
device=0
)
pipeline("Plants create energy through a process known as")量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。
下面的示例使用 bitsandbytes 将权重量化为 8 位。
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, 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",
dtype=torch.bfloat16,
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)
JambaConfig
class transformers.JambaConfig
< source >( vocab_size = 65536 tie_word_embeddings = False hidden_size = 4096 intermediate_size = 14336 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = 8 hidden_act = 'silu' initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True output_router_logits = False router_aux_loss_coef = 0.001 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 max_position_embeddings = 262144 attention_dropout = 0.0 num_experts_per_tok = 2 num_experts = 16 expert_layer_period = 2 expert_layer_offset = 1 attn_layer_period = 8 attn_layer_offset = 4 use_mamba_kernels = True mamba_d_state = 16 mamba_d_conv = 4 mamba_expand = 2 mamba_dt_rank = 'auto' mamba_conv_bias = True mamba_proj_bias = False **kwargs )
参数
- vocab_size (
int, optional, defaults to 65536) — Jamba 模型的词汇表大小。定义了在调用 JambaModel 时传入的inputs_ids可以表示的不同 token 的数量。 - tie_word_embeddings (
bool, optional, defaults toFalse) — 模型输入和输出词嵌入是否应该被绑定。请注意，这仅在模型具有输出词嵌入层时才相关。 - hidden_size (
int, optional, defaults to 4096) — 隐藏表示的维度。 - intermediate_size (
int, optional, defaults to 14336) — MLP 表示的维度。 - num_hidden_layers (
int, optional, defaults to 32) — Transformer 编码器中的隐藏层数。 - num_attention_heads (
int, optional, defaults to 32) — Transformer 编码器中每个注意力层的注意力头数。 - num_key_value_heads (
int, optional, defaults to 8) — 这是实现分组查询注意力（Grouped Query Attention）所需的 key_value 头数。如果num_key_value_heads=num_attention_heads，模型将使用多头注意力（Multi Head Attention, MHA）；如果num_key_value_heads=1，模型将使用多查询注意力（Multi Query Attention, MQA）；否则将使用 GQA。在将多头检查点转换为 GQA 检查点时，每个组的 key 和 value 头应通过对该组中的所有原始头进行平均池化来构建。更多详情请参阅 这篇论文。如果未指定，默认为8。 - hidden_act (
strorfunction, optional, defaults to"silu") — 解码器中的非线性激活函数（函数或字符串）。 - initializer_range (
float, optional, defaults to 0.02) — 初始化所有权重矩阵的截断正态分布初始化器的标准差。 - rms_norm_eps (
float, optional, defaults to 1e-06) — RMS 归一化层使用的 epsilon。 - use_cache (
bool, optional, defaults toTrue) — 模型是否应返回最后一个 key/values 注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。 - output_router_logits (
bool, optional, defaults toFalse) — 模型是否应返回路由器 logits。启用此选项将允许模型输出辅助损失。有关更多详细信息，请参阅 此处。 - router_aux_loss_coef (
float, optional, defaults to 0.001) — 总损失的辅助损失因子。 - pad_token_id (
int, optional, defaults to 0) — 填充 token 的 ID。 - bos_token_id (
int, optional, defaults to 1) — “序列开始” token 的 ID。 - eos_token_id (
int, optional, defaults to 2) — “序列结束” token 的 ID。 - max_position_embeddings (
int, optional, defaults to 262144) — 此值没有实际意义。此模型旨在使用的最大序列长度。可以用于更长的序列，但性能可能会下降。 - attention_dropout (
float, optional, defaults to 0.0) — 注意力概率的 dropout 率。 - num_experts_per_tok (
int, optional, defaults to 2) — 每个 token 的专家数量，也可解释为top-p路由参数。 - num_experts (
int, optional, defaults to 16) — 每个 Sparse MLP 层的专家数量。 - expert_layer_period (
int, optional, defaults to 2) — 每隔多少层有一个专家层 - expert_layer_offset (
int, optional, defaults to 1) — 包含专家 mlp 层的第一个层索引 - attn_layer_period (
int, optional, defaults to 8) — 每隔多少层有一个标准注意力层 - 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 to 16) — mamba 状态空间隐变量的维度 - mamba_d_conv (
int, optional, defaults to 4) — mamba 卷积核的大小 - mamba_expand (
int, optional, defaults to 2) — 用于确定 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 模型，定义模型架构。使用默认值实例化配置将产生与 Jamba-v0.1 模型类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PreTrainedConfig 的文档。
JambaModel
class transformers.JambaModel
< source >( config: JambaConfig )
参数
- config (JambaConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法以加载模型权重。
输出原始 hidden-states 的裸 Jamba 模型，没有任何特定的顶部头。
此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< source >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None position_ids: torch.LongTensor | None = None past_key_values: transformers.models.jamba.modeling_jamba.HybridMambaAttentionDynamicCache | None = None inputs_embeds: torch.FloatTensor | None = None use_cache: bool | None = None cache_position: torch.LongTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → transformers.modeling_outputs.MoeModelOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor, shape(batch_size, sequence_length), optional) — 词汇表中输入序列 token 的索引。默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor, shape(batch_size, sequence_length), optional) — 避免对填充 token 索引执行注意力的掩码。掩码值选择在[0, 1]中：- 1 表示未掩码的 token，
- 0 表示已掩码的 token。
- position_ids (
torch.LongTensor, shape(batch_size, sequence_length), optional) — 位置嵌入中每个输入序列 token 的位置索引。与position_ids相反，此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。 - past_key_values (
~models.jamba.modeling_jamba.HybridMambaAttentionDynamicCache, optional) — 可用于加速顺序解码的预计算的 hidden-states（自注意力块和交叉注意力块中的键和值）。这通常是由模型在之前的解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。仅允许 Cache 实例作为输入，请参阅我们的 kv cache 指南。如果未传递
past_key_values，则默认初始化 DynamicCache。模型将输出与输入相同的缓存格式。
如果使用
past_key_values，用户应仅输入未处理的input_ids（那些没有传递其 past key value 状态给该模型的input_ids），形状为(batch_size, unprocessed_length)，而不是所有input_ids，形状为(batch_size, sequence_length)。 - inputs_embeds (
torch.FloatTensor, shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想比模型内部的嵌入查找矩阵更精细地控制如何将input_ids索引转换为相关的向量，这将非常有用。 - use_cache (
bool, optional) — 如果设置为True，则会返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。 - cache_position (
torch.LongTensor, shape(sequence_length), optional) — 指示输入序列 token 在序列中位置的索引。与position_ids相反，此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。
返回
transformers.modeling_outputs.MoeModelOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.MoeModelOutputWithPast 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或当 config.return_dict=False 时），其中包含根据配置（JambaConfig）和输入而变化的各种元素。
-
last_hidden_state (
torch.FloatTensor, 形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 -
past_key_values (
Cache, optional, 当传递use_cache=True或当config.use_cache=True时返回) — 它是 Cache 实例。更多详情，请参阅我们的 kv cache 指南。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 后），这些术语用于计算专家混合模型的辅助损失。
JambaModel 的前向方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
JambaForCausalLM
class transformers.JambaForCausalLM
< source >( config: JambaConfig )
参数
- config (JambaConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载模型权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
Jamba 模型，用于因果语言建模。
此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< source >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None position_ids: torch.LongTensor | None = None past_key_values: transformers.models.jamba.modeling_jamba.HybridMambaAttentionDynamicCache | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None output_router_logits: bool | None = None cache_position: torch.LongTensor | None = None logits_to_keep: int | torch.Tensor = 0 **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → transformers.modeling_outputs.MoeCausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), optional) — 用于避免对填充 token 索引执行 attention 的掩码。掩码值选择在[0, 1]中：- 1 表示未掩码的 token，
- 0 表示已掩码的 token。
- position_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 词汇表中输入序列 token 的位置索引。选择范围为[0, config.n_positions - 1]。 - past_key_values (
~models.jamba.modeling_jamba.HybridMambaAttentionDynamicCache, optional) — 可以用于加速序列解码的预计算隐藏状态（自 attention 块和交叉 attention 块中的 key 和 value）。这通常是在use_cache=True或config.use_cache=True时，模型在之前的解码阶段返回的past_key_values。只有 Cache 实例允许作为输入，请参阅我们的 kv cache 指南。如果未传递
past_key_values，则默认初始化 DynamicCache。模型将输出与输入相同的 cache 格式。
如果使用
past_key_values，则用户需要只输入未处理的input_ids（即其 past key value 状态未传递给此模型的那些），形状为(batch_size, unprocessed_length)，而不是所有input_ids，形状为(batch_size, sequence_length)。 - inputs_embeds (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想比模型内部的嵌入查找矩阵更好地控制如何将input_ids索引转换为相关的向量，这将很有用。 - labels (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]或 -100 范围内（请参阅input_ids文档字符串）。索引设置为-100的 token 将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]范围内的 token 计算。 - use_cache (
bool, optional) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（请参阅past_key_values）。 - output_router_logits (
bool, optional) — 是否返回所有路由器的 logits。它们对于计算路由器损失很有用，并且在推理时应不返回。 - cache_position (
torch.LongTensorof shape(sequence_length), optional) — 描绘输入序列 token 在序列中位置的索引。与position_ids不同，该张量不受填充影响。它用于在正确位置更新 cache 并推断完整序列长度。 - logits_to_keep (
Union[int, torch.Tensor], optional, defaults to0) — 如果是int，则计算最后logits_to_keep个 token 的 logits。如果为0，则计算所有input_ids的 logits（特殊情况）。生成时只需要最后一个 token 的 logits，并且只为该 token 计算 logits 可以节省内存，这对于长序列或大词汇量来说非常显著。如果是torch.Tensor，则必须是 1D 的，对应于序列长度维度中要保留的索引。当使用 packed tensor 格式（批次和序列长度的单维度）时，这很有用。
返回
transformers.modeling_outputs.MoeCausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.MoeCausalLMOutputWithPast 对象，或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置（JambaConfig）和输入而定的各种元素。
-
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, optional, 当传递use_cache=True或当config.use_cache=True时返回) — 它是 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见
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 后的注意力权重，用于计算自注意力头中的加权平均值。
JambaForCausalLM 的 forward 方法，重写了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> 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
< source >( 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] ) → transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensorof shape(batch_size, sequence_length), optional) — 用于避免对填充 token 索引执行 attention 的掩码。掩码值选择在[0, 1]中：- 1 表示未掩码的 token，
- 0 表示已掩码的 token。
- position_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 词汇表中输入序列 token 的位置索引。选择范围为[0, config.n_positions - 1]。 - past_key_values (
~cache_utils.Cache, optional) — 可以用于加速序列解码的预计算隐藏状态（自 attention 块和交叉 attention 块中的 key 和 value）。这通常是在use_cache=True或config.use_cache=True时，模型在之前的解码阶段返回的past_key_values。只有 Cache 实例允许作为输入，请参阅我们的 kv cache 指南。如果未传递
past_key_values，则默认初始化 DynamicCache。模型将输出与输入相同的 cache 格式。
如果使用
past_key_values，则用户需要只输入未处理的input_ids（即其 past key value 状态未传递给此模型的那些），形状为(batch_size, unprocessed_length)，而不是所有input_ids，形状为(batch_size, sequence_length)。 - inputs_embeds (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想比模型内部的嵌入查找矩阵更好地控制如何将input_ids索引转换为相关的向量，这将很有用。 - labels (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]或 -100 范围内（请参阅input_ids文档字符串）。索引设置为-100的 token 将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]范围内的 token 计算。 - use_cache (
bool, optional) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（请参阅past_key_values）。
返回
transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.SequenceClassifierOutputWithPast or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (None) and inputs.
-
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, optional, 当传递use_cache=True或当config.use_cache=True时返回) — 它是 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见
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 后的注意力权重，用于计算自注意力头中的加权平均值。
The GenericForSequenceClassification forward method, overrides the __call__ special method.
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。