Transformers 文档

柿子

Transformers

加入 Hugging Face 社区

并获取增强的文档体验

协作处理模型、数据集和 Spaces

通过加速推理获得更快的示例

切换文档主题

开始使用

Persimmon

概述

Persimmon 模型由 ADEPT 创建，并由 Erich Elsen、Augustus Odena、Maxwell Nye、Sağnak Taşırlar、Tri Dao、Curtis Hawthorne、Deepak Moparthi、Arushi Somani 编写。

作者介绍了 Persimmon-8B，这是一个基于经典 transformers 架构的解码器模型，具有查询和键归一化。Persimmon-8B 是一个完全许可的模型，约有 80 亿个参数，根据 Apache 许可证发布。Persimmon-8B 的一些关键属性是长上下文大小 (16K)、性能以及多模态扩展能力。

作者展示了他们评估模型的方法，重点是实际的文本生成，镜像用户与语言模型交互的方式。这项工作还包括一项比较分析，在各种评估任务中，将 Persimmon-8B 与其他突出的模型（MPT 7B Instruct 和 Llama 2 Base 7B 1-Shot）进行比较。结果表明，即使在有限的训练数据下，Persimmon-8B 也具有竞争力的性能。

在模型细节方面，本文概述了 Persimmon-8B 的架构和训练方法，深入分析了其设计选择、序列长度和数据集构成。作者展示了一个快速推理代码，该代码通过运算符融合和 CUDA 图利用，在保持代码连贯性的同时，性能优于传统的实现方式。他们表达了对社区将如何利用这项贡献来推动创新的期待，并暗示了作为正在进行的一系列开发的一部分，未来将有更多版本发布。

此模型由 ArthurZ 贡献。原始代码可以在这里找到。

使用技巧

Persimmon 模型使用 bfloat16 训练，但原始推理使用 float16。Hub 上上传的检查点使用 torch_dtype = 'float16'，AutoModel API 将使用它将检查点从 torch.float32 转换为 torch.float16。

在线权重的 dtype 大多无关紧要，除非您在使用 model = AutoModelForCausalLM.from_pretrained("path", torch_dtype = "auto") 初始化模型时使用 torch_dtype="auto"。原因是模型将首先被下载（使用在线检查点的 dtype），然后它将被转换为 torch 的默认 dtype（变为 torch.float32）。用户应指定他们想要的 torch_dtype，如果他们不指定，则默认为 torch.float32。

不建议在 float16 中微调模型，已知会产生 nan，因此应在 bfloat16 中微调模型。

提示

要转换模型，您需要使用 git clone https://github.com/persimmon-ai-labs/adept-inference 克隆原始存储库，然后获取检查点

git clone https://github.com/persimmon-ai-labs/adept-inference
wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_base_model_release.tar
tar -xvf 8b_base_model_release.tar
python src/transformers/models/persimmon/convert_persimmon_weights_to_hf.py  --input_dir /path/to/downloaded/persimmon/weights/ --output_dir /output/path \
    --pt_model_path /path/to/8b_chat_model_release/iter_0001251/mp_rank_00/model_optim_rng.pt
    --ada_lib_path /path/to/adept-inference

对于聊天模型

wget https://axtkn4xl5cip.objectstorage.us-phoenix-1.oci.customer-oci.com/n/axtkn4xl5cip/b/adept-public-data/o/8b_chat_model_release.tar
tar -xvf 8b_base_model_release.tar

此后，可以通过以下方式加载模型

from transformers import PersimmonForCausalLM, PersimmonTokenizer

model = PersimmonForCausalLM.from_pretrained("/output/path")
tokenizer = PersimmonTokenizer.from_pretrained("/output/path")

Perismmon 使用基于 sentencepiece 的分词器，以及 Unigram 模型。它支持字节回退，这仅在快速分词器的 tokenizers==0.14.0 中可用。使用 LlamaTokenizer 是因为它是一个围绕 sentencepiece 的标准包装器。chat 模板将在后续 PR 中使用模板函数进行更新！
作者建议对聊天模式使用以下提示格式：f"human: {prompt}\n\nadept:"

PersimmonConfig

class transformers.PersimmonConfig

< source >

