Hugging Face 的 LOGO

Transformers 文档

MiniMax

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

MiniMax

概述

MiniMax-Text-01 模型由 MiniMax、Aonian Li、Bangwei Gong、Bo Yang、Boji Shan、Chang Liu、Cheng Zhu、Chunhao Zhang、Congchao Guo、Da Chen、Dong Li、Enwei Jiao、Gengxin Li、Guojun Zhang、Haohai Sun、Houze Dong、Jiadai Zhu、Jiaqi Zhuang、Jiayuan Song、Jin Zhu、Jingtao Han、Jingyang Li、Junbin Xie、Junhao Xu、Junjie Yan、Kaishun Zhang、Kecheng Xiao、Kexi Kang、Le Han、Leyang Wang、Lianfei Yu、Liheng Feng、Lin Zheng、Linbo Chai、Long Xing、Meizhi Ju、Mingyuan Chi、Mozhi Zhang、Peikai Huang、Pengcheng Niu、Pengfei Li、Pengyu Zhao、Qi Yang、Qidi Xu、Qiexiang Wang、Qin Wang、Qiuhui Li、Ruitao Leng、Shengmin Shi、Shuqi Yu、Sichen Li、Songquan Zhu、Tao Huang、Tianrun Liang、Weigao Sun、Weixuan Sun、Weiyu Cheng、Wenkai Li、Xiangjun Song、Xiao Su、Xiaodong Han、Xinjie Zhang、Xinzhu Hou、Xu Min、Xun Zou、Xuyang Shen、Yan Gong、Yingjie Zhu、Yipeng Zhou、Yiran Zhong、Yongyi Hu、Yuanxiang Fan、Yue Yu、Yufeng Yang、Yuhao Li、Yunan Huang、Yunji Li、Yunpeng Huang、Yunzhi Xu、Yuxin Mao、Zehan Li、Zekang Li、Zewei Tao、Zewen Ying、Zhaoyang Cong、Zhen Qin、Zhenhua Fan、Zhihang Yu、Zhuo Jiang、Zijia Wu 在论文 MiniMax-01: Scaling Foundation Models with Lightning Attention 中提出。

论文摘要如下：

我们推出了 MiniMax-01 系列，包括 MiniMax-Text-01 和 MiniMax-VL-01，它们可与顶级模型相媲美，同时在处理更长上下文方面提供了更优越的能力。其核心在于闪电注意力及其高效扩展。为了最大化计算能力，我们将其与混合专家（MoE）集成，创建了一个拥有 32 个专家、总参数 4560 亿的模型，其中每个令牌激活 459 亿参数。我们为 MoE 和闪电注意力开发了优化的并行策略和高效的计算-通信重叠技术。这种方法使我们能够对拥有数千亿参数、跨越数百万令牌上下文的模型进行高效的训练和推理。MiniMax-Text-01 的上下文窗口在训练期间可达 100 万令牌，并在推理期间以可承受的成本外推至 400 万令牌。我们的视觉语言模型 MiniMax-VL-01 是通过使用 5120 亿个视觉语言令牌进行持续训练构建的。在标准和内部基准测试上的实验表明，我们的模型性能与 GPT-4o 和 Claude-3.5-Sonnet 等最先进的模型相当，同时提供了 20-32 倍的更长上下文窗口。

架构细节

MiniMax 是一个强大的语言模型，总参数为 4560 亿，其中每个令牌激活 459 亿参数。为了更好地释放模型的长上下文能力，MiniMax 采用了结合闪电注意力（Lightning Attention）、Softmax 注意力和混合专家（MoE）的混合架构。利用先进的并行策略和创新的计算-通信重叠方法——例如，线性注意力序列并行加（LASP+）、变长环形注意力（varlen ring attention）、专家张量并行（ETP）等——MiniMax 的训练上下文长度扩展到 100 万令牌，并且在推理期间可以处理高达 400 万令牌的上下文。在各种学术基准测试中，MiniMax 也展示了顶级模型的性能。

