LLaMA
概述
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: 开放且高效的基础语言模型 中提出。它是一个基础语言模型的集合，参数范围从 7B 到 65B。
论文摘要如下：
我们介绍了 LLaMA，一个基础语言模型的集合，参数范围从 7B 到 65B。我们用数万亿个 token 训练我们的模型，并表明可以仅使用公开可用的数据集来训练最先进的模型，而无需依赖专有且不可访问的数据集。特别是，LLaMA-13B 在大多数基准测试中优于 GPT-3 (175B)，LLaMA-65B 则与最佳模型 Chinchilla-70B 和 PaLM-540B 相当。我们向研究界发布了所有模型。
此模型由 zphang 贡献，并得到 BlackSamorez 的贡献。Hugging Face 中的实现代码基于 GPT-NeoX，可以在 这里 找到。作者的原始代码可以在 这里 找到。
使用技巧
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 内存来以 float16 精度托管整个模型（即使最大的版本分为多个检查点，它们都包含模型每个权重的一部分，因此我们需要将它们全部加载到内存中）。因此，对于 65B 模型，需要 130GB 内存。
- LLaMA 分词器是基于 sentencepiece 的 BPE 模型。sentencepiece 的一个怪癖是，当解码序列时，如果第一个 token 是单词的开头（例如，“Banana”），分词器不会在字符串前面添加前缀空格。
此模型由 zphang 贡献，并得到 BlackSamorez 的贡献。Hugging Face 中的实现代码基于 GPT-NeoX，可以在 这里 找到。作者的原始代码可以在 这里 找到。Flax 版本的实现由 afmck 贡献，实现代码基于 Hugging Face 的 Flax GPT-Neo。
基于原始 LLaMA 模型，Meta AI 发布了一些后续作品
- Llama2: Llama2 是 Llama 的改进版本，进行了一些架构调整（分组查询注意力），并在 2 万亿个 token 上进行预训练。请参考 Llama2 文档，可以在 这里 找到。
资源
以下列出了官方 Hugging Face 和社区（由 🌎 指示）资源，可帮助您开始使用 LLaMA。如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将对其进行审核！理想情况下，资源应展示一些新内容，而不是重复现有资源。
- 一个有关如何使用提示调整来调整 LLaMA 模型以进行文本分类任务的 笔记本。🌎
- StackLLaMA: 使用 RLHF 训练 LLaMA 的实践指南，一篇关于如何训练 LLaMA 使用 RLHF 在 Stack Exchange 上回答问题的博文。
⚗️ 优化
- 一个有关如何在内存有限的 GPU 上使用 xturing 库微调 LLaMA 模型的 笔记本。🌎
⚡️ 推理
🚀 部署
- 一个有关如何使用 🤗 PEFT 库通过直观的 UI 使用 LoRA 方法微调 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 mlp_bias = False head_dim = None **kwargs )
参数
- vocab_size (
int, 可选, 默认值为 32000) — LLaMA 模型的词汇量大小。定义了调用 LlamaModel 时传递的inputs_ids可以表示的不同词元的数量。 - 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, 可选) — 这是用于实现分组查询注意力的键值头数量。如果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 个词元，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) — 注意力概率的丢弃率。 - mlp_bias (
bool, 可选, 默认为False) — 是否在 MLP 层中的 up_proj、down_proj 和 gate_proj 层使用偏差。 - head_dim (
int, 可选) — 注意力头维度。 如果为 None，则默认为 hidden_size // num_heads
这是一个配置类，用于存储 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.configLlamaTokenizer
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 add_prefix_space = True **kwargs )
参数
- vocab_file (
str) — 词汇表文件路径。 - unk_token (
strortokenizers.AddedToken, 可选, 默认为"<unk>") — 未知标记。 不在词汇表中的标记无法转换为 ID，而是设置为该标记。 - bos_token (
strortokenizers.AddedToken, 可选, 默认为"<s>") — 预训练期间使用的序列起始标记。 可以用作序列分类标记。 - eos_token (
str或tokenizers.AddedToken, 可选, 默认为"</s>") — 序列结束标记。 - pad_token (
str或tokenizers.AddedToken, 可选) — 用于使标记数组大小相同以便进行批处理的特殊标记。 然后将被注意力机制或损失计算忽略。 - sp_model_kwargs (
Dict[str, Any],可选, 可选) — 将传递给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 的合并操作的丢弃概率。
-
- 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 标记器。 基于字节级字节对编码。 默认填充标记未设置，因为原始模型中没有填充标记。
get_special_tokens_mask
< source >( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → List[int]
从没有添加特殊令牌的令牌列表中检索序列 ID。当使用分词器 prepare_for_model 方法添加特殊令牌时，会调用此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
从传递的两个序列中创建掩码，用于序列对分类任务。ALBERT
如果 token_ids_1 为 None，则仅返回掩码的第一部分 (0)。
save_vocabulary
< source >( save_directory filename_prefix: Optional = None ) → 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 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。 - 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: Optional = None already_has_special_tokens: bool = False ) → 一个范围在 [0, 1] 内的整数列表
从没有添加特殊标记的标记列表中检索序列 ID。当使用标记器 prepare_for_model 或 encode_plus 方法添加特殊标记时，会调用此方法。
create_token_type_ids_from_sequences
< 源代码 >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
创建对应于传递序列的标记类型 ID。 什么是标记类型 ID？
如果模型有特殊构建方式，则应在子类中覆盖。
使用当前的 bos_token 和 eos_token 更新底层的后期处理程序。
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: Union = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None cache_position: Optional = None )
参数
- 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 表示掩码的标记。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后一个input_ids（请参阅past_key_values）。如果您想更改填充行为，则应阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参阅 论文 中的图表 1。- 1 表示头部未掩码，
- 0 表示头部掩码。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.n_positions - 1]范围内选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor)), 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包含在模型在解码的先前阶段返回的past_key_values中，当use_cache=True或config.use_cache=True时。允许两种格式：
- 一个 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索引转换为关联向量，这将非常有用。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - cache_position (
torch.LongTensor形状为(sequence_length), 可选) — 表示输入序列标记在序列中的位置的索引。与position_ids相反，此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。
The LlamaModel forward method, overrides the __call__ special method.
虽然前向传播的配方需要在此函数内定义，但应在之后调用Module实例，而不是此函数，因为前者负责运行前处理和后处理步骤，而后者则默默地忽略它们。
LlamaForCausalLM
forward
< source >( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Union = 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 cache_position: Optional = None num_logits_to_keep: int = 0 ) → transformers.modeling_outputs.CausalLMOutputWithPast or 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 用于掩码的标记。
索引可以使用 AutoTokenizer 获取。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 。
如果使用
past_key_values，则可选地只需要输入最后一个input_ids（参见past_key_values）。如果您想更改填充行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图表 1。- 1 表示头未掩码，
- 0 表示头掩码。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.n_positions - 1]范围内选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor)), 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。 这通常包括模型在解码的先前阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：
- 一个 Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为
config.n_layers的tuple(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 (形状为
(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 而不是一个普通元组。 - cache_position (形状为
(sequence_length)的torch.LongTensor, 可选) — 指示输入序列标记在序列中的位置的索引。 与position_ids不同，此张量不受填充的影响。 它用于在正确的位置更新缓存并推断完整的序列长度。参数 — labels (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选): 用于计算掩码语言建模损失的标签。 索引应在[0, ..., config.vocab_size]或 -100 中（请参阅input_ids文档字符串）。 索引设置为-100的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的标记进行计算。num_logits_to_keep (
int, 可选): 计算最后num_logits_to_keep个标记的 logits。 如果为0，则计算所有input_ids的 logits（特殊情况）。 生成只需要最后一个标记的 logits，并且仅为该标记计算它们可以节省内存，这对于长序列或大型词汇量来说非常重要。
返回
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(tuple(torch.FloatTensor))，每个元组具有两个形状为(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时返回) —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 之后的注意力权重，用于计算自注意力头中的加权平均值。
The LlamaForCausalLM forward method, overrides the __call__ special method.
虽然前向传播的配方需要在此函数内定义，但应在之后调用Module实例，而不是此函数，因为前者负责运行前处理和后处理步骤，而后者则默默地忽略它们。
Example
>>> 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 使用最后一个 token 进行分类，就像其他因果模型（例如 GPT-2）一样。
由于它对最后一个 token 进行分类，因此需要知道最后一个 token 的位置。如果配置中定义了 pad_token_id，它会在每行找到不是填充 token 的最后一个 token。如果未定义 pad_token_id，它只会获取批次中每行中的最后一个值。由于它无法在传递 inputs_embeds 而不是 input_ids 时猜测填充 token，因此它会执行相同的操作（获取批次中每行中的最后一个值）。
此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与一般使用和行为有关的所有事项。
forward
< 源代码 >( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Union = 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 (
torch.LongTensor形状为(batch_size, sequence_length)) — 输入序列 token 在词汇表中的索引。如果提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length)，可选) — 掩码，用于避免对填充 token 索引执行注意力。掩码值在[0, 1]中选择：- 1 表示未掩码的 token，
- 0 表示掩码的 token。
索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，可以选择性地仅输入最后一个input_ids（那些没有为该模型提供过去键值状态的input_ids），形状为(batch_size, 1)，而不是所有input_ids，形状为(batch_size, sequence_length)。如果要更改填充行为，应阅读
modeling_opt._prepare_decoder_attention_mask并修改为您的需求。有关默认策略的更多信息，请参阅 论文 中的图 1。- 1 表示头未掩码，
- 0 表示头掩码。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 输入序列 token 在位置嵌入中的位置索引。在[0, config.n_positions - 1]范围内选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor))，可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码先前阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：
- 一个 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)，而不是所有input_ids，形状为(batch_size, sequence_length)。 - 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。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 - cache_position (
torch.LongTensor形状为(sequence_length)，可选) — 表示输入序列令牌在序列中的位置的索引。与position_ids不同，该张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。 - labels (
torch.LongTensor形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。
The LlamaForSequenceClassification forward method, overrides the __call__ special method.
虽然前向传播的配方需要在此函数内定义，但应在之后调用Module实例，而不是此函数，因为前者负责运行前处理和后处理步骤，而后者则默默地忽略它们。
LlamaForQuestionAnswering
class transformers.LlamaForQuestionAnswering
< source >( config )
参数
- config (LlamaConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
Llama 模型转换器，顶部带有跨度分类头，用于提取式问答任务，如 SQuAD（在隐藏状态输出之上有一个线性层，用于计算 span start logits 和 span end logits）。
此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与一般使用和行为有关的所有事项。
该 LlamaForQuestionAnswering 正向方法重写了 __call__ 特殊方法。
虽然前向传播的配方需要在此函数内定义，但应在之后调用Module实例，而不是此函数，因为前者负责运行前处理和后处理步骤，而后者则默默地忽略它们。
LlamaForTokenClassification
class transformers.LlamaForTokenClassification
< 源代码 >( config )
参数
- config (LlamaConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。
具有令牌分类头的 Llama 模型转换器（在隐藏状态输出之上有一个线性层），例如用于命名实体识别 (NER) 任务。
此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参考 PyTorch 文档了解与一般使用和行为有关的所有事项。
forward
< 源代码 >( input_ids: Optional = 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 (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length)，可选) — 掩码，避免对填充标记索引执行注意力。掩码值在[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 (
torch.LongTensor形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.n_positions - 1]范围内选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor))，可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加快顺序解码速度。这通常包括模型在解码的先前阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：
- 一个 Cache 实例，请参阅我们的 kv 缓存指南；
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（其 past key value 状态未提供给此模型）的形状为(batch_size, 1)，而不是所有input_ids的形状为(batch_size, sequence_length)。 - 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。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个简单的元组。 - cache_position (
torch.LongTensor形状为(sequence_length)，可选) — 表示输入序列token在序列中的位置的索引。与position_ids相反，该张量不受填充的影响。它用于在正确的位置更新缓存，并推断完整的序列长度。 - labels (
torch.LongTensor形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。
The LlamaForTokenClassification forward method, overrides the __call__ special method.
虽然前向传播的配方需要在此函数内定义，但应在之后调用Module实例，而不是此函数，因为前者负责运行前处理和后处理步骤，而后者则默默地忽略它们。
FlaxLlamaModel
class transformers.FlaxLlamaModel
< source >( 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。
The bare Llama Model transformer outputting raw hidden-states without any specific head on top.
This model inherits from FlaxPreTrainedModel. Check the superclass documentation for the generic methods the library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads etc.)
This model is also a Flax Linen flax.nn.Module subclass. Use it as a regular Flax Module and refer to the Flax documentation for all matter related to general usage and behavior.
Finally, this model supports inherent JAX features such as
__call__
< source >( 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 ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput or 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, sequence_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 (
jnp.ndarray形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
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"。
Example
>>> 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。
This model inherits from FlaxPreTrainedModel. Check the superclass documentation for the generic methods the library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads etc.)
This model is also a Flax Linen flax.nn.Module subclass. Use it as a regular Flax Module and refer to the Flax documentation for all matter related to general usage and behavior.
Finally, this model supports inherent JAX features such as
__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 ) → 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, sequence_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 (
jnp.ndarray形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表标记的分数）。 -
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"。
Example
>>> 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]