# TAPAS ## 概要 TAPASモデルは、Jonathan Herzig、Paweł Krzysztof Nowak、Thomas Müller、Francesco Piccinno、Julian Martin Eisenschlos による [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://huggingface.co/papers/2004.02349) で提案されました。これは、表形式のデータに関する質問に答えるために特化して設計（および事前学習）された BERT ベースのモデルです。BERT と比較して、TAPAS は相対位置埋め込みを使用し、表構造をエンコードする 7 種類のトークンタイプを備えています。TAPAS は、英語版 Wikipedia の数百万の表とそれに対応するテキストからなる大規模なデータセット上で、マスク言語モデリング（MLM）目的に対して事前学習されています。 質問応答において、TAPASは上部に2つのヘッドを備えています。1つはセル選択ヘッド、もう1つは集約ヘッドで、選択されたセルに対して（任意で）集約（カウントや合計など）を実行します。TAPASは複数のデータセットでファインチューニングされています。 - [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253)（MicrosoftによるSequential Question Answering） - [WTQ](https://github.com/ppasupat/WikiTableQuestions)（スタンフォード大学による Wiki Table Questions） - [WikiSQL](https://github.com/salesforce/WikiSQL)(Salesforce 製)。 SQAとWTQの両方で最先端の性能を達成すると同時に、WikiSQLではSOTAと同等の性能を示しており、かつはるかにシンプルなアーキテクチャを備えています。 論文の抄録は以下の通りです。 *表に対する自然言語質問への回答は、通常、セマンティックパースタスクとして扱われます。完全な論理形式の収集コストを軽減するため、論理形式ではなく意味（denotation）からなる弱教師信号に焦点を当てるアプローチが広く用いられています。しかし、弱教師信号からセマンティックパーサーを訓練することは困難を伴い、さらに、生成された論理形式は意味の取得を目的とした中間ステップとしてのみ使用されます。本論文では、論理形式を生成せずに表に対する質問応答を行う手法 TAPAS を提案します。TAPAS は弱教師信号から訓練され、表のセルを選択し、必要に応じてその選択に集約演算子を適用することで意味を予測します。TAPAS は BERT のアーキテクチャを拡張して表を入力としてエンコードし、Wikipedia から収集したテキストセグメントと表の効果的な共同事前学習から初期化され、エンドツーエンドで訓練されます。3 つの異なるセマンティックパースデータセットで実験を行い、TAPAS は SQA における SOTA 精度を 55.1 から 67.2 に向上させることでセマンティックパースモデルを上回るか同等の性能を示し、WIKISQL と WIKITQ においても SOTA と同等の性能を示しながら、よりシンプルなモデルアーキテクチャを実現していることを確認しました。さらに、私たちの設定では自明な WIKISQL から WIKITQ への転移学習により、SOTA を 4.2 ポイント上回る 48.7 の精度が得られることも確認しました。* さらに、著者らは、自動生成された数百万の学習例からなるバランスの取れたデータセットを作成し、ファインチューニング前の中間ステップでこれらを学習させることで、**テーブルエンティルメント**を認識するように TAPAS をさらに事前学習しています。TAPAS の著者らは、このさらなる事前学習を中間事前学習と呼んでいます（TAPAS はまず MLM で事前学習され、その後別のデータセットで事前学習されるためです）。彼らは、中間事前学習により SQA でのパフォーマンスがさらに向上し、新たな SOTA を達成するとともに、テーブルエンティルメント（二値分類タスク）のための 16k の Wikipedia テーブルを含む大規模データセットである [TabFact](https://github.com/wenhuchen/Table-Fact-Checking) においても SOTA を達成したことを発見しました。詳細については、Julian Martin Eisenschlos、Syrine Krichene、Thomas Müller によるフォローアップ論文 [Understanding tables with intermediate pre-training](https://www.aclweb.org/anthology/2020.findings-emnlp.27/) を参照してください。 drawing TAPASアーキテクチャ。元のブログ記事から引用。 このモデルは [nielsr](https://huggingface.co/nielsr) によって提供されました。元のコードは [こちら](https://github.com/google-research/tapas) で確認できます。 ## 使用のコツ - TAPAS は、デフォルトで相対位置埋め込みを使用するモデルです（テーブルの各セルで位置埋め込みをリセットします）。なお、これは元の TAPAS 論文の公開後に追加された機能です。著者によると、これにより通常、わずかに高いパフォーマンスが得られ、埋め込みを使い切ることなくより長いシーケンスをエンコードできるようになるとのことです。これは [TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig) の `reset_position_index_per_cell` パラメータに反映されており、デフォルトでは `True` に設定されています。[hub](https://huggingface.co/models?search=tapas) で利用可能なモデルのデフォルトバージョンはすべて、相対位置埋め込みを使用しています。`from_pretrained()` メソッドを呼び出す際に、追加の引数として `revision="no_reset"` を渡すことで、絶対位置埋め込みを使用するモデルも引き続き利用できます。なお、通常は左側ではなく右側で入力をパディングすることが推奨されています。 - TAPAS は BERT をベースにしているため、例えば `TAPAS-base` は `BERT-base` アーキテクチャに対応します。もちろん、`TAPAS-large` が最高のパフォーマンスを発揮します（論文で報告された結果は `TAPAS-large` のものです）。さまざまなサイズのモデルの結果は、[元の GitHub リポジトリ](https://github.com/google-research/tapas) に掲載されています。 - TAPASにはSQAでファインチューニングされたチェックポイントがあり、会話形式のセットアップでテーブルに関連する質問に回答できます。つまり、「彼の年齢は何歳ですか?」のような、前の質問に関連するフォローアップの質問をすることができます。なお、会話形式のセットアップの場合、TAPASのフォワードパスは少し異なります。その場合、モデルにテーブルと質問のペアを1つずつ与える必要があり、`prev_labels`のトークンタイプIDが、モデルが前の質問に対して予測した`labels`で上書きされるようにします。詳細は「Usage」セクションを参照してください。 - TAPAS は BERT に類似しており、そのためマスク言語モデリング（MLM）の目的関数に依存しています。したがって、マスクされたトークンの予測や NLU 全般では効率的ですが、テキスト生成には最適ではありません。その点については、因果言語モデリング（CLM）の目的関数で訓練されたモデルの方が優れています。なお、TAPAS は EncoderDecoderModel フレームワーク内でエンコーダーとして使用でき、GPT-2 などの自己回帰型テキストデコーダーと組み合わせることができます。 ## 使用法:ファインチューニング ここでは、独自のデータセットで[TapasForQuestionAnswering](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForQuestionAnswering)をファインチューニングする方法を説明します。 **ステップ1: TAPASの3つの利用方法のいずれかを選択するか、実験する** 基本的に、[TapasForQuestionAnswering](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForQuestionAnswering)をファインチューニングする方法は3つあり、Tapasがファインチューニングされた異なるデータセットに対応しています。 1. SQA: テーブルに関連するフォローアップ質問を対話形式で尋ねることに興味がある場合です。例えば、最初に「最初の俳優の名前は何ですか?」と質問した後、「彼はどのくらいの年齢ですか?」のようなフォローアップ質問をすることができます。ここでは、質問には集約が含まれません(すべての質問はセル選択の質問です)。 2. WTQ: 会話的な設定で質問を行うことではなく、テーブルに関連する質問、例えば行数の集計、セル値の合計、セル値の平均など、集計を伴う質問のみを行う場合に使用します。例えば、「クリスティアーノ・ロナウドのキャリアにおける総得点数は？」と質問できます。このケースは**弱教師あり**とも呼ばれ、質問への回答のみを教師信号として与えられた場合でも、モデル自身が適切な集計演算子（SUM/COUNT/AVERAGE/NONE）を学習しなければならないためです。 3. WikiSQL-supervised: このデータセットは WikiSQL に基づいており、学習時にモデルに正解の集約演算子が与えられます。これは **strong supervision**（強監督）とも呼ばれます。ここでは、適切な集約演算子の学習がはるかに容易になります。 まとめると: | **タスク** | **データセットの例** | **説明** | |-------------------------------------|---------------------|---------------------------------------------------------------------------------------------------------| | 会話 | SQA | 対話形式、セル選択のみの質問 | | 集約のための弱教師 | WTQ | 質問には集約が含まれる場合があり、モデルは正解のみを教師信号として与えられた状態で、これを学習する必要があります。 | | 集約のための強力な教師あり | WikiSQL教師あり | 質問には集約が含まれる場合があり、モデルはゴールド集約演算子が与えられた状態で、これを学習する必要があります。 | ハブから事前学習済みのベースモデルと、ランダムに初期化された分類ヘッドでモデルを初期化するには、以下のように行います。 ```python from transformers import TapasConfig, TapasForQuestionAnswering # for example, the base sized model with default SQA configuration model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", device_map="auto") # or, the base sized model with WTQ configuration config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq") model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") # or, the base sized model with WikiSQL configuration config = TapasConfig("google-base-finetuned-wikisql-supervised") model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") ``` もちろん、TAPASがファインチューニングされた3つの方法のいずれかに従う必要はありません。[TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig)を初期化する際に、任意のハイパーパラメータを定義して実験することもできます。その後、その設定に基づいて[TapasForQuestionAnswering](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForQuestionAnswering)を作成します。例えば、対話的な質問と集計を伴う可能性のある質問の両方を含むデータセットを持っている場合、次のように行うことができます。例を以下に示します。 ```python from transformers import TapasConfig, TapasForQuestionAnswering # you can initialize the classification heads any way you want (see docs of TapasConfig) config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True) # initializing the pre-trained base sized model with our custom classification heads model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") ``` もう一つの選択肢として、すでにファインチューニング済みのチェックポイントから始める方法もあります。なお、WTQ上のファインチューニング済みチェックポイントは、L2損失がやや不安定なため、いくつかの問題があります。詳細は[こちら](https://github.com/google-research/tapas/issues/91#issuecomment-735719340)を参照してください。 HuggingFaceのハブで利用可能な事前学習済みおよびファインチューニング済みのTAPASチェックポイントのリストについては、[こちら](https://huggingface.co/models?search=tapas)を参照してください。 **ステップ2: SQA形式でデータを準備する** 第二に、上記で何を選択したかに関わらず、[SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253)形式でデータセットを準備する必要があります。この形式は、以下の列を持つTSV/CSVファイルです。 - `id`: 任意。テーブルと質問のペアの ID。管理目的で使用します。 - `annotator`: 任意。テーブルと質問のペアをアノテーションした人物のIDです。管理目的で使用します。 - `position`: 質問が表に関連する第1、第2、第3のいずれであるかを示す整数。対話形式の設定（SQA）の場合のみ必要です。WTQ/WikiSQLの教師あり学習を行う場合は、この列は不要です。 - `question`: string - `table_file`: string、タブ形式のデータを含む CSV ファイルの名前 - `answer_coordinates`: 1つ以上のタプルのリスト（各タプルはセルの座標、つまり回答の一部である行と列のペア） - `answer_text`: 1 つ以上の文字列のリスト（各文字列は、回答の一部を構成するセルの値） - `aggregation_label`: 集約演算子のインデックス。集約の強教師あり学習（WikiSQL教師ありの場合）でのみ必要です。 - `float_answer`: 質問に対する浮動小数点数の答え（存在しない場合は np.nan）。集約のための弱教師あり学習（WTQ や WikiSQL など）の場合のみ必須です。 テーブル自体はフォルダ内に存在する必要があり、各テーブルは個別のcsvファイルとして保存されます。なお、TAPASアルゴリズムの著者らは、他のデータセット（WTQ、WikiSQL）をSQA形式に変換するために、一部の自動化ロジックを含む変換スクリプトを使用しました。著者による説明は[こちら](https://github.com/google-research/tapas/issues/50#issuecomment-705465960)にあります。HuggingFaceの実装で動作するこのスクリプトの変換版は[こちら](https://github.com/NielsRogge/tapas_utils)で確認できます。興味深いことに、これらの変換スクリプトは完全ではなく（`answer_coordinates`および`float_answer`フィールドは`answer_text`に基づいて設定されています）、WTQおよびWikiSQLの結果は実際により改善できる可能性があります。 **ステップ 3: TapasTokenizer を使用してデータをテンソルに変換する** 第三に、データをこのTSV/CSV形式（および対応する表形式データを含むCSVファイル）で準備した後は、[TapasTokenizer](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasTokenizer)を使用して、テーブルと質問のペアを`input_ids`、`attention_mask`、`token_type_ids`などに変換できます。同様に、上記の3つのケースのいずれを選択したかによって、ファインチューニングに必要となる[TapasForQuestionAnswering](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForQuestionAnswering)への入力が異なります。 | **タスク** | **必須の入力** | |------------------------------------|---------------------------------------------------------------------------------------------------------------------| | 会話 | `input_ids`, `attention_mask`, `token_type_ids`, `labels` | | 集約のための弱教師 | `input_ids`, `attention_mask`, `token_type_ids`, `labels`, `numeric_values`, `numeric_values_scale`, `float_answer` | | 集約のための強力な教師あり | `input ids`, `attention mask`, `token type ids`, `labels`, `aggregation_labels` | [TapasTokenizer](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasTokenizer)は、TSVファイルの`answer_coordinates`列と`answer_text`列に基づいて、`labels`、`numeric_values`、`numeric_values_scale`を作成します。`float_answer`と`aggregation_labels`は、ステップ2のTSVファイルに既に含まれています。以下に例を示します。 ```py from transformers import TapasTokenizer import pandas as pd model_name = "google/tapas-base" tokenizer = TapasTokenizer.from_pretrained(model_name) data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]} queries = [ "What is the name of the first actor?", "How many movies has George Clooney played in?", "What is the total number of movies?", ] answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]] answer_text = [["Brad Pitt"], ["69"], ["209"]] table = pd.DataFrame.from_dict(data) inputs = tokenizer( table=table, queries=queries, answer_coordinates=answer_coordinates, answer_text=answer_text, padding="max_length", return_tensors="pt", ) inputs {'input_ids': tensor([[ ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]), 'numeric_values': tensor([[ ]]), 'numeric_values_scale: tensor([[ ]]), labels: tensor([[ ]])} ``` [TapasTokenizer](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasTokenizer)は、テーブルのデータが**テキストのみ**であることを前提としています。データフレームに対して`.astype(str)`を使用することで、テキストのみのデータに変換できます。もちろん、これは単一の学習例をエンコードする方法を示しているだけです。バッチを反復処理するためにdataloaderを作成することをお勧めします: ```python import pandas as pd import torch tsv_path = "your_path_to_the_tsv_file" table_csv_path = "your_path_to_a_directory_containing_all_csv_files" class TableDataset(torch.utils.data.Dataset): def __init__(self, data, tokenizer): self.data = data self.tokenizer = tokenizer def __getitem__(self, idx): item = data.iloc[idx] table = pd.read_csv(table_csv_path + item.table_file).astype( str ) # be sure to make your table data text only encoding = self.tokenizer( table=table, queries=item.question, answer_coordinates=item.answer_coordinates, answer_text=item.answer_text, truncation=True, padding="max_length", return_tensors="pt", ) # remove the batch dimension which the tokenizer adds by default encoding = {key: val.squeeze(0) for key, val in encoding.items()} # add the float_answer which is also required (weak supervision for aggregation case) encoding["float_answer"] = torch.tensor(item.float_answer) return encoding def __len__(self): return len(self.data) data = pd.read_csv(tsv_path, sep="\t") train_dataset = TableDataset(data, tokenizer) train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=32) ``` ここでは、各テーブルと質問のペアを独立してエンコードしています。データセットが**対話形式でない**限り、この方法で問題ありません。データセットが対話形式の質問（SQAなど）を含む場合は、まずテーブルごとに`queries`、`answer_coordinates`、`answer_text`を`position`インデックスの順序でグループ化し、各テーブルとその質問をバッチでエンコードする必要があります。これにより、`prev_labels`トークンタイプ（[TapasTokenizer](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasTokenizer)のドキュメントを参照）が正しく設定されます。詳細は[このノートブック](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb)を参照してください。 **ステップ 4: モデルの学習（ファインチューニング） その後、[TapasForQuestionAnswering](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForQuestionAnswering) を次のようにファインチューニングできます（ここでは、集約の弱教師あり学習のケースを示します）： ```python from transformers import AdamW, TapasConfig, TapasForQuestionAnswering # this is the default WTQ configuration config = TapasConfig( num_aggregation_labels=4, use_answer_as_supervision=True, answer_loss_cutoff=0.664694, cell_selection_preference=0.207951, huber_loss_delta=0.121194, init_cell_selection_weights_to_zero=True, select_one_column=True, allow_empty_column_selection=False, temperature=0.0352513, ) model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") optimizer = AdamW(model.parameters(), lr=5e-5) model.train() for epoch in range(2): # loop over the dataset multiple times for batch in train_dataloader: # get the inputs; input_ids = batch["input_ids"] attention_mask = batch["attention_mask"] token_type_ids = batch["token_type_ids"] labels = batch["labels"] numeric_values = batch["numeric_values"] numeric_values_scale = batch["numeric_values_scale"] float_answer = batch["float_answer"] # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = model( input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, labels=labels, numeric_values=numeric_values, numeric_values_scale=numeric_values_scale, float_answer=float_answer, ) loss = outputs.loss loss.backward() optimizer.step() ``` ## 使用法: 推論 ここでは、[TapasForQuestionAnswering](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForQuestionAnswering) を推論（つまり、新しいデータに対する予測）に使用する方法を説明します。推論を行う場合、モデルに `input_ids`、`attention_mask`、`token_type_ids`（[TapasTokenizer](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasTokenizer) を使用して取得できます）を渡すだけで logits を得られます。次に、便利な `~models.tapas.tokenization_tapas.convert_logits_to_predictions` メソッドを使用して、これらを予測された座標および任意の集約インデックスに変換できます。 ただし、セットアップが対話型かどうかによって、推論は**異なる**点に注意してください。非対話型のセットアップでは、バッチ内のすべてのテーブルと質問のペアに対して並列で推論を実行できます。その例を以下に示します。 ```py from transformers import TapasTokenizer, TapasForQuestionAnswering import pandas as pd model_name = "google/tapas-base-finetuned-wtq" model = TapasForQuestionAnswering.from_pretrained(model_name, device_map="auto") tokenizer = TapasTokenizer.from_pretrained(model_name) data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]} queries = [ "What is the name of the first actor?", "How many movies has George Clooney played in?", "What is the total number of movies?", ] table = pd.DataFrame.from_dict(data) inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt").to(model.device) outputs = model(**inputs) predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions( inputs, outputs.logits.detach(), outputs.logits_aggregation.detach() ) # let's print out the results: id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"} aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices] answers = [] for coordinates in predicted_answer_coordinates: if len(coordinates) == 1: # only a single cell: answers.append(table.iat[coordinates[0]]) else: # multiple cells cell_values = [] for coordinate in coordinates: cell_values.append(table.iat[coordinate]) answers.append(", ".join(cell_values)) display(table) print("") for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string): print(query) if predicted_agg == "NONE": print("Predicted answer: " + answer) else: print("Predicted answer: " + predicted_agg + " > " + answer) What is the name of the first actor? Predicted answer: Brad Pitt How many movies has George Clooney played in? Predicted answer: COUNT > 69 What is the total number of movies? Predicted answer: SUM > 87, 53, 69 ``` 対話形式のセットアップの場合、各テーブルと質問のペアを**順番に**モデルに提供する必要があります。これにより、`prev_labels`トークンタイプが、直前のテーブルと質問のペアの予測された`labels`で上書きされるようになります。詳細は[このノートブック](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb)を参照してください。 ## リソース - [テキスト分類タスクガイド](../tasks/sequence_classification) - [マスクド言語モデリングタスクのガイド](../tasks/masked_language_modeling) ## TAPAS固有の出力[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] #### transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] ```python transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput(loss: typing.Optional[torch.FloatTensor] = None, logits: typing.Optional[torch.FloatTensor] = None, logits_aggregation: typing.Optional[torch.FloatTensor] = None, hidden_states: tuple[torch.FloatTensor] | None = None, attentions: tuple[torch.FloatTensor] | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L49) **パラメータ:** loss (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels`（および場合によっては `answer`、`aggregation_labels`、`numeric_values`、`numeric_values_scale`）が提供された場合に返されます）: 階層的セル選択の対数尤度損失と、（任意で）半教師あり回帰損失、および（任意で）集約の教師あり損失の合計としての総損失。 logits (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`) : セル選択ヘッドによる、各トークンに対する予測スコア。 logits_aggregation (`torch.FloatTensor`, *任意*, 形状 `(batch_size, num_aggregation_labels)`) : 集約オペレータごとの集約ヘッドの予測スコア。 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 後のアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。 [TapasForQuestionAnswering](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForQuestionAnswering)の出力型。 ## TapasConfig[[transformers.TapasConfig]] #### transformers.TapasConfig[[transformers.TapasConfig]] ```python transformers.TapasConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 1024, type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10), initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, positive_label_weight: float = 10.0, num_aggregation_labels: int = 0, aggregation_loss_weight: float = 1.0, use_answer_as_supervision: bool | None = None, answer_loss_importance: float = 1.0, use_normalized_answer_loss: bool = False, huber_loss_delta: float | None = None, temperature: float = 1.0, aggregation_temperature: float = 1.0, use_gumbel_for_cells: bool = False, use_gumbel_for_aggregation: bool = False, average_approximation_function: str = 'ratio', cell_selection_preference: float | None = None, answer_loss_cutoff: float | int | None = None, max_num_rows: int = 64, max_num_columns: int = 32, average_logits_per_cell: bool = False, select_one_column: bool = True, allow_empty_column_selection: bool = False, init_cell_selection_weights_to_zero: bool = False, reset_position_index_per_cell: bool = True, disable_per_token_loss: bool = False, aggregation_labels: dict | None = None, no_aggregation_label_index: int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, tie_word_embeddings: bool = True) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/configuration_tapas.py#L32) **パラメータ:** vocab_size (`int`、*任意*、デフォルトは`30522`) : モデルの語彙サイズ。`input_ids`で表現できるトークンの種類数を定義します。 hidden_size (`int`、*任意*、デフォルトは`768`) : 隠れ表現の次元数。 num_hidden_layers (`int`, *任意*, デフォルトは `12`) : Transformer デコーダーの隠れ層の数。 num_attention_heads (`int`、*任意*、デフォルトは `12`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。 intermediate_size (`int`、*任意*、デフォルトは `3072`) : MLP 表現の次元数。 hidden_act (`str`、*任意*、デフォルトは`gelu`) : デコーダーで使用する非線形活性化関数（関数または文字列）。例えば、`"gelu"`、`"relu"`、`"silu"`など。 hidden_dropout_prob (`Union[float, int]`、*任意*、デフォルト値は`0.1`) : embeddings、encoder、pooler 内のすべての全結合層における dropout 確率。 attention_probs_dropout_prob (`Union[float, int]`、*任意*、デフォルトは`0.1`) : 注意確率のドロップアウト率。 max_position_embeddings (`int`、*任意*、デフォルトは`1024`) : このモデルが使用される可能性のある最大シーケンス長。 type_vocab_sizes (`list[int]`、*任意*、デフォルトは`[3, 256, 256, 2, 256, 256, 10]`) : [TapasModel](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasModel)を呼び出す際に渡される`token_type_ids`の語彙サイズです。 initializer_range (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。 layer_norm_eps (`float`、*任意*、デフォルトは `1e-12`) : layer normalization レイヤーで使用する epsilon。 pad_token_id (`int`, *任意*, デフォルトは `0`) : 語彙内でパディングに使用されるトークン ID。 bos_token_id (`int`, *任意*) : 語彙内でストリームの開始に使用されるトークン ID。 eos_token_id (`Union[int, list[int]]`、*任意*) : 語彙内でストリームの終了に使用されるトークン ID。 positive_label_weight (`float`、*任意*、デフォルト値は 10.0) : 正ラベルの重み。 num_aggregation_labels (`int`、*optional*、デフォルトは 0) : 予測する集約演算子の数。 aggregation_loss_weight (`float`、*任意*、デフォルトは 1.0) : 集約損失の重要度重み。 use_answer_as_supervision (`bool`, *任意*) : 集約の例に対して、回答のみを教師信号として使用するかどうか。 answer_loss_importance (`float`、*任意*、デフォルトは 1.0) : 回帰損失の重要度重み。 use_normalized_answer_loss (`bool`、*任意*、デフォルトは`False`) : 予測値と期待値の最大値で答えの損失を正規化するかどうか。 huber_loss_delta (`float`, *任意*) : 回帰損失を計算するために使用されるデルタパラメータ。 temperature (`float`、*optional*、デフォルトは 1.0) : セル logits の確率の歪みを制御（または変更）するために使用される値。 aggregation_temperature (`float`、*optional*、デフォルト値は 1.0) : 確率の歪みを制御するために、集約ロジットをスケーリングします。 use_gumbel_for_cells (`bool`, *任意*, デフォルトは `False`) : セル選択に Gumbel-Softmax を適用するかどうか。 use_gumbel_for_aggregation (`bool`, *任意*, デフォルトは `False`) : 集約選択に Gumbel-Softmax を適用するかどうか。 average_approximation_function (`string`、*任意*、デフォルトは`"ratio"`) : 弱教師あり学習の場合、セルの期待平均を計算する方法。`"ratio"`、`"first_order"`、または`"second_order"`のいずれかです。 cell_selection_preference (`float`, *optional*) : 曖昧なケースにおけるセル選択の優先度。集約の弱教師あり学習（WTQ、WikiSQL）の場合にのみ適用されます。集約確率の総質量（"NONE"演算子を除外）がこのハイパーパラメータより大きい場合、その例に対して集約が予測されます。 answer_loss_cutoff (`float`, *任意*) : 損失が cutoff を超えるサンプルを無視します。 max_num_rows (`int`、*任意*、デフォルトは 64) : 最大行数。 max_num_columns (`int`、*任意*、デフォルトは 32) : 最大列数。 average_logits_per_cell (`bool`, *任意*, デフォルトは `False`) : セルごとに logits を平均するかどうか。 select_one_column (`bool`、*任意*、デフォルトは`True`) : モデルが単一の列からのセルのみを選択するように制約をかけるかどうか。 allow_empty_column_selection (`bool`, *任意*, デフォルトは `False`) : どの列も選択しないことを許可するかどうか。 init_cell_selection_weights_to_zero (`bool`、*任意*、デフォルトは`False`) : セル選択の重みを 0 に初期化して、初期確率が 50% になるようにするかどうか。 reset_position_index_per_cell (`bool`、*任意*、デフォルトは`True`) : 各セルで位置インデックスをリスタートするかどうか（つまり、相対位置埋め込みを使用するかどうか）。 disable_per_token_loss (`bool`, *任意*, デフォルトは `False`) : セルに対する（強い・弱い）いずれかのスーパービジョンを無効にするかどうか。 aggregation_labels (`dict[int, label]`, *任意*) : 結果を集約するために使用される集約ラベルです。例えば、WTQモデルには次のような集約ラベルがあります: `{0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}` no_aggregation_label_index (`int`, *optional*) : 集約ラベルが定義されており、その中の1つが「集約なし」を表す場合、そのインデックスを設定する必要があります。例えば、WTQモデルでは「NONE」集約ラベルがインデックス0にあり、これらのモデルではその値を0に設定します。 is_decoder (`bool`, *任意*, デフォルトは `False`) : モデルがデコーダーとして使用されるかどうかを指定します。`False` の場合、モデルはエンコーダーとして使用されます。 add_cross_attention (`bool`、*任意*、デフォルトは`False`) : モデルにクロスアテンション層を追加するかどうか。 tie_word_embeddings (`bool`、*任意*、デフォルトは`True`) : モデルの`tied_weights_keys`マッピングに従って重み埋め込みを共有するかどうか。 これはTapasModelの設定を保存するための設定クラスです。指定された引数に基づいてTapasモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[google/tapas-base-finetuned-sqa](https://huggingface.co/google/tapas-base-finetuned-sqa) と同様の設定が得られます。 設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。 例: ```python >>> from transformers import TapasModel, TapasConfig >>> # Initializing a default (SQA) Tapas configuration >>> configuration = TapasConfig() >>> # Initializing a model from the configuration >>> model = TapasModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## TapasTokenizer[[transformers.TapasTokenizer]] #### transformers.TapasTokenizer[[transformers.TapasTokenizer]] ```python transformers.TapasTokenizer(vocab_file, do_lower_case = True, do_basic_tokenize = True, never_split = None, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', empty_token = '[EMPTY]', tokenize_chinese_chars = True, strip_accents = None, cell_trim_length: int = -1, max_column_id: int | None = None, max_row_id: int | None = None, strip_column_names: bool = False, update_answer_coordinates: bool = False, min_question_length = None, max_question_length = None, model_max_length: int = 512, additional_special_tokens: list[str] | None = None, clean_up_tokenization_spaces = True, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L149) **パラメータ:** vocab_file (`str`) : 語彙を含むファイル。 do_lower_case (`bool`、*任意*、デフォルトは `True`) : トークン化時に、入力を小文字にするかどうか。 do_basic_tokenize (`bool`、*任意*、デフォルトは`True`) : WordPieceの前に基本的なトークン化を行うかどうか。 never_split (`Iterable`、*任意*) : トークナイズ中に分割されないトークンのコレクション。`do_basic_tokenize=True` の場合のみ有効です。 unk_token (`str`、*任意*、デフォルトは `"[UNK]"`) : 不明トークン。語彙に存在しないトークンは ID に変換できず、代わりにこのトークンが設定されます。 sep_token (`str`、*任意*、デフォルトは `"[SEP]"`) : 区切りトークンです。複数のシーケンスからシーケンスを構築する際に使用されます。例えば、シーケンス分類では2つのシーケンス、質問応答ではテキストと質問です。また、特殊トークンを用いて構築されたシーケンスの最後のトークンとしても使用されます。 pad_token (`str`、*任意*、デフォルトは `"[PAD]"`) : パディングに使用されるトークンです。長さの異なるシーケンスをバッチ処理する場合などに使用します。 cls_token (`str`、*任意*、デフォルトは`"[CLS]"`) : シーケンス分類（トークンごとの分類ではなく、シーケンス全体に対する分類）を行う際に使用される分類トークンです。特殊トークンを用いて構築された場合、シーケンスの最初のトークンになります。 mask_token (`str`、*任意*、デフォルトは `"[MASK]"`) : 値をマスクするために使用されるトークン。これは、マスク言語モデリングでこのモデルをトレーニングする際に使用されるトークンです。モデルが予測しようとするトークンです。 empty_token (`str`、*任意*、デフォルトは`"[EMPTY]"`) : テーブル内の空のセル値に使用されるトークン。空のセル値には、""、"n/a"、"nan"、"?"が含まれます。 tokenize_chinese_chars (`bool`、*任意*、デフォルトは`True`) : 中国語の文字をトークナイズするかどうか。日本語では無効にするのが望ましいです（この[issue](https://github.com/huggingface/transformers/issues/328)を参照）。 strip_accents (`bool`, *任意*) : アクセントをすべて除去するかどうか。このオプションが指定されない場合、`lowercase` の値によって決定されます（元の BERT と同じ）。 cell_trim_length (`int`, *optional*, デフォルトは -1) : 0 より大きい場合: セルの長さがこの値以下になるようにトリムします。また、これ以降のセルのトリムを無効にするため、`truncation` を `True` に設定して使用すべきです。 max_column_id (`int`, *任意*) : 抽出する最大のカラムID。 max_row_id (`int`, *任意*) : 抽出する最大行ID。 strip_column_names (`bool`、*任意*、デフォルトは`False`) : 列名ではなく空の文字列を追加するかどうか。 update_answer_coordinates (`bool`、*任意*、デフォルトは`False`) : 回答テキストから回答の座標を再計算するかどうか。 min_question_length (`int`, *optional*) : 各質問のトークン数における最小長（これ未満の場合はスキップされます）。 max_question_length (`int`, *optional*) : 各質問のトークン数による最大長（これを超える場合はスキップされます）。 clean_up_tokenization_spaces (`bool`、*任意*、デフォルトは`True`) : デコード後にスペースをクリーンアップするかどうか。クリーンアップとは、余分なスペースなどの潜在的なアーティファクトを削除することを指します。 TAPAS トークナイザーを構築します。WordPiece に基づいています。TAPAS モデルで使用するために、テーブルと関連する1文以上の文をフラット化します。 このトークナイザーは、ほとんどの主要なメソッドを含む[PreTrainedTokenizer](/docs/transformers/main/ja/main_classes/tokenizer#transformers.PythonBackend)を継承しています。これらのメソッドに関する詳細は、このスーパークラスを参照してください。[TapasTokenizer](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasTokenizer)は、表構造をエンコードするために複数のトークンタイプIDを作成します。より正確には、以下の順序で7つのトークンタイプIDを追加します:`segment_ids`、`column_ids`、`row_ids`、`prev_labels`、`column_ranks`、`inv_column_ranks`、`numeric_relations`: - segment_ids: トークンが質問（0）に属するかテーブル（1）に属するかを示します。特殊トークンとパディングには0を指定します。 - column_ids: トークンがテーブルのどの列に属するかを示します（1から始まります）。すべての質問トークン、特殊トークン、パディングでは0です。 - row_ids: トークンがテーブルのどの行に属するかを示します（1から始まります）。すべての質問トークン、特殊トークン、パディングでは0です。列ヘッダーのトークンも0です。 - prev_labels: 前の質問への回答（の一部）であったトークンかどうかを示します（1: 該当、0: 非該当）。SQAのような対話形式のセットアップで有用です。 - column_ranks: 該当する場合、テーブル内のトークンがその列において持つ順位を示します。例えば、値が87、53、69の列「number of movies」がある場合、これらのトークンの列順位はそれぞれ3、1、2となります。質問トークン、特殊トークン、パディングにはすべて0を指定します。 - inv_column_ranks: indicate the inverse rank of a table token relative to a column, if applicable. For example, if you have a column "number of movies" with values 87, 53 and 69, then the inverse column ranks of these tokens are 1, 3 and 2 respectively. 0 for all question tokens, special tokens and padding. - numeric_relations: 質問とテーブルのトークン間の数値関係を示します。すべての質問トークン、特殊トークン、およびパディングに対しては 0 です。 [TapasTokenizer](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasTokenizer)は、テーブルと関連する文に対して、句読点の分割やwordpieceを含むエンドツーエンドのトークン化を実行します。 #### __call__[[transformers.TapasTokenizer.__call__]] ```python __call__(table: typing.Union[ForwardRef('pd.DataFrame'), str, list[str], NoneType], queries: str | list[str] | list[int] | list[list[str]] | list[list[int]] | None = None, answer_coordinates: list[tuple] | list[list[tuple]] | None = None, answer_text: list[str] | list[list[str]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.models.tapas.tokenization_tapas.TapasTruncationStrategy = False, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L518) **パラメータ:** table (`pd.DataFrame` または `str` または `list[str]`) : 表形式のデータを含むテーブル。すべてのセルの値がテキストである必要があります。Pandas のデータフレームを文字列に変換するには、*.astype(str)* を使用してください。文字列または文字列のリストを渡した場合、それらは空のテーブルを持つクエリとして解釈されます（汎用的なトークナイザーのテストをサポートするため）。 queries (`str` または `list[str]`) : エンコード対象のテーブルに関連する質問、または質問のバッチです。バッチの場合、すべての質問は**同じ**テーブルを指している必要があります。 answer_coordinates (`list[Tuple]` または `list[list[Tuple]]`、*任意*) : バッチ内の各テーブルと質問のペアに対する回答の座標です。テーブルと質問のペアが1つだけ提供される場合、answer_coordinates は1つ以上のタプルからなる単一のリストでなければなりません。各タプルは (row_index, column_index) のペアでなければなりません。最初のデータ行（列ヘッダー行ではない）のインデックスは 0 です。最初の列のインデックスは 0 です。テーブルと質問のペアのバッチが提供される場合、answer_coordinates はタプルのリストのリストでなければなりません（各リストは単一のテーブルと質問のペアに対応します）。 answer_text (`list[str]` または `list[list[str]]`、*任意*) : バッチ内の各テーブルと質問のペアに対する回答テキストです。テーブルと質問のペアが1つだけ提供される場合、answer_text は1つ以上の文字列からなる単一のリストでなければなりません。各文字列は、対応する回答座標の回答テキストでなければなりません。テーブルと質問のペアのバッチが提供される場合、answer_coordinates は文字列のリストのリストでなければなりません（各リストは単一のテーブルと質問のペアに対応します）。 add_special_tokens (`bool`、*任意*、デフォルトは`True`) : モデルに相対的な特殊トークンを用いてシーケンスをエンコードするかどうか。 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`または`TapasTruncationStrategy`、*optional*、デフォルトは`False`) : トランケーションを有効化し、制御します。以下の値を受け取ります: - `True`または`'drop_rows_to_fit'`: 引数`max_length`で指定された最大長、またはその引数が提供されていない場合はモデルが許容する最大入力長まで、行単位で切り詰め、テーブルから行を削除します。 - `False`または`'do_not_truncate'`（デフォルト）: トランケーションを行いません（つまり、モデルが許容する最大入力サイズを超えるシーケンス長を持つバッチを出力する可能性があります）。 max_length (`int`, *optional*) : 切り詰め/パディングパラメータのいずれかによって使用される最大長を制御します。 未設定のまま、または `None` に設定されている場合、切り詰め/パディングパラメータのいずれかが最大長を必要とする場合、事前に定義されたモデルの最大長が使用されます。 モデルに特定の最大入力長がない場合（XLNet など）、最大長への切り詰め/パディングは無効になります。 is_split_into_words (`bool`、*任意*、デフォルトは `False`) : 入力がすでに事前トークン化済み（例：単語に分割済み）かどうかを示します。`True` に設定すると、トークナイザーは入力がすでに単語に分割済み（たとえば空白で分割済み）であると仮定し、それをトークン化します。これは NER やトークン分類に有用です。 pad_to_multiple_of (`int`, *optional*) : 設定すると、シーケンスを指定された値の倍数にパディングします。これは、計算能力が `>= 7.5` (Volta) の NVIDIA ハードウェア上で Tensor Cores を使用可能にするために特に有用です。 return_tensors (`str` または [TensorType](/docs/transformers/main/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、Python の整数のリストではなくテンソルを返します。指定可能な値は以下の通りです。 - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: Numpy の `np.ndarray` オブジェクトを返します。 テーブルに関連する1つ以上のシーケンスをトークナイズし、モデル用に準備するための主要なメソッドです。 #### convert_logits_to_predictions[[transformers.TapasTokenizer.convert_logits_to_predictions]] ```python convert_logits_to_predictions(data, logits, logits_agg = None, cell_classification_threshold = 0.5) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L1885) **パラメータ:** data (`dict`) : 特徴量を実際の値にマッピングする辞書。[TapasTokenizer](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasTokenizer)を使用して作成する必要があります。 logits (`torch.Tensor`、形状 `(batch_size, sequence_length)`) : トークンレベルのlogitsを含むTensor。 logits_agg (`torch.Tensor`、形状 `(batch_size, num_aggregation_labels)`、*任意*) : 集約ロジスティックを含むテンソル。 cell_classification_threshold (`float`、*optional*、デフォルト値は 0.5) : セル選択に使用される閾値です。この閾値より確率が高いすべてのテーブルセルが選択されます。 **戻り値:** 入力に応じてさまざまな要素を含む`tuple` - predicted_answer_coordinates (`list[list[[tuple]]`、長さ `batch_size`): 予測された回答の座標を、タプルのリストのリストとして返します。リストの各要素は、バッチ内の1つのサンプルの予測された回答の座標を、タプルのリストとして保持します。各タプルはセル、つまり (行インデックス, 列インデックス) です。 - predicted_aggregation_indices (`list[int]`、長さ `batch_size`、*任意*、`logits_aggregation` が指定された場合に返されます): 集約ヘッドの予測された集約演算子のインデックス。 [TapasForQuestionAnswering](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForQuestionAnswering)のlogitsを実際の予測された回答の座標および任意の集約インデックスに変換します。 この関数のベースとなっている元の実装は、[こちら](https://github.com/google-research/tapas/blob/4908213eb4df7aa988573350278b44c4dbe3f71b/tapas/experiments/prediction_utils.py#L288)で確認できます。 #### save_vocabulary[[transformers.TapasTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L386) ## TapasModel[[transformers.TapasModel]] #### transformers.TapasModel[[transformers.TapasModel]] ```python transformers.TapasModel(config: TapasConfig, add_pooling_layer = True) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L510) **パラメータ:** config ([TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 add_pooling_layer (`bool`、*任意*、デフォルトは`True`) : プーリング層を追加するかどうか 特定のヘッドを上に載せずに、生のhidden-statesを出力する素のTapas Model。 このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。 このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、PyTorchのドキュメントを参照してください。 #### forward[[transformers.TapasModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, encoder_hidden_states: typing.Optional[torch.FloatTensor] = None, encoder_attention_mask: typing.Optional[torch.FloatTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L543) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids) attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、**マスクされる**トークンは 0。 [アテンションマスクとは?](../glossary#attention-mask) token_type_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length, 7)`、*任意*) : 表形式の構造をエンコードするトークンインデックスです。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細はこのクラスを参照してください。 [トークンタイプIDとは何ですか？](../glossary#token-type-ids) position_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。[TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig) の `reset_position_index_per_cell` が `True` に設定されている場合、相対位置埋め込みが使用されます。範囲 `[0, config.max_position_embeddings - 1]` から選択されます。 [位置IDとは何ですか？](../glossary#position-ids) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 encoder_hidden_states (`torch.FloatTensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : エンコーダーの最終層の出力における隠れ状態のシーケンス。モデルがデコーダーとして設定されている場合、クロスアテンションで使用されます。 encoder_attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : エンコーダー入力の padding トークンインデックスに対する attention を回避するためのマスクです。モデルがデコーダーとして設定されている場合、このマスクは cross-attention に使用されます。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、 - **マスクされる**トークンは 0。 output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 **戻り値:** [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `tuple(torch.FloatTensor)` 設定（[TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig)）と入力に応じて、さまざまな要素で構成される [BaseModelOutputWithPooling](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 [TapasModel](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **last_hidden_state** (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`) -- モデルの最終層の出力における隠れ状態のシーケンス。 - **pooler_output** (`torch.FloatTensor`、shape `(batch_size, hidden_size)`) -- 補助事前学習タスクに使用される層をさらに通して処理された後、シーケンスの最初のトークン（分類トークン）の最終層の隠れ状態です。例えば、BERT 系のモデルでは、線形層と tanh 活性化関数を経て処理された後の分類トークンを返します。この線形層の重みは、事前学習中の次文予測（分類）目的から学習されます。 - **hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.FloatTensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 例: ```python >>> from transformers import AutoTokenizer, TapasModel >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base") >>> model = TapasModel.from_pretrained("google/tapas-base") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state ``` ## TapasForMaskedLM[[transformers.TapasForMaskedLM]] #### transformers.TapasForMaskedLM[[transformers.TapasForMaskedLM]] ```python transformers.TapasForMaskedLM(config: TapasConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L660) **パラメータ:** config ([TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 `language modeling`ヘッドを備えたTapasモデル。 このモデルは [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.TapasForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, encoder_hidden_states: typing.Optional[torch.FloatTensor] = None, encoder_attention_mask: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L684) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids) attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、**マスクされる**トークンは 0。 [アテンションマスクとは?](../glossary#attention-mask) token_type_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length, 7)`、*任意*) : 表形式の構造をエンコードするトークンインデックスです。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細はこのクラスを参照してください。 [トークンタイプIDとは何ですか？](../glossary#token-type-ids) position_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。[TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig) の `reset_position_index_per_cell` が `True` に設定されている場合、相対位置埋め込みが使用されます。範囲 `[0, config.max_position_embeddings - 1]` から選択されます。 [位置IDとは何ですか？](../glossary#position-ids) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 encoder_hidden_states (`torch.FloatTensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : エンコーダーの最終層の出力における隠れ状態のシーケンス。モデルがデコーダーとして設定されている場合、クロスアテンションで使用されます。 encoder_attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : エンコーダー入力の padding トークンインデックスに対する attention を回避するためのマスクです。モデルがデコーダーとして設定されている場合、このマスクは cross-attention に使用されます。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、 - **マスクされる**トークンは 0。 labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*optional*) : マスク付き言語モデリング損失を計算するためのラベル。インデックスは `[-100, 0, ..., config.vocab_size]` の範囲である必要があります（`input_ids` の docstring を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲のラベルを持つトークンに対してのみ計算されます。 output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 **戻り値:** [MaskedLMOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) または `tuple(torch.FloatTensor)` 設定（[TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig)）と入力に応じて、さまざまな要素で構成される、[MaskedLMOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.MaskedLMOutput)または`torch.FloatTensor`のタプル（`return_dict=False`が渡された場合、または`config.return_dict=False`の場合）。 [TapasForMaskedLM](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForMaskedLM) の 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` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 例: ```python >>> from transformers import AutoTokenizer, TapasForMaskedLM >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base") >>> model = TapasForMaskedLM.from_pretrained("google/tapas-base") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> inputs = tokenizer( ... table=table, queries="How many [MASK] has George [MASK] played in?", return_tensors="pt" ... ) >>> labels = tokenizer( ... table=table, queries="How many movies has George Clooney played in?", return_tensors="pt" ... )["input_ids"] >>> outputs = model(**inputs, labels=labels) >>> logits = outputs.logits ``` ## TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] #### transformers.TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] ```python transformers.TapasForSequenceClassification(config: TapasConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L1119) **パラメータ:** config ([TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 シーケンス分類ヘッド（プーリングされた出力の上に線形層を配置したもの）を備えたTapasモデル。例えば、TabFact（Chen et al., 2020）のようなテーブルエンタイルメントタスクに使用できます。 このモデルは [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.TapasForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L1131) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids) attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、**マスクされる**トークンは 0。 [アテンションマスクとは?](../glossary#attention-mask) token_type_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length, 7)`、*任意*) : 表形式の構造をエンコードするトークンインデックスです。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細はこのクラスを参照してください。 [トークンタイプIDとは何ですか？](../glossary#token-type-ids) position_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。[TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig) の `reset_position_index_per_cell` が `True` に設定されている場合、相対位置埋め込みが使用されます。範囲 `[0, config.max_position_embeddings - 1]` から選択されます。 [位置IDとは何ですか？](../glossary#position-ids) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 labels (`torch.LongTensor`、形状 `(batch_size,)`、*任意*) : シーケンス分類/回帰の損失を計算するためのラベル。インデックスは `[0, ..., config.num_labels - 1]` の範囲である必要があります。`config.num_labels == 1` の場合は回帰損失（平均二乗誤差）が計算され、`config.num_labels > 1` の場合は分類損失（クロスエントロピー）が計算されます。注: 元の実装では "classification_class_index" と呼ばれています。 output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 **戻り値:** [SequenceClassifierOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) または `tuple(torch.FloatTensor)` 設定（[TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig)）と入力に応じて、さまざまな要素で構成される、[SequenceClassifierOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 [TapasForSequenceClassification](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForSequenceClassification)の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` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用が 1 つ、各層の出力用が 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。 各層の出力におけるモデルのHidden-states、および任意の初期埋め込み出力。 - **attentions** (`tuple(torch.FloatTensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.FloatTensor` のタプル（各レイヤーごとに1つ）で、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。 アテンションのsoftmax後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 例: ```python >>> from transformers import AutoTokenizer, TapasForSequenceClassification >>> import torch >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-tabfact") >>> model = TapasForSequenceClassification.from_pretrained("google/tapas-base-finetuned-tabfact") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = [ ... "There is only one actor who is 45 years old", ... "There are 3 actors which played in more than 60 movies", ... ] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> labels = torch.tensor([1, 0]) # 1 means entailed, 0 means refuted >>> outputs = model(**inputs, labels=labels) >>> loss = outputs.loss >>> logits = outputs.logits ``` ## TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] #### transformers.TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] ```python transformers.TapasForQuestionAnswering(config: TapasConfig) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L781) **パラメータ:** config ([TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。 形式の質問応答タスク（SQA、WTQ、WikiSQLの教師ありタスクなど）向けに、セル選択ヘッドと任意の集約ヘッドを備えたTapasモデル（隠れ状態の出力上に線形層を配置して`logits`および任意の`logits_aggregation`を計算する）。 このモデルは [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.TapasForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.FloatTensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, table_mask: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, aggregation_labels: typing.Optional[torch.LongTensor] = None, float_answer: typing.Optional[torch.FloatTensor] = None, numeric_values: typing.Optional[torch.FloatTensor] = None, numeric_values_scale: typing.Optional[torch.FloatTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L804) **パラメータ:** input_ids (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*任意*) : 語彙における入力シーケンスのトークンインデックスです。デフォルトでは、パディングは無視されます。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細については、[PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。 [入力IDとは何ですか？](../glossary#input-ids) attention_mask (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`、*任意*) : パディングトークンのインデックスに対してアテンションを実行しないためのマスク。`[0, 1]` から選択されるマスクの値: - **マスクされない**トークンは 1、**マスクされる**トークンは 0。 [アテンションマスクとは?](../glossary#attention-mask) token_type_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length, 7)`、*任意*) : 表形式の構造をエンコードするトークンインデックスです。インデックスは [AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。詳細はこのクラスを参照してください。 [トークンタイプIDとは何ですか？](../glossary#token-type-ids) position_ids (`torch.LongTensor`、形状 `(batch_size, sequence_length)`、*任意*) : 各入力シーケンスのトークンが位置埋め込み内で占める位置のインデックス。[TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig) の `reset_position_index_per_cell` が `True` に設定されている場合、相対位置埋め込みが使用されます。範囲 `[0, config.max_position_embeddings - 1]` から選択されます。 [位置IDとは何ですか？](../glossary#position-ids) inputs_embeds (`torch.FloatTensor`、shape `(batch_size, sequence_length, hidden_size)`、*任意*) : `input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込み参照行列よりも、`input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。 table_mask (`torch.LongTensor`、形状 `(batch_size, seq_length)`、*任意*) : テーブル用のマスク。どのトークンがテーブルに属するかを示します（1）。質問トークン、テーブルヘッダー、パディングは 0 です。 labels (`torch.LongTensor`、shape `(batch_size, seq_length)`、*任意*) : 階層的セル選択損失を計算するためのトークンごとのラベル。これは、テーブル内で答えが出現する位置をエンコードします。[AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。 **答えの一部である**トークンは -1、**答えの一部ではない**トークンは -0 です。 aggregation_labels (`torch.LongTensor`、形状 `(batch_size, )`、*任意*) : 集約損失を計算するための、バッチ内の各サンプルに対する集約関数のインデックス。インデックスは `[0, ..., config.num_aggregation_labels - 1]` の範囲である必要があります。集約の強教師あり学習（WikiSQL-supervised）の場合のみ必要です。 float_answer (`torch.FloatTensor`、shape `(batch_size, )`、*optional*) : バッチ内の各例に対するFloatの回答。セル選択問題の場合は *float('nan')* に設定します。弱教師あり（WTQ）の場合のみ、アグリゲートマスクと回帰損失を計算するために必要です。 numeric_values (`torch.FloatTensor`、形状 `(batch_size, seq_length)`、*任意*) : 各トークンの数値。数値でないトークンは NaN になります。[AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。アグリゲーション（WTQ）における弱教師あり学習の場合、回帰損失を計算するためにのみ必要です。 numeric_values_scale (`torch.FloatTensor`、形状 `(batch_size, seq_length)`、*任意*) : 各トークンの数値のスケール。[AutoTokenizer](/docs/transformers/main/ja/model_doc/auto#transformers.AutoTokenizer) を使用して取得できます。アグリゲーション（WTQ）における弱教師あり学習の場合、回帰損失を計算するためにのみ必要です。 output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。 output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。 return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。 **戻り値:** [TableQuestionAnsweringOutput](/docs/transformers/main/ja/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) または `tuple(torch.FloatTensor)` 設定（[TapasConfig](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasConfig)）や入力に応じて、さまざまな要素で構成される、[TableQuestionAnsweringOutput](/docs/transformers/main/ja/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。 [TapasForQuestionAnswering](/docs/transformers/main/ja/model_doc/tapas#transformers.TapasForQuestionAnswering)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。 この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。 - **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels`（および場合によっては`answer`、`aggregation_labels`、`numeric_values`、`numeric_values_scale`）が提供された場合に返されます） -- 階層的セル選択の対数尤度損失と、（任意で）半教師あり回帰損失、および（任意で）集約の教師あり損失の合計として計算される総損失。 - **logits** (`torch.FloatTensor`、形状 `(batch_size, sequence_length)`) -- セル選択ヘッドによる、各トークンに対する予測スコア。 - **logits_aggregation** (`torch.FloatTensor`、*optional*、形状 `(batch_size, num_aggregation_labels)`) -- 集約オペレータごとの集約ヘッドの予測スコア。 - **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後のアテンション重み。自己アテンションヘッド内で加重平均を計算するために使用されます。 例: ```python >>> from transformers import AutoTokenizer, TapasForQuestionAnswering >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-wtq") >>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base-finetuned-wtq") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> logits = outputs.logits >>> logits_aggregation = outputs.logits_aggregation ```