Transformers 文档
Llama
并获得增强的文档体验
开始使用
Llama
Llama 是一个拥有 70 亿到 650 亿参数的大型语言模型家族。这些模型专注于高效推理（这对服务语言模型至关重要），通过用更多的数据 tokens 训练较小的模型，而不是用较少的数据 tokens 训练较大的模型。Llama 模型基于 GPT 架构，但它使用预归一化来提高训练稳定性，用 SwiGLU 替换 ReLU 以提高性能，并用旋转位置嵌入（RoPE）替换绝对位置嵌入以更好地处理更长的序列长度。
您可以在 Huggy Llama 组织下找到所有原始的 Llama 模型权重。
点击右侧边栏中的 Llama 模型，查看更多如何将 Llama 应用于不同语言任务的示例。
下面的示例演示了如何使用 Pipeline 或 AutoModel，以及从命令行生成文本。
import torch
from transformers import pipeline
pipeline = pipeline(
task="text-generation",
model="huggyllama/llama-7b",
torch_dtype=torch.float16,
device=0
)
pipeline("Plants create energy through a process known as")量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。
以下示例使用torchao仅将权重量化为int4。
# pip install torchao
import torch
from transformers import TorchAoConfig, AutoModelForCausalLM, AutoTokenizer
quantization_config = TorchAoConfig("int4_weight_only", group_size=128)
model = AutoModelForCausalLM.from_pretrained(
"huggyllama/llama-30b",
torch_dtype=torch.bfloat16,
device_map="auto",
quantization_config=quantization_config
)
tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-30b")
input_ids = tokenizer("Plants create energy through a process known as", return_tensors="pt").to("cuda")
output = model.generate(**input_ids, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))使用 AttentionMaskVisualizer 来更好地理解模型可以和不可以关注哪些 tokens。
from transformers.utils.attention_visualizer import AttentionMaskVisualizer
visualizer = AttentionMaskVisualizer("huggyllama/llama-7b")
visualizer("Plants create energy through a process known as")
注意事项
- tokenizer 是一个基于 SentencePiece 的字节对编码模型。在解码期间，如果第一个 token 是单词的开头（例如，“Banana”），tokenizer 不会在字符串前添加前缀空格。
LlamaConfig
class transformers.LlamaConfig
< 源代码 >( vocab_size = 32000 hidden_size = 4096 intermediate_size = 11008 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = None hidden_act = 'silu' max_position_embeddings = 2048 initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True pad_token_id = None bos_token_id = 1 eos_token_id = 2 pretraining_tp = 1 tie_word_embeddings = False rope_theta = 10000.0 rope_scaling = None attention_bias = False attention_dropout = 0.0 mlp_bias = False head_dim = None **kwargs )
参数
- vocab_size (
int, 可选, 默认为 32000) — LLaMA 模型的词汇表大小。定义了在调用 LlamaModel 时传递的inputs_ids可以表示的不同 token 的数量。 - hidden_size (
int, 可选, 默认为 4096) — 隐藏表示的维度。 - intermediate_size (
int, 可选, 默认为 11008) — MLP 表示的维度。 - num_hidden_layers (
int, 可选, 默认为 32) — Transformer 解码器中的隐藏层数量。 - num_attention_heads (
int, 可选, 默认为 32) — Transformer 解码器中每个注意力层的注意力头数量。 - num_key_value_heads (
int, 可选) — 这是用于实现分组查询注意力（Grouped Query Attention）的键值头（key_value heads）的数量。如果 `num_key_value_heads=num_attention_heads`，模型将使用多头注意力（MHA）；如果 `num_key_value_heads=1`，模型将使用多查询注意力（MQA）；否则使用 GQA。当将一个多头模型权重转换为 GQA 模型权重时，每个组的键和值头应该通过对该组内所有原始头进行平均池化来构建。更多细节，请查看这篇论文。如果未指定，将默认为 `num_attention_heads`。 - hidden_act (
str或function, 可选, 默认为"silu") — 解码器中的非线性激活函数（函数或字符串）。 - max_position_embeddings (
int, 可选, 默认为 2048) — 该模型可能使用的最大序列长度。Llama 1 支持最多 2048 个 token，Llama 2 最多 4096，CodeLlama 最多 16384。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。 - rms_norm_eps (
float, 可选, 默认为 1e-06) — rms 归一化层使用的 epsilon 值。 - use_cache (
bool, 可选, 默认为True) — 模型是否应返回最后一个键/值注意力（并非所有模型都使用）。仅当 `config.is_decoder=True` 时相关。 - pad_token_id (
int, 可选) — 填充 token 的 ID。 - bos_token_id (
int, 可选, 默认为 1) — 序列开始 token 的 ID。 - eos_token_id (
int, 可选, 默认为 2) — 序列结束 token 的 ID。 - pretraining_tp (
int, 可选, 默认为 1) — 实验性功能。预训练期间使用的张量并行等级。请参阅此文档以了解更多信息。这个值对于确保预训练结果的精确复现是必需的。请参阅此问题。 - tie_word_embeddings (
bool, 可选, 默认为False) — 是否绑定词嵌入权重。 - 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 高频分量的缩放因子。 - attention_bias (
bool, 可选, 默认为False) — 在自注意力机制中，是否在查询、键、值和输出投影层中使用偏置。 - attention_dropout (
float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。 - mlp_bias (
bool, 可选, 默认为False) — 是否在 MLP 层的 up_proj、down_proj 和 gate_proj 层中使用偏置。 - head_dim (
int, 可选) — 注意力头的维度。如果为 None，则默认为 hidden_size // num_attention_heads
这是用于存储 LlamaModel 配置的配置类。它用于根据指定的参数实例化一个 LLaMA 模型，定义模型架构。使用默认值实例化配置将产生与 LLaMA-7B 类似的配置，例如 meta-llama/Llama-2-7b-hf
配置对象继承自 PretrainedConfig，可用于控制模型输出。更多信息请阅读 PretrainedConfig 的文档。
>>> from transformers import LlamaModel, LlamaConfig
>>> # Initializing a LLaMA llama-7b style configuration
>>> configuration = LlamaConfig()
>>> # Initializing a model from the llama-7b style configuration
>>> model = LlamaModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLlamaTokenizer
class transformers.LlamaTokenizer
< 来源 >( vocab_file unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' pad_token = None sp_model_kwargs: typing.Optional[dict[str, typing.Any]] = None add_bos_token = True add_eos_token = False clean_up_tokenization_spaces = False use_default_system_prompt = False spaces_between_special_tokens = False legacy = None add_prefix_space = True **kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - unk_token (
str或tokenizers.AddedToken, 可选, 默认为"<unk>") — 未知词元。不在词汇表中的词元无法转换为 ID，将被设置为此词元。 - bos_token (
str或tokenizers.AddedToken, 可选, 默认为"<s>") — 序列开始词元，在预训练期间使用。可用作序列分类器词元。 - eos_token (
str或tokenizers.AddedToken, 可选, 默认为"</s>") — 序列结束词元。 - pad_token (
str或tokenizers.AddedToken, 可选) — 用于将词元数组填充至相同大小以进行批处理的特殊词元。之后将被注意力机制或损失计算忽略。 - sp_model_kwargs (
dict[str, Any],Optional, 可选) — 将传递给SentencePieceProcessor.__init__()方法。SentencePiece 的 Python 包装器 可用于设置以下内容等：-
enable_sampling: 启用子词正则化。 -
nbest_size: unigram 的采样参数。对于 BPE-Dropout 无效。nbest_size = {0,1}: 不执行采样。nbest_size > 1: 从 nbest_size 个结果中采样。nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤和后向采样算法从所有假设（格）中采样。
-
alpha: unigram 采样的平滑参数，以及 BPE-dropout 的合并操作的 dropout 概率。
-
- add_bos_token (
bool, 可选, 默认为True) — 是否在序列开始处添加bos_token。 - add_eos_token (
bool, 可选, 默认为False) — 是否在序列末尾添加eos_token。 - clean_up_tokenization_spaces (
bool, 可选, 默认为False) — 解码后是否清理空格，清理操作包括移除可能存在的额外空格等伪影。 - use_default_system_prompt (
bool, 可选, 默认为False) — 是否使用 Llama 的默认系统提示。 - spaces_between_special_tokens (
bool, 可选, 默认为False) — 是否在特殊词元之间添加空格。 - legacy (
bool, 可选) — 是否使用分词器的 `legacy` 行为。Legacy 指的是在合并 #24622 和 #25224 之前的行为，这些合并包含了正确处理特殊词元后出现的词元的修复。请确保同时将 `from_slow` 设置为 `True`。一个简单的例子：legacy=True:
构建一个 Llama 分词器。基于字节级的字节对编码（Byte-Pair-Encoding）。由于原始模型中没有填充词元，因此默认的填充词元未设置。
get_special_tokens_mask
< 来源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]
从没有添加特殊标记的标记列表中检索序列ID。此方法在使用分词器prepare_for_model方法添加特殊标记时调用。
create_token_type_ids_from_sequences
< 来源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
根据传入的两个序列创建掩码，用于序列对分类任务。一个 ALBERT
如果 token_ids_1 为 None，则此方法仅返回掩码的第一部分（0s）。
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence | second sequence |如果 token_ids_1 为 None，则只返回掩码的第一部分（0s）。
save_vocabulary
< 来源 >( save_directory filename_prefix: typing.Optional[str] = None ) → Tuple(str)
将词汇表和特殊标记文件保存到目录。
LlamaTokenizerFast
class transformers.LlamaTokenizerFast
< 来源 >( vocab_file = None tokenizer_file = None clean_up_tokenization_spaces = False unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' add_bos_token = True add_eos_token = False use_default_system_prompt = False legacy = None add_prefix_space = None **kwargs )
参数
- vocab_file (
str, 可选) — SentencePiece 文件（通常扩展名为 .model），包含实例化分词器所需的词汇表。 - tokenizer_file (
str, 可选) — tokenizers 文件（通常扩展名为 .json），包含加载分词器所需的所有内容。 - clean_up_tokenization_spaces (
bool, 可选, 默认为False) — 解码后是否清理空格，清理操作包括移除可能存在的额外空格等伪影。 - unk_token (
str或tokenizers.AddedToken, 可选, 默认为"<unk>") — 未知词元。不在词汇表中的词元无法转换为 ID，将被设置为此词元。 - bos_token (
str或tokenizers.AddedToken, 可选, 默认为"<s>") — 序列开始词元，在预训练期间使用。可用作序列分类器词元。 - eos_token (
str或tokenizers.AddedToken, 可选, 默认为"</s>") — 序列结束词元。 - add_bos_token (
bool, 可选, 默认为True) — 是否在序列开始处添加bos_token。 - add_eos_token (
bool, 可选, 默认为False) — 是否在序列末尾添加eos_token。 - use_default_system_prompt (
bool, 可选, 默认为False) — 是否使用 Llama 的默认系统提示 - legacy (
bool, 可选) — 是否使用分词器的 `legacy` 行为。Legacy 指的是在合并 #24622 和 #25224 之前的行为，这些合并包含了正确处理特殊词元后出现的词元的修复。请确保同时将 `from_slow` 设置为 `True`。一个简单的例子：legacy=True:
构建 Llama 分词器。基于字节级字节对编码。
这主要使用 ByteFallback 且不进行规范化。
>>> from transformers import LlamaTokenizerFast
>>> tokenizer = LlamaTokenizerFast.from_pretrained("hf-internal-testing/llama-tokenizer")
>>> tokenizer.encode("Hello this is a test")
[1, 15043, 445, 338, 263, 1243]如果你想更改 `bos_token` 或 `eos_token`，请确保在初始化模型时指定它们，或调用 `tokenizer.update_post_processor()` 以确保后处理正确完成（否则编码序列的第一个词元和最后一个词元的值将不正确）。更多详情，请查看 [后处理器] (https://huggingface.co/docs/tokenizers/api/post-processors) 文档。
此分词器继承自 PreTrainedTokenizerFast，其中包含大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。
get_special_tokens_mask
< 来源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → 一个范围在 [0, 1] 内的整数列表
从未添加特殊令牌的令牌列表中检索序列 ID。使用分词器 prepare_for_model 或 encode_plus 方法添加特殊令牌时会调用此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
创建与传入序列对应的标记类型 ID。什么是标记类型 ID？
如果模型有特殊的构建方式，应在子类中重写此方法。
使用当前的 bos_token 和 eos_token 更新底层后处理器。
LlamaModel
class transformers.LlamaModel
< source >( config: LlamaConfig )
参数
- config (LlamaConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查阅 from_pretrained() 方法来加载模型权重。
原始的 Llama 模型，输出原始的隐藏状态，顶部没有任何特定的头。
该模型继承自 PreTrainedModel。请查阅超类的文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
该模型也是一个 PyTorch torch.nn.Module 的子类。可以像使用常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) → transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 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, 可选) — 预先计算的隐藏状态（自注意块和交叉注意块中的键和值），可用于加速序列解码。这通常包括在解码的前一阶段由模型返回的 `past_key_values`，当 `use_cache=True` 或 `config.use_cache=True` 时。允许两种格式：
- 一个 Cache 实例，请参阅我们的 kv 缓存指南；
- 一个长度为 `config.n_layers` 的 `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`。
- inputs_embeds (
torch.FloatTensor，形状为(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`。 - cache_position (
torch.LongTensor，形状为(sequence_length)，可选) — 描述输入序列标记在序列中位置的索引。与 `position_ids` 相反，此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。
返回
transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPast 或一个 `torch.FloatTensor` 的元组（如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时），包含各种元素，具体取决于配置 (LlamaConfig) 和输入。
-
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=True` 或 `config.use_cache=True` 时返回) — 这是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预先计算的隐藏状态（自注意块中的键和值，如果 `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 后的注意力权重，用于计算自注意力头中的加权平均值。
LlamaModel 的 forward 方法会覆盖 `__call__` 特殊方法。
虽然前向传播的配方需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默忽略它们。
LlamaForCausalLM
class transformers.LlamaForCausalLM
< source >( config )
参数
- config (LlamaForCausalLM) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查阅 from_pretrained() 方法来加载模型权重。
用于因果语言建模的 Llama 模型。
该模型继承自 PreTrainedModel。请查阅超类的文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
该模型也是一个 PyTorch torch.nn.Module 的子类。可以像使用常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.llama.modeling_llama.KwargsForCausalLM] ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 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, 可选) — 预先计算的隐藏状态（自注意块和交叉注意块中的键和值），可用于加速序列解码。这通常包括在解码的前一阶段由模型返回的 `past_key_values`，当 `use_cache=True` 或 `config.use_cache=True` 时。允许两种格式：
- 一个 Cache 实例，请参阅我们的 kv 缓存指南；
- 一个长度为 `config.n_layers` 的 `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`。
- 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` 的标记将被忽略 (遮盖)，损失仅对标签在 `[0, ..., config.vocab_size]` 中的标记计算。 - use_cache (
bool, 可选) — 如果设置为 `True`，将返回 `past_key_values` 键值状态，可用于加速解码（参见 `past_key_values`）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 `attentions`。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 `hidden_states`。 - 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.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个 `torch.FloatTensor` 的元组（如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时），包含各种元素，具体取决于配置 (LlamaConfig) 和输入。
-
loss (
torch.FloatTensor形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个 token 预测）。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
past_key_values (
Cache, 可选, 当传递 `use_cache=True` 或 `config.use_cache=True` 时返回) — 这是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见
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 后的注意力权重，用于计算自注意力头中的加权平均值。
LlamaForCausalLM 的 forward 方法会覆盖 `__call__` 特殊方法。
虽然前向传播的配方需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默忽略它们。
示例
>>> from transformers import AutoTokenizer, LlamaForCausalLM
>>> model = LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> 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."LlamaForSequenceClassification
class transformers.LlamaForSequenceClassification
< source >( config )
参数
- config (LlamaForSequenceClassification) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查阅 from_pretrained() 方法来加载模型权重。
在 LLaMa 模型 Transformer 的顶部添加了一个序列分类头（线性层）。
LlamaForSequenceClassification 使用最后一个标记来进行分类，就像其他因果模型（例如 GPT-2）一样。
由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果配置中定义了 `pad_token_id`，它会在每行中找到最后一个非填充标记。如果没有定义 `pad_token_id`，它会简单地取批处理中每行的最后一个值。由于当传递 `inputs_embeds` 而不是 `input_ids` 时它无法猜测填充标记，因此它会做同样的操作（取批处理中每行的最后一个值）。
该模型继承自 PreTrainedModel。请查阅超类的文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
该模型也是一个 PyTorch torch.nn.Module 的子类。可以像使用常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 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, optional) — 预计算的隐藏状态（自注意力和交叉注意力块中的键和值），可用于加速序列解码。这通常包含在解码的前一阶段，当use_cache=True或config.use_cache=True时由模型返回的 `past_key_values`。允许两种格式：
- Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组，每个元组包含 2 个形状为 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的张量。这也称为旧版缓存格式。
模型将输出与输入相同的缓存格式。如果未传递 `past_key_values`，则将返回旧版缓存格式。
如果使用 `past_key_values`，用户可以选择只输入最后一个 `input_ids`（即那些没有为其提供过去键值状态的 `input_ids`），其形状为 `(batch_size, 1)`，而不是所有形状为 `(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,)`，可选) — 用于计算序列分类/回归损失的标签。索引应在 `[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`。
返回
transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
一个 `transformers.modeling_outputs.SequenceClassifierOutputWithPast` 或一个 `torch.FloatTensor` 元组（如果传递 `return_dict=False` 或 `config.return_dict=False`），根据配置 (LlamaConfig) 和输入包含各种元素。
-
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), 可选, 当传递 `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 后的注意力权重，用于计算自注意力头中的加权平均值。
LlamaForSequenceClassification 的前向方法会覆盖 `__call__` 特殊方法。
虽然前向传播的配方需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默忽略它们。
单标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, LlamaForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> model = LlamaForSequenceClassification.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> 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 = LlamaForSequenceClassification.from_pretrained("meta-llama/Llama-2-7b-hf", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, LlamaForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> model = LlamaForSequenceClassification.from_pretrained("meta-llama/Llama-2-7b-hf", 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 = LlamaForSequenceClassification.from_pretrained(
... "meta-llama/Llama-2-7b-hf", 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).lossLlamaForQuestionAnswering
class transformers.LlamaForQuestionAnswering
< 源代码 >( config )
参数
- config (LlamaForQuestionAnswering) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
Llama 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.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = 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 **kwargs ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为 `(batch_size, sequence_length)`，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 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 缓存指南；
- 长度为 `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`。
- 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`。
返回
transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个 `torch.FloatTensor` 元组（如果传递 `return_dict=False` 或 `config.return_dict=False`），根据配置 (LlamaConfig) 和输入包含各种元素。
-
loss (
torch.FloatTensorof shape(1,), 可选, 当提供labels时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。 -
start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 范围起始分数（SoftMax 之前）。 -
end_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 范围结束分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。
LlamaForQuestionAnswering 的前向方法会覆盖 `__call__` 特殊方法。
虽然前向传播的配方需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默忽略它们。
示例
>>> from transformers import AutoTokenizer, LlamaForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> model = LlamaForQuestionAnswering.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> 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)
...LlamaForTokenClassification
class transformers.LlamaForTokenClassification
< 源代码 >( config )
参数
- config (LlamaForTokenClassification) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
Llama Transformer 模型，在其顶部添加了一个标记分类头（在隐藏状态输出之上添加一个线性层），例如用于命名实体识别（NER）任务。
该模型继承自 PreTrainedModel。请查阅超类的文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
该模型也是一个 PyTorch torch.nn.Module 的子类。可以像使用常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< 源代码 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为 `(batch_size, sequence_length)`，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 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 缓存指南；
- 长度为 `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`。
- inputs_embeds (
torch.FloatTensor，形状为 `(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`。
返回
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.TokenClassifierOutput 或一个 `torch.FloatTensor` 元组（如果传递 `return_dict=False` 或 `config.return_dict=False`），根据配置 (LlamaConfig) 和输入包含各种元素。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供labels时返回) — 分类损失。 -
logits (形状为
(batch_size, sequence_length, config.num_labels)的torch.FloatTensor) — 分类分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。
LlamaForTokenClassification 的前向方法会覆盖 `__call__` 特殊方法。
虽然前向传播的配方需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默忽略它们。
示例
>>> from transformers import AutoTokenizer, LlamaForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> model = LlamaForTokenClassification.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> 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)
...FlaxLlamaModel
class transformers.FlaxLlamaModel
< 源代码 >( config: LlamaConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (LlamaConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
- dtype (
jax.numpy.dtype，可选，默认为jax.numpy.float32) — 计算的数据类型。可以是 `jax.numpy.float32`、`jax.numpy.float16` 或 `jax.numpy.bfloat16` 之一。这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算都将使用给定的 `dtype` 执行。
请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。
基础的 Llama 模型 Transformer，输出原始的隐藏状态，顶部没有任何特定的头。
该模型继承自 FlaxPreTrainedModel。请查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头等）。
该模型也是 Flax Linen flax.nn.Module 的子类。可以像常规 Flax Module 一样使用它，并参考 Flax 文档了解所有与一般用法和行为相关的事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< 源代码 >( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None past_key_values: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray，形状为 `(batch_size, input_ids_length)`) — 词汇表中输入序列标记的索引。如果提供填充，默认情况下将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray，形状为 `(batch_size, sequence_length)`，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在 `[0, 1]` 中选择：- 1 表示标记未被屏蔽，
- 0 表示标记被屏蔽。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用 `past_key_values`，则可以选择只输入最后一个 `decoder_input_ids`（参见 `past_key_values`）。
如果你想更改填充行为，应阅读 `modeling_opt._prepare_decoder_attention_mask` 并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。
- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- position_ids (
numpy.ndarray，形状为 `(batch_size, input_ids_length)`，可选) — 每个输入序列标记在位置嵌入中的位置索引。在 `[0, config.n_positions - 1]` 范围内选择。 - 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.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一个 `torch.FloatTensor` 元组（如果传递 `return_dict=False` 或 `config.return_dict=False`），根据配置 (LlamaConfig) 和输入包含各种元素。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最后一层输出的隐藏状态序列。 -
hidden_states (
tuple(jnp.ndarray)，可选，当传递 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — `jnp.ndarray` 元组（一个用于嵌入层的输出，一个用于每层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(jnp.ndarray)，可选，当传递 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — `jnp.ndarray` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
`FlaxLlamaPreTrainedModel` 的前向方法会覆盖 `__call__` 特殊方法。
虽然前向传播的配方需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默忽略它们。
此示例使用一个随机模型，因为真实的模型都非常大。要获得正确的结果，应使用 openlm-research/open_llama_3b_v2 而不是 afmck/testing-llama-tiny。如果在加载该检查点时遇到内存不足的问题，可以尝试在 `from_pretrained` 调用中添加 `device_map="auto"`。
示例
>>> from transformers import AutoTokenizer, FlaxLlamaModel
>>> tokenizer = AutoTokenizer.from_pretrained("afmck/testing-llama-tiny")
>>> model = FlaxLlamaModel.from_pretrained("afmck/testing-llama-tiny")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateFlaxLlamaForCausalLM
class transformers.FlaxLlamaForCausalLM
< 源代码 >( config: LlamaConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
参数
- config (LlamaConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
- dtype (
jax.numpy.dtype, 可选, 默认为jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16或jax.numpy.bfloat16之一。这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算都将使用给定的
dtype执行。请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。
Llama Transformer 模型，顶部带有一个语言建模头（线性层）。
该模型继承自 FlaxPreTrainedModel。请查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头等）。
该模型也是 Flax Linen flax.nn.Module 的子类。可以像常规 Flax Module 一样使用它，并参考 Flax 文档了解所有与一般用法和行为相关的事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< 源码 >( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None past_key_values: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray，形状为(batch_size, input_ids_length)) — 词汇表中输入序列标记的索引。如果提供填充，默认将被忽略。索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray，形状为(batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被掩码，
- 0 表示标记被掩码。
索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择只输入最后的decoder_input_ids（参见past_key_values）。如果您想更改填充行为，应阅读
modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。- 1 表示头未被掩码，
- 0 表示头被掩码。
- position_ids (
numpy.ndarray，形状为(batch_size, input_ids_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.n_positions - 1]范围内选择。 - 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.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（LlamaConfig）和输入，包含各种元素。
-
logits (形状为
(batch_size, sequence_length, config.vocab_size)的jnp.ndarray) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。 -
hidden_states (
tuple(jnp.ndarray)，可选，当传递 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — `jnp.ndarray` 元组（一个用于嵌入层的输出，一个用于每层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(jnp.ndarray)，可选，当传递 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — `jnp.ndarray` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
`FlaxLlamaPreTrainedModel` 的前向方法会覆盖 `__call__` 特殊方法。
虽然前向传播的配方需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理预处理和后处理步骤，而后者会静默忽略它们。
此示例使用一个随机模型，因为真实的模型都非常大。要获得正确的结果，应使用 openlm-research/open_llama_3b_v2 而不是 afmck/testing-llama-tiny。如果在加载该检查点时遇到内存不足的问题，可以尝试在 `from_pretrained` 调用中添加 `device_map="auto"`。
示例
>>> from transformers import AutoTokenizer, FlaxLlamaForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("afmck/testing-llama-tiny")
>>> model = FlaxLlamaForCausalLM.from_pretrained("afmck/testing-llama-tiny")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
>>> outputs = model(**inputs)
>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]