Hugging Face 的标志

Transformers 文档

MPT

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

MPT

概述

MPT 模型是由 MosaicML 团队提出的，并发布了多种规模和微调变体。MPT 模型是一系列开源且可商用的 LLM，在 1T 个标记上进行了预训练。

MPT 模型是 GPT 风格的仅解码器转换器，并进行了一些改进：性能优化的层实现、提供更高训练稳定性的架构更改，以及通过用 ALiBi 替换位置嵌入来消除上下文长度限制。

  • MPT 基础：在下一个标记预测上预训练的 MPT 基础模型
  • MPT 指令：在基于指令的任务上微调的 MPT 基础模型
  • MPT 故事作者：在 books3 语集中包含的 65k 标记的小说摘录上微调 2500 步的 MPT 基础模型，这使得模型能够处理非常长的序列

原始代码可在 llm-foundry 存储库中找到。

在 发布博文 中阅读更多相关信息

使用技巧

  • 在 llm-foundry 存储库的这一部分 中详细了解模型训练背后的一些技术
  • 如果要使用模型的高级版本（triton 内核、直接闪存注意力集成），仍然可以通过在调用 from_pretrained 时添加 trust_remote_code=True 来使用原始模型实现。

资源

  • 关于如何在免费 Google Colab 实例上微调 MPT-7B 以将模型转换为聊天机器人的 微调笔记本。

MptConfig

类 transformers.MptConfig

< >

( d_model: int = 2048 n_heads: int = 16 n_layers: int = 24 expansion_ratio: int = 4 max_seq_len: int = 2048 vocab_size: int = 50368 resid_pdrop: float = 0.0 layer_norm_epsilon: float = 1e-05 emb_pdrop: float = 0.0 learned_pos_emb: bool = True attn_config: MptAttentionConfig = None init_device: str = 'cpu' logit_scale: Union = None no_bias: bool = True verbose: int = 0 embedding_fraction: float = 1.0 norm_type: str = 'low_precision_layernorm' use_cache: bool = False initializer_range = 0.02 **kwargs )

参数

  • d_model (int, 可选, 默认为 2048) — 嵌入和隐藏状态的维度。
  • n_heads (int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。
  • n_layers (int, 可选, 默认为 24) — Transformer 编码器中隐藏层的数量。
  • expansion_ratio (int, 可选, 默认为 4) — MLP 中上/下缩放的比例。
  • max_seq_len (int，可选，默认为 2048) — 模型的最大序列长度。
  • vocab_size (int，可选，默认为 50368) — Mpt 模型的词汇量大小。定义了在调用 MptModel 时传递的 inputs_ids 可以表示的不同标记的最大数量。查看 此讨论 了解如何定义 vocab_size。
  • resid_pdrop (float，可选，默认为 0.0) — 应用于注意力输出与残差组合之前的 dropout 概率。
  • layer_norm_epsilon (float，可选，默认为 1e-05) — 层归一化层中使用的 epsilon 值。
  • emb_pdrop (float，可选，默认为 0.0) — 嵌入层的 dropout 概率。
  • learned_pos_emb (bool，可选，默认为 True) — 是否使用学习的位置嵌入。
  • attn_config (dict，可选) — 用于配置模型注意力模块的字典。
  • init_device (str，可选，默认为 "cpu") — 用于参数初始化的设备。为了向后兼容而定义
  • logit_scale (float，可选) — 如果不为 None，则按此值缩放 logits。
  • no_bias (bool，可选，默认为 True) — 是否在所有线性层中使用偏置。
  • verbose (int，可选，默认为 0) — 用于日志记录的详细程度。在以前版本的 MPT 模型中用于日志记录。此参数已弃用。
  • embedding_fraction (float，可选，默认为 1.0) — 嵌入层梯度的缩放比例。
  • norm_type (str，可选，默认为 "low_precision_layernorm") — 要使用的层归一化类型。所有 MPT 模型都使用相同的层归一化实现。为了向后兼容而定义。
  • use_cache (bool，可选，默认为 False) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
  • initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

这是用于存储 MptModel 配置的配置类。它用于根据指定的参数实例化 Mpt 模型，定义模型架构。使用默认值实例化配置将产生与 Mpt-7b 架构 mosaicml/mpt-7b 类似的配置。

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

示例

>>> from transformers import MptConfig, MptModel

>>> # Initializing a Mpt configuration
>>> configuration = MptConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = MptModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

MptModel

类 transformers.MptModel

< >

( config: MptConfig )

参数

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

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

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

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

前向传播

< >

( 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 ) → transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或 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]（输入过去的键值状态的 sequence_length）。词汇表中输入序列标记的索引。

    如果使用了 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 不应作为 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 (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 时返回) — 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 和 config.add_cross_attention=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于计算交叉注意力头中的加权平均值。

