# Mistral 3

[Mistral 3](https://mistral.ai/news/mistral-small-3)はレイテンシに最適化されたモデルであり、レイヤー数を大幅に削減することで、1回のフォワードパスあたりの時間を短縮しています。このモデルはビジョン理解機能を追加し、パフォーマンスを損なうことなく最大128Kトークンまでの長いコンテキスト長をサポートします。

元の Mistral 3 チェックポイントは、[Mistral AI](https://huggingface.co/mistralai/models?search=mistral-small-3) 組織の下で確認できます。

> [!TIP]
> このモデルは [cyrilvallez](https://huggingface.co/cyrilvallez) と [yonigozlan](https://huggingface.co/yonigozlan) によって提供されました。Mistral3 をさまざまなタスクに適用する方法の例については、右側のサイドバーにある Mistral3 モデルをクリックしてください。
>
> `use_kernels=True` を [from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) に設定すると、対応するレイヤーが Hub からの最適化されたカーネルに置き換えられます。詳細は [カーネルの読み込み](../kernel_doc/loading_kernels) を参照してください。

以下の例では、[Pipeline](/docs/transformers/main/ja/main_classes/pipelines#transformers.Pipeline)と[AutoModel](/docs/transformers/main/ja/model_doc/auto#transformers.AutoModel)クラスを使用して画像からテキストを生成する方法を示しています。

```python
from transformers import pipeline

messages = [
    {"role": "user",
        "content":[
            {"type": "image",
            "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",},
            {"type": "text", "text": "Describe this image."}
        ,]
    ,}
,]

pipeline = pipeline(
    task="image-text-to-text",
    model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
    device=0
)
outputs = pipeline(text=messages, max_new_tokens=50, return_full_text=False)

outputs[0]["generated_text"]
'The image depicts a vibrant and lush garden scene featuring a variety of wildflowers and plants. The central focus is on a large, pinkish-purple flower, likely a Greater Celandine (Chelidonium majus), with a'
```

```python
from transformers import AutoModelForImageTextToText, AutoProcessor

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(
    model_checkpoint,
    device_map="auto",
)

messages = [
    {"role": "user",
        "content":[
            {"type": "image",
            "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",},
            {"type": "text", "text": "Describe this image."}
        ,]
    ,}
,]

inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True, return_dict=True,
    return_tensors="pt").to(model.device)

generate_ids = model.generate(**inputs, max_new_tokens=20)
decoded_output = processor.decode(generate_ids[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True)

decoded_output
'The image depicts a vibrant and lush garden scene featuring a variety of wildflowers and plants. The central focus is on a large, pinkish-purple flower, likely a Greater Celandine (Chelidonium majus), with a'
```

## 注記

- Mistral 3 はテキストのみの生成をサポートしています。

```py
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = ".mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

SYSTEM_PROMPT = "You are a conversational agent that always answers straight to the point, always end your accurate response with an ASCII drawing of a cat."
user_prompt = "Give me 5 non-formal ways to say 'See you later' in French."

messages = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": user_prompt},
]

text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = processor(text=text, return_tensors="pt").to(0)
generate_ids = model.generate(**inputs, max_new_tokens=50, do_sample=False)
decoded_output = processor.batch_decode(generate_ids[:, inputs["input_ids"].shape[1] :], skip_special_tokens=True)[0]

print(decoded_output)
"1. À plus tard!
 2. Salut, à plus!
 3. À toute!
 4. À la prochaine!
 5. Je me casse, à plus!

```

 /\_/\
( o.o )
 > ^ <

```"
````

- Mistral 3 は、バッチ化された画像とテキストの入力をサポートします。

```py
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

messages = [
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                 {"type": "text", "text": "Write a haiku for this image"},
             ],
         },
     ],
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"},
                 {"type": "text", "text": "Describe this image"},
             ],
         },
     ],
 ]

 inputs = processor.apply_chat_template(messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

 output = model.generate(**inputs, max_new_tokens=25)

 decoded_outputs = processor.batch_decode(output, skip_special_tokens=True)
 decoded_outputs
["Write a haiku for this imageCalm waters reflect\nWhispers of the forest's breath\nPeace on wooden path"
, "Describe this imageThe image depicts a vibrant street scene in what appears to be a Chinatown district. The focal point is a traditional Chinese"]
```

- Mistral 3 は、テキストごとに異なる数の画像を含む、バッチ化された画像およびテキストの入力もサポートしていました。以下の例では、bitsandbytes を使用してモデルを量子化しています。

```py
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText, BitsAndBytesConfig

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
quantization_config = BitsAndBytesConfig(load_in_4bit=True)
model = AutoModelForImageTextToText.from_pretrained(
     model_checkpoint, quantization_config=quantization_config
 device_map="auto")

messages = [
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                 {"type": "text", "text": "Write a haiku for this image"},
             ],
         },
     ],
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg"},
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/dreamstime_golden_gate_flowers.jpg"},
                 {"type": "text", "text": "These images depict two different landmarks. Can you identify them?"},
             ],
         },
     ],
 ]

 inputs = processor.apply_chat_template(messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

 output = model.generate(**inputs, max_new_tokens=25)

 decoded_outputs = processor.batch_decode(output, skip_special_tokens=True)
 decoded_outputs
["Write a haiku for this imageSure, here is a haiku inspired by the image:\n\nCalm lake's wooden path\nSilent forest stands guard\n", "These images depict two different landmarks. Can you identify them? Certainly! The images depict two iconic landmarks:\n\n1. The first image shows the Statue of Liberty in New York City."]
```

## Mistral3Config[[transformers.Mistral3Config]]

#### transformers.Mistral3Config[[transformers.Mistral3Config]]

```python
transformers.Mistral3Config(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, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_index: int = 10, projector_hidden_act: str = 'gelu', vision_feature_layer: int | list[int] = -1, multimodal_projector_bias: bool = False, spatial_merge_size: int = 2, tie_word_embeddings: bool = True)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/configuration_mistral3.py#L26)

**パラメータ:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *任意*) : ビジョンバックボーンの config オブジェクトまたは辞書。

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *任意*) : テキストバックボーンの config オブジェクトまたは辞書。