( vocab_size = 262144 hidden_size = 4096 intermediate_size = 16384 num_hidden_layers = 36 num_attention_heads = 64 hidden_act = 'relu2' max_position_embeddings = 16384 initializer_range = 0.02 layer_norm_eps = 1e-05 use_cache = True tie_word_embeddings = False rope_theta = 25000.0 rope_scaling = None qk_layernorm = True hidden_dropout = 0.0 attention_dropout = 0.0 partial_rotary_factor = 0.5 pad_token_id = None bos_token_id = 1 eos_token_id = 2 **kwargs )

参数

vocab_size (int, 可选, 默认为 262144) — Persimmon 模型的词汇表大小。定义了在调用 PersimmonModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
hidden_size (int, 可选, 默认为 4096) — 隐藏层表示的维度。
intermediate_size (int, 可选, 默认为 16384) — MLP 表示的维度。
num_hidden_layers (int, 可选, 默认为 36) — Transformer 编码器中隐藏层的数量。
num_attention_heads (int, 可选, 默认为 64) — Transformer 编码器中每个注意力层的注意力头数。
hidden_act (str 或 function, 可选, 默认为 "relu2") — 解码器中的非线性激活函数（函数或字符串）。
max_position_embeddings (int, 可选, 默认为 16384) — 此模型可能使用的最大序列长度。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, 可选, 默认为 1e-5) — rms 归一化层使用的 epsilon 值。
use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅当 config.is_decoder=True 时相关。
tie_word_embeddings(bool, 可选, 默认为 False) — 是否绑定权重 embedding。
rope_theta (float, 可选, 默认为 25000.0) — RoPE embedding 的基周期。
rope_scaling (Dict, 可选) — 包含 RoPE embedding 的缩放配置的字典。注意：如果您应用新的 rope 类型，并期望模型在更长的 max_position_embeddings 上工作，我们建议您相应地更新此值。预期内容：rope_type (str): 要使用的 RoPE 的子变体。可以是 [‘default’, ‘linear’, ‘dynamic’, ‘yarn’, ‘longrope’, ‘llama3’] 之一，其中 ‘default’ 是原始 RoPE 实现。factor (float, 可选): 用于除 ‘default’ 之外的所有 rope 类型。应用于 RoPE embedding 的缩放因子。在大多数缩放类型中，因子 x 将使模型能够处理长度为 x * 原始最大预训练长度的序列。original_max_position_embeddings (int, 可选): 与 ‘dynamic’, ‘longrope’ 和 ‘llama3’ 一起使用。预训练期间使用的原始最大位置 embedding。attention_factor (float, 可选): 与 ‘yarn’ 和 ‘longrope’ 一起使用。应用于注意力计算的缩放因子。如果未指定，则默认为实现建议的值，使用 factor 字段推断建议值。beta_fast (float, 可选): 仅与 ‘yarn’ 一起使用。用于设置线性 ramp 函数中外推（仅限）边界的参数。如果未指定，则默认为 32。beta_slow (float, 可选): 仅与 ‘yarn’ 一起使用。用于设置线性 ramp 函数中内插（仅限）边界的参数。如果未指定，则默认为 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 高频分量的缩放因子。
qk_layernorm (bool, 可选, 默认为 True) — 是否在投影隐藏状态后对 Queries 和 Keys 进行归一化。
hidden_dropout (float, 可选, 默认为 0.0) — 将 MLP 应用于隐藏状态后的 dropout 比率。
attention_dropout (float, 可选, 默认为 0.0) — 计算注意力分数后的 dropout 比率。
partial_rotary_factor (float, 可选, 默认为 0.5) — 将进行旋转 embedding 的 query 和 key 的百分比。
示例 —

这是用于存储 PersimmonModel 配置的配置类。它用于根据指定的参数实例化 Persimmon 模型，定义模型架构。使用默认值实例化配置将产生与 adept/persimmon-8b-base 相似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。

>>> from transformers import PersimmonModel, PersimmonConfig

>>> # Initializing a Persimmon persimmon-7b style configuration
>>> configuration = PersimmonConfig()

PersimmonModel

class transformers.PersimmonModel

< 源代码 >

( config: PersimmonConfig )

参数

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

裸 Persimmon 模型，输出原始隐藏状态，顶部没有任何特定的头部。此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

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

