Transformers 4.37 中文文档（四十）（1）

原文：huggingface.co/docs/transformers

LLaMA

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/llama

概述

Hugo Touvron、Thibaut Lavril、Gautier Izacard、Xavier Martinet、Marie-Anne Lachaux、Timothée Lacroix、Baptiste Rozière、Naman  Goyal、Eric Hambro、Faisal Azhar、Aurelien Rodriguez、Armand Joulin、Edouard  Grave、Guillaume Lample 在LLaMA: Open and Efficient Foundation Language Models中提出了 LLaMA 模型。它是一个包含从 7B 到 65B 参数的基础语言模型的集合。

该论文的摘要如下：

我们介绍 LLaMA，这是一个包含从 7B 到 65B  参数的基础语言模型的集合。我们在数万亿标记上训练我们的模型，并展示了可以仅使用公开可用的数据集训练最先进的模型，而无需使用专有和不可访问的数据集。特别是，LLaMA-13B  在大多数基准测试中优于 GPT-3（175B），而 LLaMA-65B 与最佳模型 Chinchilla-70B 和 PaLM-540B  竞争。我们向研究社区发布了所有我们的模型。

此模型由zphang贡献，BlackSamorez也有贡献。 Hugging Face 中的实现代码基于 GPT-NeoX 这里。作者的原始代码可以在这里找到。

使用提示

• LLaMA 模型的权重可以通过填写此表格获得。
  
• 下载权重后，需要使用转换脚本将其转换为 Hugging Face Transformers 格式。可以使用以下（示例）命令调用脚本：
  

python src/transformers/models/llama/convert_llama_weights_to_hf.py \
    --input_dir /path/to/downloaded/llama/weights --model_size 7B --output_dir /output/path

• 转换后，可以通过以下方式加载模型和分词器：

from transformers import LlamaForCausalLM, LlamaTokenizer
tokenizer = LlamaTokenizer.from_pretrained("/output/path")
model = LlamaForCausalLM.from_pretrained("/output/path")

请注意，执行脚本需要足够的 CPU RAM 来托管整个模型的 float16 精度（即使最大版本分为几个检查点，它们每个都包含模型的每个权重的一部分，因此我们需要将它们全部加载到 RAM 中）。对于 65B 模型，因此需要 130GB 的 RAM。

• LLaMA 分词器是基于sentencepiece的 BPE 模型。sentencepiece 的一个特点是，在解码序列时，如果第一个标记是单词的开头（例如“Banana”），分词器不会在字符串前添加前缀空格。

此模型由zphang贡献，BlackSamorez也有贡献。 Hugging Face 中的实现代码基于 GPT-NeoX 这里。作者的原始代码可以在这里找到。实现的 Flax 版本由afmck贡献，实现中的代码基于 Hugging Face 的 Flax GPT-Neo。

基于原始 LLaMA 模型，Meta AI 发布了一些后续作品：

• Llama2：Llama2 是 Llama 的改进版本，具有一些架构调整（Grouped Query Attention），并且在 2 万亿标记上进行了预训练。请参考可以在这里找到的 Llama2 的文档。

资源

一系列官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 LLaMA。如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将对其进行审查！资源应该理想地展示一些新内容，而不是重复现有资源。

文本分类

• 一个关于如何使用提示调整来适应 LLaMA 模型进行文本分类任务的笔记本。

问答

• StackLLaMA: 用 RLHF 训练 LLaMA 的实用指南，一篇关于如何使用 RLHF 训练 LLaMA 以回答Stack Exchange上问题的博文。

⚗️ 优化

• 一个关于如何使用 xturing 库在 GPU 上微调 LLaMA 模型的笔记本，该 GPU 具有有限的内存。🌎

⚡️ 推理

• 一个关于如何使用🤗 PEFT 库中的 PeftModel 运行 LLaMA 模型的笔记本。🌎
  
• 一个关于如何使用 LangChain 加载 PEFT 适配器 LLaMA 模型的笔记本。🌎
  

🚀 部署

• 一个关于如何使用 LoRA 方法通过🤗 PEFT 库进行 LLaMA 模型微调的笔记本。🌎
  
• 一个关于如何在 Amazon SageMaker 上部署 Open-LLaMA 模型进行文本生成的笔记本。🌎
  

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 **kwargs )

参数

• vocab_size (int, optional, 默认为 32000) — LLaMA 模型的词汇量。定义在调用 LlamaModel 时可以表示的不同标记的数量。
  
• hidden_size (int, optional, 默认为 4096) — 隐藏表示的维度。
  
• intermediate_size (int, optional, 默认为 11008) — MLP 表示的维度。
  
• num_hidden_layers (int, optional, 默认为 32) — Transformer 解码器中的隐藏层数。
  
