Transformers 4.37 中文文档（二十七）（2）-阿里云开发者社区

Transformers 4.37 中文文档（二十七）（1）https://developer.aliyun.com/article/1563730

CanineForQuestionAnswering

`class transformers.CanineForQuestionAnswering`

( config )

参数

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

CANINE 模型在顶部具有一个用于提取问答任务的跨度分类头，例如 SQuAD（在隐藏状态输出的顶部使用线性层来计算span start logits和span end logits）。

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

`forward`

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput 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.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：

1 表示未被masked的标记，
0 表示被masked的标记。

什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：

0 对应于句子 A的标记，
1 对应于句子 B的标记。

什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：

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

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回的张量下的attentions。
output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。
start_positions（形状为(batch_size,)的torch.LongTensor，可选） — 用于计算标记跨度的起始位置（索引）的标签。位置被夹在序列的长度（sequence_length）上。序列外的位置不会被考虑在内计算损失。
end_positions（形状为(batch_size,)的torch.LongTensor，可选） — 用于计算标记跨度的结束位置（索引）的标签。位置被夹在序列的长度（sequence_length）上。序列外的位置不会被考虑在内计算损失。

transformers.modeling_outputs.QuestionAnsweringModelOutput 或torch.FloatTensor元组

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（CanineConfig）和输入。

loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回） — 总跨度提取损失是起始位置和结束位置的交叉熵之和。
start_logits（形状为(batch_size, sequence_length)的torch.FloatTensor） — 跨度起始分数（SoftMax 之前）。
end_logits（形状为(batch_size, sequence_length)的torch.FloatTensor） — 跨度结束分数（SoftMax 之前）。
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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, CanineForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("Splend1dchan/canine-c-squad")
>>> model = CanineForQuestionAnswering.from_pretrained("Splend1dchan/canine-c-squad")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
'nice puppet'
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
8.81

CodeGen

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

概述

CodeGen 模型在Erik Nijkamp、Bo Pang、Hiroaki Hayashi、Lifu Tu、Huan Wang、Yingbo Zhou、Silvio Savarese 和 Caiming Xiong 的《程序合成的对话范式》中提出。

CodeGen 是一个自回归语言模型，用于在The Pile、BigQuery 和 BigPython 上顺序训练程序合成。

论文摘要如下：

程序合成旨在生成计算机程序作为给定问题规范的解决方案。我们提出了一种通过大型语言模型进行对话式程序合成的方法，该方法解决了在先前方法中面临的在广泛的程序空间和用户意图规范中搜索的挑战。我们的新方法将编写规范和程序的过程视为用户和系统之间的多轮对话。它将程序合成视为一个序列预测问题，其中规范用自然语言表达，所需程序是有条件地抽样的。我们在自然语言和编程语言数据上训练了一系列大型语言模型，称为 CodeGen。通过数据中的弱监督和数据规模和模型规模的扩大，对话能力从简单的自回归语言建模中出现。为了研究对话式程序合成的模型行为，我们开发了一个多轮编程基准（MTPB），在这个基准中，解决每个问题都需要通过用户和模型之间的多轮对话进行多步合成。我们的研究结果显示了对话能力的出现以及所提出的对话式程序合成范式的有效性。此外，我们的 CodeGen 模型（在 TPU-v4 上训练的参数高达 16B）在 HumanEval 基准测试中优于 OpenAI 的 Codex。我们将包括检查点在内的训练库 JaxFormer 作为开源贡献提供：此链接。

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

检查点命名

CodeGen 模型的检查点可在不同的预训练数据上以不同大小的变量大小获得。
格式为：Salesforce/codegen-{size}-{data}，其中

size: 350M、2B、6B、16B
data:

nl: 在 The Pile 上预训练
multi: 初始化为nl，然后在多种编程语言数据上进一步预训练
mono: 初始化为multi，然后在 Python 数据上进一步预训练

例如，Salesforce/codegen-350M-mono提供了一个在 The Pile、多种编程语言和 Python 上顺序预训练的 3.5 亿参数检查点。

使用示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> checkpoint = "Salesforce/codegen-350M-mono"
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)
>>> text = "def hello_world():"
>>> completion = model.generate(**tokenizer(text, return_tensors="pt"))
>>> print(tokenizer.decode(completion[0]))
def hello_world():
    print("Hello World")
