Transformers documentation
Mixtral
该模型于 2024-01-08 在 HF papers 上发布，并于 2023-12-11 贡献至 Hugging Face Transformers。
Mixtral
概述
Mixtral-8x7B 由 Albert Jiang、Alexandre Sablayrolles、Arthur Mensch、Chris Bamford、Devendra Singh Chaplot、Diego de las Casas、Florian Bressand、Gianna Lengyel、Guillaume Lample、Lélio Renard Lavaud、Lucile Saulnier、Marie-Anne Lachaux、Pierre Stock、Teven Le Scao、Thibaut Lavril、Thomas Wang、Timothée Lacroix 和 William El Sayed 在 Mixtral of Experts 博客文章 中发布。
该博客文章的引言部分写道：
今天，我们团队自豪地发布了 Mixtral 8x7B，这是一款采用开放权重的高质量稀疏专家混合（SMoE）模型，基于 Apache 2.0 许可证。在大多数基准测试中，Mixtral 的性能优于 Llama 2 70B，且推理速度提升 6 倍。它是采用宽松许可证的最强开放权重模型，在成本与性能的权衡方面也是整体表现最佳的模型。具体而言，在大多数标准基准测试中，它的性能与 GPT3.5 相当或更优。
Mixtral-8x7B 是 mistral.ai 继 Mistral-7B 之后发布的第二个大型语言模型（LLM）。
架构细节
Mixtral-8x7B 是一个仅包含解码器的 Transformer，其架构选择如下：
- Mixtral is a Mixture of Experts (MoE) model with 8 experts per MLP, with a total of 45 billion parameters. To learn more about mixture-of-experts, refer to the blog post.
- 尽管该模型拥有 450 亿个参数，但单次前向传播所需的计算量与一个 140 亿参数模型相同。这是因为，虽然每个专家都必须被加载到内存中（需要约 700 亿参数的内存占用），但来自隐藏状态的每个 token 都会被分发两次（top 2 路由），因此计算量（即每次前向计算所需的操作量）仅为 2 X sequence_length。
以下实现细节与 Mistral AI 的首个模型 Mistral-7B 相同：
- 滑动窗口注意力 - 使用 8k 上下文长度和固定缓存大小进行训练，理论注意力跨度为 128K 个 token
- GQA（分组查询注意力）—— 实现更快的推理速度和更小的缓存占用。
- 字节回退 BPE 分词器 - 确保字符永远不会被映射到词表外（OOV）标记。
有关更多详细信息，请参阅发布博客文章。
许可证
Mixtral-8x7B 采用 Apache 2.0 许可证发布。
使用技巧
Mistral 团队发布了 2 个检查点：
- 一个基础模型，Mixtral-8x7B-v0.1，该模型已在互联网规模的数据上经过预训练，用于预测下一个 token。
- 一个经过指令微调的模型 Mixtral-8x7B-Instruct-v0.1，它是基于监督微调（SFT）和直接偏好优化（DPO）针对聊天场景优化的基础模型。
基础模型可以按以下方式使用：
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
prompt = "My favourite condiment is"
model_inputs = tokenizer([prompt], 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]
"My favourite condiment is to ..."经过指令微调的模型可以按以下方式使用：
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
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 加速 Mixtral
上述代码片段展示了未使用任何优化技巧的推理过程。不过，通过利用 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("mistralai/Mixtral-8x7B-v0.1", attn_implementation="flash_attention_2", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
prompt = "My favourite condiment is"
model_inputs = tokenizer([prompt], 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"预期加速
下图展示了预期的加速效果，对比了使用 mistralai/Mixtral-8x7B-v0.1 检查点时，transformers 中纯推理时间的原生实现与 Flash Attention 2 版本模型之间的差异。
滑动窗口 Attention
当前实现支持滑动窗口注意力机制和内存高效的缓存管理。
要启用滑动窗口注意力，只需确保使用与滑动窗口注意力兼容的 flash-attn 版本（>=2.3.0）。
Flash Attention-2 模型还采用了更节省内存的缓存切片机制——按照 Mistral 模型官方实现中推荐的滚动缓存机制，我们将缓存大小固定为 self.config.sliding_window，仅支持 padding_side="left" 的批量生成，并使用当前 token 的绝对位置来计算位置嵌入。
使用量化缩小 Mixtral
由于 Mixtral 模型拥有 450 亿个参数，在半精度（float16）下大约需要 90GB 的 GPU 显存，因为每个参数占用 2 字节。不过，可以使用 量化 来缩小模型的体积。如果将模型量化到 4 位（即每个参数占用半字节），那么一块 40GB 显存的 A100 就足以容纳整个模型，因为此时大约只需要 27 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("mistralai/Mixtral-8x7B-Instruct-v0.1", quantization_config=True, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
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"该模型由 Younes Belkada 和 Arthur Zucker 贡献。 原始代码可在此处找到。
资源
以下是 Hugging Face 官方和社区（以 🌎 标识）提供的资源列表，可帮助您快速上手 Mixtral。如果您希望提交资源以收录于此，欢迎随时发起 Pull Request，我们将进行审核！理想情况下，该资源应展示一些新内容，而非重复现有资源。
- 可以在此处找到一个用于对 Mixtral-8x7B 执行监督微调（SFT）的演示笔记本。🌎
- 一篇关于使用 PEFT 微调 Mixtral-8x7B 的博客文章。🌎
- Hugging Face 的 Alignment Handbook 包含用于对 Mistral-7B 执行监督微调（SFT）和直接偏好优化的脚本和配方。其中包括用于全量微调、在单个加速器上运行 QLoRa 以及多加速器微调的脚本。
- 因果语言建模任务指南
MixtralConfig
类 transformers.MixtralConfig
< 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 = None )
参数
- 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，则可选地包含用于缩放的参数。
这是用于存储 MixtralModel 配置的类。它根据指定的参数实例化 Mixtral 模型，并定义模型架构。使用默认值实例化配置将得到与 mistralai/Mixtral-8x7B-v0.1 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
示例：
>>> from transformers import MixtralModel, MixtralConfig
>>> # Initializing a Mixtral 7B style configuration
>>> configuration = MixtralConfig()
>>> # Initializing a model from the Mixtral 7B style configuration
>>> model = MixtralModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMistralCommonBackend
class transformers.MistralCommonBackend
< source >( tokenizer_path: str | os.PathLike | pathlib.Pathmode: str | ValidationMode = 'test'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )
用于封装 mistral-common 分词器的类。
否则，分词器将回退到 Transformers 的分词器实现。
有关 mistral-common 的更多信息，请参阅 mistral-common。
此类是 mistral_common.tokens.tokenizers.mistral.MistralTokenizer 的封装。
它提供了一个兼容 Hugging Face 的接口，用于使用官方的 mistral-common 分词器进行分词，并继承自 PreTrainedTokenizerBase 类。
以下是与 PythonBackend 类的主要行为差异：
- 不支持序列对。为了保持兼容性，保留了该签名，但所有与序列对相关的参数均会被忽略。序列对的返回值将返回为
None。 - 不支持
is_split_into_words参数。 - 无法向分词器添加新 token。与 Transformers 不同，特殊 token 的处理方式有所区别。在
mistral-common中，特殊 token 永远不会被直接编码。这意味着：tokenizer.encode("<s>")不会返回<s>token 的 ID，而是返回一个 ID 列表，对应于字符串"<s>"的分词结果。更多信息请参阅 mistral-common 文档。
如果您有改进此类的建议，请根据问题类型在相应的 GitHub 仓库中提交 issue：若与 tokenizer 相关，请在 mistral-common GitHub 仓库 中提交；若与 Hugging Face 接口相关，请在 Transformers GitHub 仓库 中提交。
add_special_tokens
< source >( special_tokens_dict: dictreplace_extra_special_tokens: bool = True )
MistralCommonBackend 在设计上未实现 add_special_tokens。
如果您希望实现此行为，请在 Transformers 或 mistral-common 仓库中提交 issue 以提出请求。
MistralCommonBackend 在设计上未实现 add_special_tokens。
如果您希望实现此行为，请在 Transformers 或 mistral-common 仓库中提交 issue 以提出请求。
apply_chat_template
< source >( conversation: list[dict[str, str]] | list[list[dict[str, str]]]tools: list[dict | collections.abc.Callable] | None = Noneadd_generation_prompt: bool = Falsecontinue_final_message: bool = Falsetokenize: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool = Falsemax_length: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_dict: bool = Truereasoning_effort: ReasoningEffort | None = None**kwargs ) → Union[str, list[int], list[str], list[list[int]], BatchEncoding]
参数
- conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) — 一个字典列表，包含 “role” 和 “content” 键，表示当前的聊天历史记录。
- tools (
List[Union[Dict, Callable]], 可选) — 一个工具（可调用函数）列表，模型可以访问这些工具。如果模板不支持函数调用，此参数将不起作用。每个工具应以 JSON Schema 的形式传入，提供工具的名称、描述和参数类型。有关更多信息，请参阅我们的 聊天模板指南 。 - add_generation_prompt (
bool, 可选) — 此参数对MistralCommonBackend无效。但为了保持 API 的一致性，它不能与continue_final_message同时使用。 如果任何对话以助手消息结尾，则会引发错误。在这种情况下，请改用continue_final_message。 - continue_final_message (bool, 可选) —
如果设置此项，聊天将被格式化，使得聊天中的最后一条消息是开放式的，不包含任何 EOS token。模型将继续该消息，而不是开始一条新消息。这允许你“预填充”模型响应的一部分。不能与
add_generation_prompt同时使用。 - tokenize (
bool，默认为True) — 是否对输出进行分词。如果为False，输出将是一个字符串。 - padding (
bool,str或 PaddingStrategy, 可选, 默认为False) — 选择一种策略，根据模型的填充侧和填充索引对返回的序列进行填充，可选策略如下：True或'longest'：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。'max_length'：填充至由参数max_length指定的最大长度；若未提供该参数，则填充至模型可接受的最大输入长度。False或'do_not_pad'（默认值）：不进行填充（即可以输出包含不同长度序列的批次）。
- truncation（
bool，默认为False）— 是否将序列截断至最大长度。如果 tokenize 为False，则此参数无效。 - max_length (
int, 可选) — 用于填充或截断的最大长度（以 token 计）。如果 tokenize 为False，则此参数无效。如果未指定，将使用分词器的max_length属性作为默认值。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回特定框架的张量。如果 tokenize 为False. 可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。
- return_dict (
bool，默认为False) — 是否返回包含命名输出的字典。如果 tokenize 为False，则此参数无效。 如果至少一个对话包含图像，其像素值将返回在pixel_values键中，图像尺寸将返回在image_sizes键中。 - reasoning_effort (
ReasoningEffort, 可选) — 对于支持推理的模型，用于聊天补全的推理力度。可能的值如下：ReasoningEffort.none：模型不会进行推理。ReasoningEffort.high：模型将采用推理方式。 如果未指定，则使用默认的推理强度。
- kwargs（额外的关键字参数，可选）—
传递给 mistral-common 的
ChatCompletionRequest.from_openai方法的额外参数。
返回值
Union[str, list[int], list[str], list[list[int]], BatchEncoding]
到目前为止的已分词聊天内容，包括控制标记。此输出已准备好传递给模型，可以直接传递，也可以通过 generate() 等方法进行传递。
将包含 "role" 和 "content" 键的字典列表转换为 token id 列表。
batch_decode
< source >( sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → list[str]
参数
- sequences (
Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — 分词后的输入 ID 列表。可通过__call__方法获取。 - skip_special_tokens（
bool，可选，默认为False）— 是否在解码过程中移除特殊标记。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理分词空格。如果为None，则默认为self.clean_up_tokenization_spaces。 - kwargs（额外的关键字参数，可选） —
MistralCommonBackend.batch_decode不支持此参数。 如果使用该参数，将引发错误。
返回值
list[str]
解码后的句子列表。
通过调用 decode，将 token id 的列表的列表转换为字符串列表。
此方法是为了向后兼容而提供的。decode 方法现在原生支持批量输入，因此您可以直接使用 decode 而无需使用 batch_decode。
build_inputs_with_special_tokens
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
通过添加特殊标记，从序列构建模型输入。
此方法会根据分词器的 mode 动态构建输入：
"test"：seq0 [EOS]"finetuning"：[BOS] seq0
convert_added_tokens
< source >( obj: tokenizers.AddedToken | typing.Anysave: bool = Falseadd_type_field: bool = True )
MistralCommonBackend 在设计上未实现 convert_added_tokens。
如果您希望实现此行为，请在 Transformers 或 mistral-common 仓库中提交 issue 以提出请求。
create_token_type_ids_from_sequences
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
使用添加了特殊标记的标记 ID 创建一个全零掩码。
保留以匹配 Transformers 的实现。
decode
< source >( token_ids: typing.Union[int, list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → Union[str, list[str]]
参数
- token_ids (
Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]) — 单个序列或一批（序列列表）的标记化输入 ID。可通过__call__方法获取。 - skip_special_tokens（
bool，可选，默认为False）— 是否在解码过程中移除特殊标记。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理分词空格。如果为None，则默认为self.clean_up_tokenization_spaces。 - kwargs（额外的关键字参数，可选） —
MistralCommonBackend.decode不支持此参数。 如果使用该参数，将引发错误。
返回值
Union[str, list[str]]
单个序列的解码字符串，或一批序列的解码字符串列表。
使用分词器和词汇表将字符串中的 id 序列进行转换，并可选择移除特殊标记以及清理分词空格。
encode
< source >( text: str | list[int]text_pair: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Noneverbose: bool = Truereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[int], torch.Tensor
参数
- text (
str或list[int]) — 要编码的第一个序列。它可以是一个字符串，或一个整数列表（即分词后的字符串 ID）。 - text_pair (
None，可选) —MistralCommonBackend.encode不支持此参数。保留该参数以匹配PreTrainedTokenizerBase.encode的签名。 - add_special_tokens (
bool，可选，默认为True) — 在编码序列时是否添加特殊标记。此操作将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了哪些标记会自动添加到输入 ID 中。如果您希望自动添加bos或eos标记，此功能非常有用。当 Tokenizer 以finetuning模式加载时，它会同时添加bos和eos。否则，在“test”模式下，它仅添加bos。 - padding (
bool,str或 PaddingStrategy, ，可选, ，默认为False) — 启用并控制填充。接受以下值：True或'longest'：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。'max_length'：填充至由参数max_length指定的最大长度；若未提供该参数，则填充至模型可接受的最大输入长度。False或'do_not_pad'（默认值）：不进行填充（即可以输出包含不同长度序列的批次）。
- truncation (
bool,str或 TruncationStrategy, 可选, 默认值为False) — 启用并控制截断。接受以下值：True或'longest_first'：截断至由参数max_length指定的最大长度，或者在未提供该参数时，截断至模型可接受的最大输入长度。False或'do_not_truncate'（默认值）：不进行截断（即，可以输出序列长度大于模型最大可接受输入大小的批次）。
- max_length (
int, 可选) — 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 None，则当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（如 XLNet），则禁用截断/填充到最大长度的功能。如果未设置或设置为
None，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。 - stride (
int，可选，默认为 0) — 如果与max_length一起设置为某个数值，则当return_overflowing_tokens=True时，返回的溢出 token 将包含截断序列末尾的若干 token，以在截断序列和溢出序列之间提供一定的重叠。此参数的值定义了重叠 token 的数量。 - pad_to_multiple_of (
int, 可选) — 如果设置，则将序列填充为所提供值的倍数。需要启用padding。 这对于在计算能力为>= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。 - padding_side (
str, 可选) — 模型应应用填充的一侧。应在 [‘right’, ‘left’] 之间进行选择。 默认值取自同名的类属性。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。
- **kwargs —
MistralCommonBackend.encode不支持。 如果使用了该参数，将引发错误。
返回值
list[int], torch.Tensor
文本的标记化 ID。
使用分词器和词汇表将字符串转换为 id（整数）序列。
from_pretrained
< source >( pretrained_model_name_or_path: str | os.PathLike*init_inputsmode: str | ValidationMode = 'test'cache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )
参数
- pretrained_model_name_or_path (
str或os.PathLike) — 可以是以下之一：- 一个字符串，即托管在 huggingface.co 上某个模型仓库中的预定义分词器的 model id。
- 指向包含分词器配置的目录的路径，例如使用
MistralCommonBackend.tokenization_mistral_common.save_pretrained方法保存的路径，如./my_model_directory/。
- mode (
Union[str, ValidationMode], 可选, 默认为ValidationMode.test) — 的验证模式。可能的值包括：MistralTokenizer"finetuning" 或 ValidationMode.finetuning：微调模式。"test" 或 ValidationMode.test：测试模式。它会改变 tokenizer 验证输入并准备模型请求的方式。"finetuning"或ValidationMode.finetuning：微调模式。"test"或ValidationMode.test：测试模式。 它会改变分词器验证输入并准备模型请求的方式。
- cache_dir (
str或os.PathLike，可选) — 如果不应使用标准缓存，则下载的预定义分词器词汇文件应缓存到的目录路径。 - force_download (
bool，可选，默认为False) — 是否强制（重新）下载词汇表文件，并在缓存版本已存在时覆盖它们。 - token（
str或 bool，可选）— 用于远程文件的 HTTP 承载者授权令牌。如果为True，则使用运行hf auth login时生成的令牌（存储在~/.huggingface中）。 - local_files_only（
bool，可选，默认为False）— 是否仅依赖本地文件，而不尝试下载任何文件。 - revision (
str，可选，默认为"main") — 要使用的特定模型版本。由于我们在 huggingface.co 上使用基于 git 的系统来存储模型和其他工件，因此它可以是分支名称、标签名称或提交 id，revision可以是 git 允许的任何标识符。 - max_length (
int, 可选) — 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 None，则当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（如 XLNet），则禁用截断/填充到最大长度的功能。如果未设置或设置为
None，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。 - padding_side (
str，可选，默认为"left") — 模型应应用填充的一侧。应在 [‘right’, ‘left’] 之间进行选择。 默认值取自同名的类属性。 - truncation_side (
str，可选，默认为"right") — 模型应应用截断的一侧。应在 [‘right’, ‘left’] 中进行选择。 - model_input_names (
List[str]，可选) — 模型前向传播接受的输入列表（例如"token_type_ids"或"attention_mask"）。默认值取自同名的类属性。 - clean_up_tokenization_spaces (
bool，可选，默认为False) — 模型是否应清理在分词过程中对输入文本进行切分时添加的空格。 - kwargs（额外的关键字参数，可选） —
MistralCommonBackend.from_pretrained不支持此参数。 如果使用该参数，将引发错误。
从预定义的 tokenizer 实例化一个 MistralCommonBackend。
MistralCommonBackend 出于设计考虑未实现 get_chat_template，因为 mistral-common 不使用聊天模板。
get_special_tokens_mask
< source >( token_ids_0: listtoken_ids_1: None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]
从未添加特殊标记的标记列表中获取序列 ID。当使用分词器的 prepare_for_model 或 encode_plus 方法添加特殊标记时，会调用此方法。
返回一个从 token 到索引的字典形式的词汇表。
这是一种有损转换。由于部分 UTF-8 字节序列会被转换为 �，可能会有多个 token id 解码为相同的字符串。
num_special_tokens_to_add
< source >( pair: typing.Literal[False] = False ) → int
在编码包含特殊标记的序列时，返回所添加标记的数量。
这会编码一个虚拟输入并检查新增的 token 数量，因此效率不高。请勿将其放在训练循环内部。
prepare_for_model
< source >( ids: listpair_ids: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_length: bool = Falseverbose: bool = Trueprepend_batch_axis: bool = Falsereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → BatchEncoding
参数
- ids (
list[int]) — 第一个序列的标记化输入 ID。 - pair_ids (
None，可选) —MistralCommonBackend不支持。保留此参数以匹配PreTrainedTokenizerBase的接口。 - add_special_tokens (
bool，可选，默认为True) — 在编码序列时是否添加特殊标记。此操作将使用底层的PretrainedTokenizerBase.build_inputs_with_special_tokens函数，该函数定义了哪些标记会自动添加到输入 ID 中。如果您希望自动添加bos或eos标记，此功能非常有用。当 Tokenizer 以finetuning模式加载时，它会同时添加bos和eos。否则，在“test”模式下，它仅添加bos。 - padding (
bool,str或 PaddingStrategy, ，可选, ，默认为False) — 启用并控制填充。接受以下值：True或'longest'：填充至批次中最长的序列（如果仅提供单个序列，则不进行填充）。'max_length'：填充至由参数max_length指定的最大长度；若未提供该参数，则填充至模型可接受的最大输入长度。False或'do_not_pad'（默认值）：不进行填充（即可以输出包含不同长度序列的批次）。
- truncation (
bool,str或 TruncationStrategy, 可选, 默认值为False) — 启用并控制截断。接受以下值：True或'longest_first'：截断至由参数max_length指定的最大长度，或者在未提供该参数时，截断至模型可接受的最大输入长度。False或'do_not_truncate'（默认值）：不进行截断（即，可以输出序列长度大于模型最大可接受输入大小的批次）。
- max_length (
int, 可选) — 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 None，则当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（如 XLNet），则禁用截断/填充到最大长度的功能。如果未设置或设置为
None，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。 - stride (
int，可选，默认为 0) — 如果与max_length一起设置为某个数值，则当return_overflowing_tokens=True时，返回的溢出 token 将包含截断序列末尾的若干 token，以在截断序列和溢出序列之间提供一定的重叠。此参数的值定义了重叠 token 的数量。 - pad_to_multiple_of (
int, 可选) — 如果设置，则将序列填充为所提供值的倍数。需要启用padding。 这对于在计算能力为>= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。 - padding_side (
str, 可选) — 模型应应用填充的一侧。应在 [‘right’, ‘left’] 之间进行选择。 默认值取自同名的类属性。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。
- return_token_type_ids (
bool, 可选) — 是否返回 token type ID。对于MistralCommonBackend，它返回一个与序列长度相同的零列表，因为仅支持单个序列。 - return_attention_mask (
bool, 可选) — 是否返回注意力掩码。如果保持默认值，将根据特定分词器的默认设置返回注意力掩码，该设置由return_outputs属性定义。 - return_overflowing_tokens (
bool，可选，默认为False) — 是否返回溢出的 token 序列。如果提供了输入 id 的序列对（或序列对批次），且truncation_strategy = longest_first或True，则会抛出错误，而不是返回溢出的 token。 - return_special_tokens_mask (
bool，可选，默认为False) — 是否返回特殊 token 掩码信息。 - return_length (
bool，可选，默认为False) — 是否返回编码后输入的长度。 - verbose (
bool，可选，默认为True) — 是否打印更多信息和警告。 - return_offsets_mapping (
Literal[False]，可选) — 固定为 False，以与 Transformers 的签名保持一致。 - split_special_tokens (
Literal[False]，可选) — 固定为 False，以匹配 Transformers 的函数签名。 - **kwargs — 传递给
self.tokenize()方法
返回值
一个包含以下字段的 BatchEncoding：
-
input_ids — 要输入模型的 token id 列表。
-
attention_mask — 索引列表，指定模型应关注哪些 token（当
return_attention_mask=True或 “attention_mask” 位于self.model_input_names中时）。 -
overflowing_tokens — 溢出 token 序列的列表（当指定了
max_length且return_overflowing_tokens=True时）。 -
num_truncated_tokens — 被截断的 token 数量（当指定了
max_length且return_overflowing_tokens=True时）。 -
special_tokens_mask — 由 0 和 1 组成的列表，其中 1 表示添加的特殊标记，0 表示常规序列标记（当
add_special_tokens=True且return_special_tokens_mask=True时）。 -
length — 输入的长度（当
return_length=True时）
准备输入 ID 序列，使其能够被模型使用。它会添加特殊标记，在序列溢出时进行截断（同时考虑特殊标记），并为溢出的标记管理一个移动窗口（步长由用户定义）。
save_chat_templates
< source >( save_directory: str | os.PathLiketokenizer_config: dictfilename_prefix: str | Nonesave_jinja_files: bool )
MistralCommonBackend 出于设计考虑未实现 save_chat_templates，因为 mistral-common 不使用聊天模板。
save_pretrained
< source >( save_directory: str | os.PathLike | pathlib.Pathpush_to_hub: bool = Falsetoken: str | bool | None = Nonecommit_message: str | None = Nonerepo_id: str | None = Noneprivate: bool | None = Nonesave_format: str | None = None**kwargs ) → tuple[str, ...]
参数
- save_directory (
str | os.PathLike | Path) — 保存 tokenizer 的目录。 - push_to_hub (
bool，可选，默认为False) — 保存后推送到 HF Hub。 - token（
str或bool，可选）— 用于 Hub 身份验证的令牌。 - commit_message (
str, 可选) — 推送时的提交信息。 - repo_id (
str, 可选) — Hub 仓库 ID。 - private (
bool，可选) — 仓库是否为私有。 - save_format (
str, 可选) —"mistral"用于保存原生 tekken 格式，"hf"用于 HuggingFace 格式。 None 保留原始格式。 - kwargs (
dict，可选) — 不支持 — 将引发错误。
返回值
tuple[str, ...]
已保存文件的路径。
保存完整的分词器状态。
当 save_format 为 "mistral"（对于 tekken 分词器则为 None）时，原始分词器文件（例如 tekken.json）会被写入 save_directory。当 save_format 为 "hf" 时，则会生成 HF 格式的文件（tokenizer.json + tokenizer_config.json）。
MistralCommonBackend 在设计上未实现 save_vocabulary。
这是因为 mistral-common 由一个分词器文件进行配置。如果您希望保存词表，请考虑改用 save_pretrained 方法。
tokenize
< source >( text: strreturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[str]
使用分词器将字符串转换为标记序列。
对于基于单词的词汇表，按单词进行拆分；对于基于子词的词汇表，按子词进行拆分。
truncate_sequences
< source >( ids: listpair_ids: None = Nonenum_tokens_to_remove: int = 0truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first'stride: int = 0**kwargs ) → Tuple[list[int], None, list[int]]
参数
- ids (
list[int]) — 分词后的输入 ID。可以通过依次调用tokenize和convert_tokens_to_ids方法从字符串中获取。 - pair_ids (
None，可选) —MistralCommonBackend不支持。保留此参数以匹配PreTrainedTokenizerBase.truncate_sequences的签名。 - num_tokens_to_remove (
int，可选，默认为 0) — 使用截断策略要移除的 token 数量。 - truncation_strategy (
str或 TruncationStrategy, 可选, 默认为'longest_first') — 截断策略。可以是：'longest_first'：截断至参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。'do_not_truncate'（默认值）：不进行截断（即，可以输出序列长度超过模型最大允许输入大小的批次）。
- stride (
int，可选，默认为 0) — 如果设置为正数，返回的溢出 token 将包含主序列中的一些 token。该参数的值定义了额外 token 的数量。
返回值
Tuple[list[int], None, list[int]]
截断后的 ids 以及溢出 token 的列表。为了与 Transformers 的签名保持一致，返回 None。
按照策略就地截断序列对。
MixtralModel
class transformers.MixtralModel
< source >( config: MixtralConfig )
参数
- config (MixtralConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
未添加任何特定头部的裸 Mixtral 模型，直接输出原始隐藏状态。
该模型继承自 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.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MoeModelOutputWithPast or tuple(torch.FloatTensor)
参数
- 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 (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - use_cache (
bool，可选) — 如果设置为True，则会返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
返回值
MoeModelOutputWithPast 或 tuple(torch.FloatTensor)
MoeModelOutputWithPast 或 torch.FloatTensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（MixtralConfig）和输入。
MixtralModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层输出的隐藏状态序列。past_key_values（
Cache，可选，在传入use_cache=True或config.use_cache=True时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含预计算的隐藏状态（自注意力块中的键和值，以及如果
config.is_encoder_decoder=True则还包括交叉注意力块中的键和值），可用于（参见past_key_values输入）加速顺序解码。hidden_states (
tuple(torch.FloatTensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.FloatTensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions（
tuple(torch.FloatTensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回）—— 一个torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
router_logits (
tuple(torch.FloatTensor)，可选，当传入output_router_probs=True且config.add_router_probs=True，或当config.output_router_probs=True时返回) — 一个torch.FloatTensor元组（每层一个），形状为(batch_size, sequence_length, num_experts)。由 MoE 路由器计算的原始路由器 logits（softmax 之后），这些术语用于计算混合专家模型的辅助损失。
MixtralForCausalLM
class transformers.MixtralForCausalLM
< source >( config: MixtralConfig )
参数
- config (MixtralConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
用于因果语言建模的 Mixtral 模型。
该模型继承自 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.FloatTensor] = 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.FloatTensor)
参数
- 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 (
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的 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.FloatTensor)
MoeCausalLMOutputWithPast 或 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（MixtralConfig）和输入。
MixtralForCausalLM 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 语言建模损失（用于下一个 token 预测）。logits（形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。aux_loss (
torch.FloatTensor，可选，当传入output_router_logits=True或config.output_router_logits=True，且模型使用负载均衡损失训练其路由器时返回) — 稀疏模块的负载均衡辅助损失。那些改用路由器偏置来平衡其专家（DeepSeek-V3 及由其衍生的架构）的模型，此处返回None，但仍会返回router_logits。router_logits (
tuple(torch.FloatTensor)，可选，在传入output_router_logits=True或config.output_router_logits=True时返回) — 一个torch.FloatTensor元组（每个稀疏层对应一个），形状为(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.FloatTensor)，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.FloatTensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions（
tuple(torch.FloatTensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回）—— 一个torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> from transformers import AutoTokenizer, MixtralForCausalLM
>>> model = MixtralForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
>>> 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."MixtralForSequenceClassification
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.FloatTensor | 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 (
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）。
返回值
SequenceClassifierOutputWithPast
GenericForSequenceClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
MixtralForTokenClassification
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.FloatTensor | 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 (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传入嵌入表示，而不是传入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实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
MixtralForQuestionAnswering
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.FloatTensor | 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 (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传入嵌入表示，而不是传入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实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。