MptModel 的 forward 方法，覆盖了 __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

类 transformers.MptForCausalLM

< >

( config: MptConfig )

参数

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

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

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

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

前向传播

< >

( 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 ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — 如果 past_key_values 为 None，则 input_ids_length = sequence_length；否则 input_ids_length = 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 (长度为 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 (torch.FloatTensor 形状为 (batch_size, sequence_length)，可选) — 掩码以避免对填充标记索引执行注意力。在 [0, 1] 中选择的掩码值：

    • 未屏蔽标记为 1，
    • 屏蔽标记为 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, sequence_length), 可选) — 用于语言建模的标签。请注意，标签在模型内部**已移位**，即您可以设置 labels = input_ids 索引在 [-100, 0, ..., config.vocab_size] 中选择 所有设置为 -100 的标签都将被忽略（掩码），损失仅针对 [0, ..., config.vocab_size] 中的标签计算

返回值

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

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

  • loss (torch.FloatTensor 形状为 (1,), 可选, 当提供 labels 时返回) — 语言建模损失（用于下一个词预测）。

  • logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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 之后的注意力权重，用于计算自注意力头中的加权平均值。

  • 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 时相关。

    包含预先计算的隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

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

类 transformers.MptForSequenceClassification

< >

( 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 文档了解与一般用法和行为相关的所有事项。

前向传播

< >

( 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 ) → transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 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]（输入过去键值状态的 sequence_length）。词汇表中输入序列标记的索引。

    如果使用 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 (torch.FloatTensor 形状为 (batch_size, sequence_length)，可选) — 掩码以避免对填充标记索引执行注意力。掩码值在 [0, 1] 中选择：

    • 1 表示未被掩码的标记，
    • 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）和输入的不同元素。

  • loss (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(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 之后的注意力权重，用于计算自注意力头中的加权平均值。

MptForSequenceClassification 的 forward 方法覆盖了 __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

类 transformers.MptForTokenClassification

< >

( config: MptConfig )

参数

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

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

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

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

前向传播

< >

( 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 ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, input_ids_length)) — input_ids_length = 如果 past_key_values 为 None 则为 sequence_length，否则为 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 (长度为 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 (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 掩码以避免对填充标记索引执行注意力。在 [0, 1] 中选择的掩码值：

    • 未屏蔽标记为 1，
    • 屏蔽标记为 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.TokenClassifierOutput 或 tuple(torch.FloatTensor)

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

  • 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

MptForTokenClassification forward 方法，覆盖 __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

类 transformers.MptForQuestionAnswering

< >

( config )

参数

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

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

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

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

前向传播

< >

( 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)) — 如果 past_key_values 为 None，则 input_ids_length = sequence_length，否则 input_ids_length = 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 (长度为 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 (torch.FloatTensor 形状为 (batch_size, sequence_length)，可选) — 掩码以避免对填充标记索引执行注意力。在 [0, 1] 中选择的掩码值：

    • 1 表示 未屏蔽 的标记，
    • 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 而不是普通的元组。
  • start_positions (torch.LongTensor 形状为 (batch_size,)，可选) — 用于计算标记分类损失的标记跨度开始位置（索引）的标签。位置会被限制在序列的长度（sequence_length）内。序列之外的位置不会被考虑用于计算损失。
  • end_positions (torch.LongTensor ，形状为 (batch_size,)，可选) — 用于计算标记分类损失的标记跨度结束位置（索引）的标签。位置会被限制在序列长度 (sequence_length) 范围内。序列外的位置不会被考虑用于计算损失。

MptForQuestionAnswering 的 forward 方法重写了 __call__ 特殊方法。

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

< > 在 GitHub 上更新

←MPNet MRA→