Transformers documentation
MiniMax
该模型于 2025-01-14 在 HF papers 上发布，并于 2025-06-04 贡献至 Hugging Face Transformers。
MiniMax
MiniMax-M2 于 2025‑10‑27 发布。由于整体性能更优，我们建议大多数使用场景使用 MiniMax‑M2。
概述
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。这些模型的性能可与顶级模型相媲美，同时在处理更长上下文方面具备更出色的能力。其核心在于 lightning attention 及其高效扩展。为了最大化计算能力，我们将其与 Mixture of Experts (MoE) 相结合，构建了一个包含 32 个专家、总参数量达 4560 亿的模型，其中每个 token 激活 459 亿参数。我们为 MoE 和 lightning attention 开发了优化的并行策略以及高效的计算-通信重叠技术。该方法使我们能够在数百万 token 的上下文范围内，对具有数千亿参数的模型进行高效的训练和推理。MiniMax-Text-01 的上下文窗口在训练期间可高达 100 万 token，并以可承受的成本在推理期间外推至 400 万 token。我们的视觉语言模型 MiniMax-VL-01 是通过使用 5120 亿个视觉语言 token 进行持续训练而构建的。在标准基准和内部基准上的实验表明，我们的模型性能与 GPT-4o 和 Claude-3.5-Sonnet 等最先进模型相当，同时提供长 20 至 32 倍的上下文窗口。
架构细节
MiniMax 是一个拥有 4560 亿总参数的大型语言模型，其中每个 token 激活 459 亿参数。为了更好地释放模型的长上下文能力，MiniMax 采用了一种混合架构，结合了 Lightning Attention、Softmax Attention 和 Mixture-of-Experts (MoE)。借助先进的并行策略和创新的计算-通信重叠方法——例如 Linear Attention Sequence Parallelism Plus (LASP+)、varlen ring attention、Expert Tensor Parallel (ETP) 等，MiniMax 的训练上下文长度被扩展至 100 万 token，并且在推理阶段可以处理高达 400 万 token 的上下文。在各种学术基准测试中，MiniMax 也展现了顶级模型的性能。
MiniMax 的架构简要描述如下：
- 总参数量：456B
- 每个 Token 的激活参数：45.9B
- 层数：80
- 混合注意力：每 7 个 lightning attention 之后放置一个 softmax attention。
- 注意力头数量：64
- 注意力头维度：128
- 专家混合（Mixture of Experts）：
- 专家数量：32
- 专家隐藏维度：9216
- Top-2 路由策略
- 位置编码：对注意力头维度的一半应用旋转位置嵌入（RoPE），基础频率为 10,000,000
- 隐藏层大小：6144
- 词表大小：200,064
有关更多详细信息，请参阅发布博客文章。
许可证
MiniMax 在 MINIMAX MODEL LICENSE AGREEMENT 下发布。
使用技巧
预训练模型可以按以下方式使用：
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(model.device)
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 是模型内部所用注意力机制的一种更快实现。
首先，请确保安装最新版本的 Flash Attention 2，以包含滑动窗口注意力功能。
pip install -U flash-attn --no-build-isolation
请确保您的硬件与 Flash-Attention 2 兼容。有关详细信息，请参阅 flash attention 仓库 的官方文档。同时，请确保以半精度（例如 torch.float16）加载您的模型。
要使用 Flash Attention-2 加载并运行模型，请参阅以下代码片段：
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("MiniMaxAI/MiniMax-Text-01-hf", 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(model.device)
model.to(model.device)
generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"The expected output"滑动窗口 Attention
当前实现支持滑动窗口注意力机制和内存高效的缓存管理。
要启用滑动窗口注意力，只需确保使用与滑动窗口注意力兼容的 flash-attn 版本（>=2.3.0）。
Flash Attention-2 模型还采用了更节省内存的缓存切片机制——按照 Mistral 模型官方实现中推荐的滚动缓存机制，我们将缓存大小固定为 self.config.sliding_window，仅支持 padding_side="left" 的批量生成，并使用当前 token 的绝对位置来计算位置嵌入。
使用量化缩小 MiniMax
由于 MiniMax 模型拥有 4560 亿个参数，在半精度（float16）下大约需要 912GB 的 GPU 显存，因为每个参数占用 2 字节。不过，可以使用量化来缩小模型的体积。如果将模型量化到 4 位（即每个参数占用半字节），则大约需要 228 GB 的显存。
量化模型只需向模型传入 quantization_config 即可。下面我们将使用 bitsandbytes 量化库（有关其他量化方法，请参阅 此页面）：
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(model.device)
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。如果您希望提交资源以收录于此，欢迎随时发起 Pull Request，我们将进行审核！理想情况下，该资源应展示一些新内容，而非重复现有资源。
Hugging Face 的 Alignment Handbook 提供了用于对 Mistral-7B 执行监督微调（SFT）和直接偏好优化的脚本和配方。其中包括用于全量微调、单 GPU 上的 QLoRa 以及多 GPU 微调的脚本。
在批量生成时使用左侧填充。请参阅 填充侧。
MiniMaxConfig
类 transformers.MiniMaxConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 32000hidden_size: int = 4096intermediate_size: int = 14336num_hidden_layers: int = 32num_attention_heads: int = 32num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'silu'max_position_embeddings: int = 131072initializer_range: float = 0.02rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = Falsesliding_window: int | None = Noneattention_dropout: float | int = 0.0num_experts_per_tok: int = 2num_local_experts: int = 8output_router_logits: bool = Falserouter_aux_loss_coef: float = 0.001router_jitter_noise: float = 0.0rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonelayer_types: list[str] | None = Noneblock_size: int = 256full_attn_alpha_factor: int | float = 1full_attn_beta_factor: int | float = 1linear_attn_alpha_factor: int | float = 1linear_attn_beta_factor: int | float = 1mlp_alpha_factor: int | float = 1mlp_beta_factor: int | float = 1 )
参数
- vocab_size (
int，可选，默认为32000) — 模型的词汇表大小。定义了input_ids可以表示的不同 token 数量。 - 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 头数。如果num_key_value_heads=num_attention_heads，模型将使用 Multi Head Attention (MHA)；如果num_key_value_heads=1，模型将使用 Multi Query Attention (MQA)；否则使用 GQA。在将多头检查点转换为 GQA 检查点时，每个组的 key 和 value 头应通过对该组内所有原始头进行 meanpooling 来构建。更多详情请参阅 这篇论文。如果未指定，则默认为num_attention_heads。 - head_dim (
int，可选) — 注意力头维度。如果为 None，则默认为 hidden_size // num_attention_heads - hidden_act (
str，可选，默认为silu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu"等。 - max_position_embeddings (
int，可选，默认为131072) — 该模型可能使用的最大序列长度。 - initializer_range (
float，可选，默认为0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - rms_norm_eps (
float，可选，默认为1e-05) — RMS 归一化层使用的 epsilon 值。 - use_cache (
bool，可选，默认为True) — 模型是否应返回最后一次键/值注意力（并非所有模型都使用）。仅当config.is_decoder=True或模型为仅解码器生成式模型时相关。 - pad_token_id (
int, 可选) — 词表中用于填充的 token id。 - bos_token_id (
int，可选，默认为1) — 词汇表中用于表示流起始的 token id。 - eos_token_id (
Union[int, list[int]]，可选，默认为2) — 词汇表中用于表示流结束（end-of-stream）的 token id。 - tie_word_embeddings (
bool，可选，默认为False) — 是否根据模型的tied_weights_keys映射来绑定权重嵌入。 - sliding_window (
int, 可选) — 滑动窗口注意力的窗口大小。如果为None，则不应用滑动窗口。 - attention_dropout (
Union[float, int]，可选，默认为0.0) — 注意力概率的 dropout 比率。 - num_experts_per_tok (
int，可选，默认为2) — 每个 token 路由到的专家数量。这是 token 选择路由的 top-k 值。 - num_local_experts (
int，可选，默认为8) — 每个设备上的本地专家数量。num_experts应能被num_local_experts整除。 - output_router_logits (
bool，可选，默认为False) — 是否由模型返回路由器 logits。启用此选项后，模型还将输出辅助损失，包括负载均衡损失和路由器 z-loss。 - router_aux_loss_coef (
float，可选，默认值为0.001) — 辅助负载均衡损失系数。用于惩罚 MoE 模型中专家路由的不均衡。 - router_jitter_noise (
float，可选，默认值为0.0) — 在训练期间为 router logits 添加的噪声量，以实现更好的负载均衡。 - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], 可选) — 包含 RoPE 嵌入配置参数的字典。该字典应包含rope_theta的值，并且如果希望使用 RoPE 处理更长的max_position_embeddings，则可选地包含用于缩放的参数。 - layer_types (
list[str], 可选) — 一个列表，用于显式地将每个层索引映射到其层类型。如果未提供，将根据 config 值自动生成。 - block_size (
int，可选，默认值为 256) — 每个注意力块的长度，决定查询、键和值如何分组并处理，以执行块内和块间注意力。 - full_attn_alpha_factor (
float，可选，默认为 1) — 在常规注意力之后的残差连接中，残差值的权重。 - full_attn_beta_factor (
float，可选，默认为 1) — 在常规注意力之后，残差连接中隐藏状态值的权重。 - linear_attn_alpha_factor (
float，可选，默认为 1) — lightning attention 之后残差连接中残差值的权重。 - linear_attn_beta_factor (
float, 可选，默认为 1) — 在 lightning attention 之后，残差连接中隐藏状态值的权重。 - mlp_alpha_factor (
float，可选，默认为 1) — MLP 之后残差连接中残差值的权重。 - mlp_beta_factor (
float，可选，默认为 1) — MLP 之后残差连接中隐藏状态值的权重。
这是用于存储 MiniMaxModel 配置的类。它根据指定的参数实例化 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.configMiniMaxModel
class transformers.MiniMaxModel
< source >( config: MiniMaxConfig )
参数
- config (MiniMaxConfig) — 模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
未添加任何特定头部的裸 Minimax 模型，直接输出原始隐藏状态。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.models.minimax.modeling_minimax.MiniMaxCache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )
MiniMaxForCausalLM
class transformers.MiniMaxForCausalLM
< source >( config: MiniMaxConfig )
参数
- config (MiniMaxConfig) — 模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
用于因果语言建模的 Minimax 模型。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_router_logits: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MoeCausalLMOutputWithPast or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - past_key_values (
~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由past_key_values在解码的先前阶段返回，当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。 - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引值应在[0, ..., config.vocab_size]范围内，或为 -100（参见input_ids的文档字符串）。索引值设为-100的 token 将被忽略（即被掩码），损失仅针对标签位于[0, ..., config.vocab_size]范围内的 token 进行计算。 - use_cache (
bool，可选) — 如果设置为True，则会返回past_key_values键值状态，可用于加速解码（参见past_key_values）。 - output_router_logits (
bool, 可选) — 是否返回所有路由器的 logits。它们对于计算路由器损失很有用，在推理期间不应返回。 - logits_to_keep (
Union[int, torch.Tensor], 可选，默认为0) — 如果为int，则计算最后logits_to_keep个 token 的 logits。如果为0，则计算所有input_ids的 logits（特殊情况）。生成过程只需要最后一个 token 的 logits，仅针对该 token 进行计算可以节省内存，对于长序列或大词汇量而言，这种节省相当显著。 如果为torch.Tensor，则必须是一维张量，对应于序列长度维度中需要保留的索引。 这在使用打包张量格式（将批次和序列长度合并为单一维度）时非常有用。
返回值
MoeCausalLMOutputWithPast 或 tuple(torch.Tensor)
MoeCausalLMOutputWithPast 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（MiniMaxConfig）和输入。
MiniMaxForCausalLM 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个 token 预测）。logits（形状为
(batch_size, sequence_length, config.vocab_size)的torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。aux_loss (
torch.Tensor，可选，当传入output_router_logits=True或config.output_router_logits=True，且模型使用负载均衡损失训练其路由器时返回) — 稀疏模块的负载均衡辅助损失。那些改用路由器偏差来平衡其专家（DeepSeek-V3 及由其衍生的架构）的模型，此处返回None，但仍会返回router_logits。router_logits (
tuple(torch.Tensor)，可选，在传入output_router_logits=True或config.output_router_logits=True时返回) — 一个torch.Tensor元组（每个稀疏层对应一个），形状为(batch_size * sequence_length, num_experts)。由 MoE 路由器计算的原始路由器 logits。可用于计算负载均衡损失，或检查 token 如何被分发到各个专家。
past_key_values（
Cache，可选，在传入use_cache=True或config.use_cache=True时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.Tensor | None = Nonelabels: torch.LongTensor | None = Noneuse_cache: bool | None = None**kwargs: Unpack[TransformersKwargs] ) → SequenceClassifierOutputWithPast
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - past_key_values (
Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的past_key_values组成，此时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。 - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入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）。
返回值
SequenceClassifierOutputWithPast
GenericForSequenceClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
MiniMaxForTokenClassification
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.Tensor | None = Nonelabels: torch.LongTensor | None = Noneuse_cache: bool | None = None**kwargs: Unpack[TransformersKwargs] ) → TokenClassifierOutput
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - past_key_values (
Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的past_key_values组成，此时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。 - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels（形状为
(batch_size, sequence_length)的torch.LongTensor，可选） — 用于计算 token 分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。 - use_cache (
bool，可选) — 如果设置为True，则会返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
返回值
TokenClassifierOutput
GenericForTokenClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
MiniMaxForQuestionAnswering
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.Tensor | None = Nonestart_positions: torch.LongTensor | None = Noneend_positions: torch.LongTensor | None = None**kwargs: Unpack[TransformersKwargs] ) → QuestionAnsweringModelOutput
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - past_key_values (
Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回的past_key_values组成，此时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。 - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - start_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的标注片段起始位置（索引）的标签。 位置会被截断到序列长度（sequence_length）。序列之外的位置在计算损失时不予考虑。 - end_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的标注片段结束位置（索引）的标签。 位置会被截断到序列长度（sequence_length）。序列之外的位置在计算损失时不予考虑。
返回值
QuestionAnsweringModelOutput
GenericForQuestionAnswering 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。