image_token_index (`int`、*optional*、デフォルトは`10`) : 入力画像のプレースホルダーとして使用される画像トークンのインデックス。

projector_hidden_act (`str`、*任意*、デフォルトは `gelu`) : マルチモーダルプロジェクターで使用する活性化関数。

vision_feature_layer (`Union[int, list[int]]`、*任意*、デフォルトは`-1`) : 視覚特徴を選択するレイヤーのインデックスです。複数のインデックスが指定された場合、対応するインデックスの視覚特徴が連結されて視覚特徴が形成されます。

multimodal_projector_bias (`bool`、*任意*、デフォルトは`False`) : マルチモーダルプロジェクターでバイアスを使用するかどうか。

spatial_merge_size (`int`、*optional*、デフォルトは`2`) : 近傍の patch をマージしてビジュアルトークンの数を削減するために使用される、空間マージウィンドウのサイズです。

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

これはMistral3Modelの設定を保存するための設定クラスです。指定された引数に基づいてMistral3モデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[mistralai/Mistral-Small-3.1-24B-Instruct-2503](https://huggingface.co/mistralai/Mistral-Small-3.1-24B-Instruct-2503)と類似した設定が得られます。

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

例:

```python
>>> from transformers import Mistral3ForConditionalGeneration, Mistral3Config, PixtralVisionConfig, MistralConfig

>>> # Initializing a Pixtral-vision config
>>> vision_config = PixtralVisionConfig()

>>> # Initializing a Mistral config
>>> text_config = MistralConfig()

>>> # Initializing a Mistral3 configuration
>>> configuration = Mistral3Config(vision_config, text_config)

>>> # Initializing a model from the mistral3.1 configuration
>>> model = Mistral3ForConditionalGeneration(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のシグネチャに一致します。

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

## Mistral3Model[[transformers.Mistral3Model]]

#### transformers.Mistral3Model[[transformers.Mistral3Model]]

```python
transformers.Mistral3Model(config: Mistral3Config)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L199)

**パラメータ:**

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

…

このモデルは [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.Mistral3Model.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.FloatTensor] = 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, vision_feature_layer: int | list[int] | None = None, use_cache: bool | None = None, image_sizes: typing.Optional[torch.Tensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L269)

