# FlauBERT

## 概要

FlauBERTモデルは、Hang Le らによる論文 [FlauBERT: Unsupervised Language Model Pre-training for French](https://huggingface.co/papers/1912.05372) で提案されました。これは、マスク言語モデリング（MLM）の目的関数（BERTと同様）を用いて事前学習された Transformer モデルです。

論文の抄録は以下の通りです。

*言語モデルは、多様な自然言語処理（NLP）タスクにおいて最先端の結果を達成するための重要なステップとなっています。現在利用可能な膨大な量のラベルなしテキストを活用することで、文レベルでの文脈化を伴いながら、下流タスクへのファインチューニングが可能な連続的な単語表現を事前学習する効率的な方法を提供します。これは、文脈化された表現を用いた英語での研究（Dai and Le, 2015; Peters et al., 2018; Howard and Ruder, 2018; Radford et al., 2018; Devlin et al., 2019; Yang et al., 2019b）によって広く実証されています。本論文では、非常に大規模かつ異質なフランス語コーパス上で学習されたモデル FlauBERT を紹介し、共有します。異なるサイズのモデルは、フランス国立科学研究センター（CNRS）の Jean Zay スーパーコンピュータを用いて学習されています。我々は、これらのフランス語言語モデルを多様な NLP タスク（テキスト分類、パラフレーズ、自然言語推論、パース、単語の曖昧性除去）に適用し、多くの場合、他の事前学習アプローチを上回ることを示しました。FlauBERT の異なるバージョンと、下流タスクのための統合評価プロトコルである FLUE（French Language Understanding Evaluation）は、フランス語 NLP におけるさらなる再現可能な実験のために研究コミュニティに共有されています。*

このモデルは [formiel](https://huggingface.co/formiel) によって提供されました。元のコードは [こちら](https://github.com/getalp/Flaubert) で確認できます。

ヒント:

- RoBERTaと同様に、文の順序予測を行わず（MLM目的のみで学習）します。

## リソース

- [テキスト分類タスクガイド](../tasks/sequence_classification)
- [トークン分類タスクガイド](../tasks/token_classification)
- [質問応答タスクガイド](../tasks/question_answering)
- [マスクド言語モデリングタスクのガイド](../tasks/masked_language_modeling)
- [多肢選択タスクガイド](../tasks/multiple_choice)

## FlaubertConfig[[transformers.FlaubertConfig]]

#### transformers.FlaubertConfig[[transformers.FlaubertConfig]]

```python
transformers.FlaubertConfig(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, pre_norm: bool = False, layerdrop: float | int = 0.0, vocab_size: int = 30145, emb_dim: int = 2048, n_layers: int = 12, n_heads: int = 16, dropout: float | int = 0.1, attention_dropout: float | int = 0.1, gelu_activation: bool = True, sinusoidal_embeddings: bool = False, causal: bool = False, asm: bool = False, n_langs: int = 1, use_lang_emb: bool = True, max_position_embeddings: int = 512, embed_init_std: float = 0.02209708691207961, layer_norm_eps: float = 1e-12, init_std: float = 0.02, bos_index: int = 0, eos_index: int = 1, pad_index: int = 2, unk_index: int = 3, mask_index: int = 5, is_encoder: bool = True, summary_type: str = 'first', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, start_n_top: int = 5, end_n_top: int = 5, mask_token_id: int = 0, lang_id: int = 0, pad_token_id: int | None = 2, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, tie_word_embeddings: bool = True)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/configuration_flaubert.py#L24)

**パラメータ:**

pre_norm (`bool`, *任意*, デフォルトは `False`) : 各レイヤーの attention に続く feed forward レイヤーの前または後に layer normalization を適用するかどうかを指定します (Vaswani et al., Tensor2Tensor for Neural Machine Translation. 2018)

layerdrop (`Union[float, int]`、*任意*、デフォルトは `0.0`) : LayerDrop の確率です。詳細については、[LayerDrop の論文](see https://huggingface.co/papers/1909.11556)を参照してください。

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

emb_dim (`int`、*任意*、デフォルトは 2048) : 埋め込み層の次元数。

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

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

dropout (`Union[float, int]`、*任意*、デフォルトは`0.1`) : すべての dropout 層の比率。

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

gelu_activation (`bool`、*任意*、デフォルトは True) : GeLU 活性化関数を使用するかどうか。

sinusoidal_embeddings (`bool`, *任意*, デフォルトは `False`) : 絶対位置埋め込みの代わりに、正弦波位置埋め込みを使用するかどうか。

causal (`bool`、*任意*、デフォルトは`False`) : モデルが因果的な挙動をするかどうかを指定します。因果モデルでは、双方向コンテキストではなく左側のコンテキストのみを注意するように、三角形の注意マスクを使用します。

asm (`bool`、*任意*、デフォルトは`False`) : 予測層に線形層の代わりに適応型 log softmax 投影層を使用するかどうか。

n_langs (`int`、*optional*、デフォルトは 1) : モデルが処理する言語の数です。単一言語のモデルの場合は 1 に設定します。

use_lang_emb (`bool`、*任意*、デフォルトは `True`) : 言語埋め込みを使用するかどうか。一部のモデルでは追加の言語埋め込みを使用します。その使用方法については、[多言語モデルのページ](http://huggingface.co/transformers/multilingual.html#xlm-language-embeddings)を参照してください。

embed_init_std (`float`、*optional*、デフォルトは 2048^-0.5) : 埋め込み行列の初期化に使用される truncated_normal_initializer の標準偏差です。

max_position_embeddings (`int`、*任意*、デフォルトは`512`) : このモデルが使用される可能性のある最大シーケンス長。

embed_init_std (`float`、*任意*、デフォルトは `2048**-0.5`) : 埋め込み層の初期化標準偏差。

layer_norm_eps (`float`、*任意*、デフォルトは `1e-12`) : layer normalization レイヤーで使用する epsilon。

init_std (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。

bos_index (`int`、*任意*、デフォルトは 0) : 語彙における文の開始トークンのインデックス。

eos_index (`int`, *optional*, デフォルトは 1) : 語彙における文の終了トークンのインデックス。

pad_index (`int`, *optional*, デフォルトは 2) : 語彙におけるパディングトークンのインデックス。

unk_index (`int`、*任意*、デフォルトは 3) : 語彙における不明トークンのインデックス。

mask_index (`int`、*任意*、デフォルトは 5) : 語彙におけるマスキングトークンのインデックス。

is_encoder (`bool`、*任意*、デフォルトは True) : モデルがエンコーダーとして使用されるかどうか。

summary_type (`string`、*任意*、デフォルトは "first") : シーケンスサマリーを行う際に使用される引数です。シーケンス分類モデルおよび複数選択モデルで使用されます。以下のオプションのいずれかである必要があります: - `"last"`: 最後のトークンの隠れ状態を取得します (XLNet のように)。 - `"first"`: 最初のトークンの隠れ状態を取得します (BERT のように)。 - `"mean"`: 全トークンの隠れ状態の平均を取得します。 - `"cls_index"`: 分類トークンの位置を示す Tensor を指定します (GPT/GPT-2 のように)。 - `"attn"`: 現在未実装です。マルチヘッドアテンションを使用します。

summary_use_proj (`bool`、*任意*、デフォルトは`True`) : シーケンスサマリーを行う際に使用される引数です。シーケンス分類モデルおよび複数選択モデルで使用されます。ベクトル抽出後に射影を追加するかどうかを指定します。

summary_activation (`str`, *任意*) : シーケンスサマリーを行う際に使用する引数です。シーケンス分類モデルおよび複数選択モデルで使用されます。出力にtanh活性化を適用するには`"tanh"`を指定してください。それ以外の値を指定すると、活性化は適用されません。

summary_proj_to_labels (`bool`、*任意*、デフォルトは `True`) : シーケンス分類モデルおよび複数選択モデルで使用されます。投影の出力が `config.num_labels` クラスか `config.hidden_size` クラスを持つかを指定します。

summary_first_dropout (`float`、*optional*、デフォルトは 0.1) : シーケンス分類モデルおよび複数選択モデルで使用されます。投影と活性化の後に適用する dropout の比率です。

start_n_top (`int`、*任意*、デフォルト値は 5)：SQuAD 評価スクリプトで使用されます。

end_n_top (`int`、*任意*、デフォルト値は 5)：SQuAD 評価スクリプトで使用されます。

mask_token_id (`int`、*任意*、デフォルト値は 0) : MLM コンテキストでテキストを生成する際に、マスクされたトークンを識別するためのモデル非依存パラメータです。

lang_id (`int`、*optional*、デフォルト値は 1) : モデルが使用する言語の ID です。このパラメータは、特定の言語でテキストを生成する際に使用されます。

pad_token_id (`int`、*任意*、デフォルトは `2`) : 語彙内でパディングに使用されるトークン ID。

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

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

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

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

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

## FlaubertTokenizer[[transformers.FlaubertTokenizer]]

#### transformers.FlaubertTokenizer[[transformers.FlaubertTokenizer]]

```python
transformers.FlaubertTokenizer(vocab_file, merges_file, do_lowercase = False, unk_token = '<unk>', bos_token = '<s>', sep_token = '</s>', pad_token = '<pad>', cls_token = '</s>', mask_token = '<special1>', additional_special_tokens = ['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>'], lang2id = None, id2lang = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/tokenization_flaubert.py#L121)

**パラメータ:**

vocab_file (`str`) : 語彙ファイル。

merges_file (`str`) : ファイルをマージします。

do_lowercase (`bool`、*任意*、デフォルトは `False`) : 小文字化を制御します。

unk_token (`str`、*任意*、デフォルトは `"<unk>"`) : 不明トークン。語彙に存在しないトークンは ID に変換できず、代わりにこのトークンが設定されます。

bos_token (`str`、*任意*、デフォルトは `"<s>"`) : 事前学習で使用されたシーケンスの開始トークンです。シーケンス分類器のトークンとして使用できます。    特殊トークンを使用してシーケンスを構築する場合は、シーケンスの開始にこのトークンは使用されません。使用されるのは `cls_token` です。

sep_token (`str`、*任意*、デフォルトは `"</s>"`) : 区切りトークンです。複数のシーケンスからシーケンスを構築する際に使用されます。例えば、シーケンス分類では2つのシーケンス、質問応答ではテキストと質問です。また、特殊トークンを用いて構築されたシーケンスの最後のトークンとしても使用されます。

pad_token (`str`、*任意*、デフォルトは `"<pad>"`) : パディングに使用されるトークンです。長さの異なるシーケンスをバッチ処理する場合などに使用します。

cls_token (`str`、*任意*、デフォルトは `"</s>"`) : シーケンス分類（トークンごとの分類ではなく、シーケンス全体の分類）を行う際に使用される分類トークンです。特殊トークンを用いて構築された場合、シーケンスの最初のトークンになります。

mask_token (`str`、*任意*、デフォルトは `"<special1>"`) : 値をマスクするために使用されるトークン。これは、マスク言語モデリングでこのモデルを訓練する際に使用されるトークンです。モデルが予測しようとするトークンです。

additional_special_tokens (`List[str]`、*任意*、デフォルトは `['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>']`) : 追加の特殊トークンのリスト。

lang2id (`Dict[str, int]`、*任意*) : 言語の文字列識別子とその ID を対応づけた辞書。

id2lang (`Dict[int, str]`, *任意*) : 言語 ID をその文字列識別子にマッピングする辞書。

Flaubertのトークナイザーを構築します。Byte-Pair Encodingに基づいています。トークナイズ処理は以下の通りです。

- Mosesによる前処理とトークン化。
- すべての入力テキストを正規化します。
- 引数`special_tokens`と関数`set_special_tokens`は、語彙に追加のシンボル（__classify__など）を追加するために使用できます。
- 引数 `do_lowercase` は、小文字化を制御します（事前学習済み語彙では自動的に設定されます）。

このトークナイザーは、[PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しており、主要なメソッドのほとんどが含まれています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。

#### build_inputs_with_special_tokens[[transformers.FlaubertTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/tokenization_flaubert.py#L430)

**パラメータ:**

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

token_ids_1 (`List[int]`, *任意*) : シーケンスペア用の任意の2番目のIDリスト。

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

適切な特殊トークンを含む[入力 ID](../glossary#input-ids)のリスト。

シーケンス分類タスクにおいて、シーケンスまたはシーケンスのペアからモデルの入力を構築するために、特殊トークンを追加して連結します。XLMのシーケンスは、次の形式を持ちます:

- 単一シーケンス: `<s> X </s>`
- シーケンスのペア: `<s> A </s> B </s>`

#### convert_tokens_to_string[[transformers.FlaubertTokenizer.convert_tokens_to_string]]

```python
convert_tokens_to_string(tokens)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/tokenization_flaubert.py#L424)

単一の文字列内のトークン（文字列）のシーケンスに変換します。

#### get_special_tokens_mask[[transformers.FlaubertTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/tokenization_flaubert.py#L458)

**パラメータ:**

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

token_ids_1 (`List[int]`, *任意*) : シーケンスペア用の任意の2番目のIDリスト。

already_has_special_tokens (`bool`、*任意*、デフォルトは`False`) : トークンリストが、モデル用の特殊トークンを含む形式で既に整形されているかどうかを示します。

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

範囲 [0, 1] の整数のリスト: 特殊トークンは 1、シーケンストークンは 0。

特殊トークンが追加されていないトークンリストからシーケンスIDを取得します。このメソッドは、トークナイザーの`prepare_for_model`メソッドを使用して特殊トークンを追加する際に呼び出されます。

## FlaubertModel[[transformers.FlaubertModel]]

#### transformers.FlaubertModel[[transformers.FlaubertModel]]

```python
transformers.FlaubertModel(config: FlaubertConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L690)

**パラメータ:**

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

特定のヘッドを付加せず、生の隠れ状態を出力する、素のFlaubertモデル。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.FlaubertModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, lengths: typing.Optional[torch.LongTensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L763)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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)

langs (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 入力内の各トークンの言語を示すために使用される、トークンの並列シーケンスです。インデックスは言語 ID であり、モデルの設定で提供される 2 つの変換マッピング（多言語モデルでのみ提供されます）を使用して、言語名から取得できます。具体的には、*言語名から言語 ID への変換*は `model.config.lang2id`（文字列から int への辞書）に、*言語 ID から言語名への変換*は `model.config.id2lang`（int から文字列への辞書）にあります。使用例の詳細は、[多言語ドキュメント](../multilingual)を参照してください。

token_type_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

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

lengths (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : パディングトークンインデックスでのアテンション計算を回避するために使用できる、各文の長さ。同じ結果を得るには `attention_mask` を使用することもできます（上記を参照）。互換性のために残されています。 `[0, ..., input_ids.size(-1)]` から選択されたインデックス:

cache (`dict[str, torch.Tensor]`, *任意*) : モデルによって計算された事前計算済みヒドゥンステート（アテンションブロック内のキーとバリュー）を`torch.Tensor`として含む、文字列をキーとする辞書です（`cache`出力を参照）。シーケンシャルデコーディングの高速化に使用できます。この辞書オブジェクトは、フォワードパス中に新たに計算されたヒドゥンステートを追加するためにインプレースで変更されます。

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

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [BaseModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutput) または `tuple(torch.Tensor)`

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

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

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

- **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。
- **hidden_states** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

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

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

## FlaubertWithLMHeadModel[[transformers.FlaubertWithLMHeadModel]]

#### transformers.FlaubertWithLMHeadModel[[transformers.FlaubertWithLMHeadModel]]

```python
transformers.FlaubertWithLMHeadModel(config: FlaubertConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L940)

**パラメータ:**

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

入力埋め込みの重みと結合された線形層を上部に備えた言語モデリングヘッド付きの Flaubert Model transformer。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.FlaubertWithLMHeadModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L972)

**パラメータ:**

input_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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)

langs (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 入力内の各トークンの言語を示すために使用される、トークンの並列シーケンスです。インデックスは言語 ID であり、モデルの設定で提供される 2 つの変換マッピング（多言語モデルでのみ提供されます）を使用して、言語名から取得できます。具体的には、*言語名から言語 ID への変換*は `model.config.lang2id`（文字列から int への辞書）に、*言語 ID から言語名への変換*は `model.config.id2lang`（int から文字列への辞書）にあります。使用例の詳細は、[多言語ドキュメント](../multilingual)を参照してください。

token_type_ids (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

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

lengths (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : パディングトークンインデックスでのアテンション計算を回避するために使用できる、各文の長さ。同じ結果を得るには `attention_mask` を使用することもできます（上記を参照）。互換性のために残されています。 `[0, ..., input_ids.size(-1)]` から選択されたインデックス:

cache (`dict[str, torch.Tensor]`, *任意*) : モデルによって計算された事前計算済みヒドゥンステート（アテンションブロック内のキーとバリュー）を`torch.Tensor`として含む、文字列をキーとする辞書です（`cache`出力を参照）。シーケンシャルデコーディングの高速化に使用できます。この辞書オブジェクトは、フォワードパス中に新たに計算されたヒドゥンステートを追加するためにインプレースで変更されます。

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

labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 言語モデリング用のラベル。モデル内部でラベルは**シフト**されるため、`labels = input_ids` と設定できます。インデックスは `[-100, 0, ..., config.vocab_size]` から選択されます。`-100` に設定されたすべてのラベルは無視（マスク）され、損失は `[0, ..., config.vocab_size]` 内のラベルに対してのみ計算されます。

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [MaskedLMOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) または `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- マスクド言語モデリング (MLM) の損失。
- **logits** (`torch.Tensor`、形状 `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **hidden_states** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

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

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

例:

```python
>>> import torch
>>> from transformers import AutoTokenizer, FlaubertWithLMHeadModel

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertWithLMHeadModel.from_pretrained("flaubert/flaubert_base_uncased")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## FlaubertForSequenceClassification[[transformers.FlaubertForSequenceClassification]]

#### transformers.FlaubertForSequenceClassification[[transformers.FlaubertForSequenceClassification]]

```python
transformers.FlaubertForSequenceClassification(config: FlaubertConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L1049)

**パラメータ:**

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

Flaubert モデルの上部にシーケンス分類/回帰ヘッド（プーリングされた出力の上部に線形層）を備えたモデル。GLUE タスクなどに使用できます。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.FlaubertForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L1061)

**パラメータ:**

input_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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)

langs (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 入力内の各トークンの言語を示すために使用される、トークンの並列シーケンスです。インデックスは言語 ID であり、モデルの設定で提供される 2 つの変換マッピング（多言語モデルでのみ提供されます）を使用して、言語名から取得できます。具体的には、*言語名から言語 ID への変換*は `model.config.lang2id`（文字列から int への辞書）に、*言語 ID から言語名への変換*は `model.config.id2lang`（int から文字列への辞書）にあります。使用例の詳細は、[多言語ドキュメント](../multilingual)を参照してください。

token_type_ids (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

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

lengths (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : パディングトークンインデックスでのアテンション計算を回避するために使用できる、各文の長さ。同じ結果を得るには *attention_mask* を使用することもできます（上記を参照）。互換性のために残されています。選択されるインデックスは `[0, ..., input_ids.size(-1)]` です。

cache (`dict[str, torch.Tensor]`, *任意*) : 事前計算済みのKV状態を含む`EncoderDecoderCache`のインスタンスです。逐次デコーディングの高速化に使用できます。

inputs_embeds (`torch.Tensor`、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` の場合は分類損失（クロスエントロピー）が計算されます。

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) または `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 分類損失（config.num_labels==1 の場合は回帰損失）。
- **logits** (`torch.Tensor`、形状 `(batch_size, config.num_labels)`) -- SoftMax 適用前の分類（または config.num_labels==1 の場合は回帰）スコア。
- **hidden_states** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

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

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

単一ラベル分類の例:

```python
>>> import torch
>>> from transformers import AutoTokenizer, FlaubertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

マルチラベル分類の例:

```python
>>> import torch
>>> from transformers import AutoTokenizer, FlaubertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForSequenceClassification.from_pretrained("flaubert/flaubert_base_uncased", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = FlaubertForSequenceClassification.from_pretrained(
...     "flaubert/flaubert_base_uncased", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## FlaubertForMultipleChoice[[transformers.FlaubertForMultipleChoice]]

#### transformers.FlaubertForMultipleChoice[[transformers.FlaubertForMultipleChoice]]

```python
transformers.FlaubertForMultipleChoice(config: FlaubertConfig, *inputs, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L1496)

**パラメータ:**

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

RocStories/SWAGタスクなど、プーリングされた出力の上に線形層とsoftmaxを配置した多肢選択分類ヘッドを備えたFlaubertモデル。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.FlaubertForMultipleChoice.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L1507)

**パラメータ:**

input_ids (`torch.LongTensor`、shape `(batch_size, num_choices, sequence_length)`) : 語彙における入力シーケンスのトークンインデックス。[AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用してインデックスを取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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)

langs (`torch.LongTensor`、shape `(batch_size, num_choices, sequence_length)`、*任意*) : 入力内の各トークンの言語を示すために使用される、トークンの並列シーケンスです。インデックスは言語 ID で、モデルの構成で提供される 2 つの変換マッピングを使用して、言語名から取得できます（多言語モデルでのみ提供されます）。より正確には、*言語名から言語 ID への変換*は `model.config.lang2id`（文字列から整数への辞書）に、*言語 ID から言語名への変換*は `model.config.id2lang`（整数から文字列への辞書）にあります。使用例の詳細は、[多言語ドキュメント](../multilingual)を参照してください。

token_type_ids (`torch.LongTensor`、shape `(batch_size, num_choices, sequence_length)`、*任意*) : 入力の第1部分と第2部分を区別するためのセグメントトークンインデックス。インデックスは`[0, 1]`から選択されます:  - 0 は*文A*のトークンに対応します。 - 1 は*文B*のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

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

lengths (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : パディングトークンインデックスでのアテンション計算を回避するために使用できる、各文の長さ。同じ結果を得るには *attention_mask* を使用することもできます（上記を参照）。互換性のために残されています。選択されるインデックスは `[0, ..., input_ids.size(-1)]` です。

cache (`dict[str, torch.Tensor]`, *任意*) : 事前計算済みのKV状態を含む`EncoderDecoderCache`のインスタンスです。逐次デコーディングの高速化に使用できます。

inputs_embeds (`torch.Tensor`、shape `(batch_size, num_choices, sequence_length, hidden_size)`、*optional*) : `input_ids`を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、`input_ids`のインデックスを関連するベクトルに変換する方法をより細かく制御したい場合に便利です。

labels (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : 多肢選択分類の損失を計算するためのラベル。インデックスは `[0, ..., num_choices-1]` の範囲である必要があります。ここで `num_choices` は入力テンソルの2次元目のサイズです（上記の `input_ids` を参照）。

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [MultipleChoiceModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) または `tuple(torch.Tensor)`

[MultipleChoiceModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput)または`torch.Tensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）で、[FlaubertConfig](/docs/transformers/v5.23.0/ja/model_doc/flaubert#transformers.FlaubertConfig)および入力に応じて、さまざまな要素で構成されます。

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

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

- **loss** (`torch.Tensor`、形状 *(1,)*、*オプション*、`labels` が指定された場合に返されます) -- 分類損失。
- **logits** (`torch.Tensor`、形状 `(batch_size, num_choices)`) -- *num_choices* は入力テンソルの2番目の次元です（*input_ids* を参照）。

  分類スコア（SoftMax 適用前）。
- **hidden_states** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

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

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

例:

```python
>>> from transformers import AutoTokenizer, FlaubertForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForMultipleChoice.from_pretrained("flaubert/flaubert_base_uncased")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## FlaubertForTokenClassification[[transformers.FlaubertForTokenClassification]]

#### transformers.FlaubertForTokenClassification[[transformers.FlaubertForTokenClassification]]

```python
transformers.FlaubertForTokenClassification(config: FlaubertConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L1151)

**パラメータ:**

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

トークン分類ヘッド（隠れ状態の出力上に配置された線形層）を備えたFlaubert transformer。例えば、固有表現抽出（NER）タスクに使用されます。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.FlaubertForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L1163)

**パラメータ:**

input_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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)

langs (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 入力内の各トークンの言語を示すために使用される、トークンの並列シーケンスです。インデックスは言語 ID であり、モデルの設定で提供される 2 つの変換マッピング（多言語モデルでのみ提供されます）を使用して、言語名から取得できます。具体的には、*言語名から言語 ID への変換*は `model.config.lang2id`（文字列から int への辞書）に、*言語 ID から言語名への変換*は `model.config.id2lang`（int から文字列への辞書）にあります。使用例の詳細は、[多言語ドキュメント](../multilingual)を参照してください。

token_type_ids (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

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

lengths (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : パディングトークンインデックスでのアテンション計算を回避するために使用できる、各文の長さ。同じ結果を得るには *attention_mask* を使用することもできます（上記を参照）。互換性のために残されています。選択されるインデックスは `[0, ..., input_ids.size(-1)]` です。

cache (`dict[str, torch.Tensor]`, *任意*) : 事前計算済みのKV状態を含む`EncoderDecoderCache`のインスタンスです。逐次デコーディングの高速化に使用できます。

inputs_embeds (`torch.Tensor`、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]` の範囲である必要があります。

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [TokenClassifierOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) または `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- 分類損失。
- **logits** (`torch.Tensor`、形状 `(batch_size, sequence_length, config.num_labels)`) -- SoftMax 適用前の分類スコア。
- **hidden_states** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

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

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

例:

```python
>>> from transformers import AutoTokenizer, FlaubertForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForTokenClassification.from_pretrained("flaubert/flaubert_base_uncased")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

## FlaubertForQuestionAnsweringSimple[[transformers.FlaubertForQuestionAnsweringSimple]]

#### transformers.FlaubertForQuestionAnsweringSimple[[transformers.FlaubertForQuestionAnsweringSimple]]

```python
transformers.FlaubertForQuestionAnsweringSimple(config: FlaubertConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L1242)

**パラメータ:**

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

SQuAD などの抽出型質問応答タスク向けに、`span start logits` と `span end logits` を計算するために、隠れ状態の出力上に線形層を配置したスパン分類ヘッドを備えた Flaubert モデル。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.FlaubertForQuestionAnsweringSimple.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L1252)

**パラメータ:**

input_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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)

langs (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 入力内の各トークンの言語を示すために使用される、トークンの並列シーケンスです。インデックスは言語 ID であり、モデルの設定で提供される 2 つの変換マッピング（多言語モデルでのみ提供されます）を使用して、言語名から取得できます。具体的には、*言語名から言語 ID への変換*は `model.config.lang2id`（文字列から int への辞書）に、*言語 ID から言語名への変換*は `model.config.id2lang`（int から文字列への辞書）にあります。使用例の詳細は、[多言語ドキュメント](../multilingual)を参照してください。

token_type_ids (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

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

lengths (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : パディングトークンインデックスでのアテンション計算を回避するために使用できる、各文の長さ。同じ結果を得るには *attention_mask* を使用することもできます（上記を参照）。互換性のために残されています。選択されるインデックスは `[0, ..., input_ids.size(-1)]` です。

cache (`dict[str, torch.Tensor]`, *任意*) : 事前計算済みのKV状態を含む`EncoderDecoderCache`のインスタンスです。逐次デコーディングの高速化に使用できます。

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

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

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

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [QuestionAnsweringModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) または `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が指定された場合に返されます) -- 総スパン抽出損失は、開始位置と終了位置の Cross-Entropy の和です。
- **start_logits** (`torch.Tensor`、形状 `(batch_size, sequence_length)`) -- スパン開始スコア（SoftMax 適用前）。
- **end_logits** (`torch.Tensor`、形状 `(batch_size, sequence_length)`) -- スパンの終了スコア（SoftMax 適用前）。
- **hidden_states** (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

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

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

例:

```python
>>> from transformers import AutoTokenizer, FlaubertForQuestionAnsweringSimple
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("flaubert/flaubert_base_uncased")
>>> model = FlaubertForQuestionAnsweringSimple.from_pretrained("flaubert/flaubert_base_uncased")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```

## FlaubertForQuestionAnswering[[transformers.FlaubertForQuestionAnswering]]

#### transformers.FlaubertForQuestionAnswering[[transformers.FlaubertForQuestionAnswering]]

```python
transformers.FlaubertForQuestionAnswering(config: FlaubertConfig)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L1377)

**パラメータ:**

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

SQuAD などの抽出型質問応答タスク用に、span 分類ヘッドを上部に備えた Flaubert transformer（hidden-states の出力上に線形層を配置し、`span start logits` と `span end logits` を計算する）。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/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.FlaubertForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, is_impossible: typing.Optional[torch.Tensor] = None, cls_index: typing.Optional[torch.Tensor] = None, p_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/flaubert/modeling_flaubert.py#L1387)

**パラメータ:**

input_ids (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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)

langs (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 入力内の各トークンの言語を示すために使用される、トークンの並列シーケンスです。インデックスは言語 ID であり、モデルの設定で提供される 2 つの変換マッピング（多言語モデルでのみ提供されます）を使用して、言語名から取得できます。具体的には、*言語名から言語 ID への変換*は `model.config.lang2id`（文字列から int への辞書）に、*言語 ID から言語名への変換*は `model.config.id2lang`（int から文字列への辞書）にあります。使用例の詳細は、[多言語ドキュメント](../multilingual)を参照してください。

token_type_ids (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 入力の前半と後半を示すセグメントトークンインデックス。インデックスは `[0, 1]` から選択されます:  - 0 は *文 A* のトークンに対応します。 - 1 は *文 B* のトークンに対応します。  [トークンタイプIDとは何ですか？](../glossary#token-type-ids)

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

lengths (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : パディングトークンインデックスでのアテンション計算を回避するために使用できる、各文の長さ。同じ結果を得るには *attention_mask* を使用することもできます（上記を参照）。互換性のために残されています。選択されるインデックスは `[0, ..., input_ids.size(-1)]` です。

cache (`dict[str, torch.Tensor]`, *任意*) : 事前計算済みのKV状態を含む`EncoderDecoderCache`のインスタンスです。逐次デコーディングの高速化に使用できます。

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

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

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

is_impossible (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : 質問に回答があるかどうかのラベル（SQuAD 2.0）

cls_index (`torch.LongTensor`、形状 `(batch_size,)`、*任意*) : 回答の妥当性を計算する入力として使用する、分類トークンの位置（インデックス）のラベル。

p_mask (`torch.Tensor`、形状 `(batch_size, sequence_length)`、*任意*) : 回答に含まれないトークンのマスク（例: [CLS]、[PAD] など）。1.0 はトークンをマスクすることを示し、0.0 はマスクしないことを示します。

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/v5.23.0/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** `FlaubertForQuestionAnsweringOutput` または `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`、shape `(1,)`、*optional*、`start_positions` と `end_positions` が両方指定された場合に返されます) -- 開始トークン、終了トークン（指定された場合は is_impossible）の分類損失の合計として計算される分類損失。
- **start_top_log_probs** (`torch.Tensor`、形状 `(batch_size, config.start_n_top)`、*任意*、`start_positions` または `end_positions` が指定されていない場合に返されます) -- 開始トークンの上位 config.start_n_top 件の候補の対数確率(ビームサーチ)。
- **start_top_index** (`torch.LongTensor`、shape `(batch_size, config.start_n_top)`、*任意*、`start_positions` または `end_positions` が指定されていない場合に返されます) -- 上位 config.start_n_top 個の開始トークンの候補のインデックス（ビームサーチ）。
- **end_top_log_probs** (`torch.Tensor`、shape `(batch_size, config.start_n_top * config.end_n_top)`、*optional*、`start_positions` または `end_positions` が指定されていない場合に返されます) -- 上位 `config.start_n_top * config.end_n_top` の終了トークンの可能性の対数確率(ビームサーチ)。
- **end_top_index**（`torch.LongTensor`、shape `(batch_size, config.start_n_top * config.end_n_top)`、*optional*、`start_positions` または `end_positions` が指定されていない場合に返されます）-- 上位 `config.start_n_top * config.end_n_top` の終了トークンの候補のインデックス（ビームサーチ）。
- **cls_logits** (`torch.Tensor`、形状 `(batch_size,)`、*任意*、`start_positions` または `end_positions` が指定されていない場合に返されます) -- 回答の `is_impossible` ラベルに対する対数確率。
- **hidden_states** (`tuple[torch.Tensor]`、*optional*、`output_hidden_states=True` が渡された場合、または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

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

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

例:

```python
>>> from transformers import AutoTokenizer, FlaubertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = FlaubertForQuestionAnswering.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
...     0
... )  # Batch size 1
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])

>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)
>>> loss = outputs.loss
```

