Transformers

( transformers_version: str | None = None architectures: list[str] | None = None output_hidden_states: bool | None = False return_dict: bool | None = True dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None chunk_size_feed_forward: int = 0 is_encoder_decoder: bool = False id2label: dict[int, str] | dict[str, str] | None = None label2id: dict[str, int] | dict[str, str] | None = None problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None vocab_size: int = 32000 hidden_size: int = 4096 intermediate_size: int = 14336 num_hidden_layers: int = 32 num_attention_heads: int = 32 num_key_value_heads: int = 8 head_dim: int | None = None hidden_act: str = 'silu' max_position_embeddings: int = 131072 initializer_range: float = 0.02 rms_norm_eps: float = 1e-05 use_cache: bool = True pad_token_id: int | None = None bos_token_id: int | None = 1 eos_token_id: int | list[int] | None = 2 tie_word_embeddings: bool = False sliding_window: int | None = None attention_dropout: float | int = 0.0 num_experts_per_tok: int = 2 num_local_experts: int = 8 output_router_logits: bool = False router_aux_loss_coef: float = 0.001 router_jitter_noise: float = 0.0 rope_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，模型将使用多头注意力 (MHA)；如果 num_key_value_heads=1，模型将使用多查询注意力 (MQA)；否则使用 GQA。在将多头检查点转换为 GQA 检查点时，每个组的键和值头应通过对该组内的所有原始头进行均值池化来构建。有关更多详情，请查看这篇论文。如果未指定，将默认为 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, 可选) — 词表中用于填充（padding）的 token ID。
bos_token_id (int, 可选, 默认为 1) — 词表中用于流开始（beginning-of-stream）的 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) — 在训练期间添加到路由器 logits 中的噪声量，以实现更好的负载均衡。
rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], 可选) — 包含 RoPE 嵌入配置参数的字典。该字典应包含 rope_theta 的值，以及在需要使用更长的 max_position_embeddings 并使用 RoPE 进行缩放时可选的参数。

这是用于存储 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.config

MistralCommonBackend

class transformers.MistralCommonBackend

( tokenizer_path: str | os.PathLike | pathlib.Path mode: ValidationMode = <ValidationMode.test: 'test'> model_max_length: int = 1000000000000000019884624838656 padding_side: str = 'left' truncation_side: str = 'right' model_input_names: list[str] | None = None clean_up_tokenization_spaces: bool = False **kwargs )

包装 mistral-common 分词器的类。

mistral-common 是 Mistral AI 模型的官方分词器库。要使用它，您需要安装它：