**パラメータ:**

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)

pixel_values (`torch.FloatTensor`、形状 `(batch_size, num_channels, image_size, image_size)`、*任意*) : 入力画像に対応するテンソルです。ピクセル値は [PixtralImageProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralImageProcessor) を使用して取得できます。詳細については [PixtralImageProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) を参照してください（[PixtralProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralProcessor) は画像の処理に [PixtralImageProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralImageProcessor) を使用します）。

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` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

vision_feature_layer (`Union[int, list[int]]`、*任意*) : 視覚特徴を選択するレイヤーのインデックスです。複数のインデックスが指定された場合、対応するインデックスの視覚特徴が連結されて視覚特徴が形成されます。

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

image_sizes (`torch.Tensor`、shape `(batch_size, 2)`、*optional*) : バッチ内の各画像のサイズ（高さ、幅）。

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *任意*) : キーがサポートされているモダリティ、値がそのモダリティのエンコード済み出力である辞書。各エンコード済み出力は、(`pooler_output`、*任意*: `last_hidden_states`、*任意*: `hidden_states`、*任意*: `attentions`) という形式のタプルで、`pooler_output` の形状は `(batch_size, sequence_length, hidden_size)`、*任意*) であり、エンコーダーのマルチモーダル特徴量をテキスト埋め込みにマージしたシーケンスです。

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

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

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

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

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。

  `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, 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)を参照してください。

  逐次デコーディングを高速化するために使用できる（`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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **image_hidden_states** (`torch.FloatTensor`、*任意*) -- サイズが`(batch_size, num_images, sequence_length, hidden_size)`の`torch.FloatTensor`。ビジョンエンコーダーによって生成され、最後の隠れ状態を投影した後のモデルの image_hidden_states です。

#### get_image_features[[transformers.Mistral3Model.get_image_features]]

```python
get_image_features(pixel_values: FloatTensor, image_sizes: Tensor, vision_feature_layer: int | list[int] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

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

**パラメータ:**

pixel_values (`torch.FloatTensor`、形状 `(batch_size, num_channels, image_size, image_size)`) : 入力画像に対応するテンソルです。ピクセル値は [PixtralImageProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralImageProcessor) を使用して取得できます。詳細は [PixtralImageProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) を参照してください（[PixtralProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralProcessor) は画像の処理に [PixtralImageProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralImageProcessor) を使用します）。

image_sizes (`torch.Tensor`、shape `(batch_size, 2)`) : バッチ内の各画像のサイズ。各画像について (height, width) です。

vision_feature_layer (`Union[int, list[int]]`、*任意*) : 視覚特徴を選択するレイヤーのインデックスです。複数のインデックスが指定された場合、対応するインデックスの視覚特徴が連結されて視覚特徴が形成されます。

**戻り値:** [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `tuple(torch.FloatTensor)`

設定（[Mistral3Config](/docs/transformers/main/ja/model_doc/mistral3#transformers.Mistral3Config)）や入力に応じて、さまざまな要素で構成される、[BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

ビジョンタワーから画像の最終隠れ状態を取得し、マルチモーダル投影を適用します。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。
- **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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。

#### get_placeholder_mask[[transformers.Mistral3Model.get_placeholder_mask]]

```python
get_placeholder_mask(input_ids: LongTensor, inputs_embeds: FloatTensor, image_features: FloatTensor)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L245)

`input_ids`または`inputs_embeds`からマルチモーダルのプレースホルダーマスクを取得し、プレースホルダートークンの数がマルチモーダル機能の長さと等しいことを確認します。長さが異なる場合、エラーが発生します。

## Mistral3ForConditionalGeneration[[transformers.Mistral3ForConditionalGeneration]]

#### transformers.Mistral3ForConditionalGeneration[[transformers.Mistral3ForConditionalGeneration]]

```python
transformers.Mistral3ForConditionalGeneration(config: Mistral3Config)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L336)

**パラメータ:**

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

ビジョンバックボーンと言語モデルで構成されるMISTRAL3モデル。

このモデルは [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.Mistral3ForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.FloatTensor] = 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, logits_to_keep: typing.Union[int, torch.Tensor] = 0, image_sizes: typing.Optional[torch.Tensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L366)

**パラメータ:**

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)

pixel_values (`torch.FloatTensor`、形状 `(batch_size, num_channels, image_size, image_size)`、*任意*) : 入力画像に対応するテンソルです。ピクセル値は [PixtralImageProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralImageProcessor) を使用して取得できます。詳細については [PixtralImageProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) を参照してください（[PixtralProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralProcessor) は画像の処理に [PixtralImageProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralImageProcessor) を使用します）。

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`を参照）。

logits_to_keep (`Union[int, torch.Tensor]`、*任意*、デフォルトは `0`) : `int` の場合、最後の `logits_to_keep` トークンについて logits を計算します。`0` の場合、すべての `input_ids` について logits を計算します（特殊ケース）。生成には最後のトークンの logits だけで十分であり、そのトークンのみについて計算することでメモリを節約できます。これは、長いシーケンスや大規模な語彙サイズの場合に特に顕著な効果があります。`torch.Tensor` の場合、シーケンス長次元で保持するインデックスに対応する 1 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。

image_sizes (`torch.Tensor`、shape `(batch_size, 2)`、*optional*) : バッチ内の各画像のサイズ（高さ、幅）。

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *任意*) : キーがサポートされているモダリティ、値がそのモダリティのエンコード済み出力である辞書。各エンコード済み出力は、(`pooler_output`、*任意*: `last_hidden_states`、*任意*: `hidden_states`、*任意*: `attentions`) という形式のタプルで、`pooler_output` の形状は `(batch_size, sequence_length, hidden_size)`、*任意*) であり、エンコーダーのマルチモーダル特徴量をテキスト埋め込みにマージしたシーケンスです。

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

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

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

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

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失(次のトークンの予測用)。
- **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **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` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。
- **image_hidden_states** (`torch.FloatTensor`、*任意*) -- サイズが`(batch_size, num_images, sequence_length, hidden_size)`の`torch.FloatTensor`。ビジョンエンコーダーによって生成され、最後の隠れ状態を投影した後のモデルの image_hidden_states です。

例:

```python
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, Mistral3ForConditionalGeneration

>>> model = Mistral3ForConditionalGeneration.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> processor = AutoProcessor.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")

>>> prompt = "<s>[INST][IMG]What is the image?[/INST]"
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(images=image, text=prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_new_tokens=15)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is the image?The image depicts two cats lying on a pink blanket."
```

#### get_image_features[[transformers.Mistral3ForConditionalGeneration.get_image_features]]

```python
get_image_features(pixel_values: FloatTensor, image_sizes: Tensor, vision_feature_layer: int | list[int] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral3/modeling_mistral3.py#L349)

**パラメータ:**

pixel_values (`torch.FloatTensor`、形状 `(batch_size, num_channels, image_size, image_size)`) : 入力画像に対応するテンソルです。ピクセル値は [PixtralImageProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralImageProcessor) を使用して取得できます。詳細は [PixtralImageProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) を参照してください（[PixtralProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralProcessor) は画像の処理に [PixtralImageProcessor](/docs/transformers/main/ja/model_doc/pixtral#transformers.PixtralImageProcessor) を使用します）。

image_sizes (`torch.Tensor`、shape `(batch_size, 2)`) : バッチ内の各画像のサイズ。各画像について (height, width) です。

vision_feature_layer (`Union[int, list[int]]`、*任意*) : 視覚特徴を選択するレイヤーのインデックスです。複数のインデックスが指定された場合、対応するインデックスの視覚特徴が連結されて視覚特徴が形成されます。

**戻り値:** [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `tuple(torch.FloatTensor)`

設定（[Mistral3Config](/docs/transformers/main/ja/model_doc/mistral3#transformers.Mistral3Config)）や入力に応じて、さまざまな要素で構成される、[BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

- **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。
- **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 PIL import Image
>>> from transformers import AutoProcessor, Mistral3ForConditionalGeneration

>>> model = Mistral3ForConditionalGeneration.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> processor = AutoProcessor.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```