Transformer 解码器，由 config.num_hidden_layers 层组成。每一层都是一个 PersimmonDecoderLayer

forward

< 源代码 >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = 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 return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None )

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将忽略填充。

索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.Tensor，形状为 (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 (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [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 实例，请参阅我们的 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（那些没有将其过去的键值状态提供给此模型的输入 ID），形状为 (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 相反，此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整序列长度。

PersimmonModel 的 forward 方法，覆盖了 __call__ 特殊方法。

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

PersimmonForCausalLM

class transformers.PersimmonForCausalLM

< 源代码 >

( config )

forward

< 源代码 >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = 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 return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs ) → transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果提供 padding，默认情况下将被忽略。

索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 IDs？
attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在 padding token 索引上执行 attention 的掩码。 Mask 值在 [0, 1] 中选择：
- 1 表示 token 未被掩码，
- 0 表示 token 被掩码。
什么是 attention 掩码？

索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids （参见 past_key_values）。

如果要更改 padding 行为，您应该阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。
- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围 [0, config.n_positions - 1] 中选择。

什么是位置 IDs？
past_key_values (Cache or tuple(tuple(torch.FloatTensor)), optional) — 预先计算的隐藏状态（self-attention 块和 cross-attention 块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

允许两种格式：
- Cache 实例，请参阅我们的 kv 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 (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
use_cache (bool, optional) — 如果设置为 True，则返回 past_key_values 键值状态，并且可以用于加速解码（参见 past_key_values）。
output_attentions (bool, optional) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
cache_position (torch.LongTensor of shape (sequence_length), optional) — 描述输入序列 tokens 在序列中位置的索引。与 position_ids 相反，此张量不受 padding 的影响。它用于在正确的位置更新缓存并推断完整的序列长度。
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算 masked language modeling 损失的标签。索引应为 [0, ..., config.vocab_size] 或 -100 （请参阅 input_ids 文档字符串）。索引设置为 -100 的 tokens 将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的 tokens 计算。
logits_to_keep (int or torch.Tensor, optional) — 如果为 int，则计算最后 logits_to_keep 个 tokens 的 logits。如果为 0，则计算所有 input_ids 的 logits（特殊情况）。生成只需要最后一个 token logits，并且仅针对该 token 计算它们可以节省内存，这对于长序列或大词汇量来说变得非常重要。如果为 torch.Tensor，则必须是与序列长度维度中要保留的索引相对应的 1D 张量。这在使用打包张量格式（批次和序列长度的单维度）时很有用。

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

transformers.modeling_outputs.CausalLMOutputWithPast 或 torch.FloatTensor 的元组 (如果传递 return_dict=False 或当 config.return_dict=False 时) ，包含各种元素，具体取决于配置 (PersimmonConfig) 和输入。

loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 语言建模损失（用于下一个 token 预测）。
logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模 head 的预测分数（SoftMax 之前每个词汇表 token 的分数）。
past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组都有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量）。

包含预先计算的隐藏状态（self-attention 块中的键和值），可以用于（参见 past_key_values 输入）加速顺序解码。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型具有嵌入层，则为嵌入的输出，+ 每层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每层输出的隐藏状态，以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

attention softmax 之后的 Attention 权重，用于计算 self-attention head 中的加权平均值。

PersimmonForCausalLM forward 方法，覆盖了 __call__ 特殊方法。

示例

>>> from transformers import AutoTokenizer, PersimmonForCausalLM

>>> model = PersimmonForCausalLM.from_pretrained("adept/persimmon-8b-base")
>>> tokenizer = AutoTokenizer.from_pretrained("adept/persimmon-8b-base")

>>> prompt = "human: Hey, what should I eat for dinner?"
>>> 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]
'human: Hey, what should I eat for dinner?\n\ncat: 🐱\n\nhuman: 😐\n\n'

PersimmonForSequenceClassification

class transformers.PersimmonForSequenceClassification

< source >

( config )

参数

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

带有序列分类 head (线性层) 的 Persimmon transformer。

PersimmonForSequenceClassification 使用最后一个 token 来进行分类，就像其他因果模型 (例如 GPT-2) 一样。

由于它对最后一个 token 进行分类，因此需要知道最后一个 token 的位置。如果在配置中定义了 pad_token_id，它会在每行中找到最后一个不是 padding token 的 token。如果未定义 pad_token_id，它只会获取批次中每行的最后一个值。由于当传递 inputs_embeds 而不是 input_ids 时，它无法猜测 padding tokens，因此它会执行相同的操作 (获取批次中每行的最后一个值)。

此模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法 (例如下载或保存、调整输入嵌入大小、剪枝 head 等)。

此模型也是 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.Union[transformers.cache_utils.Cache, typing.List[torch.FloatTensor], NoneType] = 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 return_dict: typing.Optional[bool] = None )

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果提供 padding，默认情况下将被忽略。

索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 IDs？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。
什么是 attention mask？

索引可以使用 AutoTokenizer 获得。请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详细信息。

如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids（请参阅 past_key_values）。

如果您想更改 padding 行为，您应该阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。有关默认策略的更多信息，请参见论文中的图 1。
- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [0, config.n_positions - 1] 中选择。

什么是 position IDs？
past_key_values (Cache 或 tuple(tuple(torch.FloatTensor))，可选) — 预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

允许两种格式：
- Cache 实例，请参阅我们的 kv cache 指南；
- 长度为 config.n_layers 的 tuple(tuple(torch.FloatTensor)) 元组，每个元组具有 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)，而不是所有形状为 (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，可选) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息，请参见返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
cache_position (torch.LongTensor，形状为 (sequence_length)，可选) — 索引，描述输入序列 token 在序列中的位置。与 position_ids 相反，此张量不受 padding 的影响。它用于在正确的位置更新缓存并推断完整序列长度。
labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1，则计算回归损失（均方损失）。如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。

PersimmonForSequenceClassification forward 方法，覆盖了 __call__ 特殊方法。

PersimmonForTokenClassification

class transformers.PersimmonForTokenClassification

< source >

( config )

参数

config (PersimmonConfig) — 模型配置类，其中包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，而只会加载配置。查看 from_pretrained() 方法以加载模型权重。

Persimmon 模型 Transformer，顶部带有一个 token 分类头（隐藏状态输出顶部的线性层），例如用于命名实体识别 (NER) 任务。

此模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法 (例如下载或保存、调整输入嵌入大小、剪枝 head 等)。

此模型也是 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[typing.List[torch.FloatTensor]] = 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 return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。默认情况下，如果您提供 padding，则会忽略 padding。

索引可以使用 AutoTokenizer 获得。请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详细信息。

什么是 input IDs？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。
什么是 attention mask？

索引可以使用 AutoTokenizer 获得。请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详细信息。

如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids（请参阅 past_key_values）。

如果您想更改 padding 行为，您应该阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。有关默认策略的更多信息，请参见论文中的图 1。
- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [0, config.n_positions - 1] 中选择。

什么是 position IDs？
past_key_values (Cache 或 tuple(tuple(torch.FloatTensor))，可选) — 预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

允许两种格式：
- Cache 实例，请参阅我们的 kv cache 指南；
- 长度为 config.n_layers 的 tuple(tuple(torch.FloatTensor)) 元组，每个元组具有 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)，而不是所有形状为 (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), 可选) — 索引，描述输入序列 token 在序列中的位置。与 position_ids 相反，此张量不受 padding 的影响。它用于在正确的位置更新缓存，并推断完整的序列长度。
labels (torch.LongTensor，形状为 (batch_size,), 可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1，则计算回归损失（均方误差损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。

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

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (PersimmonConfig) 和输入。

loss (torch.FloatTensor，形状为 (1,), 可选, 当提供 labels 时返回) — 分类损失。
logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.num_labels)) — 分类得分（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型具有嵌入层，则为嵌入的输出，+ 每层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每层输出的隐藏状态，以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

attention softmax 之后的 Attention 权重，用于计算 self-attention head 中的加权平均值。

PersimmonForTokenClassification 的前向传播方法，覆盖了 __call__ 特殊方法。

示例

>>> from transformers import AutoTokenizer, PersimmonForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("adept/persimmon-8b-base")
>>> model = PersimmonForTokenClassification.from_pretrained("adept/persimmon-8b-base")

>>> 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]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

< > 在 GitHub 上更新

←PEGASUS-X Phi→