Transformers 文档
MiniMax
并获得增强的文档体验
开始使用
该模型发布于 2025-01-14，并于 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（闪电注意力机制）及其高效的扩展能力。为了最大化计算能力，我们将其与混合专家模型（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 和混合专家（MoE）的混合架构。利用先进的并行策略和创新的计算-通信重叠方法——如线性注意力序列并行增强版（LASP+）、不定长环形注意力（varlen ring attention）、专家张量并行（ETP）等，MiniMax 的训练上下文长度延伸到了 100 万 token，且在推理过程中可以处理多达 400 万 token 的上下文。在各项学术基准测试中，MiniMax 也展现出了顶级模型的性能。
MiniMax 的架构概况如下：
- 总参数量：456B
- 每 token 激活参数量：45.9B
- 层数：80
- 混合注意力：每 7 层 Lightning Attention 后配置一层 Softmax Attention。
- 注意力头数：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(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: (...)"如你所见，指令微调模型需要应用 聊天模板（chat template） 以确保输入以正确的格式准备。
使用 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", 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(model.device)
>>> 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 模型还使用了一种更节省内存的缓存切片机制——正如使用滚动缓存（rolling cache）机制的 Mistral 模型官方实现所建议的那样，我们保持缓存大小固定（self.config.sliding_window），仅在 padding_side="left" 时支持批量生成，并使用当前 token 的绝对位置来计算位置嵌入。
通过量化缩小 MiniMax
由于 MiniMax 模型拥有 4560 亿个参数，在半精度（float16）下需要约 912GB 的显存，因为每个参数占用 2 个字节。但是，可以通过 量化 来缩小模型尺寸。如果将模型量化为 4 位（即每个参数占用半个字节），则仅需约 228GB 显存。
量化模型非常简单，只需向模型传递一个 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(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）和直接偏好优化（DPO）的脚本与方案。其中包括全量微调、单 GPU 上的 QLoRa 以及多 GPU 微调的脚本。
- 因果语言建模任务指南
MiniMaxConfig
class transformers.MiniMaxConfig
< source >( vocab_size: int | None = 32000 hidden_size: int | None = 4096 intermediate_size: int | None = 14336 num_hidden_layers: int | None = 32 num_attention_heads: int | None = 32 num_key_value_heads: int | None = 8 head_dim: int | None = None hidden_act: str | None = 'silu' max_position_embeddings: int | None = 131072 initializer_range: float | None = 0.02 rms_norm_eps: int | None = 1e-05 use_cache: bool | None = True pad_token_id: int | None = None bos_token_id: int | None = 1 eos_token_id: int | None = 2 tie_word_embeddings: bool | None = False sliding_window: int | None = None attention_dropout: float | None = 0.0 num_experts_per_tok: int | None = 2 num_local_experts: int | None = 8 output_router_logits: bool | None = False router_aux_loss_coef: float | None = 0.001 router_jitter_noise: float | None = 0.0 rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict[str, transformers.modeling_rope_utils.RopeParameters] | None = None layer_types: list[str] | None = None block_size: int | None = 256 full_attn_alpha_factor: int | None = 1 full_attn_beta_factor: int | None = 1 linear_attn_alpha_factor: int | None = 1 linear_attn_beta_factor: int | None = 1 mlp_alpha_factor: int | None = 1 mlp_beta_factor: int | None = 1 **kwargs )
参数
- vocab_size (
int, 可选, 默认为 32000) — MiniMax 模型的词表大小。定义了调用 MiniMaxModel 时传入的inputs_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，模型将使用多头注意力（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 个 token 的序列。 - 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 (
int, 可选, 默认为 2) — “序列结束”token 的 ID。 - tie_word_embeddings (
bool, 可选, 默认为False) — 模型的输入和输出词嵌入是否应该绑定。 - sliding_window (
int, 可选) — 滑动窗口注意力的窗口大小。如果未指定，将默认使用4096。 - attention_dropout (
float, 可选, 默认为 0.0) — 注意力概率的丢弃率（dropout ratio）。 - num_experts_per_tok (
int, 可选, 默认为 2) — 每个 token 路由到的专家数量，也可以解释为top-k路由参数。 - num_local_experts (
int, 可选, 默认为 8) — 每个稀疏 MLP 层的专家数量。 - output_router_logits (
bool, 可选, 默认为False) — 是否应由模型返回路由器的 logits。启用此选项还将允许模型输出辅助损失。详见此处。 - router_aux_loss_coef (
float, 可选, 默认为 0.001) — 总损失中的辅助损失系数。 - router_jitter_noise (
float, 可选, 默认为 0.0) — 添加到路由器的噪声量。 - rope_parameters (
RopeParameters, 可选) — 包含 RoPE 嵌入配置参数的字典。该字典应包含rope_theta的值，以及可选的缩放参数（如果您希望在更长的max_position_embeddings下使用 RoPE）。 - layer_types (
list, 可选) — 每一层的注意力模式。 - block_size (
int, 可选, 默认为 256) — 每个注意力块的长度，决定了查询（queries）、键（keys）和值（values）如何分组处理，以进行块内和块间注意力。 - 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 模型，定义模型架构。使用默认值实例化配置将产生与 MiniMax 类似的配置。
配置对象继承自 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
< 源码 >( config: MiniMaxConfig )
参数
- config (MiniMaxConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。
基础 Minimax 模型，输出原始隐藏状态，顶部没有任何特定头部。
此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None position_ids: torch.LongTensor | None = None past_key_values: transformers.models.minimax.modeling_minimax.MiniMaxCache | None = None inputs_embeds: torch.FloatTensor | None = None use_cache: bool | None = None cache_position: torch.LongTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] )
MiniMaxForCausalLM
class transformers.MiniMaxForCausalLM
< 源码 >( 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 (MiniMaxForCausalLM) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。
用于因果语言建模（causal language modeling）的 Minimax 模型。
此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源码 >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None position_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None output_router_logits: bool | None = None cache_position: torch.LongTensor | None = None logits_to_keep: int | torch.Tensor = 0 **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → transformers.modeling_outputs.MoeCausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 词汇表中输入序列 token 的索引。默认情况下将忽略填充（padding）。索引可以使用 AutoTokenizer 获取。详见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — 遮罩，以避免对填充 token 索引执行注意力。遮罩值选自[0, 1]：- 1 表示 未遮罩 的 token，
- 0 表示 已遮罩 的 token。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 每个输入序列 token 在位置嵌入中的位置索引。选值范围为[0, config.n_positions - 1]。 - 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，用户应当只输入形状为(batch_size, unprocessed_length)的未处理input_ids（即那些尚未将过去键值状态提供给此模型的 ID），而不是所有形状为(batch_size, sequence_length)的input_ids。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 可选。您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型内部嵌入查找矩阵更自主地控制如何将input_ids索引转换为关联向量，这很有用。 - labels (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于计算遮罩语言建模损失的标签。索引应在[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。它们对于计算路由器损失很有用，但在推理时不应返回。 - cache_position (形状为
(sequence_length)的torch.LongTensor, 可选) — 描述输入序列 token 在序列中位置的索引。与position_ids不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整序列长度。 - logits_to_keep (
Union[int, torch.Tensor], 可选, 默认为0) — 如果是int，则计算最后logits_to_keep个 token 的 logits。如果是0（特殊情况），则计算所有input_ids的 logits。生成过程中仅需要最后一个 token 的 logits，仅为该 token 计算 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), 可选, 当传递output_router_probs=True且config.add_router_probs=True时，或config.output_router_probs=True时返回) — 形状为(batch_size, sequence_length, num_experts)的torch.FloatTensor元组（每一层一个）。由 MoE 路由器计算的原始路由器对数（softmax 后），这些术语用于计算专家混合模型的辅助损失。
-
past_key_values (
Cache, optional, 当传递use_cache=True或当config.use_cache=True时返回) — 它是 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见
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__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
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
forward
< 源码 >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None position_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 词汇表中输入序列 token 的索引。默认情况下将忽略填充（padding）。索引可以使用 AutoTokenizer 获取。详见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — 遮罩，以避免对填充 token 索引执行注意力。遮罩值选自[0, 1]：- 1 表示 未遮罩 的 token，
- 0 表示 已遮罩 的 token。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 每个输入序列 token 在位置嵌入中的位置索引。选值范围为[0, config.n_positions - 1]。 - 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，用户应当只输入形状为(batch_size, unprocessed_length)的未处理input_ids（即那些尚未将过去键值状态提供给此模型的 ID），而不是所有形状为(batch_size, sequence_length)的input_ids。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 可选。您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型内部嵌入查找矩阵更自主地控制如何将input_ids索引转换为关联向量，这很有用。 - labels (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于计算遮罩语言建模损失的标签。索引应在[0, ..., config.vocab_size]范围内或为 -100（见input_ids文档字符串）。索引设置为-100的 token 将被忽略（遮罩），损失仅针对标签在[0, ..., config.vocab_size]之间的 token 进行计算。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
返回
transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.SequenceClassifierOutputWithPast or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (None) and inputs.
-
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 cache 指南。包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见
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 后的注意力权重，用于计算自注意力头中的加权平均值。
The GenericForSequenceClassification forward method, overrides the __call__ special method.
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
MiniMaxForTokenClassification
forward
< 源码 >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None position_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 词汇表中输入序列 token 的索引。默认情况下将忽略填充（padding）。索引可以使用 AutoTokenizer 获取。详见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — 遮罩，以避免对填充 token 索引执行注意力。遮罩值选自[0, 1]：- 1 表示 未遮罩 的 token，
- 0 表示 已遮罩 的 token。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 每个输入序列 token 在位置嵌入中的位置索引。选值范围为[0, config.n_positions - 1]。 - 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，用户应当只输入形状为(batch_size, unprocessed_length)的未处理input_ids（即那些尚未将过去键值状态提供给此模型的 ID），而不是所有形状为(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, sequence_length)，可选) — 用于计算掩码语言模型损失的标签。索引应在[0, ..., config.vocab_size]之间或为 -100（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]之间的标记进行计算。 - use_cache (
bool，可选) — 如果设置为True，将返回past_key_values键值状态，可用于加速解码（请参阅past_key_values）。
返回
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.TokenClassifierOutput or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (None) and inputs.
-
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 后的注意力权重，用于计算自注意力头中的加权平均值。
The GenericForTokenClassification forward method, overrides the __call__ special method.
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
MiniMaxForQuestionAnswering
forward
< 来源 >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None position_ids: torch.LongTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None start_positions: torch.LongTensor | None = None end_positions: torch.LongTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 输入序列标记在词汇表中的索引。默认情况下将忽略填充（Padding）。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]范围内选择。 - 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，用户应仅输入形状为(batch_size, unprocessed_length)的未处理input_ids（即那些尚未将过去键值状态提供给该模型的标记），而不是形状为(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）范围内。序列之外的位置不计入损失计算。
返回
transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.QuestionAnsweringModelOutput or a tuple of torch.FloatTensor (if return_dict=False is passed or when config.return_dict=False) comprising various elements depending on the configuration (None) and inputs.
-
loss (
torch.FloatTensorof shape(1,), 可选, 当提供labels时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。 -
start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 范围起始分数（SoftMax 之前）。 -
end_logits (
torch.FloatTensorof 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 后的注意力权重，用于计算自注意力头中的加权平均值。
The GenericForQuestionAnswering forward method, overrides the __call__ special method.
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。