Transformers 4.37 中文文档（五十一）（2）

Transformers 4.37 中文文档（五十一）（1）https://developer.aliyun.com/article/1565775

Persimmon

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/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大多数情况下并不重要，除非您在使用torch_dtype="auto"初始化模型时使用model = AutoModelForCausalLM.from_pretrained("path", 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模型。它支持 bytefallback，仅在快速分词器的tokenizers==0.14.0中可用。LlamaTokenizer被用作它是一个围绕 sentencepiece 的标准包装器。chat模板将在后续 PR 中使用模板函数进行更新！
  
• 作者建议为聊天模式使用以下提示格式：f"human: {prompt}\n\nadept:"
  

PersimmonConfig

class transformers.PersimmonConfig

<来源>

( 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 时可以表示的不同标记的数量。
  
• hidden_size (int, optional, defaults to 4096) — 隐藏表示的维度。
  
• intermediate_size (int, optional, defaults to 16384) — MLP 表示的维度。
  
• num_hidden_layers (int, optional, defaults to 36) — Transformer 编码器中的隐藏层数。
  
• num_attention_heads (int, optional, defaults to 64) — Transformer 编码器中每个注意力层的注意力头数。
  
• hidden_act (str or function, optional, defaults to "relu2") — 解码器中的非线性激活函数（函数或字符串）。
  
• max_position_embeddings (int, optional, defaults to 16384) — 该模型可能使用的最大序列长度。
  
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• layer_norm_eps (float, optional, defaults to 1e-5) — rms 归一化层使用的 epsilon。
  
• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（不是所有模型都使用）。仅在config.is_decoder=True时相关。
  
• tie_word_embeddings(bool, optional, defaults to False) — 是否绑定权重嵌入
  
• rope_theta (float, optional, defaults to 25000.0) — RoPE 嵌入的基本周期。
  
• rope_scaling (Dict, optional) — 包含 RoPE 嵌入缩放配置的字典。当前支持两种缩放策略：线性和动态。它们的缩放因子必须是大于 1 的浮点数。期望的格式是{"type": 策略名称, "factor": 缩放因子}。使用此标志时，不要将max_position_embeddings更新为预期的新最大值。有关这些缩放策略行为的更多信息，请参阅以下主题：www.reddit.com/r/LocalPersimmon/comments/14mrgpr/dynamically_scaled_rope_further_increases/。这是一个实验性功能，可能在未来版本中发生破坏性 API 更改。
  
• qk_layernorm (bool, optional, default to True) — 在投影隐藏状态后是否对查询和键进行归一化
  
• hidden_dropout (float, optional, default to 0.0) — 在将 MLP 应用于隐藏状态后的 dropout 比率。
  
• attention_dropout (float, optional, default to 0.0) — 计算注意力分数后的 dropout 比率。
  
• partial_rotary_factor (float, optional, default to 0.5) — 查询和键中将具有旋转嵌入的百分比。
  示例 —
  

这是用于存储 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

< source >

( config: PersimmonConfig )

参数

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

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

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

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

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 (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (torch.Tensor of shape (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 of shape (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 实例；
  
• 长度为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 而不是普通元组。
  

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

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

PersimmonForCausalLM

class transformers.PersimmonForCausalLM

<来源>

( 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]中选择：

• 对于“未掩码”的标记为 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 实例；
  
• 长度为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 而不是普通元组。
  参数 — 标签（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时）包括根据配置（PersimmonConfig）和输入的各种元素。

• loss（torch.FloatTensor，形状为(1,)，可选，当提供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的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。
  包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码。
  
• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

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

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

示例：

>>> 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()方法以加载模型权重。

带有顶部序列分类头（线性层）的 Persimmon 变换器。

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

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

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

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

forward

< source >

( 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 (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[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 of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。
  什么是位置 ID？
  
• past_key_values (Cache or tuple(tuple(torch.FloatTensor)), optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的先前阶段返回的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 (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) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  
• labels (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。
  

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

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

Phi

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

概述

Phi-1 模型是由 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 在Textbooks Are All You Need中提出的。

Phi-1.5 模型是由 Yuanzhi Li、Sébastien Bubeck、Ronen Eldan、Allie Del Giorno、Suriya Gunasekar 和 Yin Tat Lee 在Textbooks Are All You Need II: phi-1.5 technical report中提出的。

摘要

在 Phi-1 和 Phi-1.5  论文中，作者展示了数据质量对训练相对于模型大小的重要性。他们选择了高质量的“教科书”数据以及合成生成的数据，用于训练其具有 13 亿参数的小型  Transformer 模型 Phi-1。尽管规模较小，phi-1 在 HumanEval 上的 pass@1 准确率为 50.6%，在  MBPP 上为 55.5%。他们对 Phi-1.5 采用相同策略，并创建了另一个具有 13 亿参数的模型，其在自然语言任务上的性能与大 5  倍的模型相当，并超过了大多数非前沿 LLMs。Phi-1.5 表现出许多更大 LLMs  的特征，比如能够“逐步思考”或进行一些基本的上下文学习。通过这两个实验，作者成功地展示了在训练机器学习模型时训练数据质量的巨大影响。

Phi-1 论文的摘要如下：

我们介绍 phi-1，一个用于代码的新型大型语言模型，比竞争模型规模明显更小：phi-1 是一个基于 Transformer  的模型，具有 13 亿参数，在 8 个 A100 上训练了 4 天，使用了来自网络的“教科书质量”数据（60 亿标记）和使用  GPT-3.5（10 亿标记）合成生成的教科书和练习。尽管规模较小，phi-1 在 HumanEval 上的 pass@1 准确率为  50.6%，在 MBPP 上为 55.5%。与 phi-1-base 相比，我们在编码练习数据集上微调之前的模型，以及  phi-1-small，一个具有 350M 参数的较小模型，使用与 phi-1 相同的流程训练，仍然在 HumanEval 上达到 45%。

Phi-1.5 论文的摘要如下：

我们继续研究基于较小 Transformer 的语言模型的能力，这是由 TinyStories 发起的——一个可以生成连贯英语的 1  千万参数模型，以及关于 phi-1 的后续工作，这是一个 13 亿参数模型，其 Python  编码性能接近最先进水平。后者提出使用现有的大型语言模型（LLMs）生成“教科书质量”数据，以增强学习过程，相比传统网络数据。我们遵循“Textbooks  Are All You Need”的方法，这次专注于自然语言中的常识推理，并创建一个新的 13 亿参数模型，命名为  phi-1.5，其在自然语言任务上的性能与大 5 倍的模型相当，并且在更复杂的推理任务（如小学数学和基本编码）上超过了大多数非前沿  LLMs。总的来说，phi-1.5 表现出许多更大 LLMs  的特征，包括好的——比如能够“逐步思考”或进行一些基本的上下文学习——以及坏的，包括幻觉和产生有毒和偏见的可能性——令人鼓舞的是，由于缺乏网络数据，我们在这方面看到了改善。我们开源  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("phi-2")
>>> tokenizer = AutoTokenizer.from_pretrained("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?\nInput: Company A: ABC Inc.\nCompany B: XYZ Ltd.\nJoint Venture: A new online platform for e-commerce'

示例：

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

预期加速

下面是一个预期的加速图表，比较了在使用序列长度为 2048 时，transformers 中使用microsoft/phi-1检查点的原生实现和模型的 Flash Attention 2 版本之间的纯推理时间。

Transformers 4.37 中文文档（五十一）（3）https://developer.aliyun.com/article/1565777