hello_world()

资源

因果语言建模任务指南

CodeGenConfig

`class transformers.CodeGenConfig`

<来源>

( vocab_size = 50400 n_positions = 2048 n_ctx = 2048 n_embd = 4096 n_layer = 28 n_head = 16 rotary_dim = 64 n_inner = None activation_function = 'gelu_new' resid_pdrop = 0.0 embd_pdrop = 0.0 attn_pdrop = 0.0 layer_norm_epsilon = 1e-05 initializer_range = 0.02 use_cache = True bos_token_id = 50256 eos_token_id = 50256 tie_word_embeddings = False **kwargs )

参数

vocab_size（int，可选，默认为 50400）—CodeGen 模型的词汇量。定义了在调用 CodeGenModel 时可以表示的不同标记的数量。
n_positions（int，可选，默认为 2048）—此模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
n_ctx（int，可选，默认为 2048）—此属性在CodeGenModel.__init__中使用，没有实际效果。
n_embd（int，可选，默认为 4096）—嵌入和隐藏状态的维度。
n_layer (int, optional, defaults to 28) — Transformer 编码器中隐藏层的数量。
n_head (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数。
rotary_dim (int, optional, defaults to 64) — 应用旋转位置嵌入的嵌入中的维度数量。
n_inner (int, optional) — 内部前馈层的维度。None 将将其设置为 n_embd 的 4 倍
activation_function (str, optional, defaults to "gelu_new") — 激活函数，在列表 ["relu", "silu", "gelu", "tanh", "gelu_new"] 中选择。
resid_pdrop (float, optional, defaults to 0.0) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
embd_pdrop (int, optional, defaults to 0.0) — 嵌入的丢弃比率。
attn_pdrop (float, optional, defaults to 0.0) — 注意力的丢弃比率。
layer_norm_epsilon (float, optional, defaults to 1e-05) — 层归一化层中要使用的 epsilon。
initializer_range (float, optional, defaults to 0.02) — 初始化所有权重矩阵的截断正态初始化器的标准差。
use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
bos_token_id (int, optional, defaults to 50256) — 流的开始标记 id。
eos_token_id (int, optional, defaults to 50256) — 流的结束标记 id。
tie_word_embeddings (bool, optional, defaults to False) — 模型的输入和输出词嵌入是否应该绑定。请注意，只有在模型具有输出词嵌入层时，这才相关。

这是配置类，用于存储 CodeGenModel 的配置。它用于根据指定的参数实例化 CodeGen 模型，定义模型架构。使用默认值实例化配置将产生类似于 CodeGen Salesforce/codegen-2B-mono 架构的配置。配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import CodeGenConfig, CodeGenModel
>>> # Initializing a CodeGen 6B configuration
>>> configuration = CodeGenConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = CodeGenModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

CodeGenTokenizer

`class transformers.CodeGenTokenizer`

< source >

( vocab_file merges_file errors = 'replace' unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' pad_token = None add_prefix_space = False add_bos_token = False **kwargs )

参数

vocab_file (str) — 词汇文件的路径。
merges_file (str) — 合并文件的路径。
errors (str, optional, defaults to "replace") — 解码字节为 UTF-8 时要遵循的范例。有关更多信息，请参阅 bytes.decode。
unk_token（str，optional，默认为"<|endoftext|>"）–未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。
bos_token（str，optional，默认为"<|endoftext|>"）–序列标记的开头。
eos_token（str，optional，默认为"<|endoftext|>"）–序列结束标记。
pad_token (str, optional) — 用于填充的标记，例如在批处理不同长度的序列时使用。
add_prefix_space (bool, optional, defaults to False) — 是否在输入中添加初始空格。这允许将前导单词视为任何其他单词。（CodeGen 分词器通过前面的空格检测单词的开头）。
add_bos_token (bool, optional, defaults to False) — 是否在序列开头添加一个序列开始标记。

构建一个 CodeGen 分词器。基于字节级字节对编码。

此分词器已经训练过，将空格视为标记的一部分（有点像 sentencepiece），因此一个单词将

在句子开头（无空格）或不在句子开头时，可能会以不同方式编码：

>>> from transformers import CodeGenTokenizer
>>> tokenizer = CodeGenTokenizer.from_pretrained("Salesforce/codegen-350M-mono")
>>> tokenizer("Hello world")["input_ids"]
[15496, 995]
>>> tokenizer(" Hello world")["input_ids"]
[18435, 995]

当实例化此分词器时或在对某些文本进行调用时，通过传递add_prefix_space=True可以避免这种行为，但由于模型不是以这种方式进行预训练的，可能会导致性能下降。

当与is_split_into_words=True一起使用时，此分词器将在每个单词之前添加一个空格（甚至是第一个单词）。

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

`save_vocabulary`

<来源>

( save_directory: str filename_prefix: Optional = None )

CodeGenTokenizerFast

`class transformers.CodeGenTokenizerFast`

<来源>

( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' add_prefix_space = False **kwargs )

参数

vocab_file（str，可选）— 词汇文件的路径。
merges_file（str，可选）— 合并文件的路径。
tokenizer_file（str，可选）— tokenizers文件的路径（通常具有 .json 扩展名），其中包含加载分词器所需的所有内容。
unk_token（str，optional，默认为"<|endoftext|>"）–未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。
bos_token（str，optional，默认为"<|endoftext|>"）–序列标记的开头。
eos_token（str，optional，默认为"<|endoftext|>"）–序列结束标记。
add_prefix_space（bool，可选，默认为False）— 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（CodeGen 分词器通过前面的空格检测单词的开头）。

构建一个“快速”CodeGen 分词器（由 HuggingFace 的tokenizers库支持）。基于字节级字节对编码。

此分词器已经训练成将空格视为标记的一部分（有点像 sentencepiece），因此一个单词将

在句子开头（无空格）或不在句子开头时，将以不同方式编码：

>>> from transformers import CodeGenTokenizerFast
>>> tokenizer = CodeGenTokenizerFast.from_pretrained("Salesforce/codegen-350M-mono")
>>> tokenizer("Hello world")["input_ids"]
[15496, 995]
>>> tokenizer(" Hello world")["input_ids"]
[18435, 995]

当实例化此分词器时，通过传递add_prefix_space=True可以避免这种行为，但由于模型不是以这种方式进行预训练的，可能会导致性能下降。

当与is_split_into_words=True一起使用时，此分词器需要使用add_prefix_space=True进行实例化。

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

`decode`

<来源>

( token_ids: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None truncate_before_pattern: Optional = None **kwargs ) → export const metadata = 'undefined';str

参数

token_ids（Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]）— 标记化输入 id 的列表。可以使用__call__方法获得。
skip_special_tokens（bool，可选，默认为False）— 是否在解码中删除特殊标记。
clean_up_tokenization_spaces（bool，可选）— 是否清理分词空格。如果为None，将默认为self.clean_up_tokenization_spaces（在tokenizer_config中可用）。
truncate_before_patter（List[str]，optional，默认为None）–将用于截断返回字符串的正则表达式字符串的列表。这可用于删除多余的代码段（例如，如果在新行开头观察到注释符号“#”，则截断）。一个示例模式可以是[”^#”, re.escape(”<|endoftext|>”),

str

解码后的句子。

使用分词器和词汇表将 id 序列转换为字符串，具有删除特殊标记和清理分词空格的选项。

类似于执行self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

”。kwargs（额外的关键字参数，可选）：将传递给底层模型特定的解码方法。

CodeGenModel

`class transformers.CodeGenModel`

<来源>

( config )

参数

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

裸的 CodeGen 模型变换器输出原始的隐藏状态，没有特定的头部。这个模型是一个 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

`forward`

< source >

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: 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.BaseModelOutputWithPast or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
可以使用 AutoProcenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
什么是输入 ID？
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力。掩码值选定在 [0, 1]：

1 用于 未被掩码 的标记，
0 用于被 掩码 的标记。

什么是注意力掩码？
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引选定在 [0, 1]：

0 对应于一个 句子 A 标记，
1 对应于一个 句子 B 标记。

什么是标记类型 ID？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选定范围为 [0, config.n_positions - 1]。
什么是位置 ID？
head_mask (torch.FloatTensor，形状为 (num_attention_heads,) 或 (n_layer, num_attention_heads)，可选) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1]：

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

inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_dim)，可选) — 可选地，您可以选择直接传递一个嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

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

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

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。
如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
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)的张量，如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。
包含预先计算的隐藏状态（自注意力块中的键和值，以及在交叉注意力块中如果config.is_encoder_decoder=True的情况下可选地使用）可用（请参见past_key_values输入）以加快顺序解码的速度。
hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层的输出，则为嵌入的输出一个+每一层的输出一个）。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, CodeGenModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/codegen-2B-mono")
>>> model = CodeGenModel.from_pretrained("Salesforce/codegen-2B-mono")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