pip install transformers[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。特殊 token 的处理方式与 Transformers 不同。在 mistral-common 中，特殊 token 永远不会被直接编码。这意味着：tokenizer.encode("<s>") 将不会返回 <s> token 的 ID。相反，它将返回字符串 "<s>" 的分词结果对应的 ID 列表。更多信息请参见 mistral-common 文档。

如果您对改进此类有任何建议，请根据问题是与分词器相关还是与 Hugging Face 接口相关，在 mistral-common GitHub 存储库或 Transformers GitHub 存储库中提交 issue。

add_special_tokens

( special_tokens_dict: dict replace_extra_special_tokens: bool = True )

MistralCommonBackend 因设计原因未实现 add_special_tokens。

如果您希望实现此功能，请在 Transformers 或 mistral-common 存储库中提交 issue 以请求。

add_tokens

( special_tokens_dict: dict replace_extra_special_tokens: bool = True )

MistralCommonBackend 因设计原因未实现 add_special_tokens。

如果您希望实现此功能，请在 Transformers 或 mistral-common 存储库中提交 issue 以请求。

apply_chat_template

( conversation: list[dict[str, str]] | list[list[dict[str, str]]] tools: list[dict | collections.abc.Callable] | None = None add_generation_prompt: bool = False continue_final_message: bool = False tokenize: bool = True padding: bool | str | transformers.utils.generic.PaddingStrategy = False truncation: bool = False max_length: int | None = None return_tensors: str | transformers.utils.generic.TensorType | None = None return_dict: bool = True reasoning_effort: mistral_common.protocol.instruct.request.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 同时使用。如果任何对话以 assistant 消息结尾，则会引发错误。在这种情况下，请改用 continue_final_message。
continue_final_message (bool, 可选) — 如果设置了此参数，对话将被格式化，使得对话中的最后一条消息是开放式的，不带任何 EOS token。模型将继续这条消息，而不是开始一条新消息。这允许您为模型“预填”部分响应。不能与 add_generation_prompt 同时使用。
tokenize (bool, 默认为 True) — 是否对输出进行分词（tokenize）。如果为 False，输出将是一个字符串。
padding (bool, str 或 PaddingStrategy, 可选, 默认为 False) — 从以下策略中选择一种来对返回的序列进行填充（根据模型的填充方向和填充索引）：
- True 或 'longest'：填充到批次（batch）中最长的序列（如果仅提供单个序列，则不进行填充）。
- 'max_length'：填充到由参数 max_length 指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。
- False 或 'do_not_pad'（默认）：不填充（即，可以输出包含不同长度序列的批次）。
truncation (bool, 默认为 False) — 是否在最大长度处截断序列。如果 tokenize 为 False，则此参数无效。
max_length (int, 可选) — 用于填充或截断的最大长度（以 token 为单位）。如果 tokenize 为 False，则此参数无效。如果未指定，将默认使用分词器（tokenizer）的 max_length 属性。
return_tensors (str 或 TensorType, 可选) — 如果设置，将返回特定框架的张量。如果 tokenize 为 False，则此参数无效。可接受的值为：
- 'pt'：返回 PyTorch torch.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]

已分词的聊天内容，包括控制 token。此输出已准备好直接传递给模型，或通过 generate() 等方法传递。

将包含“role”和“content”键的字典列表转换为 token ID 列表。

batch_decode

( sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')] skip_special_tokens: bool = False clean_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) — 是否在解码中移除特殊 token。
clean_up_tokenization_spaces (bool, 可选) — 是否清理分词空格。如果为 None，将默认使用 self.clean_up_tokenization_spaces。
kwargs (附加关键字参数, 可选) — MistralCommonBackend.batch_decode 不支持此参数。如果使用将引发错误。

list[str]

解码后的句子列表。

通过调用 decode 将标记 ID 列表的列表转换为字符串列表。

此方法仅用于向后兼容。decode 方法现在支持批处理输入，因此您可以直接使用 decode 而不是 batch_decode。

build_inputs_with_special_tokens

( token_ids_0: list token_ids_1: None = None ) → list[int]

参数

token_ids_0 (list[int]) — 将向其中添加特殊 token 的 ID 列表。
token_ids_1 (None, 可选) — 无，保留以匹配 Transformers 的签名。

list[int]

包含特殊标记的输入 ID 列表。

通过添加特殊 token 从序列构建模型输入。

此方法根据分词器的 mode 动态构建输入

"test"：seq0 [EOS]
"finetuning"：[BOS] seq0

convert_added_tokens

( obj: typing.Union[tokenizers.AddedToken, typing.Any] save: bool = False add_type_field: bool = True )

MistralCommonBackend 因设计原因未实现 convert_added_tokens。

如果您希望实现此功能，请在 Transformers 或 mistral-common 存储库中提交 issue 以请求。

create_token_type_ids_from_sequences

( token_ids_0: list token_ids_1: None = None ) → list[int]

参数

token_ids_0 (list[int]) — ID 列表。
token_ids_1 (None, 可选) — 无，保留以匹配 Transformers 的签名。

list[int]

根据配置的模式生成 token 类型 ID。

使用特殊标记添加的 token id 创建一个零掩码。

为匹配 Transformers 的实现而保留。

decode

( token_ids: typing.Union[int, list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')] skip_special_tokens: bool = False clean_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) — 是否在解码中移除特殊 token。
clean_up_tokenization_spaces (bool, 可选) — 是否清理分词空格。如果为 None，将默认使用 self.clean_up_tokenization_spaces。
kwargs (附加关键字参数, 可选) — MistralCommonBackend.decode 不支持此参数。如果使用将引发错误。

Union[str, list[str]]

单个序列的解码字符串，或序列批次的解码字符串列表。

使用分词器和词汇表将 ID 序列转换为字符串，可以选择移除特殊标记并清理分词空间。

编码

( text: str | list[int] text_pair: None = None add_special_tokens: bool = True padding: bool | str | transformers.utils.generic.PaddingStrategy = False truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None max_length: int | None = None stride: int = 0 pad_to_multiple_of: int | None = None padding_side: str | None = None return_tensors: str | transformers.utils.generic.TensorType | None = None verbose: bool = True return_offsets_mapping: typing.Literal[False] = False split_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) — 是否在编码序列时添加特殊 token。这将使用底层的 PretrainedTokenizerBase.build_inputs_with_special_tokens 函数，该函数定义了哪些 token 会被自动添加到输入 ID 中。如果您想自动添加 bos 或 eos token，这会非常有用。当 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），则到最大长度的截断/填充将被禁用。
stride (int，可选，默认为 0) — 如果与 max_length 一起设置为一个数字，那么当 return_overflowing_tokens=True 时返回的溢出标记将包含一些来自被截断序列末尾的标记，以便在截断序列和溢出序列之间提供一些重叠。该参数的值定义了重叠标记的数量。
pad_to_multiple_of (int，可选) — 如果设置，将把序列填充到提供值的整数倍。需要启用 padding。这对于在计算能力 >= 7.5 的 NVIDIA 硬件（Volta）上启用 Tensor Core 特别有用。
padding_side (str，可选) — 模型应该在其上应用填充的一侧。应在 [‘right’, ‘left’] 之间进行选择。默认值取自同名的类属性。
return_tensors (str 或 TensorType，可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
- 'pt'：返回 PyTorch torch.Tensor 对象。
**kwargs — MistralCommonBackend.encode 不支持。如果使用将引发错误。

list[int], torch.Tensor

文本的 tokenized ID。

使用分词器和词汇表将字符串转换为 ID 序列（整数）。

from_pretrained

( pretrained_model_name_or_path: str | os.PathLike *init_inputs mode: str | mistral_common.protocol.instruct.validator.ValidationMode = <ValidationMode.test: 'test'> cache_dir: str | os.PathLike | None = None force_download: bool = False local_files_only: bool = False token: str | bool | None = None revision: str = 'main' model_max_length: int = 1000000000000000019884624838656 padding_side: str = 'left' truncation_side: str = 'right' model_input_names: list[str] | None = None clean_up_tokenization_spaces: bool = False **kwargs )

参数

pretrained_model_name_or_path (str 或 os.PathLike) — 可以是以下之一：
- 一个字符串，托管在 huggingface.co 上的模型仓库中的预定义分词器的模型 ID。
- 指向包含分词器配置的目录的路径，例如使用 MistralCommonBackend.tokenization_mistral_common.save_pretrained 方法保存的目录，例如 ./my_model_directory/。
mode (Union[str, ValidationMode]，*可选*，默认为 ValidationMode.test) — MistralTokenizer 分词器的验证模式。可能的值有：
- "finetuning" 或 ValidationMode.finetuning：微调（fine-tuning）模式。
- "test" 或 ValidationMode.test：测试（test）模式。它会改变分词器验证输入以及准备向模型发送请求的方式。
cache_dir (str 或 os.PathLike，可选) — 如果不使用标准缓存，下载的预定义分词器词表文件应缓存其中的目录路径。
force_download (bool，可选，默认为 False) — 是否强制（重新）下载词表文件并覆盖已存在的缓存版本。
token (str 或 bool，可选) — 用于远程文件的 HTTP bearer 授权的 token。如果为 True，将使用运行 hf auth login 时生成的 token（存储在 ~/.huggingface 中）。
local_files_only (bool，可选，默认为 False) — 是否仅依赖本地文件而不尝试下载任何文件。
revision (str，*可选*，默认为 "main") — 要使用的具体模型版本。它可以是分支名、标签名或提交 ID。由于我们在 huggingface.co 上使用基于 git 的系统来存储模型和其他组件，因此 revision 可以是 git 允许的任何标识符。
max_length (int，可选) — 控制截断/填充参数之一所使用的最大长度。

如果未设置或设置为 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。

get_chat_template

( chat_template: str | None = None tools: list[dict] | None = None )

MistralCommonBackend 因设计原因未实现 get_chat_template，因为 mistral-common 不使用 chat templates。

get_special_tokens_mask

( token_ids_0: list token_ids_1: None = None already_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]

参数

token_ids_0 (list[int]) — 序列的 ID 列表。
token_ids_1 (None，可选) — None，保留以匹配 Transformers 的实现。
already_has_special_tokens (bool，可选，默认为 False) — 标记列表是否已经格式化，包含了模型的特殊标记。

一个范围在 [0, 1] 的整数列表

特殊令牌为 1，序列令牌为 0。

从未添加特殊令牌的令牌列表中检索序列 ID。使用分词器 prepare_for_model 或 encode_plus 方法添加特殊令牌时会调用此方法。

get_vocab

( ) → Dict[str, int]

Dict[str, int]

词汇表。

返回作为 token 到 index 字典的词汇表。

这是一个有损转换。由于 partial UTF-8 字节序列被转换为 �，可能会有多个 token ID 解码为相同的字符串。

num_special_tokens_to_add

( pair: typing.Literal[False] = False ) → int

参数

pair (Literal[False]，可选) — False, 保留以匹配 Transformer 的方法签名。

int

添加到序列中的特殊标记数量。

返回使用特殊标记编码序列时添加的标记数量。

此方法对一个虚拟输入进行编码，并检查添加的标记数量，因此效率不高。请勿将其放入您的训练循环中。

prepare_for_model

( ids: list pair_ids: None = None add_special_tokens: bool = True padding: bool | str | transformers.utils.generic.PaddingStrategy = False truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None max_length: int | None = None stride: int = 0 pad_to_multiple_of: int | None = None padding_side: str | None = None return_tensors: str | transformers.utils.generic.TensorType | None = None return_token_type_ids: bool | None = None return_attention_mask: bool | None = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_length: bool = False verbose: bool = True prepend_batch_axis: bool = False return_offsets_mapping: typing.Literal[False] = False split_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 标记，这非常有用。当分词器以 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），则到最大长度 of 截断/填充将被禁用。
stride (int，可选，默认为 0) — 如果与 max_length 一起设置为一个数字，那么当 return_overflowing_tokens=True 时返回的溢出标记将包含一些来自被截断序列末尾的标记，以便在截断序列 and 溢出序列之间提供一些重叠。该参数的值定义了重叠标记的数量。
pad_to_multiple_of (int，可选) — 如果设置，将把序列填充到提供值的整数倍。需要启用 padding。这对于在计算能力 >= 7.5 的 NVIDIA 硬件（Volta）上启用 Tensor Core 特别有用。
padding_side (str，可选) — 模型应该在其上应用填充的一侧。应在 [‘right’, ‘left’] 之间进行选择。默认值取自同名的类属性。
return_tensors (str 或 TensorType，可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
- 'pt'：返回 PyTorch torch.Tensor 对象。
return_token_type_ids (bool，可选) — 是否返回标记类型 ID（token type ID）。对于 MistralCommonBackend，由于仅支持单个序列，它会返回一个与序列长度相同的全零列表。

什么是标记类型 ID？
return_attention_mask (bool，可选) — 是否返回注意力掩码（attention mask）。如果保持默认设置，将根据特定分词器的默认设置（由 return_outputs 属性定义）返回注意力掩码。

什么是注意力掩码？
return_overflowing_tokens (bool，可选，默认为 False) — 是否返回溢出的标记序列。如果在设置了 truncation_strategy = longest_first 或 True 的情况下提供了一对输入 ID 序列（或一批序列对），则会引发错误，而不是返回溢出的标记。
return_special_tokens_mask (bool，可选，默认为 False) — 是否返回特殊标记掩码信息。
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

具有以下字段的 BatchEncoding

input_ids — 要输入到模型中的标记 ID 列表。

什么是输入 ID？
attention_mask — 指定模型应关注哪些标记的索引列表（当 return_attention_mask=True 或如果 *“attention_mask”* 在 self.model_input_names 中时）。

什么是注意力掩码？
overflowing_tokens — 溢出标记序列列表（当指定 max_length 且 return_overflowing_tokens=True 时）。
num_truncated_tokens — 截断标记的数量（当指定 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

( save_directory: str | os.PathLike tokenizer_config: dict filename_prefix: str | None save_jinja_files: bool )

MistralCommonBackend 不实现 save_chat_templates 是出于设计考虑，因为 mistral-common 不使用 chat templates。

save_pretrained

参数

save_directory (str 或 os.PathLike) — 用于保存分词器的目录路径。
push_to_hub (bool, 可选, 默认为 False) — 是否在保存模型后将其推送到 Hugging Face 模型 Hub。您可以使用 repo_id 指定要推送到的仓库（在您的命名空间中，默认使用 save_directory 的名称）。
token (str 或 bool, 可选, 默认为 None) — 用于推送到模型 Hub 的 Token。如果为 True，将使用 HF_TOKEN 环境变量中的 Token。
commit_message (str, 可选) — 推送到 Hub 时使用的提交信息。
repo_id (str, 可选) — 要推送到 Hub 的仓库名称。
private (bool, 可选) — 模型仓库是否为私有。
kwargs (Dict[str, Any], 可选) — MistralCommonBackend.save_pretrained 不支持此参数。如果使用，将引发错误。

str 的元组

已保存的文件。

保存完整的 tokenizer 状态。

此方法可确保完整的 tokenizer 稍后可以使用 ~MistralCommonBackend.tokenization_mistral_common.from_pretrained 类方法重新加载。

save_vocabulary

( save_directory: str filename_prefix: str | None = None )

MistralCommonBackend 不实现 save_vocabulary，这是出于设计考虑。

这是因为 mistral-common 由一个 tokenizer 文件配置。如果您想保存词汇表，请考虑使用 save_pretrained 方法。

tokenize

( text: str return_offsets_mapping: typing.Literal[False] = False split_special_tokens: typing.Literal[False] = False **kwargs ) → list[str]

参数

text (str) — 要进行编码的序列。
return_offsets_mapping (Literal[False], 可选) — 设为 False，保留此参数以匹配 Transformers 的方法签名。
split_special_tokens (Literal[False], 可选) — 设为 False，保留此参数以匹配 Transformers 的方法签名。
**kwargs (附加关键字参数) — MistralCommonBackend.tokenize 不支持该参数。如果使用，将引发错误。

list[str]

令牌列表。

使用分词器将字符串转换为标记序列。

根据词汇表拆分为单词或子词。

truncate_sequences

( ids: list pair_ids: None = None num_tokens_to_remove: int = 0 truncation_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 方法将字符串转换为此 ID 列表。
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 的数量。

list[int], None, list[int] 的元组

截断后的 ids 和溢出标记列表。None 返回以匹配 Transformers 的签名。

根据策略原地截断序列对。

MixtralModel

class transformers.MixtralModel

( config: MixtralConfig )

参数

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

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

该模型继承自 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 use_cache: bool | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → MoeModelOutputWithPast 或 tuple(torch.FloatTensor)

参数

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

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

什么是 input IDs？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充 token 索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示未被掩码的 token，
- 0 表示被掩码的 token。
什么是注意力掩码？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列 token 在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 范围内选择。

什么是位置 ID？
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（那些其过去键值状态未提供给此模型的 token），而不是所有形状为 (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 的前向传播方法，覆盖了 __call__ 特殊方法。

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

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
past_key_values (Cache，*可选*，当传入 use_cache=True 或 config.use_cache=True 时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。

Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if config.is_encoder_decoder=True in the cross-attention blocks) that can be used (see past_key_values input) to speed up sequential decoding.
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
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 后），这些术语用于计算专家混合模型的辅助损失。

MixtralForCausalLM

class transformers.MixtralForCausalLM

( 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 (MixtralForCausalLM) — 模型的配置类，包含模型的所有参数。使用配置文件初始化并不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法来加载模型权重。

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

该模型继承自 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 logits_to_keep: int | torch.Tensor = 0 **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → MoeCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

参数

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

索引可以使用 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 缓存指南。如果不传递 past_key_values，默认将初始化 DynamicCache。

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

如果使用 past_key_values，用户应仅输入未处理的 input_ids（即其过去键值状态未提供给此模型的那些 ID），形状为 (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 的标记将被忽略（屏蔽），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
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 个标记的 logits。如果为 0，计算所有 input_ids 的 logits（特殊情况）。生成时仅需要最后标记的 logits，仅针对该标记进行计算可节省显存，这对于长序列或大词汇量的情况尤为重要。如果是 torch.Tensor，必须是对应于序列长度维度中要保留索引的一维张量。这在使用打包张量格式（batch 和序列长度的单一维度）时非常有用。

MoeCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

一个 MoeCausalLMOutputWithPast 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或 config.return_dict=False），具体取决于配置（MixtralConfig）和输入。

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

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

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

示例

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

class transformers.MixtralForSequenceClassification

( config )

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] ) → SequenceClassifierOutputWithPast or tuple(torch.FloatTensor)

参数

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

索引可以使用 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 缓存指南。如果不传递 past_key_values，默认将初始化 DynamicCache。

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

如果使用 past_key_values，用户应仅输入未处理的 input_ids（即其过去键值状态未提供给此模型的那些 ID），形状为 (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 的标记将被忽略（屏蔽），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
use_cache (bool，可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（详见 past_key_values）。

SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

一个 SequenceClassifierOutputWithPast 或 torch.FloatTensor 元组（如果传入了 return_dict=False 或当 config.return_dict=False 时），根据配置（None）和输入，其包含不同的元素。

The GenericForSequenceClassification forward method, overrides the __call__ special method.

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

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。
logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。
past_key_values (Cache，*可选*，当传入 use_cache=True 或 config.use_cache=True 时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。

包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

MixtralForTokenClassification

class transformers.MixtralForTokenClassification

( config )

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] ) → TokenClassifierOutput 或 tuple(torch.FloatTensor)

参数

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

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

什么是输入 ID？
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] 中选择。

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

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

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

如果使用 past_key_values，用户应仅输入未处理的 input_ids（即那些未将之前的键值状态提供给该模型的输入），形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的所有 input_ids。
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）。

TokenClassifierOutput 或 tuple(torch.FloatTensor)

一个 TokenClassifierOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含取决于配置 (None) 和输入的各种元素。

The GenericForTokenClassification forward method, overrides the __call__ special method.

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

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失。
logits (形状为 (batch_size, sequence_length, config.num_labels) 的 torch.FloatTensor) — 分类分数（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

MixtralForQuestionAnswering

class transformers.MixtralForQuestionAnswering

( config )

forward