Hugging Face 的 LOGO

Transformers 文档

MPT

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

该模型于 2023 年 7 月 25 日贡献给 Hugging Face Transformers。

MPT

概述

MPT 模型由 MosaicML 团队提出，并发布了多种尺寸和微调版本。MPT 模型是一系列基于 1T token 预训练的开源且可商用的大语言模型（LLM）。

MPT 模型是 GPT 风格的仅解码器（decoder-only）Transformer，具有多项改进：性能优化的层实现、提升训练稳定性的架构更改，以及通过将位置嵌入替换为 ALiBi 从而消除了上下文长度限制。

  • MPT base：基于下一个 token 预测进行预训练的 MPT 基础模型。
  • MPT instruct：在基于指令的任务上进行微调的 MPT 基础模型。
  • MPT storywriter：在 books3 语料库中的小说书籍 65k-token 节选上微调 2500 步的 MPT 基础模型，这使模型能够处理非常长的序列。

原始代码可在 llm-foundry 仓库中获取。

有关更多信息，请参阅 发布博客文章。

使用技巧

  • 了解更多关于模型训练背后的技术，请参阅 llm-foundry 仓库的此部分。
  • 如果您想使用该模型的高级版本（Triton 内核、直接 Flash Attention 集成），您仍然可以通过在调用 from_pretrained 时添加 trust_remote_code=True 来使用原始模型实现。

资源

  • 微调 Notebook：关于如何在免费的 Google Colab 实例上微调 MPT-7B 以将其转化为聊天机器人的指南。

MptConfig

class transformers.MptConfig

< >

（配置参数列表省略...）

参数

  • 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) — 模型词汇表大小。定义了 input_ids 可以表示的不同 token 的数量。
  • resid_pdrop (Union[float, int], 可选, 默认为 0.0) — 嵌入层、编码器和池化层中所有全连接层的丢弃（dropout）概率。
  • layer_norm_epsilon (float, 可选, 默认为 1e-05) — 层归一化层中使用的 epsilon 值。
  • emb_pdrop (Union[float, int], 可选, 默认为 0.0) — 嵌入层的丢弃比率。
  • learned_pos_emb (bool, 可选, 默认为 True) — 是否使用学习到的位置嵌入。
  • attn_config (dict, 可选) — 用于配置模型注意力模块的字典。
  • init_device (str, 可选, 默认为 "cpu") — 用于参数初始化的设备。为向后兼容性定义。
  • logit_scale (float, 可选) — 如果不为 None，则按此值缩放 logit。
  • no_bias (bool, 可选, 默认为 True) — 是否在所有线性层中使用偏置（bias）。
  • embedding_fraction (float, 可选, 默认为 1.0) — 用于缩放嵌入层梯度的分数。
  • norm_type (str, 可选, 默认为 "low_precision_layernorm") — 要使用的层归一化类型。所有 MPT 模型均使用相同的层归一化实现。为向后兼容性定义。
  • use_cache (bool, 可选, 默认为 False) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅当 config.is_decoder=True 或模型是仅解码器生成模型时相关。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • tie_word_embeddings (bool, 可选, 默认为 True) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。
  • pad_token_id (int, 可选) — 词汇表中用于填充（padding）的 token ID。
  • bos_token_id (int, 可选) — 词汇表中用于序列起始（beginning-of-stream）的 token ID。
  • eos_token_id (Union[int, list[int]], 可选) — 词汇表中用于序列结束（end-of-stream）的 token ID。

这是用于存储 MptModel 配置的配置类。它根据指定的参数实例化一个 MPT 模型，从而定义模型架构。使用默认值实例化配置将产生与 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

class transformers.MptModel

< >

( config: MptConfig )

参数

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

原始的 Mpt 模型，输出未经处理的隐藏状态，顶部没有任何特定的头。

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None attention_mask: torch.Tensor | None = None inputs_embeds: torch.LongTensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

