# Perceiver ## 概要 Perceiver IOモデルは、Andrew Jaegle、Sebastian Borgeaud、Jean-Baptiste Alayrac、Carl Doersch、Catalin Ionescu、David Ding、Skanda Koppula、Daniel Zoran、Andrew Brock、Evan Shelhamer、Olivier Hénaff、Matthew M. Botvinick、Andrew Zisserman、Oriol Vinyals、João Carreira によって、[Perceiver IO: A General Architecture for Structured Inputs & Outputs](https://huggingface.co/papers/2107.14795) で提案されました。 Perceiver IOは、任意の入力に加えて任意の出力も処理できるように[Perceiver](https://huggingface.co/papers/2103.03206)を一般化したものです。元のPerceiverは単一の分類ラベルのみを生成していましたが、Perceiver IOは分類ラベルに加えて、言語、光流、音声付きマルチモーダル動画などを生成できます。これは、元のPerceiverと同じ構成要素を使用して実現されています。Perceiver IOの計算複雑度は入力と出力のサイズに対して線形であり、処理の大部分が潜在空間で行われるため、標準的なTransformersでは処理できないほど大きな入力と出力を処理できます。例えば、Perceiver IOはトークン化された入力ではなく、バイトを直接使用してBERTスタイルのマスク言語モデリングを実行できます。 論文の抄録は以下の通りです。 *最近提案された Perceiver モデルは、計算量とメモリ使用量が入力サイズに対して線形にスケールしながら、画像、音声、マルチモーダル、点群など複数のドメインで優れた結果を達成しています。Perceiver は多様な入力に対応できますが、出力としてはクラススコアのような非常に単純なものしか生成できません。Perceiver IO は、モデルの潜在空間を柔軟にクエリして学習することで、任意のサイズや意味を持つ出力を生成し、この制約を克服します。これにより、元のモデルの魅力ある特性を損なうことなく、モデルの深さとデータサイズを分離したまま、データサイズに対して線形にスケールする特性を維持します。ただし、現在は入力サイズと出力サイズの両方に対して線形にスケールします。完全な Perceiver IO モデルは、自然言語や視覚理解、StarCraft II、マルチタスクおよびマルチモーダルドメインなど、出力空間が高度に構造化されたタスクで強力な結果を達成しています。特に注目すべき点として、Perceiver IO は入力トークン化を必要とせずに GLUE 言語ベンチマークで Transformer ベースの BERT ベースラインに匹敵する性能を示し、Sintel 光流推定では最先端の性能を達成しています。* Perceiverの動作を説明するTLDR（要点）は以下の通りです： Transformerの自己注意機構の主な問題は、計算時間とメモリ要件がシーケンス長の2乗に比例して増加することです。そのため、BERTやRoBERTaのようなモデルは、最大シーケンス長が512トークンに制限されています。Perceiverは、入力に対して自己注意を実行する代わりに、潜在変数のセットに対して自己注意を実行し、入力はクロスアテンションでのみ使用することで、この問題を解決しようとしています。これにより、256や512のような固定数の潜在変数を使用するため、計算時間とメモリ要件はもはや入力の長さに依存しなくなります。これらの潜在変数はランダムに初期化され、その後、バックプロパゲーションを用いてエンドツーエンドで学習されます。 内部では、[PerceiverModel](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverModel) が、`(batch_size, num_latents, d_latents)` という形状のテンソルである latents を作成します。モデルには、テキスト、画像、音声など、任意の `inputs` を提供する必要があります。モデルはこれを用いて、latents とのクロスアテンションを実行します。Perceiver エンコーダーの出力は、同じ形状のテンソルです。その後、BERT と同様に、latents の最後の隠れ状態をシーケンス次元に沿って平均化し、その上に線形層を配置して `d_latents` を `num_labels` に射影することで、分類ロジットに変換できます。 これが、元のPerceiver論文のアイデアでした。ただし、出力できるのは分類のロジットのみでした。後続の研究であるPerceiverIOでは、これを一般化し、モデルが任意のサイズの出力を生成できるようにしました。どのように実現したのか、と疑問に思うかもしれません。そのアイデアは比較的シンプルです。任意のサイズの出力を定義し、その出力をクエリとして、ラテンツの最後の隠れ状態をキーとバリューとして用いてクロスアテンションを適用します。 Perceiverでマスク言語モデリング（BERTスタイル）を実行したい場合を例に考えてみましょう。Perceiverでは、入力の長さが自己注意レイヤーの計算時間に影響しないため、モデルに長さ2048の`inputs`として生バイトを渡すことができます。次に、この2048トークンのうち特定のトークンをマスクすると、`outputs`の形状を`(batch_size, 2048, 768)`として定義できます。その後、ラテンツの最終的な隠れ状態を用いてクロスアテンションを実行し、`outputs`テンソルを更新します。クロスアテンション後も、テンソルの形状は`(batch_size, 2048, 768)`のままです。次に、通常の言語モデリングヘッドを上に配置し、最終次元をモデルの語彙サイズに射影します。これにより、形状`(batch_size, 2048, 262)`のロジットが作成されます（Perceiverは262のバイトIDからなる語彙サイズを使用しているため）。 drawing Perceiver IOアーキテクチャ。元の論文より引用 このモデルは [nielsr](https://huggingface.co/nielsr) によって提供されました。元のコードは [こちら](https://github.com/deepmind/deepmind-research/tree/master/perceiver) で確認できます。 PyTorch のバグにより、Perceiver は `torch.nn.DataParallel` と **併用できません**。詳細は [issue #36035](https://github.com/pytorch/pytorch/issues/36035) を参照してください。 ## リソース - Perceiverの最も簡単な始め方は、[tutorial notebooks](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/Perceiver)を確認することです。 - モデルの動作を完全に理解したい場合は、[ブログ記事](https://huggingface.co/blog/perceiver)を参照してください。 はライブラリに実装されています。なお、ライブラリで利用可能なモデルは、Perceiverで実現できることのいくつかの例を示しているにすぎません。質問応答、名詞句認識、物体検出、音声分類、動画分類など、さらに多くのユースケースがあります。 - [テキスト分類タスクガイド](../tasks/sequence_classification) - [マスクド言語モデリングタスクのガイド](../tasks/masked_language_modeling) - [画像分類タスクガイド](../tasks/image_classification) ## Perceiver固有の出力[[transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput]] #### transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput(logits: typing.Optional[torch.FloatTensor] = None, last_hidden_state: typing.Optional[torch.FloatTensor] = None, hidden_states: tuple[torch.FloatTensor] | None = None, attentions: tuple[torch.FloatTensor] | None = None, cross_attentions: tuple[torch.FloatTensor] | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L53) **パラメータ:** logits (`torch.FloatTensor`、shape `(batch_size, num_labels)`) : SoftMax 適用前の分類スコア（config.num_labels==1 の場合は回帰）。 last_hidden_state (`torch.FloatTensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : モデルの最終層の出力における隠れ状態のシーケンス。 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)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。 attentions (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（各レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンション softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。 cross_attentions (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 適用後のデコーダーのクロスアテンションレイヤーのアテンション重みです。 Perceiverベースモデルの出力の基底クラス。潜在的な隠れ状態、アテンション、クロスアテンションを含む可能性があります。 #### transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverDecoderOutput(logits: typing.Optional[torch.FloatTensor] = None, cross_attentions: tuple[torch.FloatTensor] | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L72) **パラメータ:** logits (`torch.FloatTensor`、shape `(batch_size, num_labels)`) : 基本デコーダーの出力。 cross_attentions (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 適用後のデコーダーのクロスアテンションレイヤーのアテンション重みです。 クロスアテンションを含む可能性のある Perceiver デコーダーの出力の基底クラス。 #### transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput(loss: typing.Optional[torch.FloatTensor] = None, logits: typing.Optional[torch.FloatTensor] = None, hidden_states: tuple[torch.FloatTensor] | None = None, attentions: tuple[torch.FloatTensor] | None = None, cross_attentions: tuple[torch.FloatTensor] | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L88) **パラメータ:** loss (`torch.FloatTensor`、shape `(1,)`、*任意*、`labels` が指定された場合に返されます) : マスクド言語モデリング (MLM) の損失。 logits (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.vocab_size)`) : 言語モデリングヘッドの予測スコア（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)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。 attentions (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（各レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンション softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。 cross_attentions (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 適用後のデコーダーのクロスアテンションレイヤーのアテンション重みです。 Perceiverのマスク言語モデルの出力の基底クラス。 #### transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput[[transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput(loss: typing.Optional[torch.FloatTensor] = None, logits: typing.Optional[torch.FloatTensor] = None, hidden_states: tuple[torch.FloatTensor] | None = None, attentions: tuple[torch.FloatTensor] | None = None, cross_attentions: tuple[torch.FloatTensor] | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L110) **パラメータ:** loss (`torch.FloatTensor`、shape `(1,)`、*任意*、`labels` が指定された場合に返されます) : 分類（または config.num_labels==1 の場合は回帰）の損失。 logits (`torch.FloatTensor`、shape `(batch_size, config.num_labels)`) : SoftMax 適用前の分類スコア（config.num_labels==1 の場合は回帰スコア）。 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)` です。各層の出力におけるモデルの隠れ状態と、任意の初期埋め込み出力です。 attentions (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（各レイヤーごとに 1 つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンション softmax 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。 cross_attentions (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 適用後のデコーダーのクロスアテンションレイヤーのアテンション重みです。 シーケンス/画像分類モデル、光流、マルチモーダルオートエンコーディングのPerceiverの出力の基底クラス。 ## PerceiverConfig[[transformers.PerceiverConfig]] #### transformers.PerceiverConfig[[transformers.PerceiverConfig]] ```python transformers.PerceiverConfig(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, num_latents: int = 256, d_latents: int = 1280, d_model: int = 768, num_blocks: int = 1, num_self_attends_per_block: int = 26, num_self_attention_heads: int = 8, num_cross_attention_heads: int = 8, qk_channels: int | None = None, v_channels: int | None = None, cross_attention_shape_for_attention: str = 'kv', self_attention_widening_factor: int = 1, cross_attention_widening_factor: int = 1, hidden_act: str = 'gelu', attention_probs_dropout_prob: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, use_query_residual: bool = True, vocab_size: int = 262, max_position_embeddings: int = 2048, image_size: int | list[int] | tuple[int, int] = 56, train_size: list[int] | tuple[int, ...] = (368, 496), num_frames: int = 16, audio_samples_per_frame: int = 1920, samples_per_patch: int = 16, output_shape: list[int] | tuple[int, ...] = (1, 16, 224, 224), output_num_channels: int = 512, _label_trainable_num_channels: int = 1024) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/configuration_perceiver.py#L24) **パラメータ:** num_latents (`int`、*任意*、デフォルトは 256) : 潜在変数の数。 d_latents (`int`、*optional*、デフォルトは 1280) : 潜在埋め込みの次元数。 d_model (`int`、*任意*、デフォルトは`768`) : エンコーダ層とプーラー層のサイズ。 num_blocks (`int`、*任意*、デフォルトは 1) : Transformer エンコーダーのブロック数。 num_self_attends_per_block (`int`, *optional*, デフォルトは 26) : ブロックあたりの自己注意層の数。 num_self_attention_heads (`int`, *optional*, デフォルトは 8) : Transformer エンコーダーの各自己注意層におけるアテンションヘッドの数。 num_cross_attention_heads (`int`, *optional*, デフォルトは 8) : Transformer エンコーダーの各クロスアテンション層におけるアテンションヘッドの数。 qk_channels (`int`, *optional*) : エンコーダーのクロスアテンション層および自己アテンション層で、アテンションを適用する前にクエリとキーを射影する次元。指定されない場合、クエリの次元を維持したままデフォルトになります。 v_channels (`int`, *optional*) : エンコーダーのクロスアテンション層および自己アテンション層で、アテンションを適用する前に値を射影する次元。指定されない場合、クエリの次元を維持したままデフォルトになります。 cross_attention_shape_for_attention (`str`、*任意*、デフォルトは`"kv"`) : エンコーダーのクロスアテンション層でクエリとキーをダウンサンプリングする際に使用する次元。 self_attention_widening_factor (`int`、*optional*、デフォルトは 1) : Transformer エンコーダーのクロスアテンション層におけるフィードフォワード層の次元数。 cross_attention_widening_factor (`int`、*optional*、デフォルトは 1) : Transformer エンコーダーの自己注意層におけるフィードフォワード層の次元数。 hidden_act (`str`、*任意*、デフォルトは`gelu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"`など。 attention_probs_dropout_prob (`Union[float, int]`、*任意*、デフォルトは`0.1`) : 注意確率のドロップアウト率。 initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。 layer_norm_eps (`float`、*任意*、デフォルトは `1e-12`) : layer normalization レイヤーで使用する epsilon。 use_query_residual (`float`、*optional*、デフォルトは`True`) : エンコーダーのクロスアテンション層にクエリ残差を追加するかどうか。 vocab_size (`int`、*任意*、デフォルトは`262`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。 max_position_embeddings (`int`、*任意*、デフォルトは`2048`)：このモデルが使用される可能性のある最大シーケンス長です。 image_size (`int`、*任意*、デフォルトは 56) : [PerceiverForImageClassificationLearned](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) における前処理後の画像サイズ。 train_size (`list[int]`、*optional*、デフォルトは`[368, 496]`) : 光流モデルの画像の学習サイズ。 num_frames (`int`、*optional*、デフォルトは 16) : マルチモーダルオートエンコーディングモデルで使用する動画フレーム数。 audio_samples_per_frame (`int`, *optional*, デフォルトは 1920) : マルチモーダルオートエンコーディングモデルにおけるフレームあたりの音声サンプル数。 samples_per_patch (`int`、*optional*、デフォルトは 16) : マルチモーダルオートエンコーディングモデルのオーディオを前処理する際の、パッチごとのオーディオサンプル数。 output_shape (`list[int]`、*optional*、デフォルトは`[1, 16, 224, 224]`) : マルチモーダルオートエンコーディングモデルのビデオデコーダークエリの出力の形状 (batch_size, num_frames, height, width) です。これはチャネル次元を除きます。 output_num_channels (`int`、*optional*、デフォルトは 512) : 各モダリティデコーダーの出力チャネル数。 This is the configuration class to store the configuration of a PerceiverModel. It is used to instantiate a Perceiver model according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the [deepmind/language-perceiver](https://huggingface.co/deepmind/language-perceiver) 設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 例: ```python >>> from transformers import PerceiverModel, PerceiverConfig >>> # Initializing a Perceiver deepmind/language-perceiver style configuration >>> configuration = PerceiverConfig() >>> # Initializing a model from the deepmind/language-perceiver style configuration >>> model = PerceiverModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## PerceiverTokenizer[[transformers.PerceiverTokenizer]] #### transformers.PerceiverTokenizer[[transformers.PerceiverTokenizer]] ```python transformers.PerceiverTokenizer(pad_token = '[PAD]', bos_token = '[BOS]', eos_token = '[EOS]', mask_token = '[MASK]', cls_token = '[CLS]', sep_token = '[SEP]', model_max_length = 2048, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/tokenization_perceiver.py#L23) **パラメータ:** pad_token (`str`、*任意*、デフォルトは `"[PAD]"`) : パディングに使用されるトークンです。長さの異なるシーケンスをバッチ処理する場合などに使用します。 bos_token (`str`、*任意*、デフォルトは`"[BOS]"`) : BOS トークン（語彙に予約されていますが、実際には使用されません）。 eos_token (`str`、*任意*、デフォルトは`"[EOS]"`) : シーケンスの終了トークン（語彙に予約されていますが、実際には使用されません）。特殊トークンを使用してシーケンスを構築する場合、シーケンスの終了に使用されるのはこのトークンではなく、`sep_token`です。 mask_token (`str`、*任意*、デフォルトは`"[MASK]"`) : マスクされた言語モデリングに有用なMASKトークン。 cls_token (`str`、*任意*、デフォルトは`"[CLS]"`) : CLS トークン（語彙に予約されていますが、実際には使用されていません）。 sep_token (`str`、*任意*、デフォルトは`"[SEP]"`) : 2つのシーケンスからシーケンスを構築する際に使用される区切りトークン。 Perceiver トークナイザーを構築します。Perceiver は、生のバイトの utf-8 エンコーディングをそのまま使用します。 このトークナイザーは、[PreTrainedTokenizer](/docs/transformers/main/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しており、主要なメソッドのほとんどが含まれています。これらのメソッドに関する詳細については、このスーパークラスを参照してください。 #### __call__[[transformers.PerceiverTokenizer.__call__]] ```python __call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2449) **パラメータ:** text (`str`、`list[str]`、`list[list[str]]`、*任意*) : エンコード対象のシーケンスまたはシーケンスのバッチです。各シーケンスは文字列、または文字列のリスト（プレトークナイズ済み文字列）であることができます。シーケンスが文字列のリスト（プレトークナイズ済み）として提供される場合、`is_split_into_words=True` を設定する必要があります（シーケンスのバッチとの曖昧さを解消するため）。 text_pair (`str`、`list[str]`、`list[list[str]]`、*任意*) : エンコード対象のシーケンスまたはシーケンスのバッチです。各シーケンスは文字列、または文字列のリスト（プレトークナイズ済み文字列）であることができます。シーケンスが文字列のリスト（プレトークナイズ済み）として提供される場合、`is_split_into_words=True` を設定する必要があります（シーケンスのバッチとの曖昧さを解消するため）。 text_target (`str`、`list[str]`、`list[list[str]]`、*任意*) : ターゲットテキストとしてエンコードするシーケンスまたはシーケンスのバッチです。各シーケンスは文字列または文字列のリスト（プレトークナイズされた文字列）であることができます。シーケンスが文字列のリスト（プレトークナイズ）として提供される場合、`is_split_into_words=True` を設定する必要があります（シーケンスのバッチとの曖昧さを解消するため）。 text_pair_target (`str`、`list[str]`、`list[list[str]]`、*任意*) : ターゲットテキストとしてエンコードするシーケンスまたはシーケンスのバッチです。各シーケンスは文字列または文字列のリスト（プレトークナイズされた文字列）であることができます。シーケンスが文字列のリスト（プレトークナイズ）として提供される場合、`is_split_into_words=True` を設定する必要があります（シーケンスのバッチとの曖昧さを解消するため）。 tokenizer_kwargs (`dict[str, Any]`、*省略可*) : トークナイザーに渡す追加の kwargs です。これらは明示的なパラメータやその他の kwargs とマージされますが、明示的なパラメータが優先されます。 add_special_tokens (`bool`、*任意*、デフォルトは`True`) : シーケンスをエンコードする際に特殊トークンを追加するかどうか。これは、入力 ID に自動的に追加されるトークンを定義する基盤となる`PretrainedTokenizerBase.build_inputs_with_special_tokens`関数を使用します。`bos`または`eos`トークンを自動的に追加したい場合に便利です。 padding (`bool`、`str` または [PaddingStrategy](/docs/transformers/main/ja/internal/file_utils#transformers.utils.PaddingStrategy)、*optional*、デフォルトは `False`) : パディングの有効化と制御を行います。以下の値を受け取ります: - `True` または `'longest'`: バッチ内の最長のシーケンスの長さにパディングします（単一のシーケンスのみが提供された場合は、パディングを行いません）。 - `'max_length'`: 引数 `max_length` で指定された最大長、またはその引数が提供されていない場合はモデルが受け入れ可能な最大入力長までパディングします。 - `False` または `'do_not_pad'`（デフォルト）: パディングを行いません（つまり、長さが異なるシーケンスのバッチを出力できます）。 truncation (`bool`、`str` または [TruncationStrategy](/docs/transformers/main/ja/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)、*optional*、デフォルトは `False`) : トランケーションを有効化し、制御します。以下の値を受け取ります: - `True` または `'longest_first'`: 引数 `max_length` で指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。ペアのシーケンス（またはペアのバッチ）が提供されている場合、ペアの中で最も長いシーケンスからトークン単位で1トークンずつ削除します。 - `'only_first'`: 引数 `max_length` で指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。ペアのシーケンス（またはペアのバッチ）が提供されている場合、ペアの最初のシーケンスのみを切り詰めます。 - `'only_second'`: 引数 `max_length` で指定された最大長、またはその引数が指定されていない場合はモデルが許容する最大入力長まで切り詰めます。ペアのシーケンス（またはペアのバッチ）が提供されている場合、ペアの2番目のシーケンスのみを切り詰めます。 - `False` または `'do_not_truncate'`（デフォルト）: トランケーションを行いません（つまり、モデルが許容する最大入力サイズを超えるシーケンス長を持つバッチを出力する可能性があります）。 max_length (`int`, *optional*) : 切り詰め/パディングパラメータのいずれかによって使用される最大長を制御します。 未設定のまま、または `None` に設定されている場合、切り詰め/パディングパラメータのいずれかが最大長を必要とする場合、事前に定義されたモデルの最大長が使用されます。 モデルに特定の最大入力長がない場合（XLNet など）、最大長への切り詰め/パディングは無効になります。 stride (`int`、*optional*、デフォルト値は 0) : `max_length` とともに数値が設定されている場合、`return_overflowing_tokens=True` のときに返されるオーバーフローしたトークンは、切り詰められたシーケンスの末尾の一部のトークンを含み、切り詰められたシーケンスとオーバーフローしたシーケンスの間に重複部分を持たせます。この引数の値は、重複するトークンの数を定義します。 is_split_into_words (`bool`、*任意*、デフォルトは `False`) : 入力がすでに事前トークン化済み（例：単語に分割済み）かどうかを示します。`True` に設定すると、トークナイザーは入力がすでに単語に分割済み（たとえば空白で分割済み）であると仮定し、それをトークン化します。これは NER やトークン分類に有用です。 pad_to_multiple_of (`int`, *optional*) : 設定すると、シーケンスを指定された値の倍数にパディングします。`padding` が有効になっている必要があります。これは、計算能力が `>= 7.5` (Volta) の NVIDIA ハードウェア上で Tensor Cores を使用可能にするために特に有用です。 padding_side (`str`, *任意*) : モデルにパディングを適用する側です。['right', 'left'] から選択する必要があります。デフォルト値は、同名のクラス属性から取得されます。 return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、Python の整数のリストではなくテンソルを返します。指定可能な値は以下の通りです。 - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: Numpy の `np.ndarray` オブジェクトを返します。 return_token_type_ids (`bool`、*省略可*) : トークンタイプIDを返すかどうか。デフォルトのままにすると、`return_outputs` 属性で定義される特定のトークナイザーのデフォルトに従って、トークンタイプIDを返します。 [トークンタイプIDとは?](../glossary#token-type-ids) return_attention_mask (`bool`、*省略可*) : アテンションマスクを返すかどうか。デフォルトのままにすると、`return_outputs` 属性で定義される特定のトークナイザーのデフォルトに従って、アテンションマスクを返します。 [アテンションマスクとは?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *任意*, デフォルトは `False`) : 溢れたトークンシーケンスを返すかどうかを指定します。入力 ID のシーケンスのペア（またはペアのバッチ）が `truncation_strategy = longest_first` または `True` とともに提供された場合、溢れたトークンを返す代わりにエラーが発生します。 return_special_tokens_mask (`bool`, *任意*, デフォルトは `False`) : 特殊トークンのマスク情報を返すかどうか。 return_offsets_mapping (`bool`、*任意*、デフォルトは`False`) : 各トークンについて`(char_start, char_end)`を返すかどうか。これは[PreTrainedTokenizerFast](/docs/transformers/main/ja/main_classes/tokenizer#transformers.TokenizersBackend)を継承する fast tokenizer のみで利用可能であり、Python の tokenizer を使用している場合、このメソッドは`NotImplementedError`を送出します。 return_length (`bool`、*任意*、デフォルトは`False`) : エンコードされた入力の長さを返すかどうか。 verbose (`bool`、*任意*、デフォルトは `True`) : 詳細な情報や警告を表示するかどうか。 - ****kwargs** : `self.tokenize()` メソッドに渡されます **戻り値:** [BatchEncoding](/docs/transformers/main/ja/main_classes/tokenizer#transformers.BatchEncoding) 以下のフィールドを持つ[BatchEncoding](/docs/transformers/main/ja/main_classes/tokenizer#transformers.BatchEncoding): - **input_ids** -- モデルに渡すトークンIDのリスト。 [入力IDとは何ですか？](../glossary#input-ids) - **token_type_ids** -- モデルに渡すトークンタイプIDのリスト（`return_token_type_ids=True`の場合、または`self.model_input_names`に*"token_type_ids"*が含まれる場合）。 [トークンタイプIDとは?](../glossary#token-type-ids) - **attention_mask** -- モデルがどのトークンに注意すべきかを指定するインデックスのリスト（`return_attention_mask=True` の場合、または `self.model_input_names` に *"attention_mask"* が含まれている場合）。 [アテンションマスクとは?](../glossary#attention-mask) - **overflowing_tokens** -- 溢れ出したトークンシーケンスのリスト（`max_length`が指定され、`return_overflowing_tokens=True`の場合）。 - **num_truncated_tokens** -- トークンが切り詰められた数（`max_length`が指定され、`return_overflowing_tokens=True`の場合）。 - **special_tokens_mask** -- 0 と 1 のリスト。1 は追加された特殊トークンを、0 は通常のシーケンストークンを示します（`add_special_tokens=True` かつ `return_special_tokens_mask=True` の場合）。 - **length** -- 入力データの長さ（`return_length=True`の場合） 1 つ以上のシーケンス、または 1 つ以上のシーケンスのペアをトークナイズし、モデル用に準備するための主要なメソッドです。 ## PerceiverImageProcessor[[transformers.PerceiverImageProcessor]] #### transformers.PerceiverImageProcessor[[transformers.PerceiverImageProcessor]] ```python transformers.PerceiverImageProcessor(**kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/image_processing_perceiver.py#L33) **パラメータ:** do_convert_rgb (`bool`, *kwargs*, *optional*) : 画像を RGB に変換するかどうか。 do_resize (`bool`, *kwargs*, *任意*, デフォルトは `True`) : 画像をリサイズするかどうか。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*、デフォルト値は `{'height' : 224, 'width': 224}`): モデルへの最大入力サイズを記述します。 default_to_square (`bool`, *kwargs*, *任意*、デフォルトは `True`) : size が整数の場合、リサイズ時に正方形の画像をデフォルトとするかどうか。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*、デフォルト値は`{'height' : 256, 'width': 256}`): `center_crop`を適用した後の出力画像のサイズ。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*、デフォルトは `3`) : 画像をリサイズする場合に使用するリサンプリングフィルター。`PILImageResampling` の列挙型のいずれかになります。`do_resize` が `True` に設定されている場合のみ有効です。 do_rescale (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像をリスケールするかどうか。 rescale_factor (`float`, *kwargs*, *optional*, デフォルトは `0.00392156862745098`) : `do_rescale` が `True` に設定されている場合、画像をリスケールするための係数。 do_normalize (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像を正規化するかどうかを指定します。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.485, 0.456, 0.406]`) : 正規化に使用する画像の平均値です。`do_normalize` が `True` に設定されている場合のみ有効です。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.229, 0.224, 0.225]`) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。 do_pad (`bool`, *kwargs*, *任意*) : 画像にパディングを適用するかどうか。パディングは、バッチ内の最大サイズに合わせるか、画像ごとに固定の正方形サイズに合わせるかのいずれかで行われます。正確なパディング戦略はモデルによって異なります。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 画像をパディングするサイズを`{"height": int, "width" int}`で指定します。前処理に提供されたすべての画像サイズより大きい必要があります。`pad_size`が指定されない場合、バッチ内の最大の幅と高さにパディングされます。`do_pad=True.`の場合にのみ適用されます。 do_center_crop (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像を中央クロップするかどうか。 data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *任意*) : 入力画像のチャネル次元の形式です。設定されていない場合、入力画像からチャネル次元の形式が推論されます。以下のいずれかになります: - `"channels_first"` または `ChannelDimension.FIRST`: (num_channels, height, width) 形式の画像。 - `"channels_last"` または `ChannelDimension.LAST`: (height, width, num_channels) 形式の画像。 - `"none"` または `ChannelDimension.NONE`: (height, width) 形式の画像。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 動画を処理するデバイスです。未設定の場合、入力動画からデバイスが推論されます。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`に設定されている場合はスタックされたテンソルを返し、それ以外の場合はテンソルのリストを返します。 disable_grouping (`bool`, *kwargs*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。None の場合、画像が CPU にある場合は True、それ以外の場合は False に設定されます。この選択は、https://github.com/huggingface/transformers/pull/38157 に詳しく記載されている実証的な観察に基づいています。 image_seq_length (`int`, *kwargs*, *任意*) : 入力内の各画像に使用される画像トークンの数です。後方互換性のために追加されましたが、将来のモデルではプロセッサの属性として設定されるべきです。 PerceiverImageProcessor 画像プロセッサを構築します。 #### preprocess[[transformers.PerceiverImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382) **パラメータ:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : 前処理対象の画像。ピクセル値が 0 から 255 の範囲にある単一の画像またはバッチの画像を想定しています。ピクセル値が 0 から 1 の範囲にある画像を渡す場合は、`do_rescale=False` を設定してください。 image_like_kwargs (`dict[str, Any]`、*省略可*) : 追加の画像類似の入力も前処理対象にするための開発者向けフラグです。引数として kwarg を渡す方法が機能しない場合のみ使用してください。例えば、`preprocess(images, masks=masks)` が推奨される方法ですが、一部のモデルでは引数の優先順位の問題が発生します。そのような場合は、代わりに `preprocess(images, image_like_inputs={"masks": masks})` を使用できます。 do_convert_rgb (`bool`, *kwargs*, *optional*) : 画像を RGB に変換するかどうか。 do_resize (`bool`, *kwargs*, *optional*) : 画像をリサイズするかどうか。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : モデルへの最大入力次元を記述します。 default_to_square (`bool`, *kwargs*, *optional*) : size が int の場合、リサイズ時に正方形の画像をデフォルトとするかどうか。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` を適用した後の出力画像のサイズ。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 画像をリサイズする場合に使用するリサンプリングフィルタ。`PILImageResampling` の列挙型のいずれかです。`do_resize` が `True` に設定されている場合のみ有効です。 do_rescale (`bool`, *kwargs*, *任意*) : 画像をリスケールするかどうか。 rescale_factor (`float`, *kwargs*, *optional*) : `do_rescale` が `True` に設定されている場合、画像をリサイズするためのリスケール係数。 do_normalize (`bool`, *kwargs*, *optional*) : 画像を正規化するかどうかを指定します。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の平均値。`do_normalize` が `True` に設定されている場合のみ有効です。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。 do_pad (`bool`, *kwargs*, *任意*) : 画像にパディングを適用するかどうか。パディングは、バッチ内の最大サイズに合わせるか、画像ごとに固定の正方形サイズに合わせるかのいずれかで行われます。正確なパディング戦略はモデルによって異なります。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 画像をパディングするサイズを`{"height": int, "width" int}`で指定します。前処理に提供されたすべての画像サイズより大きい必要があります。`pad_size`が指定されない場合、バッチ内の最大の幅と高さにパディングされます。`do_pad=True.`の場合にのみ適用されます。 do_center_crop (`bool`, *kwargs*, *optional*) : 画像を中央クロップするかどうか。 data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *任意*) : 入力画像のチャネル次元の形式です。設定されていない場合、入力画像からチャネル次元の形式が推論されます。以下のいずれかになります: - `"channels_first"` または `ChannelDimension.FIRST`: (num_channels, height, width) 形式の画像。 - `"channels_last"` または `ChannelDimension.LAST`: (height, width, num_channels) 形式の画像。 - `"none"` または `ChannelDimension.NONE`: (height, width) 形式の画像。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 動画を処理するデバイスです。未設定の場合、入力動画からデバイスが推論されます。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`に設定されている場合はスタックされたテンソルを返し、それ以外の場合はテンソルのリストを返します。 disable_grouping (`bool`, *kwargs*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。None の場合、画像が CPU にある場合は True、それ以外の場合は False に設定されます。この選択は、https://github.com/huggingface/transformers/pull/38157 に詳しく記載されている実証的な観察に基づいています。 image_seq_length (`int`, *kwargs*, *任意*) : 入力内の各画像に使用される画像トークンの数です。後方互換性のために追加されましたが、将来のモデルではプロセッサの属性として設定されるべきです。 **戻り値:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- __call__ メソッドによって返されるリスト/配列/テンソルの辞書（'pixel_values' など）。 - **tensor_type** (`Union[None, str, TensorType]`、*省略可*) -- 初期化時に PyTorch/Numpy の Tensor 内の整数リストを変換するために、ここで tensor_type を指定できます。 画像または画像のバッチを前処理します。 ## PerceiverImageProcessorPil[[transformers.PerceiverImageProcessorPil]] #### transformers.PerceiverImageProcessorPil[[transformers.PerceiverImageProcessorPil]] ```python transformers.PerceiverImageProcessorPil(**kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/image_processing_pil_perceiver.py#L31) **パラメータ:** do_convert_rgb (`bool`, *kwargs*, *optional*) : 画像を RGB に変換するかどうか。 do_resize (`bool`, *kwargs*, *任意*, デフォルトは `True`) : 画像をリサイズするかどうか。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*、デフォルト値は `{'height' : 224, 'width': 224}`): モデルへの最大入力サイズを記述します。 default_to_square (`bool`, *kwargs*, *任意*、デフォルトは `True`) : size が整数の場合、リサイズ時に正方形の画像をデフォルトとするかどうか。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*、デフォルト値は`{'height' : 256, 'width': 256}`): `center_crop`を適用した後の出力画像のサイズ。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*、デフォルトは `3`) : 画像をリサイズする場合に使用するリサンプリングフィルター。`PILImageResampling` の列挙型のいずれかになります。`do_resize` が `True` に設定されている場合のみ有効です。 do_rescale (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像をリスケールするかどうか。 rescale_factor (`float`, *kwargs*, *optional*, デフォルトは `0.00392156862745098`) : `do_rescale` が `True` に設定されている場合、画像をリスケールするための係数。 do_normalize (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像を正規化するかどうかを指定します。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.485, 0.456, 0.406]`) : 正規化に使用する画像の平均値です。`do_normalize` が `True` に設定されている場合のみ有効です。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.229, 0.224, 0.225]`) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。 do_pad (`bool`, *kwargs*, *任意*) : 画像にパディングを適用するかどうか。パディングは、バッチ内の最大サイズに合わせるか、画像ごとに固定の正方形サイズに合わせるかのいずれかで行われます。正確なパディング戦略はモデルによって異なります。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 画像をパディングするサイズを`{"height": int, "width" int}`で指定します。前処理に提供されたすべての画像サイズより大きい必要があります。`pad_size`が指定されない場合、バッチ内の最大の幅と高さにパディングされます。`do_pad=True.`の場合にのみ適用されます。 do_center_crop (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像を中央クロップするかどうか。 data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *任意*) : 入力画像のチャネル次元の形式です。設定されていない場合、入力画像からチャネル次元の形式が推論されます。以下のいずれかになります: - `"channels_first"` または `ChannelDimension.FIRST`: (num_channels, height, width) 形式の画像。 - `"channels_last"` または `ChannelDimension.LAST`: (height, width, num_channels) 形式の画像。 - `"none"` または `ChannelDimension.NONE`: (height, width) 形式の画像。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 動画を処理するデバイスです。未設定の場合、入力動画からデバイスが推論されます。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`に設定されている場合はスタックされたテンソルを返し、それ以外の場合はテンソルのリストを返します。 disable_grouping (`bool`, *kwargs*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。None の場合、画像が CPU にある場合は True、それ以外の場合は False に設定されます。この選択は、https://github.com/huggingface/transformers/pull/38157 に詳しく記載されている実証的な観察に基づいています。 image_seq_length (`int`, *kwargs*, *任意*) : 入力内の各画像に使用される画像トークンの数です。後方互換性のために追加されましたが、将来のモデルではプロセッサの属性として設定されるべきです。 PerceiverImageProcessor 画像プロセッサを構築します。 #### preprocess[[transformers.PerceiverImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382) **パラメータ:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : 前処理対象の画像。ピクセル値が 0 から 255 の範囲にある単一の画像またはバッチの画像を想定しています。ピクセル値が 0 から 1 の範囲にある画像を渡す場合は、`do_rescale=False` を設定してください。 image_like_kwargs (`dict[str, Any]`、*省略可*) : 追加の画像類似の入力も前処理対象にするための開発者向けフラグです。引数として kwarg を渡す方法が機能しない場合のみ使用してください。例えば、`preprocess(images, masks=masks)` が推奨される方法ですが、一部のモデルでは引数の優先順位の問題が発生します。そのような場合は、代わりに `preprocess(images, image_like_inputs={"masks": masks})` を使用できます。 do_convert_rgb (`bool`, *kwargs*, *optional*) : 画像を RGB に変換するかどうか。 do_resize (`bool`, *kwargs*, *optional*) : 画像をリサイズするかどうか。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : モデルへの最大入力次元を記述します。 default_to_square (`bool`, *kwargs*, *optional*) : size が int の場合、リサイズ時に正方形の画像をデフォルトとするかどうか。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop` を適用した後の出力画像のサイズ。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 画像をリサイズする場合に使用するリサンプリングフィルタ。`PILImageResampling` の列挙型のいずれかです。`do_resize` が `True` に設定されている場合のみ有効です。 do_rescale (`bool`, *kwargs*, *任意*) : 画像をリスケールするかどうか。 rescale_factor (`float`, *kwargs*, *optional*) : `do_rescale` が `True` に設定されている場合、画像をリサイズするためのリスケール係数。 do_normalize (`bool`, *kwargs*, *optional*) : 画像を正規化するかどうかを指定します。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の平均値。`do_normalize` が `True` に設定されている場合のみ有効です。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。 do_pad (`bool`, *kwargs*, *任意*) : 画像にパディングを適用するかどうか。パディングは、バッチ内の最大サイズに合わせるか、画像ごとに固定の正方形サイズに合わせるかのいずれかで行われます。正確なパディング戦略はモデルによって異なります。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 画像をパディングするサイズを`{"height": int, "width" int}`で指定します。前処理に提供されたすべての画像サイズより大きい必要があります。`pad_size`が指定されない場合、バッチ内の最大の幅と高さにパディングされます。`do_pad=True.`の場合にのみ適用されます。 do_center_crop (`bool`, *kwargs*, *optional*) : 画像を中央クロップするかどうか。 data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *任意*) : 入力画像のチャネル次元の形式です。設定されていない場合、入力画像からチャネル次元の形式が推論されます。以下のいずれかになります: - `"channels_first"` または `ChannelDimension.FIRST`: (num_channels, height, width) 形式の画像。 - `"channels_last"` または `ChannelDimension.LAST`: (height, width, num_channels) 形式の画像。 - `"none"` または `ChannelDimension.NONE`: (height, width) 形式の画像。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 動画を処理するデバイスです。未設定の場合、入力動画からデバイスが推論されます。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`に設定されている場合はスタックされたテンソルを返し、それ以外の場合はテンソルのリストを返します。 disable_grouping (`bool`, *kwargs*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。None の場合、画像が CPU にある場合は True、それ以外の場合は False に設定されます。この選択は、https://github.com/huggingface/transformers/pull/38157 に詳しく記載されている実証的な観察に基づいています。 image_seq_length (`int`, *kwargs*, *任意*) : 入力内の各画像に使用される画像トークンの数です。後方互換性のために追加されましたが、将来のモデルではプロセッサの属性として設定されるべきです。 **戻り値:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- __call__ メソッドによって返されるリスト/配列/テンソルの辞書（'pixel_values' など）。 - **tensor_type** (`Union[None, str, TensorType]`、*省略可*) -- 初期化時に PyTorch/Numpy の Tensor 内の整数リストを変換するために、ここで tensor_type を指定できます。 画像または画像のバッチを前処理します。 ## PerceiverTextPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverTextPreprocessor(config: PerceiverConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2664) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルの設定。 Perceiver Encoder用のテキスト前処理。`inputs`を埋め込み、位置エンコーディングを追加するために使用できます。 埋め込みの次元数は、設定の`d_model`属性によって決定されます。 ## PerceiverImagePreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor(config, prep_type = 'conv', spatial_downsample: int = 4, temporal_downsample: int = 1, position_encoding_type: str = 'fourier', in_channels: int = 3, out_channels: int = 64, conv_after_patching: bool = False, conv_after_patching_in_channels: int = 54, conv2d_use_batchnorm: bool = True, concat_or_add_pos: str = 'concat', project_pos_dim: int = -1, **position_encoding_kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2827) **パラメータ:** config ([*PerceiverConfig*]) : モデルの設定。 prep_type (`str`、*任意*、デフォルトは`"conv"`) : 前処理の種類。"conv1x1"、"conv"、"patches"、"pixels"のいずれかを指定できます。 spatial_downsample (`int`、*optional*、デフォルトは 4) : 空間的下サンプリング係数。 temporal_downsample (`int`、*optional*、デフォルトは 1) : 時間方向のダウンサンプリング係数（時間次元が存在する場合のみ関連します）。 position_encoding_type (`str`、*任意*、デフォルトは`"fourier"`) : 位置エンコーディングの種類。"fourier"または"trainable"を指定できます。 in_channels (`int`、*任意*、デフォルトは 3) : 入力のチャネル数。 out_channels (`int`、*任意*、デフォルトは 64) : 出力のチャネル数。 conv_after_patching (`bool`, *任意*, デフォルトは `False`) : パッチ適用後に畳み込み層を適用するかどうか。 conv_after_patching_in_channels (`int`, *optional*, デフォルトは 54) : パッチ適用後の畳み込み層の入力のチャネル数。 conv2d_use_batchnorm (`bool`、*任意*、デフォルトは`True`) : 畳み込み層でバッチ正規化を使用するかどうか。 concat_or_add_pos (`str`、*任意*、デフォルトは`"concat"`) : 位置エンコーディングを入力に結合する方法。"concat"または"add"を指定できます。 project_pos_dim (`int`, *optional*, デフォルトは -1) : 位置エンコーディングを射影する次元数です。-1 の場合、射影は適用されません。 - ****position_encoding_kwargs** (`Dict`, *任意*) : 位置エンコーディング用のキーワード引数。 Perceiver Encoder用の画像前処理。 注: *out_channels* 引数は、*prep_type* が "conv1x1" または "conv" に設定されている場合、畳み込み層の出力チャネル数を指します。絶対位置埋め込みを追加する場合は、位置エンコーディングの kwargs の *num_channels* が *out_channels* と等しく設定されていることを確認してください。 ## PerceiverOneHotPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverOneHotPreprocessor(config: PerceiverConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L3065) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルの設定。 Perceiver Encoder用のOne-hotプリプロセッサです。入力にダミーのインデックス次元を追加するために使用できます。 ## PerceiverAudioPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverAudioPreprocessor(config, prep_type: str = 'patches', samples_per_patch: int = 96, position_encoding_type: str = 'fourier', concat_or_add_pos: str = 'concat', out_channels = 64, project_pos_dim = -1, **position_encoding_kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L3091) **パラメータ:** config ([*PerceiverConfig*]) : モデルの設定。 prep_type (`str`、*任意*、デフォルトは`"patches"`) : 使用するプリプロセッサの種類。サポートされているのは "patches" のみです。 samples_per_patch (`int`、*optional*、デフォルトは 96) : パッチごとのサンプル数。 position_encoding_type (`str`、*任意*、デフォルトは`"fourier"`) : 使用する位置エンコーディングの種類。"trainable"または"fourier"を指定できます。 concat_or_add_pos (`str`、*任意*、デフォルトは`"concat"`) : 位置エンコーディングを入力に結合する方法。"concat"または"add"を指定できます。 out_channels (`int`、*任意*、デフォルトは 64) : 出力のチャネル数。 project_pos_dim (`int`, *optional*, デフォルトは -1) : 位置エンコーディングを射影する次元数です。-1 の場合、射影は適用されません。 - ****position_encoding_kwargs** (`Dict`, *任意*) : 位置エンコーディング用のキーワード引数。 Perceiver Encoder用のオーディオ前処理。 ## PerceiverMultimodalPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor(modalities: Mapping, mask_probs: collections.abc.Mapping[str, float] | None = None, min_padding_size: int = 2) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L3194) **パラメータ:** modalities (`Mapping[str, PreprocessorType]`) : モダリティ名をプリプロセッサにマッピングする辞書。 mask_probs (`dict[str, float]`) : モダリティ名をそのモダリティのマスク確率にマッピングする辞書。 min_padding_size (`int`, *optional*, デフォルトは 2) : すべてのモダリティに対する最小パディングサイズです。最終的な出力の num_channels は、すべてのモダリティにおける最大チャンネル数に min_padding_size を加えた値になります。 Perceiver Encoder向けのマルチモーダル前処理。 各モダリティの入力は前処理され、その後、学習可能な位置埋め込みでパディングされて、チャネル数が同じになるように調整されます。 ## PerceiverProjectionDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverProjectionDecoder(config) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1839) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルの設定。 ベースラインの予測デコーダー（クロスアテンションなし）。 ## PerceiverBasicDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverBasicDecoder(config: PerceiverConfig, output_num_channels: int, position_encoding_type: str | None = 'trainable', output_index_dims: int | None = None, num_channels: int | None = 128, subsampled_index_dims: int | None = None, qk_channels: int | None = None, v_channels: int | None = None, num_heads: int | None = 1, widening_factor: int | None = 1, use_query_residual: bool | None = False, concat_preprocessed_input: bool | None = False, final_project: bool | None = True, position_encoding_only: bool | None = False, **position_encoding_kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1865) **パラメータ:** config ([*PerceiverConfig*]) : モデルの設定。 output_num_channels (`int`, *optional*) : 出力のチャネル数。*final_project*が`True`に設定されている場合のみ使用されます。 position_encoding_type (`str`、*任意*、デフォルトは "trainable") : 使用する位置エンコーディングの種類。"trainable"、"fourier"、"none" のいずれかです。 output_index_dims (`int`, *optional*) : 出力クエリの次元数です。'position_encoding_type' == 'none' の場合は無視されます。 num_channels (`int`、*optional*、デフォルトは 128) : デコーダークエリのチャネル数です。'position_encoding_type' == 'none' の場合は無視されます。 qk_channels (`int`, *任意*) : クロスアテンション層におけるクエリとキーのチャネル数。 v_channels (`int`, *任意*) : クロスアテンション層の値のチャネル数。 num_heads (`int`、*optional*、デフォルトは 1) : クロスアテンション層のアテンションヘッド数。 widening_factor (`int`、*optional*、デフォルトは 1) : クロスアテンション層のワイドニング係数。 use_query_residual (`bool`, *任意*, デフォルトは `False`) : クエリとクロスアテンション層の出力の間に残差接続を使用するかどうか。 concat_preprocessed_input (`bool`、*任意*、デフォルトは`False`) : 前処理済みの入力をクエリに連結するかどうか。 final_project (`bool`, *任意*, デフォルトは `True`) : クロスアテンション層の出力をターゲットの次元に射影するかどうか。 position_encoding_only (`bool`, *任意*, デフォルトは `False`) : このクラスを出力クエリの定義にのみ使用するか否か。 Cross-attentionベースのデコーダー。このクラスは、latentsがキーとバリューを生成するcross-attention操作を用いて、latentsの最終的なhidden statesをデコードするために使用できます。 このクラスの出力の形状は、出力クエリ（デコーダクエリとも呼ばれる）の定義方法によって異なります。 ## PerceiverClassificationDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder(config, **decoder_kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2050) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルの設定。 Cross-attention ベースの分類デコーダー。`PerceiverBasicDecoder` の軽量ラッパーで、logit を出力します。Perceiver エンコーダーの出力（shape: (batch_size, num_latents, d_latents)）を、shape (batch_size, num_labels) のテンソルに変換します。クエリの shape は (batch_size, 1, num_labels) です。 ## PerceiverOpticalFlowDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder(config, output_image_shape, output_num_channels = 2, rescale_factor = 100.0, **decoder_kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2096) Cross-attention ベースの光流デコーダー。 ## PerceiverBasicVideoAutoencodingDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverBasicVideoAutoencodingDecoder(config: PerceiverConfig, output_shape: list, position_encoding_type: str, **decoder_kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2131) **パラメータ:** config ([*PerceiverConfig*]) : モデルの設定。 output_shape (`list[int]`) : チャンネル次元を除いた出力の形状 (batch_size, num_frames, height, width)。 position_encoding_type (`str`) : 使用する位置エンコーディングの種類。"trainable"、"fourier"、または "none" のいずれかです。 Cross-attentionベースのvideo-autoencodingデコーダー。*PerceiverBasicDecoder*の軽量ラッパーで、videoのリシェイピングロジックを含みます。 ## PerceiverMultimodalDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder]] #### transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder(config: PerceiverConfig, modalities: dict, num_outputs: int, output_num_channels: int, min_padding_size: int | None = 2, subsampled_index_dims: dict[str, transformers.models.perceiver.modeling_perceiver.PerceiverAbstractDecoder] | None = None, **decoder_kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2208) **パラメータ:** config ([*PerceiverConfig*]) : モデルの設定。 modalities (`dict[str, PerceiverAbstractDecoder]`) : モダリティ名をそのモダリティのデコーダーにマッピングする辞書。 num_outputs (`int`) : デコーダーの出力数。 output_num_channels (`int`) : 出力のチャネル数。 min_padding_size (`int`, *optional*, デフォルトは 2) : すべてのモダリティに対する最小パディングサイズです。最終的な出力の num_channels は、すべてのモダリティにおける最大チャンネル数に min_padding_size を加えた値になります。 subsampled_index_dims (`dict[str, PerceiverAbstractDecoder]`, *任意*) : モダリティ名を、そのモダリティのデコーダークエリに使用するサブサンプリングされたインデックス次元にマッピングする辞書。 単一モーダルデコーダーを組み合わせることで、マルチモーダルデコーディングを行います。コンストラクタの *modalities* 引数は、モーダル名をそのモーダルのデコーダーにマッピングする辞書です。そのデコーダーは、該当するモーダルのクエリを構築するために使用されます。モーダル固有のクエリは、学習可能なモーダル固有のパラメータでパディングされた後、時間次元に沿って連結されます。 次に、すべてのモダリティにまたがる共有クロスアテンション操作があります。 ## PerceiverProjectionPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverProjectionPostprocessor(in_channels: int, out_channels: int) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2806) **パラメータ:** in_channels (`int`) : 入力におけるチャネル数。 out_channels (`int`) : 出力のチャネル数。 Perceiver用のProjection後処理。デコーダー出力のチャネルを低い次元に射影するために使用できます。 ## PerceiverAudioPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverAudioPostprocessor(config: PerceiverConfig, in_channels: int, postproc_type: str = 'patches') ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2779) **パラメータ:** config ([*PerceiverConfig*]) : モデルの設定。 in_channels (`int`) : 入力におけるチャネル数。 postproc_type (`str`、*任意*、デフォルトは`"patches"`) : 使用する Postprocessor の種類です。現在サポートされているのは "patches" のみです。 Perceiver用のオーディオ後処理。デコーダーの出力をオーディオ特徴量に変換するために使用できます。 ## PerceiverClassificationPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverClassificationPostprocessor(config: PerceiverConfig, in_channels: int) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2759) **パラメータ:** config ([*PerceiverConfig*]) : モデルの設定。 in_channels (`int`) : 入力におけるチャネル数。 Perceiver用の分類後処理。デコーダーの出力を分類ロジットに変換するために使用できます。 ## PerceiverMultimodalPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor]] #### transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor[[transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor]] ```python transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPostprocessor(modalities: Mapping, input_is_dict: bool = False) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L2725) **パラメータ:** modalities (`Mapping[str, PostprocessorType]`) : モダリティ名を、そのモダリティ用の後処理クラスにマッピングする辞書。 input_is_dict (`bool`、*任意*、デフォルトは`False`) : True の場合、入力が辞書構造であると仮定され、出力も同じ辞書構造を保持します。False の場合、入力はテンソルであり、*modality_sizes*によって後処理時にスライスされます。 Perceiver用のマルチモーダル後処理。モダリティ固有の後処理器を単一の後処理器に統合するために使用できます。 ## PerceiverModel[[transformers.PerceiverModel]] #### transformers.PerceiverModel[[transformers.PerceiverModel]] ```python transformers.PerceiverModel(config: PerceiverConfig, decoder: typing.Optional[ForwardRef('PerceiverAbstractDecoder')] = None, input_preprocessor: Callable = None, output_postprocessor: Callable = None) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L561) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを参照してください。 decoder (`PerceiverDecoder`、*任意*) : 潜在表現をタスクの予測に変換するデコーダーモジュール。 input_preprocessor (`PreprocessorType`, *任意*) : モデル用のテンソルに生入力をエンコードする Preprocessor。 output_postprocessor (`PostprocessorType`, *任意*) : モデルの出力を最終的な予測に変換する Postprocessor。 Perceiver:スケーラブルで、完全にアテンションベースのアーキテクチャ。 モデルの forward で `interpolate_pos_encoding` を `True` に設定することで、Perceiver を学習時に使用した解像度よりも高い解像度の画像でファインチューニングすることが可能です。これにより、事前学習済みの位置埋め込みがより高い解像度に補間されます。 このモデルは [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.PerceiverModel.forward]] ```python forward(inputs: FloatTensor, attention_mask: typing.Optional[torch.FloatTensor] = None, subsampled_output_points: dict[str, torch.Tensor] | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, interpolate_pos_encoding: bool = False, return_dict: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L597) **パラメータ:** inputs (`torch.FloatTensor`) : perceiverへの入力。画像、テキスト、音声、動画など、何でも構いません。 attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、**マスクされる**トークンは 0。 [アテンションマスクとは?](../glossary#attention-mask) subsampled_output_points (`dict[str, torch.Tensor]`, *任意*) : デコーダーのクエリとして使用されるテンソルの辞書です。デコーダーはこれらのクエリをモデルの潜在表現にマッピングします。サブサンプリングされたデコーディング、例えば特定の画像パッチのみをデコードする場合などに使用されます。 output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 interpolate_pos_encoding (`bool`、*任意*、デフォルトは`False`) : 事前学習済みの位置エンコーディングを補間するかどうかを指定します。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 **戻り値:** [PerceiverModelOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput) または `tuple(torch.FloatTensor)` 設定（[PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)）と入力に応じて、さまざまな要素で構成される、[PerceiverModelOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverModelOutput)または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。 [PerceiverModel](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **logits** (`torch.FloatTensor`、shape `(batch_size, num_labels)`) -- 分類スコア（config.num_labels==1 の場合は回帰スコア）（SoftMax 適用前）。 - **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*optional*) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **cross_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 PerceiverConfig, PerceiverTokenizer, PerceiverImageProcessor, PerceiverModel >>> from transformers.models.perceiver.modeling_perceiver import ( ... PerceiverTextPreprocessor, ... PerceiverImagePreprocessor, ... PerceiverClassificationDecoder, ... ) >>> import torch >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from PIL import Image >>> # EXAMPLE 1: using the Perceiver to classify texts >>> # - we define a TextPreprocessor, which can be used to embed tokens >>> # - we define a ClassificationDecoder, which can be used to decode the >>> # final hidden states of the latents to classification logits >>> # using trainable position embeddings >>> config = PerceiverConfig() >>> preprocessor = PerceiverTextPreprocessor(config) >>> decoder = PerceiverClassificationDecoder( ... config, ... num_channels=config.d_latents, ... trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1), ... use_query_residual=True, ... ) >>> model = PerceiverModel(config, input_preprocessor=preprocessor, decoder=decoder) >>> # you can then do a forward pass as follows: >>> tokenizer = PerceiverTokenizer() >>> text = "hello world" >>> inputs = tokenizer(text, return_tensors="pt").input_ids >>> with torch.no_grad(): ... outputs = model(inputs=inputs) >>> logits = outputs.logits >>> list(logits.shape) [1, 2] >>> # to train, one can train the model using standard cross-entropy: >>> criterion = torch.nn.CrossEntropyLoss() >>> labels = torch.tensor([1]) >>> loss = criterion(logits, labels) >>> # EXAMPLE 2: using the Perceiver to classify images >>> # - we define an ImagePreprocessor, which can be used to embed images >>> config = PerceiverConfig(image_size=224) >>> preprocessor = PerceiverImagePreprocessor( ... config, ... prep_type="conv1x1", ... spatial_downsample=1, ... out_channels=256, ... position_encoding_type="trainable", ... concat_or_add_pos="concat", ... project_pos_dim=256, ... trainable_position_encoding_kwargs=dict( ... num_channels=256, ... index_dims=config.image_size**2, ... ), ... ) >>> model = PerceiverModel( ... config, ... input_preprocessor=preprocessor, ... decoder=PerceiverClassificationDecoder( ... config, ... num_channels=config.d_latents, ... trainable_position_encoding_kwargs=dict(num_channels=config.d_latents, index_dims=1), ... use_query_residual=True, ... ), ... ) >>> # you can then do a forward pass as follows: >>> image_processor = PerceiverImageProcessor() >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = image_processor(image, return_tensors="pt").pixel_values >>> with torch.no_grad(): ... outputs = model(inputs=inputs) >>> logits = outputs.logits >>> list(logits.shape) [1, 2] >>> # to train, one can train the model using standard cross-entropy: >>> criterion = torch.nn.CrossEntropyLoss() >>> labels = torch.tensor([1]) >>> loss = criterion(logits, labels) ``` ## PerceiverForMaskedLM[[transformers.PerceiverForMaskedLM]] #### transformers.PerceiverForMaskedLM[[transformers.PerceiverForMaskedLM]] ```python transformers.PerceiverForMaskedLM(config: PerceiverConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L807) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを参照してください。 Perceiverをマスク言語モデリングに用いる例。 このモデルは [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.PerceiverForMaskedLM.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, input_ids: typing.Optional[torch.Tensor] = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L839) **パラメータ:** inputs (`torch.Tensor`, *任意*) : perceiverへの入力。画像、テキスト、音声、動画など、何でも構いません。 attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*optional*) : マスク付き言語モデリング損失を計算するためのラベル。インデックスは `[-100, 0, ..., config.vocab_size]` の範囲である必要があります（`input_ids` の docstring を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲のラベルを持つトークンに対してのみ計算されます。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 input_ids (`torch.Tensor`、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) **戻り値:** [PerceiverMaskedLMOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput) または `tuple(torch.FloatTensor)` 設定（[PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)）と入力に応じて、さまざまな要素で構成される、[PerceiverMaskedLMOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMaskedLMOutput)または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。 [PerceiverForMaskedLM](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForMaskedLM)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- マスクド言語モデリング (MLM) の損失。 - **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。 - **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **cross_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, PerceiverForMaskedLM >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver") >>> model = PerceiverForMaskedLM.from_pretrained("deepmind/language-perceiver") >>> # training >>> text = "This is an incomplete sentence where some words are missing." >>> inputs = tokenizer(text, padding="max_length", return_tensors="pt") >>> # mask " missing." >>> inputs["input_ids"][0, 52:61] = tokenizer.mask_token_id >>> labels = tokenizer(text, padding="max_length", return_tensors="pt").input_ids >>> outputs = model(**inputs, labels=labels) >>> loss = outputs.loss >>> round(loss.item(), 2) 19.87 >>> logits = outputs.logits >>> list(logits.shape) [1, 2048, 262] >>> # inference >>> text = "This is an incomplete sentence where some words are missing." >>> encoding = tokenizer(text, padding="max_length", return_tensors="pt") >>> # mask bytes corresponding to " missing.". Note that the model performs much better if the masked span starts with a space. >>> encoding["input_ids"][0, 52:61] = tokenizer.mask_token_id >>> # forward pass >>> with torch.no_grad(): ... outputs = model(**encoding) >>> logits = outputs.logits >>> list(logits.shape) [1, 2048, 262] >>> masked_tokens_predictions = logits[0, 52:61].argmax(dim=-1).tolist() >>> tokenizer.decode(masked_tokens_predictions) ' missing.' ``` ## PerceiverForSequenceClassification[[transformers.PerceiverForSequenceClassification]] #### transformers.PerceiverForSequenceClassification[[transformers.PerceiverForSequenceClassification]] ```python transformers.PerceiverForSequenceClassification(config: PerceiverConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L940) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを参照してください。 Perceiver をテキスト分類に使用した例。 このモデルは [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.PerceiverForSequenceClassification.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, input_ids: typing.Optional[torch.Tensor] = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L961) **パラメータ:** inputs (`torch.Tensor`, *任意*) : perceiverへの入力。画像、テキスト、音声、動画など、何でも構いません。 attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 labels (`torch.LongTensor`、形状 `(batch_size,)`、*任意*) : 分類/回帰損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。`config.num_labels == 1` の場合は回帰損失（平均二乗誤差）が計算され、`config.num_labels > 1` の場合は分類損失（クロスエントロピー）が計算されます。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 input_ids (`torch.Tensor`、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) **戻り値:** [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) または `tuple(torch.FloatTensor)` A [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) or a tuple of `torch.FloatTensor` (if `return_dict=False` is passed or when `config.return_dict=False`) comprising various elements depending on the configuration ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) and inputs. [PerceiverForSequenceClassification](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForSequenceClassification)の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 の場合は回帰）スコア。 - **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **cross_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, PerceiverForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("deepmind/language-perceiver") >>> model = PerceiverForSequenceClassification.from_pretrained("deepmind/language-perceiver") >>> text = "hello world" >>> inputs = tokenizer(text, return_tensors="pt").input_ids >>> outputs = model(inputs=inputs) >>> logits = outputs.logits >>> list(logits.shape) [1, 2] ``` ## PerceiverForImageClassificationLearned[[transformers.PerceiverForImageClassificationLearned]] #### transformers.PerceiverForImageClassificationLearned[[transformers.PerceiverForImageClassificationLearned]] ```python transformers.PerceiverForImageClassificationLearned(config: PerceiverConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1062) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを参照してください。 ImageNetなどのタスクにおける画像分類でのPerceiverの使用例。 このモデルは学習された位置埋め込みを使用しています。つまり、このモデルには画像の構造に関する特別な情報が与えられていません。論文に示されているように、このモデルはImageNetでトップ1精度72.7を達成できます。 [PerceiverForImageClassificationLearned](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) は、入力画像の前処理に [PerceiverImagePreprocessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor)（`prep_type="conv1x1"` を使用）を、[PerceiverModel](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverModel) の潜在表現を分類 logits にデコードするために [PerceiverClassificationDecoder](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder) を使用します。 このモデルは [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.PerceiverForImageClassificationLearned.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, return_dict: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1093) **パラメータ:** inputs (`torch.Tensor`, *任意*) : perceiverへの入力。画像、テキスト、音声、動画など、何でも構いません。 attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 labels (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : 画像分類/回帰の損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。`config.num_labels == 1` の場合は回帰損失（Mean-Square loss）が計算され、`config.num_labels > 1` の場合は分類損失（Cross-Entropy）が計算されます。 interpolate_pos_encoding (`bool`、*任意*、デフォルトは`False`) : 事前学習済みの位置エンコーディングを補間するかどうかを指定します。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 pixel_values (`torch.Tensor`、形状 `(batch_size, num_channels, image_size, image_size)`、*任意*) : 入力画像に対応するテンソルです。ピクセル値は [PerceiverImageProcessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverImageProcessor) を使用して取得できます。詳細については [PerceiverImageProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) を参照してください（`processor_class` は画像の処理に [PerceiverImageProcessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverImageProcessor) を使用します）。 **戻り値:** [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) または `tuple(torch.FloatTensor)` A [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) or a tuple of `torch.FloatTensor` (if `return_dict=False` is passed or when `config.return_dict=False`) comprising various elements depending on the configuration ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) and inputs. [PerceiverForImageClassificationLearned](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned)の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 の場合は回帰）スコア。 - **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **cross_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 AutoImageProcessor, PerceiverForImageClassificationLearned >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-learned") >>> model = PerceiverForImageClassificationLearned.from_pretrained("deepmind/vision-perceiver-learned") >>> inputs = image_processor(images=image, return_tensors="pt").pixel_values >>> outputs = model(inputs=inputs) >>> logits = outputs.logits >>> list(logits.shape) [1, 1000] >>> # model predicts one of the 1000 ImageNet classes >>> predicted_class_idx = logits.argmax(-1).item() >>> print("Predicted class:", model.config.id2label[predicted_class_idx]) Predicted class: tabby, tabby cat ``` ## PerceiverForImageClassificationFourier[[transformers.PerceiverForImageClassificationFourier]] #### transformers.PerceiverForImageClassificationFourier[[transformers.PerceiverForImageClassificationFourier]] ```python transformers.PerceiverForImageClassificationFourier(config: PerceiverConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1187) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを参照してください。 ImageNetなどのタスクにおける画像分類でのPerceiverの使用例。 このモデルは固定の2次元フーリエ位置埋め込みを使用しています。論文に示されているように、このモデルはImageNetでトップ1精度79.0を達成し、大規模データセット（JFTなど）で事前学習を行うと84.5に向上します。 [PerceiverForImageClassificationLearned](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) は、入力画像の前処理に [PerceiverImagePreprocessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor)（`prep_type="pixels"` を指定）を使用し、[PerceiverModel](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverModel) の潜在表現を分類 logits にデコードするために [PerceiverClassificationDecoder](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder) を使用します。 このモデルは [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.PerceiverForImageClassificationFourier.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1219) **パラメータ:** inputs (`torch.Tensor`, *任意*) : perceiverへの入力。画像、テキスト、音声、動画など、何でも構いません。 attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 labels (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : 画像分類/回帰の損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。`config.num_labels == 1` の場合は回帰損失（Mean-Square loss）が計算され、`config.num_labels > 1` の場合は分類損失（Cross-Entropy）が計算されます。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 pixel_values (`torch.Tensor`、形状 `(batch_size, num_channels, image_size, image_size)`、*任意*) : 入力画像に対応するテンソルです。ピクセル値は [PerceiverImageProcessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverImageProcessor) を使用して取得できます。詳細については [PerceiverImageProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) を参照してください（`processor_class` は画像の処理に [PerceiverImageProcessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverImageProcessor) を使用します）。 **戻り値:** [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) または `tuple(torch.FloatTensor)` [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput)、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)）と入力に応じて、さまざまな要素で構成されます。 [PerceiverForImageClassificationFourier](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForImageClassificationFourier)の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 の場合は回帰）スコア。 - **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **cross_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 AutoImageProcessor, PerceiverForImageClassificationFourier >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-fourier") >>> model = PerceiverForImageClassificationFourier.from_pretrained("deepmind/vision-perceiver-fourier") >>> inputs = image_processor(images=image, return_tensors="pt").pixel_values >>> outputs = model(inputs=inputs) >>> logits = outputs.logits >>> list(logits.shape) [1, 1000] >>> # model predicts one of the 1000 ImageNet classes >>> predicted_class_idx = logits.argmax(-1).item() >>> print("Predicted class:", model.config.id2label[predicted_class_idx]) Predicted class: tabby, tabby cat ``` ## PerceiverForImageClassificationConvProcessing[[transformers.PerceiverForImageClassificationConvProcessing]] #### transformers.PerceiverForImageClassificationConvProcessing[[transformers.PerceiverForImageClassificationConvProcessing]] ```python transformers.PerceiverForImageClassificationConvProcessing(config: PerceiverConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1310) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを参照してください。 ImageNetなどのタスクにおける画像分類でのPerceiverの使用例。 このモデルは、2D conv+maxpoolの前処理ネットワークを使用しています。論文に示されているように、このモデルはImageNetでtop-1精度82.1を達成できます。 [PerceiverForImageClassificationLearned](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForImageClassificationLearned) は、入力画像の前処理に [PerceiverImagePreprocessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor)（`prep_type="conv"` を使用）を、[PerceiverModel](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverModel) の潜在表現を分類 logits にデコードするために [PerceiverClassificationDecoder](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassificationDecoder) を使用します。 このモデルは [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.PerceiverForImageClassificationConvProcessing.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1343) **パラメータ:** inputs (`torch.Tensor`, *任意*) : perceiverへの入力。画像、テキスト、音声、動画など、何でも構いません。 attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 labels (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : 画像分類/回帰の損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。`config.num_labels == 1` の場合は回帰損失（Mean-Square loss）が計算され、`config.num_labels > 1` の場合は分類損失（Cross-Entropy）が計算されます。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 pixel_values (`torch.Tensor`、形状 `(batch_size, num_channels, image_size, image_size)`、*任意*) : 入力画像に対応するテンソルです。ピクセル値は [PerceiverImageProcessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverImageProcessor) を使用して取得できます。詳細については [PerceiverImageProcessor.__call__()](/docs/transformers/main/ja/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) を参照してください（`processor_class` は画像の処理に [PerceiverImageProcessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverImageProcessor) を使用します）。 **戻り値:** [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) または `tuple(torch.FloatTensor)` [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput)、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)）と入力に応じて、さまざまな要素で構成されます。 [PerceiverForImageClassificationConvProcessing](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForImageClassificationConvProcessing)の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 の場合は回帰）スコア。 - **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **cross_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 AutoImageProcessor, PerceiverForImageClassificationConvProcessing >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> image_processor = AutoImageProcessor.from_pretrained("deepmind/vision-perceiver-conv") >>> model = PerceiverForImageClassificationConvProcessing.from_pretrained("deepmind/vision-perceiver-conv") >>> inputs = image_processor(images=image, return_tensors="pt").pixel_values >>> outputs = model(inputs=inputs) >>> logits = outputs.logits >>> list(logits.shape) [1, 1000] >>> # model predicts one of the 1000 ImageNet classes >>> predicted_class_idx = logits.argmax(-1).item() >>> print("Predicted class:", model.config.id2label[predicted_class_idx]) Predicted class: tabby, tabby cat ``` ## PerceiverForOpticalFlow[[transformers.PerceiverForOpticalFlow]] #### transformers.PerceiverForOpticalFlow[[transformers.PerceiverForOpticalFlow]] ```python transformers.PerceiverForOpticalFlow(config: PerceiverConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1434) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを参照してください。 Sintel や KITTI などのタスクにおける光流の Perceiver の使用例。[PerceiverForOpticalFlow](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForOpticalFlow) は、入力画像の前処理に [PerceiverImagePreprocessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverImagePreprocessor)（*prep_type="patches"* を使用）を、[PerceiverModel](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverModel) の潜在表現のデコードに [PerceiverOpticalFlowDecoder](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverOpticalFlowDecoder) を使用します。 入力として、2つの連続フレームをチャネル次元に沿って連結し、各ピクセルの周囲から3 x 3のパッチを抽出します（これにより、各ピクセルあたり3 x 3 x 3 x 2 = 54の値が得られます）。パッチ内の各ピクセルの位置をエンコードするために、固定のFourier位置エンコーディングを使用します。次に、Perceiverエンコーダを適用します。デコードするには、入力に使用したのと同じエンコーディングを用いて潜在表現をクエリします。 このモデルは [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.PerceiverForOpticalFlow.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1484) **パラメータ:** inputs (`torch.Tensor`, *任意*) : perceiverへの入力。画像、テキスト、音声、動画など、何でも構いません。 attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 labels (`torch.LongTensor`、形状 `(batch_size,)`、*任意*) : 光流損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 **戻り値:** [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) または `tuple(torch.FloatTensor)` [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput)、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)）と入力に応じて、さまざまな要素で構成されます。 [PerceiverForOpticalFlow](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForOpticalFlow)の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 の場合は回帰）スコア。 - **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **cross_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 PerceiverForOpticalFlow >>> import torch >>> model = PerceiverForOpticalFlow.from_pretrained("deepmind/optical-flow-perceiver") >>> # in the Perceiver IO paper, the authors extract a 3 x 3 patch around each pixel, >>> # leading to 3 x 3 x 3 = 27 values for each pixel (as each pixel also has 3 color channels) >>> # patches have shape (batch_size, num_frames, num_channels, height, width) >>> # the authors train on resolutions of 368 x 496 >>> patches = torch.randn(1, 2, 27, 368, 496) >>> outputs = model(inputs=patches) >>> logits = outputs.logits >>> list(logits.shape) [1, 368, 496, 2] ``` ## PerceiverForMultimodalAutoencoding[[transformers.PerceiverForMultimodalAutoencoding]] #### transformers.PerceiverForMultimodalAutoencoding[[transformers.PerceiverForMultimodalAutoencoding]] ```python transformers.PerceiverForMultimodalAutoencoding(config: PerceiverConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1576) **パラメータ:** config ([PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを参照してください。 Kinetics-700などのタスクにおいて、Perceiverをマルチモーダル（動画）オートエンコーディングに用いる例。 [PerceiverForMultimodalAutoencoding](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForMultimodalAutoencoding) は、[PerceiverMultimodalPreprocessor](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalPreprocessor) を使用して、画像、音声、クラスラベルという3つのモダリティの前処理を行います。この前処理器は、モダリティ固有の前処理器を用いて各モダリティを個別に前処理し、その後それらを連結します。連結のために、学習可能な位置埋め込みを使用して、各モダリティを同じチャネル数にパディングし、時間軸方向での連結を可能にします。次に、Perceiverエンコーダーを適用します。 [PerceiverMultimodalDecoder](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder) は、[PerceiverModel](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverModel) の潜在表現をデコードするために使用されます。このデコーダーは、各モダリティ固有のデコーダーを使用してクエリを構築します。デコーダーのクエリは、前処理後の入力に基づいて作成されます。ただし、1回のフォワードパスで動画全体をオートエンコードすることは計算上実行不可能なため、潜在表現とのクロスアテンションにはデコーダークエリの一部のみを使用します。これは、各モダリティのサブサンプリングされたインデックスによって決定され、[PerceiverForMultimodalAutoencoding](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForMultimodalAutoencoding) のフォワードパスへの追加入力として提供できます。 [PerceiverMultimodalDecoder](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverMultimodalDecoder) は、異なるモダリティのデコーダークエリを時間次元に沿って連結できるように、同じチャンネル数にパディングします。その後、[PerceiverModel](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverModel) の潜在表現に対してクロスアテンションを実行します。 最後に、`~models.perceiver.modeling_perceiver.PerceiverMultiModalPostprocessor`を使用して、このテンソルを実際の動画に変換します。まず出力を異なるモダリティに分割し、その後、各モダリティに対してそれぞれに対応するポストプロセッサーを適用します。 評価時に分類ラベルをマスク（つまり、"label" モダリティにゼロのテンソルを渡す）することで、このオートエンコーディングモデルはKinetics 700の動画分類器として機能することに注意してください。 このモデルは [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.PerceiverForMultimodalAutoencoding.forward]] ```python forward(inputs: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, subsampled_output_points: dict[str, torch.Tensor] | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/perceiver/modeling_perceiver.py#L1692) **パラメータ:** inputs (`torch.Tensor`, *任意*) : perceiverへの入力。画像、テキスト、音声、動画など、何でも構いません。 attention_mask (`torch.Tensor`、shape `(batch_size, sequence_length)`、*任意*) : padding トークンのインデックスに対する attention を回避するためのマスクです。マスクの値は `[0, 1]` から選択されます: - **マスクされない**トークンは 1、- **マスクされる**トークンは 0。 [attention マスクとは?](../glossary#attention-mask) subsampled_output_points (`dict[str, torch.Tensor]`, *任意*) : デコーダーのクエリとして使用されるテンソルの辞書です。デコーダーはこれらのクエリをモデルの潜在表現にマッピングします。サブサンプリングされたデコーディング、例えば特定の画像パッチのみをデコードする場合などに使用されます。 output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 labels (`torch.LongTensor`、shape `(batch_size,)`、*任意*) : 画像分類/回帰の損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。`config.num_labels == 1` の場合は回帰損失（Mean-Square loss）が計算され、`config.num_labels > 1` の場合は分類損失（Cross-Entropy）が計算されます。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 **戻り値:** [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput) または `tuple(torch.FloatTensor)` [PerceiverClassifierOutput](/docs/transformers/main/ja/model_doc/perceiver#transformers.models.perceiver.modeling_perceiver.PerceiverClassifierOutput)、または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。設定（[PerceiverConfig](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverConfig)）と入力に応じて、さまざまな要素で構成されます。 [PerceiverForMultimodalAutoencoding](/docs/transformers/main/ja/model_doc/perceiver#transformers.PerceiverForMultimodalAutoencoding) の 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 の場合は回帰）スコア。 - **hidden_states** (`tuple[torch.FloatTensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple[torch.FloatTensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 - **cross_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 PerceiverForMultimodalAutoencoding >>> import torch >>> import numpy as np >>> # create multimodal inputs >>> images = torch.randn((1, 16, 3, 224, 224)) >>> audio = torch.randn((1, 30720, 1)) >>> inputs = dict(image=images, audio=audio, label=torch.zeros((images.shape[0], 700))) >>> model = PerceiverForMultimodalAutoencoding.from_pretrained("deepmind/multimodal-perceiver") >>> # in the Perceiver IO paper, videos are auto-encoded in chunks >>> # each chunk subsamples different index dimensions of the image and audio modality decoder queries >>> nchunks = 128 >>> image_chunk_size = np.prod((16, 224, 224)) // nchunks >>> audio_chunk_size = audio.shape[1] // model.config.samples_per_patch // nchunks >>> # process the first chunk >>> chunk_idx = 0 >>> subsampling = { ... "image": torch.arange(image_chunk_size * chunk_idx, image_chunk_size * (chunk_idx + 1)), ... "audio": torch.arange(audio_chunk_size * chunk_idx, audio_chunk_size * (chunk_idx + 1)), ... "label": None, ... } >>> outputs = model(inputs=inputs, subsampled_output_points=subsampling) >>> logits = outputs.logits >>> list(logits["audio"].shape) [1, 240] >>> list(logits["image"].shape) [1, 6272, 3] >>> list(logits["label"].shape) [1, 700] ```