# Mixtral

## 概要

[Mixtral-8x7B](https://huggingface.co/papers/2401.04088) は、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](https://mistral.ai/news/mixtral-of-experts/) ブログ記事で紹介されました。

ブログ記事の導入部には次のように記載されています:

*本日、チームはオープンウェイトの高品質なスパースなエキスパートの混合モデル（SMoE）である Mixtral 8x7B のリリースを誇りに思います。ライセンスは Apache 2.0 です。Mixtral は、ほとんどのベンチマークで Llama 2 70B を上回り、推論速度は 6 倍速いです。寛容なライセンスを持つオープンウェイトモデルの中で最も強力であり、コストとパフォーマンスのトレードオフを考慮した全体的なモデルとしても最良です。特に、ほとんどの標準ベンチマークで GPT3.5 に匹敵するか、それを上回る性能を発揮します。*

Mixtral-8x7B は、[Mistral-7B](mistral) に続き、[mistral.ai](https://mistral.ai/) によってリリースされた2番目の大規模言語モデル（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](https://huggingface.co/blog/moe).
- モデルのパラメータ数が450億に達するにもかかわらず、1回のフォワードパスに必要な計算量は、140億パラメータのモデルと同等です。これは、各エキスパートをRAMにロードする必要があるため（70B相当のRAM要件）、しかし隠れ状態からの各トークンは2回ディスパッチされる（top 2ルーティング）ため、計算量（各フォワード計算で必要な演算）は単に2 X sequence_lengthとなるからです。

以下の実装詳細は、Mistral AIの最初のモデルである[Mistral-7B](mistral)と共通しています:

- スライディングウィンドウアテンション - 8kのコンテキスト長と固定されたキャッシュサイズで学習されており、理論上のアテンション範囲は128Kトークンです
- GQA （グループド クエリ アテンション）- より高速な推論と、より小さいキャッシュサイズを可能にします。
- Byte-fallback BPE トークナイザー - 文字が語彙外トークンにマッピングされることを防ぎます。

詳細については、[リリースブログ記事](https://mistral.ai/news/mixtral-of-experts/)を参照してください。

### ライセンス

`Mixtral-8x7B`はApache 2.0ライセンスの下で公開されています。

## 使用のコツ

Mistralチームは2つのチェックポイントをリリースしました:

- インターネット規模のデータで次のトークンを予測するように事前学習されたベースモデル、[Mixtral-8x7B-v0.1](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1)。
- 指示チューニング済みモデルである[Mixtral-8x7B-Instruct-v0.1](https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1)は、教師ありファインチューニング (SFT) と直接選好最適化 (DPO) を用いてチャット用途向けに最適化されたベースモデルです。

ベースモデルは次のように使用できます:

```python
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 ..."
```

指示チューニング済みモデルは、次のように使用できます。

```python
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: (...)"
```

ご覧のとおり、指示チューニング済みモデルでは、入力が正しい形式で準備されることを保証するために、[チャットテンプレート](../chat_templating)を適用する必要があります。

## Flash Attention を使用して Mixtral を高速化

上記のコードスニペットは、最適化テクニックを一切使わない推論を示しています。しかし、モデル内で使用されるアテンションメカニズムのより高速な実装である[Flash Attention](../kernel_doc/loading_kernels#attention-kernels)を活用することで、モデルを大幅に高速化できます。

まず、スライディングウィンドウアテンション機能を含む最新のFlash Attention 2をインストールしてください。

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

Flash-Attention 2 と互換性のあるハードウェアを使用していることも確認してください。詳細については、[flash attention リポジトリ](https://github.com/Dao-AILab/flash-attention)の公式ドキュメントを参照してください。また、モデルを半精度（例: `torch.float16`）で読み込むことも確認してください。

Flash Attention-2を使用してモデルを読み込み、実行するには、以下のスニペットを参照してください。

```python
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"` の場合のみバッチ生成をサポートし、現在のトークンの絶対位置を用いて位置埋め込みを計算します。

## 量子化による Mixtral のサイズ縮小

Mixtralモデルは450億のパラメータを持つため、各パラメータが2バイトで保存される半精度（float16）では、約90GBのGPU RAMが必要です。ただし、[量子化](../quantization/overview)を用いてモデルのサイズを縮小できます。モデルを4ビット（パラメータあたり半バイト）に量子化すると、必要なRAMは約27GBに減るため、40GBのRAMを備えた単一のA100でモデル全体を収容できます。

モデルの量子化は、モデルに`quantization_config`を渡すだけで行えます。以下では、bitsandbytes量子化ライブラリを利用しますが（他の量子化方法については、[このページ](../quantization/overview)を参照してください）：

```python
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](https://huggingface.co/ybelkada) 氏と [Arthur Zucker](https://huggingface.co/ArthurZ) 氏によって提供されました。元のコードは[こちら](https://github.com/mistralai/mistral-src)で確認できます。

## リソース

Mixtralの入門を支援するための、Hugging Face公式およびコミュニティ（🌎で示されています）のリソースのリストです。ここにリソースを掲載していただくことを希望される場合は、Pull Requestをオープンしてください。レビューいたします。リソースは、既存のリソースと重複するのではなく、新しいことを示すものが望ましいです。

- Mixtral-8x7Bの教師ありファインチューニング（SFT）を行うデモノートブックは、[こちら](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/Mistral/Supervised_fine_tuning_(SFT)_of_an_LLM_using_Hugging_Face_tooling.ipynb)で確認できます。🌎
- PEFTを使用してMixtral-8x7Bをファインチューニングする[ブログ記事](https://medium.com/@prakharsaxena11111/finetuning-mixtral-7bx8-6071b0ebf114)。🌎
- Hugging Face による [Alignment Handbook](https://github.com/huggingface/alignment-handbook) には、Mistral-7B での教師ありファインチューニング (SFT) と直接選好最適化を実行するためのスクリプトとレシピが含まれています。これには、フルファインチューニング、単一アクセラレーターでの QLoRa、および複数アクセラレーターでのファインチューニングのスクリプトが含まれます。
- [因果言語モデリングタスクのガイド](../tasks/language_modeling)

## MixtralConfig[[transformers.MixtralConfig]]

#### transformers.MixtralConfig[[transformers.MixtralConfig]]

```python
transformers.MixtralConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = 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: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = 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)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/configuration_mixtral.py#L25)

**パラメータ:**

vocab_size (`int`、*任意*、デフォルトは `32000`) : モデルの語彙サイズ。`input_ids` で表現できるトークンの種類数を定義します。

hidden_size (`int`、*任意*、デフォルトは`4096`) : 隠れ表現の次元数。

intermediate_size (`int`、*optional*、デフォルトは`14336`) : MLP 表現の次元数。

num_hidden_layers (`int`、*任意*、デフォルトは`32`) : Transformerデコーダーの隠れ層の数。

num_attention_heads (`int`、*任意*、デフォルトは `32`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。

num_key_value_heads (`int`, *optional*, デフォルトは `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 ヘッドは、そのグループ内の元のすべてのヘッドを平均プーリングして構築する必要があります。詳細については、[この論文](https://huggingface.co/papers/2305.13245)を参照してください。指定されない場合、デフォルトで `num_attention_heads` が使用されます。

head_dim (`int`, *optional*) : アテンションヘッドの次元です。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`, *任意*) : 語彙内でパディングに使用されるトークンID。

bos_token_id (`int`, *任意*, デフォルトは `1`) : 語彙内でストリームの開始に使用されるトークン ID。

eos_token_id (`Union[int, list[int]]`、*任意*、デフォルトは`2`) : 語彙内でストリーム終了に使用されるトークン ID。

tie_word_embeddings (`bool`, *任意*, デフォルトは `False`) : モデルの `tied_weights_keys` マッピングに従って重み埋め込みを共有するかどうか。

sliding_window (`int`, *optional*) : スライディングウィンドウアテンションのウィンドウサイズ。`None` の場合、スライディングウィンドウは適用されません。

attention_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率。

num_experts_per_tok (`int`、*任意*、デフォルトは`2`) : 各トークンをルーティングするエキスパートの数です。これは、トークン選択ルーティングにおけるtop-kの値です。

num_local_experts (`int`, *任意*, デフォルトは `8`) : 各デバイス上のローカルエキスパートの数。 `num_experts` は `num_local_experts` で割り切れる必要があります。

output_router_logits (`bool`, *任意*, デフォルトは `False`) : モデルがルーターのロジスティック値を返すかどうかを指定します。これを有効にすると、モデルはロードバランシングロスやルーターのzロスを含む補助ロスの出力も可能になります。

router_aux_loss_coef (`float`、*任意*、デフォルトは `0.001`) : 補助的なロードバランシング損失の係数です。MoE モデルにおける不均一なエキスパートルーティングをペナルティするために使用されます。

router_jitter_noise (`float`、*任意*、デフォルトは`0.0`) : 学習時にルーターのロジットに追加するノイズの量です。より良い負荷分散のために使用します。

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : RoPE 埋め込みの設定パラメータを含む辞書です。この辞書には `rope_theta` の値が含まれていなければならず、より長い `max_position_embeddings` で RoPE を使用する場合、スケーリングに使用されるパラメータが任意で含まれます。

これは MixtralModel の設定を保存するための設定クラスです。指定された引数に基づいて Mixtral モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[mistralai/Mixtral-8x7B-v0.1](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:

```python
>>> 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[[transformers.MistralCommonBackend]]

#### transformers.MistralCommonBackend[[transformers.MistralCommonBackend]]

```python
transformers.MistralCommonBackend(tokenizer_path: str | os.PathLike | pathlib.Path, mode: str | ValidationMode = '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)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L194)

`mistral-common` のトークナイザをラップするためのクラスです。

`mistral-common` は、Mistral AI モデル用の公式トークナイザライブラリです。使用するには、以下でインストールする必要があります。

```bash
pip install transformers[mistral-common]
```

それ以外の場合、tokenizer は Transformers による tokenizer の実装にフォールバックします。

`mistral-common`の詳細については、[mistral-common](https://github.com/mistralai/mistral-common)を参照してください。

このクラスは、`mistral_common.tokens.tokenizers.mistral.MistralTokenizer` のラッパーです。公式の mistral-common トークナイザーを使用してトークン化するための Hugging Face 互換インターフェースを提供し、`PreTrainedTokenizerBase` クラスを継承しています。

`PythonBackend` クラスとの主な動作上の違いは以下の通りです:

- シーケンスのペアはサポートされていません。互換性のためにシグネチャは維持されていますが、シーケンスのペアに関連するすべての引数は無視されます。ペアの戻り値は`None`として返されます。
- `is_split_into_words` 引数はサポートされていません。
- トークナイザーに新しいトークンを追加することはできません。特殊トークンの扱いは Transformers と異なります。`mistral-common` では、特殊トークンは直接エンコードされません。つまり、`tokenizer.encode("<s>")` は `<s>` トークンの ID を返しません。代わりに、文字列 `"<s>"` のトークン化に対応する ID のリストを返します。詳細については、[mistral-common のドキュメント](https://mistralai.github.io/mistral-common/usage/tokenizers/#special-tokens)を参照してください。

このクラスの改善に関するご提案がある場合は、トークナイザーに関連する場合は[mistral-common GitHub リポジトリ](https://github.com/mistralai/mistral-common/issues)に、Hugging Face インターフェースに関連する場合は[Transformers GitHub リポジトリ](https://github.com/huggingface/transformers/issues)に、それぞれ issue を作成してください。

#### add_special_tokens[[transformers.MistralCommonBackend.add_special_tokens]]

```python
add_special_tokens(special_tokens_dict: dict, replace_extra_special_tokens: bool = True)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1679)

`MistralCommonBackend` は、設計上 `add_special_tokens` を実装していません。

この動作の実装を希望される場合は、`Transformers`または`mistral-common`リポジトリでissueを作成してご依頼ください。

#### add_tokens[[transformers.MistralCommonBackend.add_tokens]]

```python
add_tokens(special_tokens_dict: dict, replace_extra_special_tokens: bool = True)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1691)

`MistralCommonBackend` は、設計上 `add_special_tokens` を実装していません。

この動作の実装を希望される場合は、`Transformers`または`mistral-common`リポジトリでissueを作成してご依頼ください。

#### apply_chat_template[[transformers.MistralCommonBackend.apply_chat_template]]

```python
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: ReasoningEffort | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1038)

**パラメータ:**

conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) : これまでのチャット履歴を表す、"role" と "content" キーを持つ辞書のリスト。

tools (`List[Union[Dict, Callable]]`、*任意*) : モデルがアクセスできるツール（呼び出し可能な関数）のリストです。テンプレートが関数呼び出しをサポートしていない場合、この引数は無効になります。各ツールは、ツールの名前、説明、引数の型を指定した JSON Schema として渡す必要があります。詳細については、[チャットテンプレートガイド](https://huggingface.co/docs/transformers/main/en/chat_templating#automated-function-conversion-for-tool-use)を参照してください。

add_generation_prompt (`bool`, *任意*) : この引数は`MistralCommonBackend`では何もしません。ただし、APIの一貫性を保つため、`continue_final_message`と同時に使用することはできません。会話の末尾がアシスタントメッセージである場合、エラーが発生します。そのような場合は、代わりに`continue_final_message`を使用してください。

continue_final_message (bool, *optional*) : これが設定されている場合、チャットは最終メッセージがオープンエンドになるようにフォーマットされ、EOS トークンが付きません。モデルは新しいメッセージを開始するのではなく、このメッセージを続行します。これにより、モデルの応答の一部を「プリフィル」できます。`add_generation_prompt` と同時に使用することはできません。

tokenize (`bool`、デフォルトは`True`) : 出力をトークン化するかを指定します。`False`の場合、出力は文字列になります。

padding (`bool`、`str`または[PaddingStrategy](/docs/transformers/main/ja/internal/file_utils#transformers.utils.PaddingStrategy)、*省略可能*、デフォルトは`False`) : 返されるシーケンスのパディング戦略を選択します（モデルのパディング側とパディングインデックスに従います）。選択肢は以下の通りです。 - `True`または`'longest'`: バッチ内の最も長いシーケンスまでパディングします（単一のシーケンスのみが提供された場合は、パディングを行いません）。 - `'max_length'`: 引数`max_length`で指定された最大長までパディングします。この引数が提供されていない場合は、モデルが受け入れられる最大入力長までパディングします。 - `False`または`'do_not_pad'`（デフォルト）: パディングを行いません（つまり、長さが異なるシーケンスのバッチを出力できます）。

truncation (`bool`、デフォルトは`False`) : シーケンスを最大長で切り詰めるかどうか。`False`の場合、この引数は無効です。

max_length (`int`, *任意*) : パディングや切り詰めのために使用する最大長（トークン数）。tokenize が `False` の場合は無効です。指定しない場合、デフォルトとしてトークナイザーの `max_length` 属性が使用されます。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、特定のフレームワークのテンソルを返します。tokenize が `False` の場合は効果がありません。許可される値は以下の通りです: - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。

return_dict (`bool`、デフォルトは`False`) : 名前付き出力を含む辞書を返すかどうか。`False`の場合は効果がありません。少なくとも1つの会話に画像が含まれている場合、そのピクセル値は`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"`キーを持つ辞書のリストを、トークンIDのリストに変換します。

#### batch_decode[[transformers.MistralCommonBackend.batch_decode]]

```python
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)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L512)

**パラメータ:**

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 を呼び出して、トークン ID のリストのリストを文字列のリストに変換します。

このメソッドは後方互換性のために提供されています。`decode`メソッドは現在、バッチ入力をネイティブで処理するため、`batch_decode`の代わりに`decode`を直接使用できます。

#### build_inputs_with_special_tokens[[transformers.MistralCommonBackend.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1284)

**パラメータ:**

token_ids_0 (`list[int]`) : 特殊トークンが追加されるIDのリスト。

token_ids_1 (`None`, *任意*) : None。Transformers のシグネチャに合わせるため、このまま残しています。

**戻り値:** `list[int]`

適切な特殊トークンを含む入力IDのリスト。

特殊トークンを追加して、シーケンスからモデルの入力を構築します。

このメソッドは、トークナイザーの`mode`に基づいて入力を動的に構築します:
- `"test"`: seq0 [EOS]
- `"finetuning"`: [BOS] seq0

#### convert_added_tokens[[transformers.MistralCommonBackend.convert_added_tokens]]

```python
convert_added_tokens(obj: tokenizers.AddedToken | typing.Any, save: bool = False, add_type_field: bool = True)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1704)

`MistralCommonBackend` は、設計上 `convert_added_tokens` を実装していません。

この動作の実装を希望される場合は、`Transformers`または`mistral-common`リポジトリでissueを作成してご依頼ください。

#### create_token_type_ids_from_sequences[[transformers.MistralCommonBackend.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list, token_ids_1: None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1313)

**パラメータ:**

token_ids_0 (`list[int]`) : ID のリスト。

token_ids_1 (`None`, *任意*) : None。Transformers のシグネチャに合わせるため、このまま残しています。

**戻り値:** `list[int]`

設定されたパターンに従ったトークンタイプID。

…

Transformersの実装に合わせて維持されています。

#### decode[[transformers.MistralCommonBackend.decode]]

```python
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)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L475)

**パラメータ:**

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[[transformers.MistralCommonBackend.encode]]

```python
encode(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)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L378)

**パラメータ:**

text (`str` または `list[int]`) : エンコードする最初のシーケンスです。文字列または整数のリスト（トークン化された文字列 ID）を指定できます。

text_pair (`None`, *任意*) : `MistralCommonBackend.encode` ではサポートされていません。`PreTrainedTokenizerBase.encode` のシグネチャに合わせるために保持されています。

add_special_tokens (`bool`、*任意*、デフォルトは`True`) : シーケンスをエンコードする際に特殊トークンを追加するかどうか。これは、入力 ID に自動的に追加されるトークンを定義する基盤となる`PretrainedTokenizerBase.build_inputs_with_special_tokens`関数を使用します。`bos`または`eos`トークンを自動的に追加したい場合に便利です。Tokenizer が`finetuning`モードで読み込まれる場合、`bos`と`eos`の両方が追加されます。それ以外の場合、"test"モードでは`bos`のみが追加されます。

padding (`bool`、`str` または [PaddingStrategy](/docs/transformers/main/ja/internal/file_utils#transformers.utils.PaddingStrategy)、*optional*、デフォルトは `False`) : パディングの有効化と制御を行います。以下の値を受け取ります:  - `True` または `'longest'`: バッチ内の最長のシーケンスの長さにパディングします（単一のシーケンスのみが提供された場合は、パディングを行いません）。 - `'max_length'`: 引数 `max_length` で指定された最大長、またはその引数が提供されていない場合はモデルが受け入れ可能な最大入力長までパディングします。 - `False` または `'do_not_pad'`（デフォルト）: パディングを行いません（つまり、長さが異なるシーケンスのバッチを出力できます）。

truncation (`bool`、`str`または[TruncationStrategy](/docs/transformers/main/ja/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)、*optional*、デフォルトは`False`) : トランケーションを有効化し、制御します。以下の値を受け付けます: - `True`または`'longest_first'`: 引数`max_length`で指定された最大長、またはその引数が提供されていない場合はモデルが許容する最大入力長まで切り詰めます。 - `False`または`'do_not_truncate'`（デフォルト）: トランケーションを行いません（つまり、モデルが許容する最大入力サイズを超えるシーケンス長を持つバッチを出力する可能性があります）。

max_length (`int`, *optional*) : 切り詰め/パディングパラメータのいずれかによって使用される最大長を制御します。 未設定のまま、または `None` に設定されている場合、切り詰め/パディングパラメータのいずれかが最大長を必要とする場合、事前に定義されたモデルの最大長が使用されます。 モデルに特定の最大入力長がない場合（XLNet など）、最大長への切り詰め/パディングは無効になります。

stride (`int`、*optional*、デフォルト値は 0) : `max_length` とともに数値が設定されている場合、`return_overflowing_tokens=True` のときに返されるオーバーフローしたトークンは、切り詰められたシーケンスの末尾の一部のトークンを含み、切り詰められたシーケンスとオーバーフローしたシーケンスの間に重複部分を持たせます。この引数の値は、重複するトークンの数を定義します。

pad_to_multiple_of (`int`, *optional*) : 設定すると、シーケンスを指定された値の倍数にパディングします。`padding` が有効になっている必要があります。これは、計算能力が `>= 7.5` (Volta) の NVIDIA ハードウェア上で Tensor Cores を使用可能にするために特に有用です。

padding_side (`str`, *任意*) : モデルにパディングを適用する側です。['right', 'left'] から選択する必要があります。デフォルト値は、同名のクラス属性から取得されます。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、Python の整数のリストではなくテンソルを返します。許可される値は以下の通りです:  - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。

- ****kwargs** : `MistralCommonBackend.encode`ではサポートされていません。使用するとエラーが発生します。

**戻り値:** `list[int]`, `torch.Tensor`

テキストのトークン化されたIDです。

トークナイザーと語彙を使用して、文字列をid（整数）のシーケンスに変換します。

#### from_pretrained[[transformers.MistralCommonBackend.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, *init_inputs, mode: str | ValidationMode = '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)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1437)

**パラメータ:**

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`：テストモード。この設定により、トークナイザーが入力を検証し、モデルへのリクエストを準備する方法が変更されます。

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 ベースのシステムを使用しているため、`revision` には git で許可されている任意の識別子（ブランチ名、タグ名、コミット ID など）を指定できます。

max_length (`int`, *optional*) : 切り詰め/パディングパラメータのいずれかによって使用される最大長を制御します。 未設定のまま、または `None` に設定されている場合、切り詰め/パディングパラメータのいずれかが最大長を必要とする場合、事前に定義されたモデルの最大長が使用されます。 モデルに特定の最大入力長がない場合（XLNet など）、最大長への切り詰め/パディングは無効になります。

padding_side (`str`、*任意*、デフォルトは`"left"`) : モデルにパディングを適用する側です。['right', 'left'] から選択する必要があります。デフォルト値は、同名のクラス属性から取得されます。

truncation_side (`str`、*任意*、デフォルトは`"right"`) : モデルに切り詰めを適用する側です。['right', 'left'] から選択してください。

model_input_names (`List[str]`、*optional*) : モデルのフォワードパスが受け入れる入力の一覧（`"token_type_ids"` や `"attention_mask"` など）。デフォルト値は、同名のクラス属性から選択されます。

clean_up_tokenization_spaces (`bool`、*任意*、デフォルトは`False`) : トークナイズ処理中に入力テキストを分割する際に追加されたスペースを、モデルがクリーンアップすべきかどうか。

kwargs （追加のキーワード引数、*任意*）: `MistralCommonBackend.from_pretrained` によってサポートされていません。使用するとエラーが発生します。

`MistralCommonBackend`を事前定義されたトークナイザーからインスタンス化します。

#### get_chat_template[[transformers.MistralCommonBackend.get_chat_template]]

```python
get_chat_template(chat_template: str | None = None, tools: list[dict] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1713)

`MistralCommonBackend` は、`mistral-common` がチャットテンプレートを使用しないため、`get_chat_template` を実装していません。

#### get_special_tokens_mask[[transformers.MistralCommonBackend.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list, token_ids_1: None = None, already_has_special_tokens: bool = False)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L691)

**パラメータ:**

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[[transformers.MistralCommonBackend.get_vocab]]

```python
get_vocab()
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L352)

**戻り値:** `Dict[str, int]`

語彙。

トークンからインデックスへの辞書として語彙を返します。

これは有損変換です。部分的な UTF-8 バイトシーケンスが � に変換されるため、同じ文字列にデコードされるトークン ID が複数存在する可能性があります。

#### num_special_tokens_to_add[[transformers.MistralCommonBackend.num_special_tokens_to_add]]

```python
num_special_tokens_to_add(pair: typing.Literal[False] = False)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1337)

**パラメータ:**

pair (`Literal[False]`, *任意*) : False。Transformer のシグネチャに合わせるため残されています。

**戻り値:** `int`

シーケンスに追加される特殊トークンの数。

特殊トークン付きでシーケンスをエンコードする際に追加されるトークンの数を返します。

これはダミー入力をエンコードし、追加されたトークンの数をチェックするため、効率的ではありません。トレーニングループ内に配置しないでください。

#### prepare_for_model[[transformers.MistralCommonBackend.prepare_for_model]]

```python
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)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L844)

**パラメータ:**

ids (`list[int]`) : 最初のシーケンスのトークン化された入力ID。

pair_ids (`None`, *任意*) : `MistralCommonBackend`ではサポートされていません。`PreTrainedTokenizerBase`のインターフェースと一致させるために保持されています。

add_special_tokens (`bool`、*任意*、デフォルトは`True`) : シーケンスをエンコードする際に特殊トークンを追加するかどうか。これは、入力 ID に自動的に追加されるトークンを定義する基盤となる`PretrainedTokenizerBase.build_inputs_with_special_tokens`関数を使用します。`bos`または`eos`トークンを自動的に追加したい場合に便利です。Tokenizer が`finetuning`モードで読み込まれる場合、`bos`と`eos`の両方が追加されます。それ以外の場合、"test"モードでは`bos`のみが追加されます。

padding (`bool`、`str` または [PaddingStrategy](/docs/transformers/main/ja/internal/file_utils#transformers.utils.PaddingStrategy)、*optional*、デフォルトは `False`) : パディングの有効化と制御を行います。以下の値を受け取ります:  - `True` または `'longest'`: バッチ内の最長のシーケンスの長さにパディングします（単一のシーケンスのみが提供された場合は、パディングを行いません）。 - `'max_length'`: 引数 `max_length` で指定された最大長、またはその引数が提供されていない場合はモデルが受け入れ可能な最大入力長までパディングします。 - `False` または `'do_not_pad'`（デフォルト）: パディングを行いません（つまり、長さが異なるシーケンスのバッチを出力できます）。

truncation (`bool`、`str`または[TruncationStrategy](/docs/transformers/main/ja/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)、*optional*、デフォルトは`False`) : トランケーションを有効化し、制御します。以下の値を受け付けます: - `True`または`'longest_first'`: 引数`max_length`で指定された最大長、またはその引数が提供されていない場合はモデルが許容する最大入力長まで切り詰めます。 - `False`または`'do_not_truncate'`（デフォルト）: トランケーションを行いません（つまり、モデルが許容する最大入力サイズを超えるシーケンス長を持つバッチを出力する可能性があります）。

max_length (`int`, *optional*) : 切り詰め/パディングパラメータのいずれかによって使用される最大長を制御します。 未設定のまま、または `None` に設定されている場合、切り詰め/パディングパラメータのいずれかが最大長を必要とする場合、事前に定義されたモデルの最大長が使用されます。 モデルに特定の最大入力長がない場合（XLNet など）、最大長への切り詰め/パディングは無効になります。

stride (`int`、*optional*、デフォルト値は 0) : `max_length` とともに数値が設定されている場合、`return_overflowing_tokens=True` のときに返されるオーバーフローしたトークンは、切り詰められたシーケンスの末尾の一部のトークンを含み、切り詰められたシーケンスとオーバーフローしたシーケンスの間に重複部分を持たせます。この引数の値は、重複するトークンの数を定義します。

pad_to_multiple_of (`int`, *optional*) : 設定すると、シーケンスを指定された値の倍数にパディングします。`padding` が有効になっている必要があります。これは、計算能力が `>= 7.5` (Volta) の NVIDIA ハードウェア上で Tensor Cores を使用可能にするために特に有用です。

padding_side (`str`, *任意*) : モデルにパディングを適用する側です。['right', 'left'] から選択する必要があります。デフォルト値は、同名のクラス属性から取得されます。

return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、Python の整数のリストではなくテンソルを返します。許可される値は以下の通りです:  - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。

return_token_type_ids (`bool`, *任意*) : トークンタイプIDを返すかどうか。`MistralCommonBackend`では、1つのシーケンスのみサポートされるため、シーケンス長分のゼロのリストを返します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

return_attention_mask (`bool`、*省略可*) : アテンションマスクを返すかどうか。デフォルトのままにすると、`return_outputs` 属性で定義される特定のトークナイザーのデフォルトに従って、アテンションマスクを返します。  [アテンションマスクとは?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *任意*, デフォルトは `False`) : 溢れたトークンシーケンスを返すかどうかを指定します。入力 ID のシーケンスのペア（またはペアのバッチ）が `truncation_strategy = longest_first` または `True` とともに提供された場合、溢れたトークンを返す代わりにエラーが発生します。

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](/docs/transformers/main/ja/main_classes/tokenizer#transformers.BatchEncoding)

以下のフィールドを持つ[BatchEncoding](/docs/transformers/main/ja/main_classes/tokenizer#transformers.BatchEncoding):

- **input_ids** -- モデルに渡すトークンIDのリスト。

  [入力IDとは何ですか？](../glossary#input-ids)

- **attention_mask** -- モデルがどのトークンに注意すべきかを指定するインデックスのリスト（`return_attention_mask=True` の場合、または `self.model_input_names` に *"attention_mask"* が含まれている場合）。

  [アテンションマスクとは?](../glossary#attention-mask)

- **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[[transformers.MistralCommonBackend.save_chat_templates]]

```python
save_chat_templates(save_directory: str | os.PathLike, tokenizer_config: dict, filename_prefix: str | None, save_jinja_files: bool)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1718)

`MistralCommonBackend` は、`mistral-common` がチャットテンプレートを使用しないため、`save_chat_templates` を実装していません。

#### save_pretrained[[transformers.MistralCommonBackend.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike | pathlib.Path, push_to_hub: bool = False, token: str | bool | None = None, commit_message: str | None = None, repo_id: str | None = None, private: bool | None = None, save_format: str | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1552)

**パラメータ:**

save_directory (`str | os.PathLike | Path`) : トークナイザーを保存するディレクトリ。

push_to_hub (`bool`, *任意*, デフォルトは `False`) : 保存後に HF Hub にプッシュします。

token (`str` または `bool`、*省略可能*) : Hub 認証用のトークン。

commit_message (`str`, *任意*) : push 時のコミットメッセージ。

repo_id (`str`, *任意*) : HubリポジトリID。

private (`bool`, *任意*) : リポジトリがプライベートかどうか。

save_format (`str`, *任意*) : ネイティブの tekken 形式で保存するには `"mistral"`、HuggingFace 形式にするには `"hf"` を指定します。 *None* を指定すると元の形式が保持されます。

kwargs (`dict`, *任意*) : 非対応 — エラーが発生します。

**戻り値:** `tuple[str, ...]`

保存されたファイルのパス。

トークナイザーの完全な状態を保存します。

`save_format` が `"mistral"`（または tekken トークナイザーの場合は *None*）の場合、元のトークナイザーファイル（例: `tekken.json`）が *save_directory* に書き込まれます。 `save_format` が `"hf"` の場合、代わりに HF 形式のファイル（`tokenizer.json` + `tokenizer_config.json`）が生成されます。

#### save_vocabulary[[transformers.MistralCommonBackend.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1729)

`MistralCommonBackend` は、設計上 `save_vocabulary` を実装していません。

これは、`mistral-common`が1つのトークナイザーファイルで構成されているためです。語彙を保存したい場合は、代わりに`save_pretrained`メソッドの使用をご検討ください。

#### tokenize[[transformers.MistralCommonBackend.tokenize]]

```python
tokenize(text: str, return_offsets_mapping: typing.Literal[False] = False, split_special_tokens: typing.Literal[False] = False, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L645)

**パラメータ:**

text (`str`) : エンコード対象のシーケンス。

return_offsets_mapping (`Literal[False]`、*任意*) : False。Transformers のシグネチャに合わせるため残されています。

split_special_tokens (`Literal[False]`、*任意*) : False。Transformers のシグネチャに合わせるため残されています。

- ****kwargs**（追加のキーワード引数）: `MistralCommonBackend.tokenize`ではサポートされていません。使用するとエラーが発生します。

**戻り値:** `list[str]`

トークンのリスト。

トークナイザーを使用して、文字列をトークンのシーケンスに変換します。

単語ベースの語彙の場合は単語に、サブワードベースの語彙の場合はサブワードに分割します。

#### truncate_sequences[[transformers.MistralCommonBackend.truncate_sequences]]

```python
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)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L974)

**パラメータ:**

ids (`list[int]`) : トークン化された入力 ID。文字列から`tokenize`メソッドと`convert_tokens_to_ids`メソッドをチェーンすることで取得できます。

pair_ids (`None`, *任意*) : `MistralCommonBackend`ではサポートされていません。`PreTrainedTokenizerBase.truncate_sequences`のシグネチャに合わせるために保持されています。

num_tokens_to_remove (`int`、*optional*、デフォルトは 0) : トランケーション戦略を使用して削除するトークンの数。

truncation_strategy (`str` または [TruncationStrategy](/docs/transformers/main/ja/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)、*optional*、デフォルトは `'longest_first'`) : 切り詰めを行う際に採用する戦略。以下のいずれかを指定できます。 - `'longest_first'`: 引数 `max_length` で指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。 - `'do_not_truncate'` (デフォルト): 切り詰めを行いません（つまり、モデルが許容する最大入力サイズを超えるシーケンス長を持つバッチを出力する可能性があります）。

stride (`int`、*optional*、デフォルトは 0) : 正の値に設定すると、返されるオーバーフローのトークンに、返されるメインシーケンスの一部のトークンが含まれます。この引数の値は、追加されるトークンの数を定義します。

**戻り値:** `Tuple[list[int], None, list[int]]`

切り詰められた`ids`と、溢れたトークンのリスト。`None`が返され、Transformersのシグネチャに一致します。

シーケンスのペアを、戦略に従ってインプレースで切り詰めます。

## MixtralModel[[transformers.MixtralModel]]

#### transformers.MixtralModel[[transformers.MixtralModel]]

```python
transformers.MixtralModel(config: MixtralConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L399)

**パラメータ:**

config ([MixtralConfig](/docs/transformers/main/ja/model_doc/mixtral#transformers.MixtralConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

特定のヘッドを付加せずに、生のhidden-statesを出力する素のMixtral Model。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### forward[[transformers.MixtralModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L416)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(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](/docs/transformers/main/ja/model_doc/mixtral#transformers.MixtralConfig)）と入力に応じて異なります。

[MixtralModel](/docs/transformers/main/ja/model_doc/mixtral#transformers.MixtralModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  自己アテンションブロック（および `config.is_encoder_decoder=True` の場合、クロスカレンションブロック）の事前計算済みヒドゥンステート（キーとバリュー）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **router_logits** (`tuple(torch.FloatTensor)`、*optional*、`output_router_probs=True` と `config.add_router_probs=True` が渡された場合、または `config.output_router_probs=True` の場合に返されます) -- `torch.FloatTensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, sequence_length, num_experts)`。

  MoE ルーターによって計算される生（raw）のルーター logits（softmax 後）であり、Mixture of Experts モデルの補助損失を計算するためにこれらの用語が使用されます。

## MixtralForCausalLM[[transformers.MixtralForCausalLM]]

#### transformers.MixtralForCausalLM[[transformers.MixtralForCausalLM]]

```python
transformers.MixtralForCausalLM(config: MixtralConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L544)

**パラメータ:**

config ([MixtralConfig](/docs/transformers/main/ja/model_doc/mixtral#transformers.MixtralConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

因果言語モデリング用の Mixtral モデル。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。

#### forward[[transformers.MixtralForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_router_logits: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L562)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(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` の場合、シーケンス長次元で保持するインデックスに対応する 1 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。

**戻り値:** `MoeCausalLMOutputWithPast` または `tuple(torch.FloatTensor)`

`MoeCausalLMOutputWithPast`、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[MixtralConfig](/docs/transformers/main/ja/model_doc/mixtral#transformers.MixtralConfig)）と入力に応じて、さまざまな要素で構成されます。

[MixtralForCausalLM](/docs/transformers/main/ja/model_doc/mixtral#transformers.MixtralForCausalLM) の forward メソッドは、`__call__` という特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。
- **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **aux_loss** (`torch.FloatTensor`、*optional*、`output_router_logits=True` が渡された場合、または `config.output_router_logits=True` の場合、かつモデルがロードバランシング損失でルーターを学習する場合に返されます) -- スパースモジュール用のロードバランシング補助損失。ルーターバイアスでエキスパートをバランスさせるモデル（DeepSeek-V3 とそこから派生したアーキテクチャ）は、`router_logits` を返しながらも、ここでは `None` を返します。
- **router_logits** (`tuple(torch.FloatTensor)`、*optional*、`output_router_logits=True` が渡された場合または `config.output_router_logits=True` の場合に返されます) -- `torch.FloatTensor` のタプル（スパース層ごとに1つ）、形状は `(batch_size * sequence_length, num_experts)`。

  MoE ルーターによって計算される生のルーター logits です。ロードバランシング損失の計算や、トークンがどのようにエキスパートにディスパッチされるかの確認に使用できます。
- **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの隠れ状態（自己注意ブロックのキーとバリュー）が含まれます。
- **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。
- **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

例:

```python
>>> 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[[transformers.MixtralForSequenceClassification]]

#### transformers.MixtralForSequenceClassification[[transformers.MixtralForSequenceClassification]]

```python
transformers.MixtralForSequenceClassification(config)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L641)

#### forward[[transformers.MixtralForSequenceClassification.forward]]

```python
forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.FloatTensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs])
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L128)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された隠れ状態（自己アテンションブロックおよびクロスアテンションブロック内のキーとバリュー）です。通常、`use_cache=True` または `config.use_cache=True` が設定されている場合、デコードの以前の段階でモデルが返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache) を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去のキーバリュー状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(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[[transformers.MixtralForTokenClassification]]

#### transformers.MixtralForTokenClassification[[transformers.MixtralForTokenClassification]]

```python
transformers.MixtralForTokenClassification(config)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L645)

#### forward[[transformers.MixtralForTokenClassification.forward]]

```python
forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.FloatTensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs])
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L275)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された隠れ状態（自己アテンションブロックおよびクロスアテンションブロック内のキーとバリュー）です。通常、`use_cache=True` または `config.use_cache=True` が設定されている場合、デコードの以前の段階でモデルが返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache) を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去のキーバリュー状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*optional*) : トークン分類損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

**戻り値:** `TokenClassifierOutput`

`GenericForTokenClassification`のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

## MixtralForQuestionAnswering[[transformers.MixtralForQuestionAnswering]]

#### transformers.MixtralForQuestionAnswering[[transformers.MixtralForQuestionAnswering]]

```python
transformers.MixtralForQuestionAnswering(config)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mixtral/modeling_mixtral.py#L649)

#### forward[[transformers.MixtralForQuestionAnswering.forward]]

```python
forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.FloatTensor | None = None, start_positions: torch.LongTensor | None = None, end_positions: torch.LongTensor | None = None, **kwargs: Unpack[TransformersKwargs])
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L208)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids)

attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます:  - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。  [attention マスクとは?](../glossary#attention-mask)

position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids)

past_key_values (`Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された隠れ状態（自己アテンションブロックおよびクロスアテンションブロック内のキーとバリュー）です。通常、`use_cache=True` または `config.use_cache=True` が設定されている場合、デコードの以前の段階でモデルが返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache) を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去のキーバリュー状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

start_positions (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : トークン分類損失の計算に使用する、ラベル付きスパンの開始位置（インデックス）のラベル。位置はシーケンスの長さ（`sequence_length`）にクランプされます。シーケンス外の位置は、損失の計算には考慮されません。

end_positions (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : トークン分類損失の計算に使用する、ラベル付きスパンの終了位置（インデックス）のラベル。位置はシーケンスの長さ（`sequence_length`）にクランプされます。シーケンス外の位置は、損失の計算には考慮されません。

**戻り値:** `QuestionAnsweringModelOutput`

`GenericForQuestionAnswering`のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。