参数

  • input_ids (形状为 (batch_size, input_ids_length) 的 torch.LongTensor) — 如果 past_key_values 为 None，则 input_ids_length = sequence_length；否则为 past_key_values.get_seq_length()（输入过去键值状态的 sequence_length）。输入序列标记在词汇表中的索引。

    如果使用 past_key_values，则仅应将尚未计算过去的 input_ids 作为 input_ids 传入。

    索引可以通过 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • past_key_values (~cache_utils.Cache, 可选) — 预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可用于加速顺序解码。这通常由模型在解码的前一阶段返回，当 use_cache=True 或 config.use_cache=True 时使用。

    仅允许 Cache 实例作为输入，请参阅我们的 kv 缓存指南。如果未传入 past_key_values，将默认初始化 DynamicCache。

    模型将输出与输入相同格式的缓存。

    如果使用 past_key_values，用户应仅输入未经处理的 input_ids（那些其过去键值状态未提供给此模型的输入），形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的所有 input_ids。

  • attention_mask (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选自 [0, 1]：

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

    什么是注意力掩码？

  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.LongTensor, 可选) — 可选，您可以选择直接传入嵌入表示，而不是传入 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 而不是普通元组。

返回

BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

一个 BaseModelOutputWithPastAndCrossAttentions 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（MptConfig）和输入，包含各种元素。

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

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

  • last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

    如果使用了 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values (Cache，*可选*，当传入 use_cache=True 或 config.use_cache=True 时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。

    Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if config.is_encoder_decoder=True in the cross-attention blocks) that can be used (see past_key_values input) to speed up sequential decoding.

  • 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), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True and config.add_cross_attention=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

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

MptForCausalLM

class transformers.MptForCausalLM

< >

( config: MptConfig )

参数

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

带有语言建模头（与输入嵌入权重绑定的线性层）的 MPT 模型 Transformer。

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None attention_mask: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None labels: torch.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None logits_to_keep: int | torch.Tensor = 0 **kwargs ) → CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

  • input_ids (形状为 (batch_size, input_ids_length) 的 torch.LongTensor) — 如果 past_key_values 为 None，则 input_ids_length = sequence_length；否则为 past_key_values.get_seq_length()（输入过去键值状态的 sequence_length）。输入序列标记在词汇表中的索引。

    如果使用 past_key_values，则仅应将尚未计算过去的 input_ids 作为 input_ids 传入。

    索引可以通过 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • past_key_values (~cache_utils.Cache, 可选) — 预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可用于加速顺序解码。这通常由模型在解码的前一阶段返回，当 use_cache=True 或 config.use_cache=True 时使用。

    仅允许 Cache 实例作为输入，请参阅我们的 kv 缓存指南。如果未传入 past_key_values，将默认初始化 DynamicCache。

    模型将输出与输入相同格式的缓存。

    如果使用 past_key_values，用户应仅输入未经处理的 input_ids（那些其过去键值状态未提供给此模型的输入），形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的所有 input_ids。

  • attention_mask (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选自 [0, 1]：

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

    什么是注意力掩码？

  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor, 可选) — 可选，您可以选择直接传入嵌入表示，而不是传入 input_ids。这在您想要比模型内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为相关向量时非常有用。
  • labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于语言建模的标签。请注意，标签在模型内部会被移位 (shifted)，即你可以设置 labels = input_ids。索引的选择范围为 [-100, 0, ..., config.vocab_size]。所有设置为 -100 的标签都会被忽略（遮盖），损失函数仅针对 [0, ..., config.vocab_size] 范围内的标签进行计算。
  • use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多详情请查看返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。更多详情请查看返回张量中的 hidden_states。
  • return_dict (bool，可选) — 是否返回一个 ModelOutput 对象，而不是普通的元组。
  • logits_to_keep (Union[int, torch.Tensor]，可选，默认为 0) — 如果是 int，则计算最后 logits_to_keep 个 token 的 logits。如果为 0，则计算所有 input_ids 的 logits（特殊情况）。生成时通常仅需要最后一个 token 的 logits，仅计算该 token 的 logits 可以节省显存，这对于长序列或大词汇量的情况尤为显著。如果是 torch.Tensor，则必须是一维的，对应于需要在序列长度维度上保留的索引。这在通过打包 (packed) 张量格式（批次和序列长度在同一维度）时非常有用。

