Transformers 文档
Phi
并获取增强的文档体验
开始使用
Phi
概述
Phi-1 模型在 Textbooks Are All You Need 中被提出，作者是 Suriya Gunasekar, Yi Zhang, Jyoti Aneja, Caio César Teodoro Mendes, Allie Del Giorno, Sivakanth Gopi, Mojan Javaheripi, Piero Kauffmann, Gustavo de Rosa, Olli Saarikivi, Adil Salim, Shital Shah, Harkirat Singh Behl, Xin Wang, Sébastien Bubeck, Ronen Eldan, Adam Tauman Kalai, Yin Tat Lee 和 Yuanzhi Li。
Phi-1.5 模型在 Textbooks Are All You Need II: phi-1.5 technical report 中被提出，作者是 Yuanzhi Li, Sébastien Bubeck, Ronen Eldan, Allie Del Giorno, Suriya Gunasekar 和 Yin Tat Lee。
总结
在 Phi-1 和 Phi-1.5 论文中，作者展示了相对于模型大小，数据质量在训练中的重要性。他们选择了高质量的“教科书”数据以及合成生成的数据来训练他们基于 Transformer 的小型模型 Phi-1，该模型具有 13 亿个参数。尽管规模很小，phi-1 在 HumanEval 上达到了 50.6% 的 pass@1 准确率，在 MBPP 上达到了 55.5%。他们对 Phi-1.5 采用了相同的策略，并创建了另一个 13 亿参数模型，该模型在自然语言任务上的性能与大 5 倍的模型相当，并且超过了大多数非前沿 LLM。Phi-1.5 表现出许多大型 LLM 的特征，例如“逐步思考”或执行一些基本的上下文学习的能力。通过这两个实验，作者成功地展示了在训练机器学习模型时训练数据质量的巨大影响。
Phi-1 论文的摘要如下
我们介绍了 phi-1，一种用于代码的新型大型语言模型，其尺寸明显小于竞争模型：phi-1 是一个基于 Transformer 的模型，具有 13 亿个参数，在 8 个 A100 上训练了 4 天，使用了从网络上选择的“教科书质量”数据（60 亿个 tokens）以及使用 GPT-3.5 合成生成的教科书和练习（10 亿个 tokens）。尽管规模很小，phi-1 在 HumanEval 上达到了 50.6% 的 pass@1 准确率，在 MBPP 上达到了 55.5%。与 phi-1-base（我们在编码练习数据集上进行微调之前的模型）和 phi-1-small（一个使用与 phi-1 相同管道训练的较小模型，具有 3.5 亿个参数，但在 HumanEval 上仍然达到 45%）相比，它还显示出令人惊讶的新兴属性。
Phi-1.5 论文的摘要如下
我们继续深入研究更小型 Transformer 语言模型的潜力，这项研究始于 TinyStories——一个拥有 1000 万参数的模型，它可以生成连贯的英语——以及后续关于 phi-1 的工作，这是一个拥有 13 亿参数的模型，其 Python 编码性能接近最先进水平。 后者提出使用现有的大型语言模型 (LLM) 生成“教科书质量”的数据，作为一种增强学习过程的方式，与传统的网络数据相比。 我们遵循“教科书是你所需要的一切”的方法，这次专注于自然语言中的常识推理，并创建了一个新的 13 亿参数模型，名为 phi-1.5，它在自然语言任务上的性能与参数量是其 5 倍的模型相当，并且在更复杂的推理任务（如小学数学和基础编码）上超越了大多数非前沿 LLM。 更普遍地说，phi-1.5 展现出许多大型 LLM 的特征，既有好的方面——例如“逐步思考”的能力或执行一些基本的上下文学习——也有坏的方面，包括幻觉和产生有害和偏见内容的可能性——但令人鼓舞的是，由于没有使用网络数据，我们看到在这方面有所改进。 我们开源 phi-1.5，以促进对这些紧迫主题的进一步研究。
此模型由 Susnato Dhar 贡献。
Phi-1、Phi-1.5 和 Phi-2 的原始代码分别可以在这里、这里 和 这里 找到。
使用技巧
- 此模型与
Llama非常相似，主要区别在于PhiDecoderLayer，其中他们并行配置了PhiAttention和PhiMLP层。 - 此模型使用的分词器与 CodeGenTokenizer 完全相同。
如何使用 Phi-2
Phi-2 已集成到 transformers 的开发版本 (4.37.0.dev) 中。在通过 pip 发布正式版本之前，请确保您执行以下操作之一
加载模型时，请确保将
trust_remote_code=True作为from_pretrained()函数的参数传递。将您的本地
transformers更新到开发版本：pip uninstall -y transformers && pip install git+https://github.com/huggingface/transformers。 上述命令是克隆并从源代码安装的替代方法。
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/phi-2")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-2")
>>> inputs = tokenizer('Can you help me write a formal email to a potential business partner proposing a joint venture?', return_tensors="pt", return_attention_mask=False)
>>> outputs = model.generate(**inputs, max_length=30)
>>> text = tokenizer.batch_decode(outputs)[0]
>>> print(text)
Can you help me write a formal email to a potential business partner proposing a joint venture?
Input: Company A: ABC Inc.
Company B示例：
>>> from transformers import PhiForCausalLM, AutoTokenizer
>>> # define the model and tokenizer.
>>> model = PhiForCausalLM.from_pretrained("microsoft/phi-1_5")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-1_5")
>>> # feel free to change the prompt to your liking.
>>> prompt = "If I were an AI that had just achieved"
>>> # apply the tokenizer.
>>> tokens = tokenizer(prompt, return_tensors="pt")
>>> # use the model to generate new tokens.
>>> generated_output = model.generate(**tokens, use_cache=True, max_new_tokens=10)
>>> tokenizer.batch_decode(generated_output)[0]
'If I were an AI that had just achieved a breakthrough in machine learning, I would be thrilled'结合 Phi 和 Flash Attention 2
首先，请确保安装最新版本的 Flash Attention 2，以包含滑动窗口注意力机制功能。
pip install -U flash-attn --no-build-isolation
还要确保您的硬件与 Flash-Attention 2 兼容。 请阅读 flash-attn 仓库的官方文档以了解更多信息。 还要确保以半精度加载模型（例如 `torch.float16“）
要加载和运行使用 Flash Attention 2 的模型，请参考以下代码片段
>>> import torch
>>> from transformers import PhiForCausalLM, AutoTokenizer
>>> # define the model and tokenizer and push the model and tokens to the GPU.
>>> model = PhiForCausalLM.from_pretrained("microsoft/phi-1_5", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to("cuda")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-1_5")
>>> # feel free to change the prompt to your liking.
>>> prompt = "If I were an AI that had just achieved"
>>> # apply the tokenizer.
>>> tokens = tokenizer(prompt, return_tensors="pt").to("cuda")
>>> # use the model to generate new tokens.
>>> generated_output = model.generate(**tokens, use_cache=True, max_new_tokens=10)
>>> tokenizer.batch_decode(generated_output)[0]
'If I were an AI that had just achieved a breakthrough in machine learning, I would be thrilled'预期加速
下图是预期加速图，比较了使用 microsoft/phi-1 检查点在 transformers 中的原生实现与使用序列长度为 2048 的模型 Flash Attention 2 版本之间的纯推理时间。
PhiConfig
class transformers.PhiConfig
< source >( vocab_size = 51200 hidden_size = 2048 intermediate_size = 8192 num_hidden_layers = 24 num_attention_heads = 32 num_key_value_heads = None resid_pdrop = 0.0 embd_pdrop = 0.0 attention_dropout = 0.0 hidden_act = 'gelu_new' max_position_embeddings = 2048 initializer_range = 0.02 layer_norm_eps = 1e-05 use_cache = True tie_word_embeddings = False rope_theta = 10000.0 rope_scaling = None partial_rotary_factor = 0.5 qk_layernorm = False bos_token_id = 1 eos_token_id = 2 **kwargs )
参数
- vocab_size (
int, 可选，默认为 51200) — Phi 模型的词汇表大小。 定义了调用 PhiModel 时传递的inputs_ids可以表示的不同 token 的数量。 - hidden_size (
int, 可选，默认为 2048) — 隐藏层表示的维度。 - intermediate_size (
int, 可选，默认为 8192) — MLP 表示的维度。 - num_hidden_layers (
int, 可选，默认为 24) — Transformer 解码器中隐藏层的数量。 - num_attention_heads (
int, 可选，默认为 32) — Transformer 解码器中每个注意力层的注意力头数。 - num_key_value_heads (
int, 可选) — 这是应用于实现分组查询注意力机制 (Grouped Query Attention) 的 key_value 头部的数量。 如果num_key_value_heads=num_attention_heads，模型将使用多头注意力机制 (Multi Head Attention, MHA)；如果num_key_value_heads=1，模型将使用多查询注意力机制 (Multi Query Attention, MQA)；否则将使用 GQA。 当将多头检查点转换为 GQA 检查点时，每个组的 key 和 value 头部应通过平均池化该组内的所有原始头部来构建。 有关更多详细信息，请查看 这篇论文。 如果未指定，则默认为num_attention_heads。 - resid_pdrop (
float, 可选，默认为 0.0) — mlp 输出的 dropout 概率。 - embd_pdrop (
int, 可选，默认为 0.0) — 嵌入层的 dropout 比率。 - attention_dropout (
float, 可选，默认为 0.0) — 计算注意力分数后的 dropout 比率。 - hidden_act (
str或function, 可选，默认为"gelu_new") — 解码器中的非线性激活函数（函数或字符串）。 - max_position_embeddings (
int, 可选，默认为 2048) — 此模型可能使用的最大序列长度。 Phi-1 和 Phi-1.5 最多支持 2048 个 token。 - initializer_range (
float, 可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float, 可选，默认为 1e-05) — rms 归一化层使用的 epsilon 值。 - use_cache (
bool, 可选，默认为True) — 模型是否应返回最后的 key/values 注意力（并非所有模型都使用）。 仅在config.is_decoder=True时相关。 是否绑定权重嵌入。 - tie_word_embeddings (
bool, 可选，默认为False) — 是否绑定权重嵌入。 - rope_theta (
float, 可选，默认为 10000.0) — RoPE 嵌入的基period。 - 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 嵌入的缩放因子。 在大多数缩放类型中，x 的factor将使模型能够处理长度为 x * 原始最大预训练长度的序列。original_max_position_embeddings(int, 可选): 与 ‘dynamic’、‘longrope’ 和 ‘llama3’ 一起使用。 预训练期间使用的原始最大位置嵌入。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 高频分量的缩放因子 - partial_rotary_factor (
float, 可选，默认为 0.5) — 查询和键将具有 rotary embedding 的百分比。 - qk_layernorm (
bool, 可选，默认为False) — 是否在投影隐藏状态之后对 Queries 和 Keys 进行归一化。 - bos_token_id (
int, 可选, 默认为 1) — 表示序列开始的 token id。 - eos_token_id (
int, 可选, 默认为 2) — 表示序列结束的 token id。
这是用于存储 PhiModel 配置的配置类。 它用于根据指定的参数实例化 Phi 模型，定义模型架构。 使用默认值实例化配置将产生与 Phi microsoft/phi-1 相似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。 有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import PhiModel, PhiConfig
>>> # Initializing a Phi-1 style configuration
>>> configuration = PhiConfig.from_pretrained("microsoft/phi-1")
>>> # Initializing a model from the configuration
>>> model = PhiModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configPhiModel
class transformers.PhiModel
< source >( config: PhiConfig )
参数
- config (PhiConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法来加载模型权重。
- config — PhiConfig
裸 Phi 模型输出原始隐藏状态，顶部没有任何特定的 head。 此模型继承自 PreTrainedModel。 查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
Transformer 解码器，由 config.num_hidden_layers 层组成。 每层都是一个 PhiDecoderLayer
前向传播
< source >( input_ids: 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 return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] )
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。 如果您提供 padding，默认情况下 padding 将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 token 未被 mask，
- 0 表示 token 被 mask。
索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后一个input_ids（请参阅past_key_values）。如果您想更改 padding 行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需要进行修改。 有关默认策略的更多信息，请参阅 论文 中的图 1。- 1 表示 head 未被 mask，
- 0 表示 head 被 mask。
- 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)，而不是形状为(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 影响。 它用于在正确的位置更新缓存并推断完整序列长度。
PhiModel 前向传播方法，覆盖了 __call__ 特殊方法。
尽管前向传播的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
PhiForCausalLM
前向传播
< source >( input_ids: 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 cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.phi.modeling_phi.KwargsForCausalLM] ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。 如果您提供 padding，默认情况下 padding 将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 token 未被 mask，
- 0 表示 token 被 mask。
索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后一个input_ids（请参阅past_key_values）。如果您想更改 padding 行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需要进行修改。 有关默认策略的更多信息，请参阅 论文 中的图 1。- 1 表示 head 未被 mask，
- 0 表示 head 被 mask。
- 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（那些没有将其过去键值状态提供给此模型的）的形状为(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 而不是普通元组。 - 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]中的标记计算。 - logits_to_keep (
int或torch.Tensor, 可选) — 如果是int，则计算最后logits_to_keep个标记的 logits。如果为0，则计算所有input_ids的 logits（特殊情况）。生成只需要最后一个标记 logits，并且仅针对该标记计算它们可以节省内存，这对于长序列或大词汇量大小而言变得非常重要。如果是torch.Tensor，则必须是 1D，对应于要在序列长度维度中保留的索引。当使用打包张量格式（批量和序列长度的单个维度）时，这非常有用。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutputWithPast 或 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (PhiConfig) 和输入。
-
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时返回) —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 之后的注意力权重，用于计算自注意力头中的加权平均值。
PhiForCausalLM 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传播的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, PhiForCausalLM
>>> model = PhiForCausalLM.from_pretrained("meta-phi/Phi-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-phi/Phi-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."generate
< source >( inputs: typing.Optional[torch.Tensor] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None logits_processor: typing.Optional[transformers.generation.logits_process.LogitsProcessorList] = None stopping_criteria: typing.Optional[transformers.generation.stopping_criteria.StoppingCriteriaList] = None prefix_allowed_tokens_fn: typing.Optional[typing.Callable[[int, torch.Tensor], typing.List[int]]] = None synced_gpus: typing.Optional[bool] = None assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None streamer: typing.Optional[ForwardRef('BaseStreamer')] = None negative_prompt_ids: typing.Optional[torch.Tensor] = None negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None use_model_defaults: typing.Optional[bool] = None **kwargs ) → ModelOutput 或 torch.LongTensor
参数
- inputs (
torch.Tensor，形状取决于模态, 可选) — 用作生成的提示或用作模型编码器输入的序列。如果为None，则该方法使用bos_token_id和批量大小 1 初始化它。对于仅解码器模型，inputs应采用input_ids的格式。对于编码器-解码器模型，inputs 可以表示input_ids、input_values、input_features或pixel_values中的任何一个。 - generation_config (GenerationConfig, 可选) — 要用作生成调用的基本参数化的生成配置。传递给 generate 的与
generation_config属性匹配的**kwargs将覆盖它们。如果未提供generation_config，将使用默认值，默认值具有以下加载优先级：1) 来自generation_config.json模型文件（如果存在）；2) 来自模型配置。请注意，未指定的参数将继承 GenerationConfig 的默认值，应检查其文档以参数化生成。 - logits_processor (
LogitsProcessorList, 可选) — 自定义 logits 处理器，用于补充从参数和生成配置构建的默认 logits 处理器。如果传递的 logits 处理器已使用参数或生成配置创建，则会引发错误。此功能适用于高级用户。 - stopping_criteria (
StoppingCriteriaList, 可选) — 自定义停止条件，用于补充从参数和生成配置构建的默认停止条件。如果传递的停止条件已使用参数或生成配置创建，则会引发错误。如果您的停止条件取决于scores输入，请确保将return_dict_in_generate=True, output_scores=True传递给generate。此功能适用于高级用户。 - prefix_allowed_tokens_fn (
Callable[[int, torch.Tensor], List[int]], 可选) — 如果提供，此函数将波束搜索约束为每步仅允许的标记。如果未提供，则不应用约束。此函数接受 2 个参数：批次 IDbatch_id和input_ids。它必须返回一个列表，其中包含基于批次 IDbatch_id和先前生成的标记inputs_ids的下一个生成步骤的允许标记。此参数对于基于前缀的约束生成很有用，如 自回归实体检索 中所述。 - synced_gpus (
bool, 可选) — 是否继续运行 while 循环直到 max_length。除非被覆盖，否则如果将FullyShardedDataParallel或具有多个 GPU 的 DeepSpeed ZeRO Stage 3 用于避免在某个 GPU 在其他 GPU 之前完成生成时发生死锁，则此标志将设置为True。否则，默认为False。 - assistant_model (
PreTrainedModel, 可选) — 可用于加速生成的辅助模型。辅助模型必须具有完全相同的 tokenizer。当使用辅助模型预测候选标记比使用您从中调用 generate 的模型运行生成快得多时，就可以实现加速。因此，辅助模型应该小得多。 - streamer (
BaseStreamer, 可选) — 流对象，将用于流式传输生成的序列。生成的标记通过streamer.put(token_ids)传递，流对象负责任何进一步处理。 - negative_prompt_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 一些处理器（例如 CFG）所需的负面提示。批量大小必须与输入批量大小匹配。这是一个实验性功能，未来版本中可能会发生 API 更改。 - negative_prompt_attention_mask (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) —negative_prompt_ids的 Attention_mask。 - use_model_defaults (
bool, 可选) — 当为True时，generation_config中未设置的参数将设置为模型特定的默认生成配置 (model.generation_config)，而不是全局默认值 (GenerationConfig())。如果未设置，则从v4.50开始保存的模型将认为此标志为True。 - kwargs (
Dict[str, Any], 可选) —generation_config的特设参数化和/或将转发到模型的forward函数的其他模型特定 kwargs。如果模型是编码器-解码器模型，则编码器特定 kwargs 不应带有前缀，解码器特定 kwargs 应带有 decoder_ 前缀。
返回
ModelOutput 或 torch.LongTensor
ModelOutput（如果 return_dict_in_generate=True 或当 config.return_dict_in_generate=True 时）或 torch.LongTensor。
如果模型不是编码器-解码器模型 (model.config.is_encoder_decoder=False)，则可能的 ModelOutput 类型为
如果模型是编码器-解码器模型 (model.config.is_encoder_decoder=True)，则可能的 ModelOutput 类型为
为带有语言建模头的模型生成 token id 序列。
大多数生成控制参数都在 generation_config 中设置，如果未传递，则将设置为模型的默认生成配置。您可以通过将相应的参数传递给 generate() 来覆盖任何 generation_config，例如 .generate(inputs, num_beams=4, do_sample=True)。
有关生成策略和代码示例的概述，请查看以下指南。
PhiForSequenceClassification
class transformers.PhiForSequenceClassification
< source >( config )
参数
- config (PhiConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有序列分类头的 Phi 模型转换器（线性层）。
PhiForSequenceClassification 使用最后一个 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 文档以了解与常规用法和行为相关的所有事项。
前向传播
< 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，形状为(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（请参阅past_key_values）。如果您想更改填充行为，您应该阅读
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]中选择。 - 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（那些没有将其过去的键值状态提供给此模型的）形状为(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相反，此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。 - labels (
torch.LongTensor，形状为(batch_size,), 可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方误差损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。
PhiForSequenceClassification forward 方法，覆盖了 __call__ 特殊方法。
尽管前向传播的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
PhiForTokenClassification
class transformers.PhiForTokenClassification
< source >( config )
参数
- config (PhiConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有 token 分类头的 Phi 模型转换器（隐藏状态输出顶部的线性层），例如用于命名实体识别 (NER) 任务。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
前向传播
< 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 的索引。如果您提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示 token 未被掩盖，
- 0 表示 token 被掩盖。
索引可以使用 AutoTokenizer 获得。 参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详细信息。
如果使用了
past_key_values，则可以选择仅输入最后的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]中选择。 - 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(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，可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回张量下的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 时），包括各种元素，具体取决于配置 (PhiConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类损失。 -
logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（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 之后的注意力权重，用于计算自注意力头中的加权平均值。
PhiForTokenClassification 前向方法，覆盖了 __call__ 特殊方法。
尽管前向传播的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, PhiForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-1")
>>> model = PhiForTokenClassification.from_pretrained("microsoft/phi-1")
>>> 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