MiniMax 的架构简要描述如下：

  • 总参数量：4560 亿
  • 每个 Token 激活的参数量：459 亿
  • 层数：80
  • 混合注意力：每 7 个闪电注意力之后有一个 softmax 注意力。
    • 注意力头数：64
    • 注意力头维度：128
  • 混合专家模型
    • 专家数量：32
    • 专家隐藏层维度：9216
    • Top-2 路由策略
  • 位置编码：旋转位置嵌入（RoPE）应用于一半的注意力头维度，基频为 10,000,000
  • 隐藏层大小：6144
  • 词汇表大小：200,064

更多细节请参考 发布博客文章。

许可证

MiniMax 在 MINIMAX 模型许可协议下发布。

使用技巧

预训练模型可以按如下方式使用

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> model = AutoModelForCausalLM.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf", device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> messages = [
...     {"role": "user", "content": "What is your favourite condiment?"},
...     {"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
...     {"role": "user", "content": "Do you have mayonnaise recipes?"}
... ]

>>> model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")

>>> generated_ids = model.generate(model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"Mayonnaise can be made as follows: (...)"

可以看出，指令调优模型需要应用 聊天模板 以确保输入以正确的格式准备。

使用 Flash Attention 加速 MiniMax

上面的代码片段展示了没有任何优化技巧的推理过程。然而，可以通过利用 Flash Attention 来显著加速模型，这是一种模型内部注意力机制的更快实现。

首先，请确保安装最新版本的 Flash Attention 2，以包含滑动窗口注意力功能。

pip install -U flash-attn --no-build-isolation

另请确保你的硬件与 Flash-Attention 2 兼容。有关更多信息，请参阅 flash attention 存储库 的官方文档。此外，请确保以半精度（例如 `torch.float16`）加载模型。

要使用 Flash Attention-2 加载和运行模型，请参考以下代码片段

>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> model = AutoModelForCausalLM.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf", torch_dtype=torch.float16, attn_implementation="flash_attention_2", device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> prompt = "My favourite condiment is"

>>> model_inputs = tokenizer([prompt], return_tensors="pt").to("cuda")
>>> model.to(device)

>>> generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"The expected output"

滑动窗口注意力

当前的实现支持滑动窗口注意力机制和高内存效率的缓存管理。要启用滑动窗口注意力，只需确保 `flash-attn` 版本与滑动窗口注意力兼容 (`>=2.3.0`)。

Flash Attention-2 模型还使用了一种更节省内存的缓存切片机制——根据使用滚动缓存机制的 Mistral 模型的官方实现建议，我们保持缓存大小固定 (`self.config.sliding_window`)，仅对 `padding_side="left"` 支持批处理生成，并使用当前令牌的绝对位置来计算位置嵌入。

使用量化技术压缩 MiniMax 模型

由于 MiniMax 模型有 4560 亿个参数，这在半精度（float16）下将需要大约 912GB 的 GPU RAM，因为每个参数占用 2 个字节。然而，可以使用量化技术来缩小模型的大小。如果模型被量化到 4 位（即每个参数半个字节），则大约需要 228 GB 的 RAM。

量化模型就像向模型传递一个 `quantization_config` 一样简单。下面，我们将利用 bitsandbytes 量化库（但请参阅此页面了解其他量化方法）。

>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

>>> # specify how to quantize the model
>>> quantization_config = BitsAndBytesConfig(
...         load_in_4bit=True,
...         bnb_4bit_quant_type="nf4",
...         bnb_4bit_compute_dtype="torch.float16",
... )

>>> model = AutoModelForCausalLM.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf", quantization_config=True, device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> prompt = "My favourite condiment is"

>>> messages = [
...     {"role": "user", "content": "What is your favourite condiment?"},
...     {"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
...     {"role": "user", "content": "Do you have mayonnaise recipes?"}
... ]

>>> model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")

>>> generated_ids = model.generate(model_inputs, max_new_tokens=100, do_sample=True)
>>> tokenizer.batch_decode(generated_ids)[0]
"The expected output"

此模型由 geetu040 和 Shakib-IO 贡献。原始代码可以在这里找到。

资源

一系列官方 Hugging Face 和社区（由 🌎 标志表示）资源，帮助您开始使用 MiniMax。如果您有兴趣提交资源以包含在此处，请随时发起拉取请求，我们将对其进行审核！资源最好能展示一些新内容，而不是重复现有资源。

文本生成
  • Hugging Face 的 对齐手册 包含了使用 Mistral-7B 进行监督微调（SFT）和直接偏好优化（DPO）的脚本和方法。这包括全量微调、单 GPU 上的 QLoRa 以及多 GPU 微调的脚本。
  • 因果语言建模任务指南

MiniMaxConfig

class transformers.MiniMaxConfig

< >

( vocab_size = 32000 hidden_size = 4096 intermediate_size = 14336 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = 8 head_dim = None hidden_act = 'silu' max_position_embeddings = 131072 initializer_range = 0.02 rms_norm_eps = 1e-05 use_cache = True pad_token_id = None bos_token_id = 1 eos_token_id = 2 tie_word_embeddings = False rope_theta = 1000000.0 sliding_window = None attention_dropout = 0.0 num_experts_per_tok = 2 num_local_experts = 8 output_router_logits = False router_aux_loss_coef = 0.001 router_jitter_noise = 0.0 layer_types = None block_size = 256 full_attn_alpha_factor = 1 full_attn_beta_factor = 1 linear_attn_alpha_factor = 1 linear_attn_beta_factor = 1 mlp_alpha_factor = 1 mlp_beta_factor = 1 **kwargs )

参数

  • vocab_size (int, 可选, 默认为 32000) — MiniMax 模型的词汇表大小。定义了在调用 MiniMaxModel 时传入的 `inputs_ids` 可以表示的不同令牌的数量。
  • hidden_size (int, 可选, 默认为 4096) — 隐藏表示的维度。
  • intermediate_size (int, 可选, 默认为 14336) — MLP 表示的维度。
  • num_hidden_layers (int, 可选, 默认为 32) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, 可选, 默认为 32) — Transformer 编码器中每个注意力层的注意力头数量。
  • num_key_value_heads (int, 可选, 默认为 8) — 这是用于实现分组查询注意力（Grouped Query Attention）的键值头（key_value heads）数量。如果 `num_key_value_heads=num_attention_heads`，模型将使用多头注意力（MHA）；如果 `num_key_value_heads=1`，模型将使用多查询注意力（MQA）；否则使用 GQA。将多头检查点转换为 GQA 检查点时，每个组的键和值头应通过对该组内所有原始头进行均值池化来构建。更多细节，请参阅这篇论文。如果未指定，将默认为 `8`。
  • head_dim (int, 可选, 默认为 `hidden_size // num_attention_heads`) — 注意力头的维度。
  • hidden_act (str 或 `function`, 可选, 默认为 `"silu"`) — 解码器中的非线性激活函数（函数或字符串）。
  • max_position_embeddings (int, 可选, 默认为 `4096*32`) — 此模型可能使用的最大序列长度。MiniMax 的滑动窗口注意力允许长达 4096*32 个令牌的序列。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • rms_norm_eps (float, 可选, 默认为 1e-05) — rms 归一化层使用的 epsilon 值。
  • use_cache (bool, optional, defaults to True) — 模型是否应返回最后一个键/值注意力（并非所有模型都使用）。仅当 config.is_decoder=True 时相关。
  • pad_token_id (int, optional) — 填充标记的 ID。
  • bos_token_id (int, optional, defaults to 1) — “序列开始”标记的 ID。
  • eos_token_id (int, optional, defaults to 2) — “序列结束”标记的 ID。
  • tie_word_embeddings (bool, optional, defaults to False) — 是否将模型的输入和输出词嵌入绑定在一起。
  • rope_theta (float, optional, defaults to 1000000.0) — RoPE 嵌入的基础周期。
  • sliding_window (int, optional) — 滑动窗口注意力的窗口大小。如果未指定，将默认为 4096。
  • attention_dropout (float, optional, defaults to 0.0) — 注意力概率的丢弃率。
  • num_experts_per_tok (int, optional, defaults to 2) — 每个标记要路由到的专家数量，也可以解释为 top-k 路由参数。
  • num_local_experts (int, optional, defaults to 8) — 每个稀疏 MLP 层的专家数量。
  • output_router_logits (bool, optional, defaults to False) — 模型是否应返回路由器 logits。启用此选项还将允许模型输出辅助损失。更多详情请参阅此处。
  • router_aux_loss_coef (float, optional, defaults to 0.001) — 总损失的辅助损失因子。
  • router_jitter_noise (float, optional, defaults to 0.0) — 添加到路由器的噪声量。
  • layer_types (list, optional) — 每层的注意力模式。
  • block_size (int, optional, defaults to 256) — 每个注意力块的长度，决定了查询、键和值如何分组和处理，以进行块内和块间注意力。
  • full_attn_alpha_factor (float, optional, defaults to 1) — 普通注意力后残差连接中残差值的权重。
  • full_attn_beta_factor (float, optional, defaults to 1) — 普通注意力后残差连接中隐藏状态值的权重。
  • linear_attn_alpha_factor (float, optional, defaults to 1) — 闪电注意力后残差连接中残差值的权重。
  • linear_attn_beta_factor (float, optional, defaults to 1) — 闪电注意力后残差连接中隐藏状态值的权重。
  • mlp_alpha_factor (float, optional, defaults to 1) — MLP 后残差连接中残差值的权重。
  • mlp_beta_factor (float, optional, defaults to 1) — MLP 后残差连接中隐藏状态值的权重。

这是一个配置类，用于存储 MiniMaxModel 的配置。它用于根据指定的参数实例化一个 MiniMax 模型，定义模型架构。使用默认值实例化配置将产生与 MiniMax 类似的配置。

MiniMaxAI/MiniMax-Text-01-hf

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

>>> from transformers import MiniMaxModel, MiniMaxConfig

>>> # Initializing a MiniMax style configuration
>>> configuration = MiniMaxConfig()

>>> # Initializing a model from the MiniMax style configuration
>>> model = MiniMaxModel(configuration)

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

MiniMaxModel

class transformers.MiniMaxModel

< >

( config: MiniMaxConfig )

参数

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

基础的 Minimax 模型，输出原始的隐藏状态，顶部没有任何特定的头。

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

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

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None output_router_logits: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) → transformers.modeling_outputs.MoeModelOutputWithPast 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。

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

    什么是输入 ID？

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

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

    什么是注意力掩码？

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 范围内选择。

    什么是位置 ID？

  • past_key_values (list[torch.FloatTensor], optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的前一个阶段返回的 `past_key_values`，当 `use_cache=True` 或 `config.use_cache=True` 时。

    允许两种格式：

    • Cache 实例，请参阅我们的kv 缓存指南；
    • 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组，每个元组包含 2 个形状为 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的张量。这也称为传统缓存格式。

    模型将输出与输入相同的缓存格式。如果未传递 `past_key_values`，则将返回传统缓存格式。

    如果使用 `past_key_values`，用户可以选择只输入最后一个 `input_ids`（即那些没有为其提供过去键值状态的 `input_ids`），形状为 `(batch_size, 1)`，而不是所有形状为 `(batch_size, sequence_length)` 的 `input_ids`。

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 `input_ids`。如果您希望比模型内部的嵌入查找矩阵更能控制如何将 `input_ids` 索引转换为关联向量，这将非常有用。
  • use_cache (bool, optional) — 如果设置为 `True`，将返回 `past_key_values` 键值状态，可用于加速解码（请参阅 `past_key_values`）。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 `attentions`。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 `hidden_states`。
  • output_router_logits (bool, optional) — 是否返回所有路由器的 logits。它们对于计算路由器损失很有用，在推理期间不应返回。
  • cache_position (torch.LongTensor of shape (sequence_length), optional) — 描述输入序列标记在序列中位置的索引。与 `position_ids` 不同，此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。

返回

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

一个 `transformers.modeling_outputs.MoeModelOutputWithPast` 或一个 `torch.FloatTensor` 元组（如果传递了 `return_dict=False` 或 `config.return_dict=False`），根据配置（MiniMaxConfig）和输入包含各种元素。

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

  • past_key_values (Cache, optional, 当传递 `use_cache=True` 或 `config.use_cache=True` 时返回) — 这是一个 Cache 实例。更多详情请参阅我们的kv 缓存指南。

    包含预计算的隐藏状态（自注意力块中的键和值，如果 `config.is_encoder_decoder=True`，则还包括交叉注意力块中的键和值），可用于（参见 `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 后的注意力权重，用于计算自注意力头中的加权平均值。

  • router_logits (tuple(torch.FloatTensor), optional, 当传递 `output_router_probs=True` 和 `config.add_router_probs=True` 或 `config.output_router_probs=True` 时返回) — `torch.FloatTensor` 的元组（每层一个），形状为 `(batch_size, sequence_length, num_experts)`。

    由 MoE 路由器计算的原始路由器对数（softmax 后），这些术语用于计算专家混合模型的辅助损失。

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

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

MiniMaxForCausalLM

class transformers.MiniMaxForCausalLM

< >

( config )

参数

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

用于因果语言建模的 MiniMax 模型。

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None output_router_logits: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.minimax.modeling_minimax.KwargsForCausalLM] ) → transformers.modeling_outputs.MoeCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。

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

    什么是输入 ID？

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

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

    什么是注意力掩码？

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 范围内选择。

    什么是位置 ID？

  • past_key_values (list[torch.FloatTensor], optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的前一个阶段返回的 `past_key_values`，当 `use_cache=True` 或 `config.use_cache=True` 时。

    允许两种格式：

    • Cache 实例，请参阅我们的kv 缓存指南；
    • 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组，每个元组包含 2 个形状为 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的张量。这也称为传统缓存格式。

    模型将输出与输入相同的缓存格式。如果未传递 `past_key_values`，则将返回传统缓存格式。

    如果使用 `past_key_values`，用户可以选择只输入最后一个 `input_ids`（即那些没有为其提供过去键值状态的 `input_ids`），形状为 `(batch_size, 1)`，而不是所有形状为 `(batch_size, sequence_length)` 的 `input_ids`。

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 `input_ids`。如果您希望比模型内部的嵌入查找矩阵更能控制如何将 `input_ids` 索引转换为关联向量，这将非常有用。
  • labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在 `[0, ..., config.vocab_size]` 或 -100 之间（请参阅 `input_ids` 文档字符串）。索引设置为 `-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。
  • output_router_logits (bool, 可选) — 是否返回所有路由器的 logits。它们对于计算路由器损失很有用，在推理期间不应返回。
  • cache_position (torch.LongTensor, 形状为 (sequence_length), 可选) — 描述输入序列中词元位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。
  • logits_to_keep (Union[int, torch.Tensor], 默认为 0) — 如果是 int，则为最后 logits_to_keep 个词元计算 logits。如果是 0，则为所有 input_ids 计算 logits（特殊情况）。在生成任务中，通常只需要最后一个词元的 logits，仅为此词元计算可以节省内存，这对于长序列或大词汇表来说非常重要。如果是 torch.Tensor，则必须是一维的，对应于序列长度维度中要保留的索引。这在使用打包张量格式（批次和序列长度使用单一维度）时非常有用。

返回

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

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

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

  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。

  • aux_loss (torch.FloatTensor，可选，当提供 labels 时返回) — 稀疏模块的辅助损失。

  • router_logits (tuple(torch.FloatTensor), optional, 当传递 `output_router_probs=True` 和 `config.add_router_probs=True` 或 `config.output_router_probs=True` 时返回) — `torch.FloatTensor` 的元组（每层一个），形状为 `(batch_size, sequence_length, num_experts)`。

    由 MoE 路由器计算的原始路由器对数（softmax 后），这些术语用于计算专家混合模型的辅助损失。

  • past_key_values (Cache, optional, 当传递 `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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, MiniMaxForCausalLM

>>> model = MiniMaxForCausalLM.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."

MiniMaxForSequenceClassification

class transformers.MiniMaxForSequenceClassification

< >

( config )

参数

带有序列分类头的 MiniMax 模型转换器（顶层加一个线性层）。

MiniMaxForSequenceClassification 使用最后一个词元进行分类，与其他因果模型（如 GPT-2）一样。

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

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列词元的索引。默认情况下，填充将被忽略。

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

    什么是输入 ID？

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

    • 1 表示词元未被掩码，
    • 0 表示词元被掩码。

    什么是注意力掩码？

  • position_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 每个输入序列词元在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 范围内选择。

    什么是位置 ID？

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

    允许两种格式：

    • 一个 Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，其中每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也被称为传统缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传递 past_key_values，将返回传统缓存格式。

    如果使用了 past_key_values，用户可以选择只输入最后一个 input_ids（那些没有给出其过去键值状态的词元），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • inputs_embeds (torch.FloatTensor, 形状为 (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。

返回

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

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

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

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

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

单标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, MiniMaxForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")
>>> model = MiniMaxForSequenceClassification.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> 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 = MiniMaxForSequenceClassification.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...

多标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, MiniMaxForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")
>>> model = MiniMaxForSequenceClassification.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf", 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 = MiniMaxForSequenceClassification.from_pretrained(
...     "MiniMaxAI/MiniMax-Text-01-hf", 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

MiniMaxForTokenClassification

class transformers.MiniMaxForTokenClassification

< >

( config )

参数

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

带有词元分类头的 Minimax 转换器（在隐藏状态输出之上加一个线性层），例如用于命名实体识别（NER）任务。

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列词元的索引。默认情况下，填充将被忽略。

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

    什么是输入 ID？

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

    • 1 表示词元未被掩码，
    • 0 表示词元被掩码。

    什么是注意力掩码？

  • position_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 每个输入序列词元在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 范围内选择。

    什么是位置 ID？

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

    允许两种格式：

    • 一个 Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，其中每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也被称为传统缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传递 past_key_values，将返回传统缓存格式。

    如果使用了 past_key_values，用户可以选择只输入最后一个 input_ids（那些没有给出其过去键值状态的词元），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • inputs_embeds (torch.FloatTensor, 形状为 (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。

返回

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

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

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

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

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

示例

>>> from transformers import AutoTokenizer, MiniMaxForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")
>>> model = MiniMaxForTokenClassification.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

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

MiniMaxForQuestionAnswering

class transformers.MiniMaxForQuestionAnswering

< >

( config )

参数

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

带有片段分类头的 Minimax 转换器，用于像 SQuAD 这样的抽取式问答任务（在隐藏状态输出之上加一个线性层，以计算 span start logits 和 span end logits）。

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, list[torch.FloatTensor], NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列词元的索引。默认情况下，填充将被忽略。

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

    什么是输入 ID？

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

    • 1 表示词元未被掩码，
    • 0 表示词元被掩码。

    什么是注意力掩码？

  • position_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 每个输入序列词元在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 范围内选择。

    什么是位置 ID？

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

    允许两种格式：

    • 一个 Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，其中每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也被称为传统缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传递 past_key_values，将返回传统缓存格式。

    如果使用了 past_key_values，用户可以选择只输入最后一个 input_ids（那些没有给出其过去键值状态的词元），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • inputs_embeds (torch.FloatTensor, 形状为 (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。

返回

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

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

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

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

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

示例

>>> from transformers import AutoTokenizer, MiniMaxForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")
>>> model = MiniMaxForQuestionAnswering.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf")

>>> 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 上更新

←MegatronGPT2 Mistral→