返回

CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

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

MPT 模型的 forward 方法，覆盖了 __call__ 特殊方法。

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

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

  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头部的预测分数（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), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

    注意力 softmax 后的交叉注意力权重，用于计算交叉注意力头中的加权平均。

  • past_key_values (Cache，*可选*，当传入 use_cache=True 或 config.use_cache=True 时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。

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

示例

MptForSequenceClassification

class transformers.MptForSequenceClassification

< >

( config: MptConfig )

参数

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

带有序列分类头（线性层）的 MPT 模型 Transformer。

MptForSequenceClassification 使用最后一个 token 进行分类，这与其他因果模型（如 GPT-1）的做法相同。

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

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None attention_mask: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None labels: torch.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, input_ids_length)) — input_ids_length = 如果 past_key_values 为 None 则为 sequence_length，否则为 past_key_values.get_seq_length()（输入过去键值状态的 sequence_length）。词汇表中输入序列 token 的索引。

    如果使用了 past_key_values，则仅应将尚未计算其“过去”状态的 input_ids 作为 input_ids 传递。

    索引可以使用 AutoTokenizer 获取。详细信息请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是 input IDs？

  • past_key_values (~cache_utils.Cache，可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包含模型在解码的先前阶段返回的 past_key_values（当 use_cache=True 或 config.use_cache=True 时）。

    输入仅允许使用 Cache 实例，请参阅我们的 kv 缓存指南。如果没有传递 past_key_values，则默认初始化 DynamicCache。

    模型将输出与输入格式一致的缓存。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即其过去键值状态未提供给此模型的那些），形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的所有 input_ids。

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充 token 索引执行注意力的掩码。掩码值选自 [0, 1]：

    • 1 表示未被遮盖的 token，
    • 0 表示被遮盖的 token。

    什么是注意力掩码？

  • inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这会非常有用。
  • labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方误差损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。
  • use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多详情请查看返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。更多详情请查看返回张量中的 hidden_states。
  • return_dict (bool，可选) — 是否返回一个 ModelOutput 对象，而不是普通的元组。

返回

SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

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

The MptForSequenceClassification forward 方法，覆盖了 __call__ 特殊方法。

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

  • loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。

  • logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。

  • past_key_values (Cache，*可选*，当传入 use_cache=True 或 config.use_cache=True 时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。

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

  • 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), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

单标签分类示例

>>> 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()
>>> model.config.id2label[predicted_class_id]
...

>>> # 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
>>> round(loss.item(), 2)
...

多标签分类示例

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

带有 token 分类头（在隐藏状态输出之上的线性层）的 Mpt 模型，例如用于命名实体识别 (NER) 任务。

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None attention_mask: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None labels: torch.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **deprecated_arguments ) → TokenClassifierOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, input_ids_length)) — input_ids_length = sequence_length（若 past_key_values 为 None），否则为 past_key_values.get_seq_length()（输入过去键值状态的 sequence_length）。词表中输入序列标记的索引。

    如果使用了 past_key_values，则仅应将尚未计算其过去的 input_ids 作为 input_ids 传入。

    索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是 input IDs？

  • past_key_values (~cache_utils.Cache，可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速序列解码。这通常由模型在解码的前一阶段返回，当 use_cache=True 或 config.use_cache=True 时。

    仅允许使用 Cache 实例作为输入，请参阅我们的 kv cache 指南。如果没有传入 past_key_values，默认将初始化 DynamicCache。

    模型将输出与输入格式相同的缓存。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即那些没有将其过去键值状态提供给此模型的输入），形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的所有 input_ids。

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选自 [0, 1]：

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

    什么是注意力掩码？

  • inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 作为一个选项，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您想要比模型内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
  • labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵）。
  • use_cache (bool，可选) — 如果设置为 True，将返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是纯元组。

返回

TokenClassifierOutput 或 tuple(torch.FloatTensor)

一个 TokenClassifierOutput 或一个 torch.FloatTensor 元组（若传入 return_dict=False 或 config.return_dict=False 时），根据配置（MptConfig）和输入包含各种元素。

MptForTokenClassification 的 forward 方法，重写了 __call__ 特殊方法。

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

  • loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失。

  • logits (形状为 (batch_size, sequence_length, config.num_labels) 的 torch.FloatTensor) — 分类分数（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), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