• num_attention_heads (int, optional, 默认为 32) — Transformer 解码器中每个注意力层的注意力头数。
  
• num_key_value_heads (int, optional) — 这是应该用来实现分组查询注意力的 key_value 头的数量。如果num_key_value_heads=num_attention_heads，模型将使用多头注意力（MHA），如果num_key_value_heads=1，模型将使用多查询注意力（MQA），否则将使用 GQA。将多头检查点转换为 GQA 检查点时，应通过对该组中所有原始头进行均值池化来构建每个组键和值头。有关更多详细信息，请查看此论文。如果未指定，将默认为num_attention_heads。
  
• hidden_act (str 或 function, optional, 默认为"silu") — 解码器中的非线性激活函数（函数或字符串）。
  
• max_position_embeddings (int, optional, 默认为 2048) — 该模型可能使用的最大序列长度。Llama 1 支持最多 2048 个标记，Llama 2 支持最多 4096 个标记，CodeLlama 支持最多 16384 个标记。
  
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• rms_norm_eps (float, optional, 默认为 1e-06) — rms 归一化层使用的 epsilon。
  
• use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。
  
• pad_token_id (int, 可选) — 填充标记 id。
  
• bos_token_id (int, 可选, 默认为 1) — 流的开始标记 id。
  
• eos_token_id (int, 可选, 默认为 2) — 流的结束标记 id。
  
• pretraining_tp (int, 可选, 默认为 1) — 实验性功能。在预训练期间使用的张量并行性等级。请参考此文档以了解更多信息。此值对于确保预训练结果的精确可重现性是必要的。请参考此问题。
  
• tie_word_embeddings (bool, 可选, 默认为 False) — 是否绑定权重嵌入
  
• rope_theta (float, 可选, 默认为 10000.0) — RoPE 嵌入的基本周期。
  
• rope_scaling (Dict, 可选) — 包含 RoPE 嵌入的缩放配置的字典。当前支持两种缩放策略：线性和动态。它们的缩放因子必须是大于 1 的浮点数。预期格式为{"type": 策略名称, "factor": 缩放因子}。使用此标志时，不要将max_position_embeddings更新为预期的新最大值。有关这些缩放策略行为的更多信息，请参阅以下主题：www.reddit.com/r/LocalLLaMA/comments/14mrgpr/dynamically_scaled_rope_further_increases/。这是一个实验性功能，可能在未来版本中发生破坏性 API 更改。
  
• attention_bias (bool, 默认为 False, 可选, 默认为 False) — 在自注意力机制的查询、键、值和输出投影层中是否使用偏置。
  
• attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的丢失比率。
  

这是一个配置类，用于存储 LLamaModel 的配置。它用于根据指定的参数实例化 LLaMA 模型，定义模型架构。使用默认值实例化配置将产生类似于 LLaMA-7B 的配置。

配置对象继承自 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.config

LlamaTokenizer

class transformers.LlamaTokenizer

<来源>