CodeGenForCausalLM

`class transformers.CodeGenForCausalLM`

<来源>

( config )

参数

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

带有语言建模头部的 CodeGen 模型变压器。

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

`forward`

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: 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）— 词汇表中输入序列标记的索引。
可以使用AutoProcenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

1 表示未被masked的标记，
0 表示被masked的标记。

什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

0 对应于句子 A的标记。
1 对应于句子 B的标记。

什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。
什么是位置 ID？
head_mask（形状为(num_attention_heads,)或(n_layer, num_attention_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

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

inputs_embeds（形状为(batch_size, sequence_length, hidden_dim)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型内部的嵌入查找矩阵，这将非常有用。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于语言建模的标签。请注意，标签在模型内部被移位，即您可以设置labels = input_ids。在[-100, 0, ..., config.vocab_size]中选择索引。所有设置为-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时）包含不同的元素，取决于配置（CodeGenConfig）和输入。

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

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

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

示例：

>>> import torch
>>> from transformers import AutoTokenizer, CodeGenForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/codegen-2B-mono")
>>> model = CodeGenForCausalLM.from_pretrained("Salesforce/codegen-2B-mono")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

CodeLlama

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

概述

Code Llama 模型是由 Baptiste Rozière，Jonas Gehring，Fabian Gloeckle，Sten Sootla，Itai Gat，Xiaoqing Ellen Tan，Yossi Adi，Jingyu Liu，Tal Remez，Jérémy Rapin，Artyom Kozhevnikov，Ivan Evtimov，Joanna Bitton，Manish Bhatt，Cristian Canton Ferrer，Aaron Grattafiori，Wenhan Xiong，Alexandre Défossez，Jade Copet，Faisal Azhar，Hugo Touvron，Louis Martin，Nicolas Usunier，Thomas Scialom，Gabriel Synnaeve 提出的，详见Code Llama: Open Foundation Models for Code。

论文摘要如下：

我们发布了 Code Llama，这是基于 Llama 2 的一系列大型代码语言模型，提供了在开放模型中最先进的性能，填充能力，支持大型输入上下文以及编程任务的零-shot 指令跟随能力。我们提供多种风格以涵盖广泛的应用：基础模型（Code Llama），Python 专业化模型（Code Llama - Python）和指令跟随模型（Code Llama - Instruct），分别具有 7B，13B 和 34B 参数。所有模型都是在 16k 标记序列上训练的，并在最多 100k 标记的输入上显示出改进。7B 和 13B 的 Code Llama 和 Code Llama - Instruct 变体支持基于周围内容的填充。Code Llama 在几个代码基准测试中达到了开放模型的最先进性能，分别在 HumanEval 和 MBPP 上达到了 53%和 55%的分数。值得注意的是，Code Llama - Python 7B 在 HumanEval 和 MBPP 上优于 Llama 2 70B，而我们所有的模型都优于 MultiPL-E 上的其他任何公开可用模型。我们以一种允许研究和商业使用的宽松许可证发布了 Code Llama。

查看所有 Code Llama 模型检查点这里，以及在codellama org上正式发布的模型。

此模型由ArthurZucker贡献。作者的原始代码可以在这里找到。

用法提示和示例

Code Llama 基于的Llama2系列模型是使用bfloat16训练的，但原始推断使用float16。让我们看看不同的精度：

float32：PyTorch 在模型初始化时的惯例是以float32加载模型，无论模型权重存储时使用的是哪种dtype。transformers也遵循这种惯例，以保持与 PyTorch 的一致性。这将被默认选择。如果您希望AutoModel API 将加载检查点时的存储权重类型转换为dtype，则必须指定torch_dtype="auto"，例如model = AutoModelForCausalLM.from_pretrained("path", torch_dtype = "auto")。
bfloat16：Code Llama 是使用这种精度训练的，因此我们建议在进一步训练或微调时使用它。
float16：我们建议使用这种精度来运行推断，因为通常比bfloat16更快，并且评估指标显示与bfloat16相比没有明显的降级。您也可以使用bfloat16来运行推断，我们建议您在微调后使用float16和bfloat16检查推断结果。

如上所述，存储权重的dtype大多数情况下并不重要，除非您在初始化模型时使用torch_dtype="auto"。原因是模型将首先被下载（使用在线检查点的dtype），然后将被转换为torch的默认dtype（变为torch.float32）。如果有指定的torch_dtype，则将使用该指定值。

提示：

填充任务是开箱即用的。您应该在想要填充输入的地方使用tokenizer.fill_token。
模型转换脚本与Llama2系列相同：

以下是一个示例用法：

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

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

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

>>> from transformers import LlamaForCausalLM, CodeLlamaTokenizer
>>> tokenizer = CodeLlamaTokenizer.from_pretrained("codellama/CodeLlama-7b-hf")
>>> model = LlamaForCausalLM.from_pretrained("codellama/CodeLlama-7b-hf")
>>> PROMPT = '''def remove_non_ascii(s: str) -> str:
    """ <FILL_ME>
    return result
'''
>>> input_ids = tokenizer(PROMPT, return_tensors="pt")["input_ids"]
>>> generated_ids = model.generate(input_ids, max_new_tokens=128)
>>> filling = tokenizer.batch_decode(generated_ids[:, input_ids.shape[1]:], skip_special_tokens = True)[0]
>>> print(PROMPT.replace("<FILL_ME>", filling))
def remove_non_ascii(s: str) -> str:
    """ Remove non-ASCII characters from a string.
    Args:
        s: The string to remove non-ASCII characters from.
    Returns:
        The string with non-ASCII characters removed.
    """
    result = ""
    for c in s:
        if ord(c) < 128:
            result += c
    return result

如果只想要填充部分：

>>> from transformers import pipeline
>>> import torch
>>> generator = pipeline("text-generation",model="codellama/CodeLlama-7b-hf",torch_dtype=torch.float16, device_map="auto")
>>> generator('def remove_non_ascii(s: str) -> str:\n    """ <FILL_ME>\n    return result', max_new_tokens = 128, return_type = 1)

在底层，分词器自动通过进行拆分以创建一个格式化的输入字符串，遵循原始训练模式。这比自己准备模式更加健壮：它避免了很难调试的诸如标记粘合等问题。要查看此模型或其他模型所需的 CPU 和 GPU 内存量，请尝试使用此计算器，该计算器可以帮助确定该值。

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

Code Llama 与Llama2模型具有相同的架构，请参考 Llama2 的文档页面获取 API 参考。以下是 Code Llama 分词器的参考。

Transformers 4.37 中文文档（二十七）（3）https://developer.aliyun.com/article/1563737

Transformers 4.37 中文文档（二十七）（2）

CanineForQuestionAnswering

`class transformers.CanineForQuestionAnswering`

`forward`

CodeGen

概述

检查点命名

使用示例

资源

CodeGenConfig

`class transformers.CodeGenConfig`

CodeGenTokenizer

`class transformers.CodeGenTokenizer`

`save_vocabulary`

CodeGenTokenizerFast

`class transformers.CodeGenTokenizerFast`

`decode`

CodeGenModel

`class transformers.CodeGenModel`

`forward`

CodeGenForCausalLM

`class transformers.CodeGenForCausalLM`

`forward`

CodeLlama

概述

用法提示和示例

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（二十七）（2）

CanineForQuestionAnswering

class transformers.CanineForQuestionAnswering

forward

CodeGen

概述

检查点命名

使用示例

资源

CodeGenConfig

class transformers.CodeGenConfig

CodeGenTokenizer

class transformers.CodeGenTokenizer

save_vocabulary

CodeGenTokenizerFast

class transformers.CodeGenTokenizerFast

decode

CodeGenModel

class transformers.CodeGenModel

forward

CodeGenForCausalLM

class transformers.CodeGenForCausalLM

forward

CodeLlama

概述

用法提示和示例

热门文章

最新文章

相关课程

相关电子书

`class transformers.CanineForQuestionAnswering`

`forward`

`class transformers.CodeGenConfig`

`class transformers.CodeGenTokenizer`

`save_vocabulary`

`class transformers.CodeGenTokenizerFast`

`decode`

`class transformers.CodeGenModel`

`forward`

`class transformers.CodeGenForCausalLM`

`forward`