示例

>>> 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]]
>>> predicted_tokens_classes
...

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...

MptForQuestionAnswering

class transformers.MptForQuestionAnswering

< >

( config model_args: ~utils.generic.ModelArgs | None = None adapter_args: ~utils.generic.AdapterArgs | None = None lora_args: ~utils.generic.LoRAArgs | None = None tokenizer_args: ~utils.generic.TokenizerArgs | None = None dataset_args: ~utils.generic.DatasetArgs | None = None data_args: ~utils.generic.DataArgs | None = None training_args: ~utils.generic.TrainingArgs | None = None generation_args: ~utils.generic.GenerationArgs | None = None vision_tower_args: ~utils.generic.VisionTowerArgs | None = None qlora_args: ~utils.generic.QLoRAArgs | None = None vision_tower_template_args: ~utils.generic.VisionTowerTemplateArgs | None = None video_tower_args: ~utils.generic.VideoTowerArgs | None = None vision_config: ~utils.generic.VisionConfig | None = None video_config: ~utils.generic.VideoConfig | None = None load_dataset: bool | None = None load_data_collator: bool | None = None load_processor: bool | None = None load_lora_adapter: bool | None = None load_adapter: bool | None = None load_qlora_adapter: bool | None = None **kwargs: typing_extensions.Unpack[transformers.modeling_utils.PreTrainedModelKwargs] )

参数

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

Mpt Transformer，并在顶部配有一个用于抽取式问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出之上添加一个线性层，用于计算 span start logits 和 span end logits）。

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None inputs_embeds: torch.FloatTensor | None = None start_positions: torch.LongTensor | None = None end_positions: torch.LongTensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, input_ids_length)) — input_ids_length = sequence_length（若 past_key_values 为 None），否则为 past_key_values.get_seq_length()。词表中输入序列标记的索引。

    如果使用了 past_key_values，则仅应将尚未计算其过去的 input_ids 作为 input_ids 传入。

    索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是 input IDs？

  • 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 索引转换为关联向量，这将非常有用。
  • start_positions (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算标记分类损失的标签跨度起始位置（索引）。位置被限制在序列长度（sequence_length）范围内。序列之外的位置在计算损失时不予考虑。
  • end_positions (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算标记分类损失的标签跨度结束位置（索引）。位置被限制在序列长度（sequence_length）范围内。序列之外的位置在计算损失时不予考虑。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是纯元组。

返回

QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一个 QuestionAnsweringModelOutput 或一个 torch.FloatTensor 元组（若传入 return_dict=False 或 config.return_dict=False 时），根据配置（MptConfig）和输入包含各种元素。

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

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

  • loss (torch.FloatTensor of shape (1,), 可选, 当提供 labels 时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。

  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围起始分数（SoftMax 之前）。

  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围结束分数（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), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

示例

>>> from transformers import AutoTokenizer, MptForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b")
>>> model = MptForQuestionAnswering.from_pretrained("mosaicml/mpt-7b")

>>> 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)
...

>>> # 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)
...
在 GitHub 上更新

←MPNet MRA→
© . This site is unofficial and not affiliated with Hugging Face, Inc.