( vocab_file unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' pad_token = None sp_model_kwargs: Optional = 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 **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。
  
• unk_token (str 或 tokenizers.AddedToken, 可选, 默认为 "") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
  
• bos_token (str 或 tokenizers.AddedToken, 可选, 默认为 "") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。
  
• eos_token (str 或 tokenizers.AddedToken, 可选, 默认为 "") — 序列的结束标记。
  
• 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：用于单字采样的平滑参数，以及 BPE-dropout 合并操作的丢弃概率。
  

• add_bos_token (bool, optional, 默认为 True) — 是否在序列开头添加 bos_token。
  
• add_eos_token (bool, optional, 默认为 False) — 是否在序列末尾添加 eos_token。
  
• clean_up_tokenization_spaces (bool, optional, 默认为 False) — 是否在解码后清除空格，清除包括删除额外空格等潜在的瑕疵。
  
• use_default_system_prompt (bool, optional, 默认为 False) — 是否使用 Llama 的默认系统提示。
  
• spaces_between_special_tokens (bool, optional, 默认为 False) — 是否在特殊标记之间添加空格。
  
• legacy (bool, optional) — 是否使用分词器的 legacy 行为。在合并 #24622 和 #25224 之前的遗留版本中，修复了在特殊标记后出现的标记的问题。一个简单的例子：

• legacy=True:

构建一个 Llama 分词器。基于字节级字节对编码。默认的填充标记未设置，因为原始模型中没有填充标记。

build_inputs_with_special_tokens

< source >

( token_ids_0 token_ids_1 = None )

get_special_tokens_mask

< source >

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
  
• token_ids_1 (List[int], optional) — 可选的第二个 ID 列表，用于序列对。
  
• already_has_special_tokens (bool, optional, 默认为 False) — 标记列表是否已经格式化为模型的特殊标记。
  

返回

List[int]

一个整数列表，范围为 [0, 1]：1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。当使用分词器的 prepare_for_model 方法添加特殊标记时，会调用此方法。

create_token_type_ids_from_sequences

< source >

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
  
• token_ids_1 (List[int], optional) — 可选的第二个 ID 列表，用于序列对。
  

返回

List[int]

根据给定序列的 标记类型 ID 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 ALBERT

序列对掩码的格式如下：

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，则只返回掩码的第一部分（0）。

save_vocabulary

< source >

( save_directory filename_prefix: Optional = None ) → export const metadata = 'undefined';Tuple(str)

参数

• save_directory (str) — 保存词汇表的目录。

返回

Tuple(str)

保存的文件路径。

将词汇表和特殊标记文件保存到目录中。

LlamaTokenizerFast

class transformers.LlamaTokenizerFast

< source >

( 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 **kwargs )

参数

• vocab_file (str, optional) — 包含实例化分词器所需词汇表的 SentencePiece 文件（通常具有 .model 扩展名）。
  
• tokenizer_file (str, optional) — 包含加载分词器所需的所有内容的 tokenizers 文件（通常具有 .json 扩展名）。
  
• clean_up_tokenization_spaces (bool, 可选, 默认为 False) — 是否在解码后清理空格，清理包括删除额外的空格等潜在残留物。
  
• unk_token (str 或 tokenizers.AddedToken, 可选, 默认为 "") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
  
• bos_token (str 或 tokenizers.AddedToken, 可选, 默认为 "") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。
  
• eos_token (str 或 tokenizers.AddedToken, 可选, 默认为 "") — 序列结束标记。
  
• add_bos_token (bool, 可选, 默认为 True) — 是否在序列开头添加 bos_token。
  
• add_eos_token (bool, 可选, 默认为 False) — 是否在序列末尾添加 eos_token。
  
• use_default_system_prompt (bool, 可选, 默认为 False) — 是否使用 Llama 的默认系统提示。
  

构建一个 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() 确保后处理正确完成（否则编码序列的第一个标记和最后一个标记的值将不正确）。有关更多详细信息，请查看[后处理器] (huggingface.co/docs/tokenizers/api/post-processors) 文档。

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

build_inputs_with_special_tokens

<来源>

( token_ids_0 token_ids_1 = None )

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';A list of integers in the range [0, 1]

参数

• token_ids_0 (List[int]) — 第一个序列的 ID 列表。
  
• token_ids_1 (List[int], 可选) — 第二个序列的 ID 列表。
  
• already_has_special_tokens (bool, 可选, 默认为 False) — 标记列表是否已经格式化为模型的特殊标记。
  

返回

一个整数列表，范围为 [0, 1]

1 代表特殊标记，0 代表序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。当使用分词器的 prepare_for_model 或 encode_plus 方法添加特殊标记时，将调用此方法。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 第一个标记化序列。
  
• token_ids_1 (List[int], 可选) — 第二个标记化序列。
  

返回

List[int]

标记类型 ID。

创建与传递的序列对应的标记类型 ID。什么是标记类型 ID？

如果模型有特殊的构建方式，则应该在子类中重写此方法。

update_post_processor

<来源>

( )

使用当前的 bos_token 和 eos_token 更新底层后处理器。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

LlamaModel

class transformers.LlamaModel

<来源>

( config: LlamaConfig )

参数

• config（LlamaConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。config - LlamaConfig

裸的 LLaMA 模型输出原始隐藏状态，没有特定的头部。此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

由config.num_hidden_layers层组成的 Transformer 解码器。每一层都是LlamaDecoderLayer。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

• 1 表示标记未被遮罩，
  
• 0 表示标记被遮罩。
  

• 什么是注意力遮罩？
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  如果使用past_key_values，可选地只需输入最后的input_ids（请参阅past_key_values）。
  如果要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
  

• 1 表示头部未被遮罩，
  
• 0 表示头部被遮罩。
  

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。
  什么是位置 ID？
  
• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）- 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：

• 一个 Cache 实例;
  
• 元组tuple(torch.FloatTensor)的长度为config.n_layers，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也被称为传统缓存格式。
  

• 模型将输出与输入相同的缓存格式。如果未传递past_key_values，则将返回传统缓存格式。
  如果使用past_key_values，用户可以选择仅输入最后的input_ids（这些没有将其过去的键值状态提供给此模型）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有input_ids。
  
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递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 而不是普通元组。
  

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

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

LlamaForCausalLM

class transformers.LlamaForCausalLM

<来源>

( config )

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]：

• 对于未被masked的标记，值为 1，
  
• 对于被masked的标记，值为 0。
  

