Transformers 4.37 中文文档（四十六）（5）-阿里云开发者社区

Transformers 4.37 中文文档（四十六）（4）https://developer.aliyun.com/article/1565072

MptModel

`class transformers.MptModel`

( config: MptConfig )

参数

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

裸的 Mpt 模型变压器输出原始隐藏状态，没有特定的头部。

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

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

`forward`

< source >

( input_ids: Optional = None past_key_values: Optional = None attention_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.BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, input_ids_length)) — input_ids_length = sequence_length 如果 past_key_values 是 None，否则 past_key_values[0][0].shape[2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。
如果使用了 past_key_values，则只应将未计算其过去的 input_ids 作为 input_ids 传递。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以获取详细信息。
什么是输入 ID？
past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）- 包含模型计算的预先计算的隐藏状态（注意力块中的键和值），如下面的past_key_values输出所示。可用于加速顺序解码。将过去给定给该模型的input_ids不应作为input_ids传递，因为它们已经被计算过。past_key_values的每个元素都是一个元组（past_key，past_value）：

past_key: [batch_size * num_heads, head_dim, kv_length]
past_value: [batch_size * num_heads, kv_length, head_dim]

attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充令牌索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

1 表示未被掩码的标记，
0 表示被掩码的标记。

什么是注意力掩码？
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵。
如果使用past_key_values，可以选择仅输入最后的inputs_embeds（参见past_key_values）。
use_cache（bool，可选）- 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量下的attentions。
output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回的张量下的hidden_states。
return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通的元组。

返回值

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

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

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的输出的隐藏状态序列。
如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
past_key_values（可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的tuple(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 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), 可选, 当 output_attentions=True 和 config.add_cross_attention=True 被传递或者当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。
解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, MptModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptModel.from_pretrained("mosaicml/mpt-7b")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

MptForCausalLM

`class transformers.MptForCausalLM`

<来源>

( config: MptConfig )

参数

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

带有语言建模头部的 MPT 模型变压器（线性层，其权重与输入嵌入绑定）。

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

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

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_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.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, input_ids_length)） — 如果 past_key_values 是 None，则 input_ids_length = sequence_length，否则为 past_key_values[0][0].shape[2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。
如果使用了 past_key_values，只有那些未计算过去的 input_ids 应该被传递。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。
什么是输入 ID？
past_key_values (Tuple[Tuple[torch.Tensor]] 长度为 config.n_layers) — 包含由模型计算的预计算隐藏状态（注意力块中的键和值），如下面的 past_key_values 输出所示。可用于加速顺序解码。将其过去给定给此模型的 input_ids 不应作为 input_ids 传递，因为它们已经计算过了。past_key_values 的每个元素都是一个元组（past_key, past_value）：

past_key: [batch_size * num_heads, head_dim, kv_length]
past_value: [batch_size * num_heads, kv_length, head_dim]

attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：

对于未被掩盖的标记，为 1，
对于被掩盖的标记，为 0。

什么是注意力掩码？
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
如果使用了 past_key_values，则可能只需输入最后的 inputs_embeds（参见 past_key_values）。
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 of shape (batch_size, sequence_length), optional) — 语言建模的标签。请注意，模型内部的标签 已经被移位，即您可以设置 labels = input_ids 索引选在 [-100, 0, ..., config.vocab_size] 所有设置为 -100 的标签都被忽略（掩盖），损失仅计算标签在 [0, ..., config.vocab_size] 中的标签。

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或者 torch.FloatTensor 元组

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

loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 语言建模损失（用于下一个标记预测）。
logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
在注意力 softmax 之后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回） — 长度为config.n_layers的torch.FloatTensor元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态。仅在config.is_decoder = True时相关。
包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

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

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

示例：

>>> import torch
>>> from transformers import AutoTokenizer, MptForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptForCausalLM.from_pretrained("mosaicml/mpt-7b")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

MptForSequenceClassification

`class transformers.MptForSequenceClassification`

< source >

( config: MptConfig )

参数

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

MPT 模型变压器，顶部带有序列分类头（线性层）。

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

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

这个模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（如下载或保存，调整输入嵌入等）。

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

`forward`

< source >

( input_ids: Optional = None past_key_values: Optional = None attention_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.SequenceClassifierOutputWithPast or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为(batch_size, input_ids_length)) — input_ids_length = sequence_length（如果past_key_values为None）否则past_key_values[0][0].shape[2]（输入过去键值状态的sequence_length）。词汇表中输入序列标记的索引。
如果使用了past_key_values，则只能传递尚未计算其过去的input_ids作为input_ids。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
什么是输入 ID？
past_key_values (Tuple[Tuple[torch.Tensor]]，长度为config.n_layers) — 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参见下面的past_key_values输出）。可用于加速顺序解码。将其过去传递给此模型的input_ids不应作为input_ids传递，因为它们已经计算过。past_key_values的每个元素都是一个元组（past_key，past_value）：

past_key: [batch_size * num_heads, head_dim, kv_length]
past_value: [batch_size * num_heads, kv_length, head_dim]

attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 避免对填充标记索引执行注意力的掩码。选择在[0, 1]范围内的掩码值：

对于未被masked的标记为 1，
对于被masked的标记为 0。

什么是注意力掩码？
inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果要更好地控制如何将input_ids索引转换为相关向量，这很有用，而不是使用模型的内部嵌入查找矩阵。
如果使用了past_key_values，则可以选择仅输入最后的inputs_embeds（参见past_key_values）。
use_cache (bool，可选) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

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

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

损失 (torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（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)的张量）
包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码。
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 后的注意力权重。

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, MptForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptForSequenceClassification.from_pretrained("mosaicml/mpt-7b")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MptForSequenceClassification.from_pretrained("mosaicml/mpt-7b", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, MptForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptForSequenceClassification.from_pretrained("mosaicml/mpt-7b", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = MptForSequenceClassification.from_pretrained(
...     "mosaicml/mpt-7b", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

MptForTokenClassification

`class transformers.MptForTokenClassification`

<来源>

( config: MptConfig )

参数

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

在顶部具有标记分类头的 MPT 模型（隐藏状态输出的线性层），例如用于命名实体识别（NER）任务。

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

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

`forward`

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_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 **deprecated_arguments ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

input_ids（形状为(batch_size, input_ids_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length=sequence_length，否则input_ids_length=past_key_values[0][0].shape[2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。
如果使用past_key_values，只应传递尚未计算其过去的input_ids作为input_ids。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
什么是输入 ID？
past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。将其过去传递给此模型的input_ids不应作为input_ids传递，因为它们已经计算过。past_key_values的每个元素都是一个元组（past_key，past_value）:

past_key: [batch_size * num_heads, head_dim, kv_length]
past_value: [batch_size * num_heads, kv_length, head_dim]

attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]范围内：

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

什么是注意力掩码？
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
如果使用了past_key_values，则可能只需输入最后的inputs_embeds（请参见past_key_values）。
use_cache（bool，可选）— 如果设置为True，将返回past_key_values键值状态，可用于加速解码（请参见past_key_values）。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算序列分类/回归损失的标签。索引应在[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时），包括根据配置（MptConfig）和输入的不同元素。

loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回）— 分类损失。
logits（形状为(batch_size, sequence_length, config.num_labels)的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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, MptForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptForTokenClassification.from_pretrained("mosaicml/mpt-7b")
>>> 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

MptForQuestionAnswering

`class transformers.MptForQuestionAnswering`

<来源>

( config )

参数

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

MPT 模型变压器，在顶部具有用于提取问答任务的跨度分类头，如 SQuAD（在隐藏状态输出顶部的线性层，用于计算跨度起始对数和跨度结束对数）。

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

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

`forward`

<来源>

( input_ids: Optional = None attention_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 )

参数

input_ids (torch.LongTensor，形状为(batch_size, input_ids_length)) — input_ids_length = sequence_length，如果past_key_values为None，否则为past_key_values[0][0].shape[2]（输入过去键值状态的序列长度）。输入序列标记在词汇表中的索引。
如果使用past_key_values，则只有那些没有计算过去的input_ids应该作为input_ids传递。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。
什么是输入 ID？
past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参阅下面的past_key_values输出）。可用于加速顺序解码。已经给出其过去的input_ids不应作为input_ids传递给此模型，因为它们已经计算过了。past_key_values的每个元素都是一个元组（past_key，past_value）：

past_key: [batch_size * num_heads, head_dim, kv_length]
past_value: [batch_size * num_heads, kv_length, head_dim]

attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

1 表示未被掩码的标记，
0 表示被掩码的标记。

什么是注意力掩码？
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
如果使用past_key_values，则可以选择仅输入最后的inputs_embeds（请参阅past_key_values）。
use_cache（bool，可选）— 如果设置为True，则会返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
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）。序列外的位置不会被考虑在内以计算损失。

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

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

Transformers 4.37 中文文档（四十六）（5）

MptModel

`class transformers.MptModel`

`forward`

MptForCausalLM

`class transformers.MptForCausalLM`

MptForSequenceClassification

`class transformers.MptForSequenceClassification`

`forward`

MptForTokenClassification

`class transformers.MptForTokenClassification`

`forward`

MptForQuestionAnswering

`class transformers.MptForQuestionAnswering`

`forward`

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（四十六）（5）

MptModel

class transformers.MptModel

forward

MptForCausalLM

class transformers.MptForCausalLM

MptForSequenceClassification

class transformers.MptForSequenceClassification

forward

MptForTokenClassification

class transformers.MptForTokenClassification

forward

MptForQuestionAnswering

class transformers.MptForQuestionAnswering

forward

热门文章

最新文章

相关课程

相关电子书

`class transformers.MptModel`

`forward`

`class transformers.MptForCausalLM`

`class transformers.MptForSequenceClassification`

`forward`

`class transformers.MptForTokenClassification`

`forward`

`class transformers.MptForQuestionAnswering`

`forward`