# GPT-NeoX ## 概要 [GPT-NeoX-20B](https://huggingface.co/papers/2204.06745) は、Pile 上で学習された 200 億パラメータの自己回帰型言語モデルであり、その重みは寛容なライセンスの下で一般に自由かつ公開的に提供されます。提出時点において、これは我々の知る限り、公開されている重みを備えた最大の密な自己回帰型モデルです。本稿では、GPT-NeoX-20B のアーキテクチャと学習手法を説明し、言語理解、数学、知識ベースのタスクにおける性能を評価します。その結果、GPT-NeoX-20B は特に強力な few-shot 推論者であることが示され、5-shot 評価では同規模の GPT-3 や FairSeq モデルよりも大幅に性能が向上しました。学習および評価コード、ならびにモデルの重みは、[https://github.com/EleutherAI/gpt-neox](https://github.com/EleutherAI/gpt-neox) でオープンソースとして公開しています。 モデルの開発はSid Black、Stella Biderman、Eric Hallahanが主導し、[CoreWeave](https://www.coreweave.com/)の多大な支援のもとでモデルが学習されました。 GPT-NeoX-20B は fp16 で学習されているため、モデルは次のように初期化することをお勧めします: ```python model = GPTNeoXForCausalLM.from_pretrained("EleutherAI/gpt-neox-20b", device_map="auto") ``` GPT-NeoX-20B は、GPT-J-6B や GPT-Neo で使用されているものとは異なるトークナイザーを備えています。新しいトークナイザーは空白文字に追加のトークンを割り当てるため、コード生成などの特定のタスクに対してモデルがより適したものになります。 ## 使用例 `generate()` メソッドは、GPT Neo モデルを使用してテキストを生成するために使用できます。 ```python from transformers import GPTNeoXForCausalLM, GPTNeoXTokenizerFast model = GPTNeoXForCausalLM.from_pretrained("EleutherAI/gpt-neox-20b", device_map="auto") tokenizer = GPTNeoXTokenizerFast.from_pretrained("EleutherAI/gpt-neox-20b") prompt = "GPTNeoX20B is a 20B-parameter autoregressive Transformer model developed by EleutherAI." input_ids = tokenizer(prompt, return_tensors="pt").to(model.device).input_ids gen_tokens = model.generate( input_ids, do_sample=True, temperature=0.9, max_length=100, ) gen_text = tokenizer.batch_decode(gen_tokens)[0] ``` ## Flash Attention 2 の使用 Flash Attention 2 は、モデルのより高速で最適化されたバージョンです。 ### インストール まず、お使いのハードウェアが Flash Attention 2 と互換性があるかどうかを確認してください。互換性のあるハードウェアの最新リストは、[公式ドキュメント](https://github.com/Dao-AILab/flash-attention#installation-and-features)で確認できます。 次に、Flash Attention 2 の最新バージョンを[インストール](https://github.com/Dao-AILab/flash-attention#installation-and-features)します: ```bash pip install -U flash-attn --no-build-isolation ``` ### 使用方法 Flash Attention 2 を使用してモデルを読み込むには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) に引数 `attn_implementation="flash_attention_2"` を渡すことができます。また、音声品質への劣化はほぼないものの、メモリ使用量が大幅に低減され、推論が高速になるため、モデルは半精度（例: `torch.float16`）で読み込みます。 ```python from transformers import GPTNeoXForCausalLM model = GPTNeoXForCausalLM.from_pretrained("EleutherAI/gpt-neox-20b", attn_implementation="flash_attention_2", device_map="auto") ... ``` ### 期待される高速化 以下は、`stockmark/gpt-neox-japanese-1.4b` チェックポイントを使用する transformers のネイティブ実装と、シーケンス長 2048 でモデルの Flash Attention 2 バージョンを比較した、期待される高速化の図です。 ## Scaled Dot Product Attention (SDPA) の使用 PyTorchには、`torch.nn.functional`の一部として、ネイティブなスケーリングドットプロダクトアテンション（SDPA）オペレーターが含まれています。この関数は、入力や使用しているハードウェアに応じて適用できる複数の実装を備えています。詳細については、[公式ドキュメント](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html)または[GPU推論](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one#pytorch-scaled-dot-product-attention)ページを参照してください。 `torch>=2.1.1` の場合、実装が利用可能な場合はデフォルトで SDPA が使用されますが、`from_pretrained()` で `attn_implementation="sdpa"` を設定することで、SDPA の使用を明示的に指定することもできます。 ```python from transformers import GPTNeoXForCausalLM model = GPTNeoXForCausalLM.from_pretrained("EleutherAI/gpt-neox-20b", attn_implementation="sdpa", device_map="auto") ... ``` 最大限の高速化を実現するには、モデルを半精度（例: `torch.float16` または `torch.bfloat16`）で読み込むことをお勧めします。 ローカル環境でのベンチマーク（rtx3080ti-16GB、PyTorch 2.2.1、OS Ubuntu 22.04）において、`float16` を使用して [pythia-410m-deduped](https://huggingface.co/EleutherAI/pythia-410m-deduped) を実行したところ、学習および推論で以下の高速化を確認しました。 ### トレーニング | バッチサイズ | シーケンス長 | バッチあたりの時間 (Eager - 秒) | バッチあたりの時間 (SDPA - s) | 高速化率 (%) | Eager ピークメモリ (MB) | SDPA ピークメモリ (MB) | メモリ削減率(%) | |-----------:|-----------:|---------------------------:|-----------------------------:|------------:|--------------------:|-------------------:|------------------:| | 1 | 128 | 0.024 | 0.019 | 28.945 | 1789.95 | 1789.95 | 0 | | 1 | 256 | 0.039 | 0.031 | 23.18 | 1845.83 | 1844.84 | 0.053 | | 1 | 512 | 0.08 | 0.055 | 45.524 | 2278.38 | 1953.76 | 16.615 | | 1 | 1024 | 0.19 | 0.102 | 86.777 | 4772.36 | 2408.35 | 98.159 | | 1 | 2048 | 0.565 | 0.204 | 177.098 | 13484.1 | 3882.01 | 247.348 | | 2 | 128 | 0.037 | 0.032 | 15.121 | 1843.86 | 1844.78 | -0.05 | | 2 | 256 | 0.067 | 0.055 | 21.706 | 1999.72 | 1951.67 | 2.462 | | 2 | 512 | 0.144 | 0.096 | 50.046 | 3613.16 | 2406.77 | 50.125 | | 2 | 1024 | 0.366 | 0.193 | 89.666 | 8707.55 | 3878.86 | 124.487 | | 2 | 2048 | OOM | 0.379 | / | OOM | 6825.13 | SDPAはOOMになりません | | 4 | 128 | 0.06 | 0.054 | 11.539 | 1947.6 | 1952.06 | -0.228 | | 4 | 256 | 0.119 | 0.093 | 28.072 | 3008.39 | 2405.99 | 25.038 | | 4 | 512 | 0.275 | 0.187 | 47.145 | 6290.58 | 3877.29 | 62.242 | | 4 | 1024 | OOM | 0.36 | / | OOM | 6821.98 | SDPAはOOMになりません | | 4 | 2048 | OOM | 0.731 | / | OOM | 12705.1 | SDPAはOOMになりません | ### 推論 | バッチサイズ | シーケンス長 | トークンごとのレイテンシー Eager (ms) | トークンごとのレイテンシー SDPA (ms) | 高速化率 (%) | Mem Eager (MB) | Mem SDPA (MB) | メモリ削減率 (%) | |--------------:|-------------:|--------------------------------:|-------------------------------:|---------------:|------------------:|----------------:|-----------------:| | 1 | 128 | 6.569 | 5.858 | 12.14 | 974.831 | 974.826 | 0 | | 1 | 256 | 7.009 | 5.863 | 19.542 | 1029.01 | 1028.08 | 0.09 | | 1 | 512 | 7.157 | 5.965 | 19.983 | 1137.54 | 1137.52 | 0.001 | | 1 | 1024 | 7.523 | 6.506 | 15.637 | 1329.3 | 1329.26 | 0.003 | | 1 | 2048 | 9.271 | 9.205 | 0.713 | 1752.47 | 1734.51 | 1.036 | | 2 | 128 | 7.239 | 5.959 | 21.493 | 1044.8 | 1028.37 | 1.597 | | 2 | 256 | 7.228 | 6.036 | 19.757 | 1167.32 | 1137.73 | 2.601 | | 2 | 512 | 7.538 | 6.693 | 12.628 | 1352.93 | 1329.55 | 1.758 | | 2 | 1024 | 8.916 | 8.632 | 3.291 | 1752.56 | 1734.62 | 1.034 | | 2 | 2048 | 12.628 | 12.606 | 0.181 | 2558.72 | 2545.8 | 0.508 | | 4 | 128 | 7.278 | 6.046 | 20.373 | 1168.41 | 1137.79 | 2.691 | | 4 | 256 | 7.614 | 6.588 | 15.574 | 1353.1 | 1329.79 | 1.753 | | 4 | 512 | 8.798 | 8.144 | 8.028 | 1752.76 | 1734.85 | 1.032 | | 4 | 1024 | 11.765 | 11.303 | 4.09 | 2558.96 | 2546.04 | 0.508 | | 4 | 2048 | 19.568 | 17.735 | 10.33 | 4175.5 | 4165.26 | 0.246 | ## リソース - [因果言語モデリングタスクのガイド](../tasks/language_modeling) ## GPTNeoXConfig[[transformers.GPTNeoXConfig]] #### transformers.GPTNeoXConfig[[transformers.GPTNeoXConfig]] ```python transformers.GPTNeoXConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 50432, hidden_size: int = 6144, num_hidden_layers: int = 44, num_attention_heads: int = 64, intermediate_size: int = 24576, hidden_act: str = 'gelu', attention_dropout: float | int = 0.0, hidden_dropout: float | int = 0.0, classifier_dropout: float | int = 0.1, max_position_embeddings: int = 2048, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, use_cache: bool = True, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, pad_token_id: int | None = None, tie_word_embeddings: bool = False, use_parallel_residual: bool = True, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = True, is_decoder: bool = False) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/configuration_gpt_neox.py#L25) **パラメータ:** vocab_size (`int`、*任意*、デフォルトは`50432`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。 hidden_size (`int`、*任意*、デフォルトは`6144`) : 隠れ表現の次元数。 num_hidden_layers (`int`、*任意*、デフォルトは`44`) : Transformerデコーダーの隠れ層の数。 num_attention_heads (`int`、*任意*、デフォルトは`64`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。 intermediate_size (`int`、*任意*、デフォルトは`24576`) : MLP 表現の次元数。 hidden_act (`str`、*任意*、デフォルトは`gelu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"`など。 attention_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率。 hidden_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : embeddings、encoder、pooler 内のすべての全結合層における dropout 確率。 classifier_dropout (`Union[float, int]`、*任意*、デフォルトは`0.1`) : クラシファイヤのドロップアウト率。 max_position_embeddings (`int`、*任意*、デフォルトは`2048`)：このモデルが使用される可能性のある最大シーケンス長です。 initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。 layer_norm_eps (`float`、*任意*、デフォルトは`1e-05`) : Layer Normalization 層で使用する epsilon。 use_cache (`bool`、*任意*、デフォルトは `True`) : モデルが最後のキー/バリューアテンションを返すかどうか（すべてのモデルで利用されるわけではありません）。`config.is_decoder=True` の場合、またはモデルがデコーダー専用の生成モデルである場合にのみ関連します。 bos_token_id (`int`, *optional*, デフォルトは `0`) : 語彙内でストリームの開始に使用されるトークン ID。 eos_token_id (`Union[int, list[int]]`、*任意*、デフォルトは`2`) : 語彙内でストリーム終了に使用されるトークン ID。 pad_token_id (`int`, *任意*) : 語彙内でパディングに使用されるトークンID。 tie_word_embeddings (`bool`, *任意*, デフォルトは `False`) : モデルの `tied_weights_keys` マッピングに従って重み埋め込みを共有するかどうか。 use_parallel_residual (`bool`、*任意*、デフォルトは`True`) : 各 Transformer レイヤーで「並列」な定式化を使用するかどうか。大規模（例：20B）では、わずかなトレーニング速度の向上が期待できます。 rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : RoPE 埋め込みの設定パラメータを含む辞書です。この辞書には `rope_theta` の値が含まれていなければならず、より長い `max_position_embeddings` で RoPE を使用する場合、スケーリングに使用されるパラメータが任意で含まれます。 attention_bias (`bool`, *任意*, デフォルトは `True`) : セルフアテンションにおいて、クエリ、キー、バリュー、出力の投影層にバイアスを使用するかどうか。 is_decoder (`bool`, *任意*, デフォルトは `False`) : モデルがデコーダーとして使用されるかどうかを指定します。`False` の場合、モデルはエンコーダーとして使用されます。 これはGPTNeoXModelの設定を保存するための設定クラスです。指定された引数に基づいてGpt Neoxモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[EleutherAI/gpt-neox-20b](https://huggingface.co/EleutherAI/gpt-neox-20b)と類似した設定が得られます。 設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 例: ```python >>> from transformers import GPTNeoXConfig, GPTNeoXModel >>> # Initializing a GPTNeoX gpt-neox-20b style configuration >>> configuration = GPTNeoXConfig() >>> # Initializing a model (with random weights) from the gpt-neox-20b style configuration >>> model = GPTNeoXModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## GPTNeoXTokenizer[[transformers.GPTNeoXTokenizer]] #### transformers.GPTNeoXTokenizer[[transformers.GPTNeoXTokenizer]] ```python transformers.GPTNeoXTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, errors: str = 'replace', unk_token: str = '<|endoftext|>', bos_token: str = '<|endoftext|>', eos_token: str = '<|endoftext|>', pad_token: str = '<|padding|>', add_prefix_space: bool = False, trim_offsets: bool = True, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/tokenization_gpt_neox.py#L28) **パラメータ:** vocab_file (`str`, *任意*) : 語彙ファイルへのパス。 merges_file (`str`, *任意*) : マージファイルへのパス。 tokenizer_file (`str`, *任意*) : トークナイザーのシリアライズを含む、トークナイザーの JSON ファイルへのパス。 errors (`str`、*任意*、デフォルトは`"replace"`) : バイトを UTF-8 にデコードする際に従うパラダイム。詳細は[bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode)を参照してください。 unk_token (`str`、*任意*、デフォルトは `"<|endoftext|>"`) : 不明トークンです。語彙に存在しないトークンは ID に変換できず、代わりにこのトークンが設定されます。 bos_token (`str`、*任意*、デフォルトは `"<|endoftext|>"`) : シーケンスの開始トークン。 eos_token (`str`、*任意*、デフォルトは `"<|endoftext|>"`) : シーケンスの終了トークンです。 pad_token (`str`、*任意*、デフォルトは `"<|padding|>"`) : シーケンスをパディングするためのトークン。 add_prefix_space (`bool`、*任意*、デフォルトは`False`) : 入力に先頭スペースを追加するかどうか。これにより、先頭の単語を他の単語と同様に扱うことができます。(GPTNeoX トークナイザーは、先行するスペースによって単語の先頭を検出します)。 add_bos_token (`bool`、*任意*、デフォルトは`False`) : シーケンスの先頭に`bos_token`を追加するかどうか。 add_eos_token (`bool`、*任意*、デフォルトは`False`) : シーケンスの末尾に`eos_token`を追加するかどうか。 trim_offsets (`bool`, *任意*, デフォルトは `True`) : 後処理ステップでオフセットをトリムし、空白文字が含まれないようにするかどうかを指定します。 vocab (`str` または `dict[str, int]`、*省略可*) : カスタムの語彙辞書です。指定しない場合、`vocab_file` から語彙が読み込まれます。 merges (`str` または `list[str]`、*省略可能*) : カスタムなマージリストです。指定しない場合、`merges_file` からマージが読み込まれます。 GPT-NeoX-20Bのトークナイザーを構築します(HuggingFaceのtokenizersライブラリをバックエンドとして使用)。バイトレベルのByte-Pair-Encodingに基づいています。 このトークナイザーは、スペースをトークンの一部として扱うように学習されています（sentencepieceに少し似ています）。そのため、単語は 文の先頭（スペースなし）にある場合と、そうでない場合とで、エンコードの仕方が異なります。 ```python >>> from transformers import GPTNeoXTokenizer >>> tokenizer = GPTNeoXTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> tokenizer("Hello world")["input_ids"] [15496, 995] >>> tokenizer(" Hello world")["input_ids"] [18435, 995] ``` この動作を回避するには、このトークナイザーをインスタンス化する際に`add_prefix_space=True`を渡すことができますが、モデルはこの方式で事前学習されていないため、パフォーマンスが低下する可能性があります。 `is_split_into_words=True` と併用する場合、このトークナイザーは `add_prefix_space=True` を指定してインスタンス化する必要があります。 このトークナイザーは、[TokenizersBackend](/docs/transformers/main/ja/main_classes/tokenizer#transformers.TokenizersBackend) を継承しており、主要なメソッドの大部分がそこに含まれています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。 ## GPTNeoXModel[[transformers.GPTNeoXModel]] #### transformers.GPTNeoXModel[[transformers.GPTNeoXModel]] ```python transformers.GPTNeoXModel(config: GPTNeoXConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L294) **パラメータ:** config ([GPTNeoXConfig](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 Gpt Neox Modelは、特定のヘッドを上に配置せずに生のhidden-statesを出力する、素のモデルです。 このモデルは [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.GPTNeoXModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, use_cache: bool | None = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L309) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids) attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、**マスクされる**トークンは 0。 [アテンションマスクとは?](../glossary#attention-mask) position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_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)`）のみを入力する必要があります。 use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。 **戻り値:** [BaseModelOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) または `tuple(torch.FloatTensor)` [GPTNeoXConfig](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXConfig) や入力に応じて、さまざまな要素で構成される [BaseModelOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 [GPTNeoXModel](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXModel)の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)を参照してください。 自己アテンションブロック（および `config.is_encoder_decoder=True` の場合、クロスカレンションブロック）の事前計算済みヒドゥンステート（キーとバリュー）を保持します。これらは逐次デコーディングを高速化するために使用できます（`past_key_values` 入力参照）。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 ## GPTNeoXForCausalLM[[transformers.GPTNeoXForCausalLM]] #### transformers.GPTNeoXForCausalLM[[transformers.GPTNeoXForCausalLM]] ```python transformers.GPTNeoXForCausalLM(config: GPTNeoXConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L376) **パラメータ:** config ([GPTNeoXConfig](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 CLMファインチューニング用に、`language modeling`ヘッドを上部に備えたGPTNeoXモデル。 このモデルは [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.GPTNeoXForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L396) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids) attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、**マスクされる**トークンは 0。 [アテンションマスクとは?](../glossary#attention-mask) position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_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)`）のみを入力する必要があります。 labels (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 左から右への言語モデリング損失（次の単語の予測）を計算するためのラベル。インデックスは `[-100, 0, ..., config.vocab_size]` の範囲である必要があります（`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 次元である必要があります。これは、パックされたテンソル形式（バッチとシーケンス長を単一の次元にまとめる形式）を使用する場合に有用です。 **戻り値:** [CausalLMOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) または `tuple(torch.FloatTensor)` [GPTNeoXConfig](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXConfig) や入力に応じて、さまざまな要素で構成される [CausalLMOutputWithPast](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 [GPTNeoXForCausalLM](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXForCausalLM) の 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` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 例: ```python >>> from transformers import AutoTokenizer, GPTNeoXForCausalLM, GPTNeoXConfig >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> config = GPTNeoXConfig.from_pretrained("EleutherAI/gpt-neox-20b") >>> config.is_decoder = True >>> model = GPTNeoXForCausalLM.from_pretrained("EleutherAI/gpt-neox-20b", config=config) >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") >>> outputs = model(**inputs) >>> prediction_logits = outputs.logits ``` ## GPTNeoXForQuestionAnswering[[transformers.GPTNeoXForQuestionAnswering]] #### transformers.GPTNeoXForQuestionAnswering[[transformers.GPTNeoXForQuestionAnswering]] ```python transformers.GPTNeoXForQuestionAnswering(config: GPTNeoXConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L601) **パラメータ:** config ([GPTNeoXConfig](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 SQuADのような抽出型質問応答タスク向けに、Gpt Neox transformerの上部にスパン分類ヘッドを備えたモデル（隠れ状態の出力の上に線形層を置き、`span start logits`と`span end logits`を計算する）。 このモデルは [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.GPTNeoXForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L611) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids) attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、**マスクされる**トークンは 0。 [アテンションマスクとは?](../glossary#attention-mask) 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) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 start_positions (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : トークン分類損失の計算に使用する、ラベル付きスパンの開始位置（インデックス）のラベル。位置はシーケンスの長さ（`sequence_length`）にクランプされます。シーケンス外の位置は、損失の計算には考慮されません。 end_positions (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : トークン分類損失の計算に使用する、ラベル付きスパンの終了位置（インデックス）のラベル。位置はシーケンスの長さ（`sequence_length`）にクランプされます。シーケンス外の位置は、損失の計算には考慮されません。 **戻り値:** [QuestionAnsweringModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) または `tuple(torch.FloatTensor)` [GPTNeoXConfig](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXConfig) や入力に応じて、さまざまな要素で構成される [QuestionAnsweringModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 [GPTNeoXForQuestionAnswering](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXForQuestionAnswering) の forward メソッドは、`__call__` という特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 総スパン抽出損失は、開始位置と終了位置の Cross-Entropy の和です。 - **start_logits** (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`) -- SoftMax 適用前のスパン開始スコア。 - **end_logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length)`) -- スパンの終了スコア（SoftMax 適用前）。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 例: ```python >>> from transformers import AutoTokenizer, GPTNeoXForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> model = GPTNeoXForQuestionAnswering.from_pretrained("EleutherAI/gpt-neox-20b") >>> 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) ... ``` ## GPTNeoXForSequenceClassification[[transformers.GPTNeoXForSequenceClassification]] #### transformers.GPTNeoXForSequenceClassification[[transformers.GPTNeoXForSequenceClassification]] ```python transformers.GPTNeoXForSequenceClassification(config: GPTNeoXConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L474) **パラメータ:** config ([GPTNeoXConfig](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 シーケンス分類ヘッド(線形層)を上部に備えたGPTNeoXモデルのtransformerです。 [GPTNeoXForSequenceClassification](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXForSequenceClassification) は、他の因果モデル（GPT-1 など）と同様に、最後のトークンを使用して分類を行います。 最後のトークンに対して分類を行うため、最後のトークンの位置を知る必要があります。`pad_token_id`が設定に定義されている場合、各行でパディングトークンではない最後のトークンを探します。`pad_token_id`が定義されていない場合、バッチの各行の最後の値をそのまま採用します。`inputs_embeds`が`input_ids`の代わりに渡された場合、パディングトークンを推測できないため、同様にバッチの各行の最後の値を採用します。 このモデルは [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.GPTNeoXForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L484) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids) attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、**マスクされる**トークンは 0。 [アテンションマスクとは?](../glossary#attention-mask) position_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックスです。`[0, config.n_positions - 1]` の範囲から選択されます。 [位置 ID とは何か？](../glossary#position-ids) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_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)`）のみを入力する必要があります。 labels (`torch.LongTensor`、形状 `(batch_size,)`、*任意*) : シーケンス分類/回帰の損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。`config.num_labels == 1` の場合は回帰損失（平均二乗誤差）が計算され、`config.num_labels > 1` の場合は分類損失（クロスエントロピー）が計算されます。 use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。 **戻り値:** `SequenceClassifierOutputWithPast` または `tuple(torch.FloatTensor)` `SequenceClassifierOutputWithPast`、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[GPTNeoXConfig](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXConfig)）や入力に応じて、さまざまな要素で構成されます。 [GPTNeoXForSequenceClassification](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXForSequenceClassification)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 分類（または config.num_labels==1 の場合は回帰）の損失。 - **logits** (`torch.FloatTensor`、shape `(batch_size, config.num_labels)`) -- SoftMax 適用前の分類（または config.num_labels==1 の場合は回帰）スコア。 - **past_key_values** (`Cache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの隠れ状態（自己注意ブロックのキーとバリュー）が含まれます。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 単一ラベル分類の例: ```python >>> import torch >>> from transformers import AutoTokenizer, GPTNeoXForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> model = GPTNeoXForSequenceClassification.from_pretrained("EleutherAI/gpt-neox-20b") >>> 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 = GPTNeoXForSequenceClassification.from_pretrained("EleutherAI/gpt-neox-20b", 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, GPTNeoXForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> model = GPTNeoXForSequenceClassification.from_pretrained("EleutherAI/gpt-neox-20b", 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 = GPTNeoXForSequenceClassification.from_pretrained( ... "EleutherAI/gpt-neox-20b", 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 ``` ## GPTNeoXForTokenClassification[[transformers.GPTNeoXForTokenClassification]] #### transformers.GPTNeoXForTokenClassification[[transformers.GPTNeoXForTokenClassification]] ```python transformers.GPTNeoXForTokenClassification(config: GPTNeoXConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L541) #### forward[[transformers.GPTNeoXForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.FloatTensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt_neox/modeling_gpt_neox.py#L553) **パラメータ:** 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) 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)`）のみを入力する必要があります。 attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、**マスクされる**トークンは 0。 [アテンションマスクとは?](../glossary#attention-mask) 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) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : シーケンス分類/回帰の損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。`config.num_labels == 1` の場合は回帰損失（Mean-Square loss）が計算され、`config.num_labels > 1` の場合は分類損失（Cross-Entropy）が計算されます。 use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。 **戻り値:** [TokenClassifierOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) または `tuple(torch.FloatTensor)` 設定([GPTNeoXConfig](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXConfig))や入力に応じて、さまざまな要素で構成される [TokenClassifierOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput)、または `torch.FloatTensor` のタプル(`return_dict=False` が渡された場合、または `config.return_dict=False` の場合)。 [GPTNeoXForTokenClassification](/docs/transformers/main/ja/model_doc/gpt_neox#transformers.GPTNeoXForTokenClassification) の forward メソッドは、`__call__` という特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 分類損失。 - **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.num_labels)`) -- SoftMax 適用前の分類スコア。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 例: ```python >>> from transformers import AutoTokenizer, GPTNeoXForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neox-20b") >>> model = GPTNeoXForTokenClassification.from_pretrained("EleutherAI/gpt-neox-20b") >>> 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) ... ```