• 什么是注意力掩码？
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  如果使用past_key_values，则可选择仅输入最后的input_ids（请参阅past_key_values）。
  如果要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
  

• 1 表示头部未被掩码，
  
• 0 表示头部被掩码。
  

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选） - 每个输入序列标记在位置嵌入中的位置索引。选择范围在[0, config.n_positions - 1]内。
  什么是位置 ID？
  
• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选） - 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：

• 一个 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（那些没有将它们的过去键值状态提供给此模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有input_ids。
  
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选） - 可选地，您可以选择直接传递嵌入表示，而不是传递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 而不是普通元组。
  参数 - 标签（torch.LongTensor，形状为(batch_size, sequence_length)，可选）：用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（参见input_ids文档）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。
  

返回

transformers.modeling_outputs.CausalLMOutputWithPast 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或torch.FloatTensor的元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置（LlamaConfig）和输入的不同元素。

• loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回） - 语言建模损失（用于下一个标记预测）。
  
• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）
  包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。
  
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每个层的输出）。
  模型在每个层的输出处的隐藏状态以及可选的初始嵌入输出。
  
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。
  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

LlamaForCausalLM 的前向方法，覆盖了__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

<来源>

( config )

参数

• config（LlamaConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

LLaMa 模型变压器，顶部带有序列分类头（线性层）。

LlamaForSequenceClassification 使用最后一个标记进行分类，就像其他因果模型（例如 GPT-2）一样。

由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了pad_token_id，则在每行中找到不是填充标记的最后一个标记。如果未定义pad_token_id，则简单地取批次中每行的最后一个值。当传递inputs_embeds而不是input_ids时，无法猜测填充标记，因此执行相同操作（取批次中每行的最后一个值）。

该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存，调整输入嵌入，修剪头等）。

该模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。默认情况下，如果提供，将忽略填充。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

• 1 表示未被“掩盖”的标记，
  
• 0 表示被“掩盖”的标记。
  

• 什么是注意力掩码？
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  如果使用past_key_values，可以选择仅输入最后的input_ids（请参阅past_key_values）。
  如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
  

• 1 表示头部未被“掩盖”，
  
• 0 表示头部被“掩盖”。
  

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。
  什么是位置 ID？
  
• past_key_values（Cache或tuple(tuple(torch.FloatTensor))，可选）- 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：

• 一个 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（即未将其过去的键值状态提供给此模型的那些）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有input_ids。
  
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
  
• use_cache（bool，可选）- 如果设置为True，则将返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  
• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。
  

LlamaForSequenceClassification 前向方法，覆盖__call__特殊方法。

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

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, optional, 默认为 jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16或jax.numpy.bfloat16之一。
  这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定，所有计算将使用给定的dtype执行。
  请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。
  如果希望更改模型参数的数据类型，请参阅 to_fp16() 和 to_bf16()。
  

裸 Llama 模型变压器，输出原始隐藏状态而不带任何特定头部。

此模型继承自 FlaxPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是一个 Flax Linen flax.nn.Module 子类。将其用作常规 Flax 模块，并参考 Flax 文档以获取有关一般用法和行为的所有相关信息。

最后，此模型支持 JAX 的固有特性，例如：

• 即时（JIT）编译
  
• 自动微分
  
• 矢量化
  
• 并行化
  

__call__

<来源>

( input_ids attention_mask = None position_ids = None params: dict = None past_key_values: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (numpy.ndarray of shape (batch_size, input_ids_length)) — 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (numpy.ndarray of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

• 对于未被masked的标记为 1，
  
• 对于被masked的标记为 0。
  

• 什么是注意力掩码？
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  如果使用past_key_values，则可能只需输入最后的decoder_input_ids（参见past_key_values）。
  如果要更改填充行为，您应该阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。
  

• 1 表示头部未被masked，
  
• 0 表示头部被masked。
  

• position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。
  什么是位置 ID？
  
• past_key_values (Dict[str, np.ndarray], optional, 由init_cache返回或在传递先前的past_key_values时返回) — 预先计算的隐藏状态（注意力块中的键和值）的字典，可用于快速自回归解码。预先计算的键和值隐藏状态的形状为*[batch_size, max_length]*。
  
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回 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 (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
  
• hidden_states (tuple(jnp.ndarray), 可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray 元组（一个用于嵌入的输出 + 一个用于每个层的输出）。
  模型在每个层的输出处的隐藏状态加上初始嵌入输出。
  
• attentions (tuple(jnp.ndarray), 可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 jnp.ndarray 元组（每个层一个）。
  在自注意力头中用于计算加权平均值的注意力权重之后的注意力 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_state

Transformers 4.37 中文文档（四十）（2）https://developer.aliyun.com/article/1564992