# 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는 영어 위키백과에서 가져온 수백만 개의 표와 해당 텍스트로 구성된 대규모 데이터셋에서 마스킹 언어 모델링(MLM) 목적 함수를 통해 사전 학습되었습니다.

질문 답변을 위해 TAPAS는 상단에 2개의 헤드를 갖추고 있습니다. 셀 선택 헤드와 집계 헤드로, 선택된 셀들 간에 집계(예: 카운트 또는 합계)를 (선택적으로) 수행하는 데 사용됩니다. TAPAS는 여러 데이터셋에서 fine-tuning되었습니다:

- [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253) (Microsoft의 순차적 질문 응답)
- [WTQ](https://github.com/ppasupat/WikiTableQuestions)(Stanford University의 Wiki Table Questions)
- [WikiSQL](https://github.com/salesforce/WikiSQL)(Salesforce).

SQA와 WTQ 모두에서 최첨단 성능을 달성했으며, 훨씬 더 단순한 아키텍처를 갖추고 있으면서도 WikiSQL에서는 SOTA와 유사한 성능을 보입니다.

해당 논문의 초록은 다음과 같습니다:

*테이블에 대한 자연어 질문 응답은 일반적으로 의미 분석(semantic parsing) 작업으로 간주됩니다. 완전한 논리 형식(logical forms)을 수집하는 비용을 줄이기 위해, 논리 형식 대신 의미(denotations)로 구성된 약한 지도(weak supervision)에 초점을 맞춘 접근법이 널리 사용됩니다. 그러나 약한 지도를 기반으로 의미 분석기를 학습하는 것은 어려움이 있으며, 또한 생성된 논리 형식은 의미(denotation)를 검색하기 전의 중간 단계로만 사용됩니다. 본 논문에서는 논리 형식을 생성하지 않고 테이블에 대한 질문 응답을 수행하는 TAPAS 접근법을 제시합니다. TAPAS는 약한 지도를 기반으로 학습되며, 테이블 셀을 선택하고 해당 선택에 대해 선택적으로 대응하는 집계 연산자를 적용하여 의미(denotation)를 예측합니다. TAPAS는 BERT의 아키텍처를 확장하여 테이블을 입력으로 인코딩하고, Wikipedia에서 수집한 텍스트 세그먼트와 테이블의 효과적인 결합 사전 학습(joint pre-training)으로 초기화되며, 끝에서 끝(end-to-end)으로 학습됩니다. 세 가지 다른 의미 분석 데이터셋으로 실험한 결과, TAPAS는 SQA의 최첨단 정확도를 55.1에서 67.2로 향상시키고 WIKISQL 및 WIKITQ에서 최첨단 수준과 동등한 성능을 보여주며, 더 단순한 모델 아키텍처를 가진 채로 의미 분석 모델보다 우수하거나 동등한 성능을 달성했습니다. 또한, 우리의 설정에서 자명한 전이 학습(transfer learning)인 WIKISQL에서 WIKITQ로의 전이 학습이 48.7의 정확도를 달성하여 최첨단보다 4.2포인트 높은 결과를 보인다는 것도 추가로 확인했습니다.*

또한, 저자들은 **테이블 함의(table entailment)**를 인식하도록 TAPAS를 추가 사전 학습했습니다. 이를 위해 수백만 개의 자동 생성된 학습 예제로 구성된 균형 잡힌 데이터셋을 만들고, 미세 조정(fine-tuning)에 앞서 중간 단계(intermediate step)에서 학습시켰습니다. TAPAS의 저자들은 이 추가 사전 학습을 중간 사전 학습(intermediate pre-training)이라고 부릅니다(TAPAS는 먼저 MLM에서 사전 학습되고, 그 다음 다른 데이터셋에서 사전 학습되기 때문입니다). 중간 사전 학습은 SQA에서 성능을 추가로 향상시켜 새로운 최첨단(state-of-the-art) 성능을 달성했으며, 16k개의 Wikipedia 테이블로 구성된 테이블 함의(이진 분류 작업)를 위한 대규모 데이터셋인 [TabFact](https://github.com/wenhuchen/Table-Fact-Checking)에서도 최첨단 성능을 달성했습니다. 자세한 내용은 Julian Martin Eisenschlos, Syrine Krichene, Thomas Müller의 후속 논문 [Understanding tables with intermediate pre-training](https://www.aclweb.org/anthology/2020.findings-emnlp.27/)을 참고하세요.

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/tapas_architecture.png"
alt="drawing" width="600"/>

 TAPAS 아키텍처. 원래 블로그 게시물에서 가져왔습니다.

이 모델은 [nielsr](https://huggingface.co/nielsr)에 의해 기여되었습니다. 원본 코드는 [여기](https://github.com/google-research/tapas)에서 찾을 수 있습니다.

## 사용 팁

- TAPAS는 기본적으로 상대 위치 임베딩을 사용하는 모델입니다(테이블의 각 셀마다 위치 임베딩을 다시 시작). 이는 원래 TAPAS 논문이 발표된 후에 추가된 기능입니다. 저자들의 설명에 따르면, 이 방식은 일반적으로 약간 더 나은 성능을 내며, 임베딩이 부족해지지 않고 더 긴 시퀀스를 인코딩할 수 있게 합니다. 이는 [TapasConfig](/docs/transformers/v5.23.0/ko/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에서 fine-tuning된 checkpoints를 제공하며, 대화형 설정에서 테이블과 관련된 질문에 답할 수 있습니다. 이는 "그의 나이는 얼마인가요?"와 같은 이전 질문과 관련된 후속 질문을 할 수 있음을 의미합니다. 대화형 설정의 경우 TAPAS의 forward pass가 약간 다르다는 점에 유의하세요. 이 경우, 이전 질문에 대한 모델의 예측된 `labels`로 `prev_labels` 토큰 타입 id를 덮어쓸 수 있도록 테이블-질문 쌍을 하나씩 모델에 입력해야 합니다. 자세한 내용은 "Usage" 섹션을 참조하세요.
- TAPAS는 BERT와 유사하며, 따라서 masked language modeling (MLM) 목적 함수에 의존합니다. 따라서 TAPAS는 마스킹된 토큰 예측과 일반적인 NLU 작업에서 효율적이지만, 텍스트 생성에는 최적화되어 있지 않습니다. causal language modeling (CLM) 목적 함수로 학습된 모델이 텍스트 생성 측면에서 더 우수합니다. TAPAS는 EncoderDecoderModel 프레임워크에서 인코더로 사용되어 GPT-2와 같은 자기회귀 텍스트 디코더와 결합할 수 있습니다.

## 사용법: 파인튜닝

여기서는 [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasForQuestionAnswering)를 사용자 데이터셋으로 fine-tune하는 방법을 설명합니다.

**1단계: TAPAS를 사용할 수 있는 3가지 방법 중 하나를 선택하거나 실험해 보세요**

기본적으로 [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasForQuestionAnswering)를 fine-tune하는 방법은 3가지가 있으며, 이는 Tapas가 fine-tune된 서로 다른 데이터셋에 해당합니다:

1. SQA: 테이블과 관련된 후속 질문을 대화형 환경에서 묻는 데 관심이 있는 경우입니다. 예를 들어, 먼저 "첫 번째 배우의 이름은 무엇인가요?"라고 질문한 후, "그는 몇 살인가요?"와 같은 후속 질문을 할 수 있습니다. 여기서 질문에는 집계(aggregation)가 포함되지 않으며(모든 질문은 셀 선택 질문입니다).
2. WTQ: 대화형 환경에서 질문을 하는 것보다는 테이블과 관련된 질문, 예를 들어 행 수를 세거나 셀 값을 합산하거나 평균을 내는 것과 같은 집계 작업이 포함된 질문만 하고 싶을 때 사용할 수 있습니다. 예를 들어 "크리스티아누 호날두의 커리어 동안의 총 득점 수는 얼마인가요?"라고 질문할 수 있습니다. 이 경우를 **weak supervision**이라고도 하는데, 질문의 답변만 감독 신호로 주어지는 상황에서 모델 스스로 적절한 집계 연산자(SUM/COUNT/AVERAGE/NONE)를 학습해야 하기 때문입니다.
3. WikiSQL-supervised: 이 데이터셋은 WikiSQL을 기반으로 하며, 학습 과정에서 모델에 ground truth 집계 연산자를 제공합니다. 이를 **strong supervision**이라고도 합니다. 여기서 적절한 집계 연산자를 학습하는 것은 훨씬 쉽습니다.

요약하면:

| **작업**                            | **예제 데이터셋** | **설명**                                                                                         |
|-------------------------------------|---------------------|---------------------------------------------------------------------------------------------------------|
| 대화형                      | SQA                 | 대화형, 셀 선택 문제만                                                           |
| Weak supervision for aggregation    | WTQ                 | 질문에는 집계(aggregation)가 포함될 수 있으며, 모델은 오직 정답만 감독 신호로 주어지는 상황에서 이를 학습해야 합니다 |
| 집합에 대한 강력한 지도  | WikiSQL 기반  | 질문에는 집계(aggregation)가 포함될 수 있으며, 모델은 gold 집계 연산자가 주어졌을 때 이를 학습해야 합니다.  |

허브에서 사전 학습된 베이스와 무작위로 초기화된 분류 헤드를 사용하여 모델을 초기화하는 방법은 다음과 같습니다.

```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가 fine-tune된 세 가지 방식 중 하나를 반드시 따라야 하는 것은 아닙니다. [TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig)를 초기화할 때 원하는 하이퍼파라미터를 정의하여 실험한 후, 해당 구성을 기반으로 [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasForQuestionAnswering)를 생성할 수도 있습니다. 예를 들어, 대화형 질문과 집계(aggregation)가 포함된 질문이 모두 있는 데이터셋을 가지고 있다면 다음과 같이 할 수 있습니다. 아래는 예시입니다:

```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")
```

이미 fine-tuning이 완료된 checkpoint에서 시작하는 것도 가능합니다. 참고로, WTQ의 이미 fine-tuning된 checkpoint는 다소 취약한 L2-loss로 인해 일부 문제가 있습니다. 자세한 내용은 [여기](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`: 질문이 테이블과 관련하여 첫 번째, 두 번째, 세 번째인지 나타내는 정수입니다. 대화형 설정(SQA)인 경우에만 필요합니다. WTQ/WikiSQL 기반 학습을 사용하는 경우 이 열은 필요하지 않습니다.
- `question`: string
- `table_file`: string, 테이블 데이터를 포함하는 csv 파일의 이름
- `answer_coordinates`: 하나 이상의 튜플 목록 (각 튜플은 정답의 일부인 셀 좌표, 즉 행과 열의 쌍)
- `answer_text`: 하나 이상의 문자열 목록 (각 문자열은 답변의 일부인 셀 값)
- `aggregation_label`: 집계 연산자의 인덱스. 집계용 강한 지도 학습(WikiSQL 기반 지도 학습)의 경우에만 필요합니다
- `float_answer`: 질문에 대한 float 형식의 답변 (없으면 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/v5.23.0/ko/model_doc/tapas#transformers.TapasTokenizer)를 사용하여 테이블-질문 쌍을 `input_ids`, `attention_mask`, `token_type_ids` 등으로 변환할 수 있습니다. 마찬가지로, 위에서 선택한 세 가지 경우 중 어느 것에 해당하는지에 따라 [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasForQuestionAnswering)를 fine-tune하기 위해 필요한 입력이 다릅니다:

| **작업**                           | **필수 입력**                                                                                                 |
|------------------------------------|---------------------------------------------------------------------------------------------------------------------|
| 대화형                     | `input_ids`, `attention_mask`, `token_type_ids`, `labels`                                                           |
|  Weak supervision for aggregation  | `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/v5.23.0/ko/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/v5.23.0/ko/model_doc/tapas#transformers.TapasTokenizer)는 테이블 데이터가 **텍스트만** 포함해야 한다고 가정합니다. dataframe에 `.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/v5.23.0/ko/model_doc/tapas#transformers.TapasTokenizer) 문서 참조)이 올바르게 설정됩니다. 자세한 내용은 [이 노트북](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb)을 참고하세요.

**4단계: 모델 학습(파인튜닝)

이후 [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasForQuestionAnswering)를 다음과 같이 fine-tune할 수 있습니다(여기서는 집계 작업에 대한 weak supervision 사례를 보여 줍니다):

```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/v5.23.0/ko/model_doc/tapas#transformers.TapasForQuestionAnswering)를 사용하여 추론(즉, 새로운 데이터에 대한 예측)을 수행하는 방법을 설명합니다. 추론을 위해 모델에 로짓을 얻기 위해 `input_ids`, `attention_mask`, `token_type_ids`([TapasTokenizer](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasTokenizer)를 사용하여 얻을 수 있음)만 제공하면 됩니다. 다음으로, 편리한 `~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
```

대화형 설정의 경우, 각 테이블-질문 쌍을 모델에 **순차적으로** 제공해야 하며, 이전 테이블-질문 쌍의 예측된 `labels`로 `prev_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.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_aggregation: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L49)

**매개변수:**

loss (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`(그리고 경우에 따라 `answer`, `aggregation_labels`, `numeric_values`, `numeric_values_scale`)가 제공될 때 반환됨) : 계층적 셀 선택 로그 우도 손실과 (선택적으로) 반지도 학습 회귀 손실, (선택적으로) 집계용 지도 학습 손실의 합으로 계산된 총 손실.

logits (`torch.Tensor`, shape `(batch_size, sequence_length)`) : 모든 토큰에 대한 셀 선택 헤드(cell selection head)의 예측 점수.

logits_aggregation (`torch.Tensor`, *선택 사항*, shape `(batch_size, num_aggregation_labels)`) : 모든 aggregation operator에 대한 aggregation head의 예측 점수.

hidden_states (`tuple[torch.Tensor]`, *선택 사항*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환됨) : `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩의 출력에 대한 것 1개 + 각 레이어의 출력에 대한 것 1개)로, 모양은 `(batch_size, sequence_length, hidden_size)`입니다. 각 레이어 출력 시점의 모델 hidden-states와 선택적인 초기 임베딩 출력을 포함합니다.

attentions (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 튜플(레이어당 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다. attention softmax 이후의 attention 가중치로, self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

[TapasForQuestionAnswering](/docs/transformers/v5.23.0/ko/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/v5.23.0/src/transformers/models/tapas/configuration_tapas.py#L32)

**매개변수:**

vocab_size (`int`, *선택 사항*, 기본값 `30522`) : 모델의 어휘 크기입니다. `input_ids`로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다.

hidden_size (`int`, *선택 사항*, 기본값 `768`) : 숨겨진 표현의 차원.

num_hidden_layers (`int`, *선택 사항*, 기본값 `12`) : Transformer decoder의 숨겨진 레이어 수입니다.

num_attention_heads (`int`, *선택 사항*, 기본값 `12`) : Transformer decoder의 각 attention layer에 사용되는 attention head의 수입니다.

intermediate_size (`int`, *선택 사항*, 기본값 `3072`) : MLP 표현의 차원.

hidden_act (`str`, *선택 사항*, 기본값 `gelu`) : 디코더에서 사용되는 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등이 있습니다.

hidden_dropout_prob (`Union[float, int]`, *선택 사항*, 기본값 `0.1`) : 임베딩, 인코더, 풀러의 모든 완전 연결 계층에 적용되는 dropout 확률입니다.

attention_probs_dropout_prob (`Union[float, int]`, *선택 사항*, 기본값 `0.1`) : attention 확률에 적용할 dropout 비율입니다.

max_position_embeddings (`int`, *선택 사항*, 기본값 `1024`) : 이 모델이 사용될 수 있는 최대 시퀀스 길이입니다.

type_vocab_sizes (`list[int]`, *선택 사항*, 기본값 `[3, 256, 256, 2, 256, 256, 10]`) : [TapasModel](/docs/transformers/v5.23.0/ko/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`, *선택 사항*, 기본값 0) : 예측할 집계 연산자의 수입니다.

aggregation_loss_weight (`float`, *선택 사항*, 기본값 1.0) : 집계 손실(aggregation loss)의 중요도 가중치입니다.

use_answer_as_supervision (`bool`, *선택 사항*) : 집계 예제에 대한 유일한 감독으로 답변을 사용할지 여부.

answer_loss_importance (`float`, *선택 사항*, 기본값 1.0) : 회귀 손실의 중요도 가중치입니다.

use_normalized_answer_loss (`bool`, *선택 사항*, 기본값 `False`) : 예측 값과 기대 값 중 최대값으로 답변 손실을 정규화할지 여부.

huber_loss_delta (`float`, *선택 사항*) : 회귀 손실을 계산하는 데 사용되는 Delta 매개변수입니다.

temperature (`float`, *선택 사항*, 기본값 1.0) : 셀 로짓 확률의 왜도(skewness)를 제어(또는 변경)하는 데 사용되는 값.

aggregation_temperature (`float`, *선택 사항*, 기본값 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`, *선택 사항*) : 모호한 경우의 셀 선택 선호도. 집계 작업의 약한 지도 학습(WTQ, WikiSQL)에서만 적용됩니다. 집계 확률의 총 질량("NONE" 연산자 제외)이 이 하이퍼파라미터보다 높으면 해당 예시에 대해 집계가 예측됩니다.

answer_loss_cutoff (`float`, *선택 사항*) : cutoff보다 answer loss가 큰 예시를 무시합니다.

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`) : 초기 확률이 50%가 되도록 셀 선택 가중치를 0으로 초기화할지 여부

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`, *선택 사항*) : 집계 라벨이 정의되어 있고 이 라벨 중 하나가 "No aggregation"을 나타내는 경우, 해당 라벨의 인덱스로 설정해야 합니다. 예를 들어, WTQ 모델은 인덱스 0에 "NONE" 집계 라벨을 가지므로, 이러한 모델의 경우 해당 값을 0으로 설정해야 합니다.

is_decoder (`bool`, *선택 사항*, 기본값 `False`) : 모델이 디코더로 사용되는지 여부를 나타냅니다. `False`인 경우 모델은 인코더로 사용됩니다.

add_cross_attention (`bool`, *선택 사항*, 기본값 `False`) : 모델에 cross-attention 레이어를 추가할지 여부.

tie_word_embeddings (`bool`, *선택 사항*, 기본값 `True`) : 모델의 `tied_weights_keys` 매핑에 따라 가중치 임베딩을 묶을지 여부.

이것은 TapasModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Tapas 모델을 초기화하고 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 초기화하면 [google/tapas-base-finetuned-sqa](https://huggingface.co/google/tapas-base-finetuned-sqa)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/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/v5.23.0/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]"`) : 여러 시퀀스로 시퀀스를 구성할 때 사용되는 구분자 토큰입니다. 예를 들어 시퀀스 분류의 경우 두 시퀀스, 질의응답의 경우 텍스트와 질문 사이에 사용됩니다. 특수 토큰으로 구성된 시퀀스의 마지막 토큰으로도 사용됩니다.

pad_token (`str`, *선택 사항*, 기본값 `"[PAD]"`) : 패딩에 사용되는 토큰입니다. 예를 들어, 길이가 다른 시퀀스를 배치할 때 사용됩니다.

cls_token (`str`, *선택 사항*, 기본값 `"[CLS]"`) : 시퀀스 분류(토큰별 분류가 아닌 전체 시퀀스에 대한 분류)를 수행할 때 사용되는 분류기 토큰입니다. 특수 토큰을 사용하여 시퀀스를 구성할 경우 시퀀스의 첫 번째 토큰입니다.

mask_token (`str`, *선택 사항*, 기본값 `"[MASK]"`) : 값을 마스킹하는 데 사용되는 토큰입니다. 이는 masked language modeling으로 이 모델을 학습할 때 사용되는 토큰이며, 모델이 예측을 시도하는 대상이 되는 토큰입니다.

empty_token (`str`, *선택 사항*, 기본값 `"[EMPTY]"`) : 테이블에서 빈 셀 값에 사용되는 토큰입니다. 빈 셀 값에는 "", "n/a", "nan", "?"가 포함됩니다.

tokenize_chinese_chars (`bool`, *선택 사항*, 기본값 `True`) : 중국어 문자를 토큰화할지 여부입니다. 일본어에는 비활성화하는 것이 좋습니다(이 [이슈](https://github.com/huggingface/transformers/issues/328) 참조).

strip_accents (`bool`, *선택 사항*) : 모든 악센트를 제거할지 여부입니다. 이 옵션이 지정되지 않으면 `lowercase`의 값에 의해 결정됩니다(원본 BERT와 동일).

cell_trim_length (`int`, *선택 사항*, 기본값 -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`, *선택 사항*) : 토큰 수 기준 각 질문의 최소 길이(이보다 짧으면 건너뜁니다).

max_question_length (`int`, *선택 사항*) : 토큰 수 기준 각 질문의 최대 길이(이 값을 초과하면 건너뜁니다).

clean_up_tokenization_spaces (`bool`, *선택 사항*, 기본값 `True`) : 디코딩 후 공백을 정리할지 여부입니다. 정리는 불필요한 공백과 같은 잠재적 아티팩트를 제거하는 작업을 포함합니다.

TAPAS 토크나이저를 생성합니다. WordPiece 기반으로, TAPAS 모델에서 사용할 테이블과 하나 이상의 관련 문장을 평탄화(flatten)합니다.

이 토크나이저는 대부분의 주요 메서드를 포함하는 [PreTrainedTokenizer](/docs/transformers/v5.23.0/ko/main_classes/tokenizer#transformers.PythonBackend)를 상속합니다. 해당 메서드에 대한 자세한 정보는 이 상위 클래스를 참고하세요. [TapasTokenizer](/docs/transformers/v5.23.0/ko/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" 열이 있다면, 이 토큰들의 column ranks는 각각 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/v5.23.0/ko/model_doc/tapas#transformers.TapasTokenizer)는 표와 관련 문장에 대해 구두점 분할과 wordpiece를 포함한 끝에서 끝까지(end-to-end)의 토큰화를 수행합니다.

#### __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/v5.23.0/src/transformers/models/tapas/tokenization_tapas.py#L518)

**매개변수:**

table (`pd.DataFrame` 또는 `str` 또는 `list[str]`) : 표 형식 데이터를 포함하는 테이블. 모든 셀 값은 텍스트여야 합니다. Pandas dataframe을 문자열로 변환하려면 *.astype(str)*를 사용하세요. 문자열 또는 문자열 목록을 전달하면 빈 테이블을 가진 쿼리로 해석됩니다(일반적인 토크나이저 테스트를 지원하기 위함).

queries (`str` 또는 `list[str]`) : 인코딩할 테이블과 관련된 질문 또는 질문 배치입니다. 배치의 경우 모든 질문은 **동일한** 테이블을 참조해야 합니다.

answer_coordinates (`list[Tuple]` 또는 `list[list[Tuple]]`, *선택 사항*) : 배치 내 각 테이블-질문 쌍의 답변 좌표입니다. 테이블-질문 쌍이 하나만 제공되는 경우, answer_coordinates는 하나 이상의 튜플로 구성된 단일 리스트여야 합니다. 각 튜플은 (row_index, column_index) 쌍이어야 합니다. 첫 번째 데이터 행(열 헤더 행이 아님)의 인덱스는 0입니다. 첫 번째 열의 인덱스는 0입니다. 테이블-질문 쌍의 배치가 제공되는 경우, answer_coordinates는 튜플의 리스트로 구성된 리스트여야 합니다(각 리스트는 단일 테이블-질문 쌍에 해당).

answer_text (`list[str]` 또는 `list[list[str]]`, *선택 사항*) : 배치 내 각 테이블-질문 쌍의 답변 텍스트입니다. 테이블-질문 쌍이 하나만 제공되는 경우, answer_text는 하나 이상의 문자열로 구성된 단일 리스트여야 합니다. 각 문자열은 해당 답변 좌표의 답변 텍스트여야 합니다. 테이블-질문 쌍의 배치가 제공되는 경우, answer_coordinates는 문자열의 리스트의 리스트여야 합니다(각 리스트는 단일 테이블-질문 쌍에 해당합니다).

add_special_tokens (`bool`, *선택 사항*, 기본값 `True`) : 해당 모델에 대한 특수 토큰을 기준으로 시퀀스를 인코딩할지 여부.

padding (`bool`, `str` 또는 [PaddingStrategy](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.utils.PaddingStrategy), *optional*, 기본값 `False`) : 패딩을 활성화하고 제어합니다. 다음 값을 허용합니다: - `True` 또는 `'longest'`: 배치 내 가장 긴 시퀀스 길이로 패딩합니다(단일 시퀀스만 제공된 경우 패딩하지 않음). - `'max_length'`: `max_length` 인수로 지정된 최대 길이로 패딩하거나, 해당 인수가 제공되지 않은 경우 모델이 허용하는 최대 입력 길이로 패딩합니다. - `False` 또는 `'do_not_pad'` (기본값): 패딩하지 않음(즉, 서로 다른 길이의 시퀀스를 가진 배치를 출력할 수 있음).

truncation (`bool`, `str` 또는 `TapasTruncationStrategy`, *선택 사항*, 기본값 `False`) : 잘림을 활성화하고 제어합니다. 다음 값을 허용합니다:  - `True` 또는 `'drop_rows_to_fit'`: `max_length` 인수로 지정된 최대 길이로 잘리거나, 해당 인수가 제공되지 않으면 모델이 허용하는 최대 입력 길이로 잘립니다. 이는 행 단위로 잘리며, 테이블에서 행을 제거합니다. - `False` 또는 `'do_not_truncate'` (기본값): 잘리지 않습니다(즉, 모델이 허용하는 최대 입력 크기보다 긴 시퀀스 길이를 가진 배치로 출력할 수 있습니다).

max_length (`int`, *선택 사항*) : truncation/padding 매개변수 중 하나가 사용할 최대 길이를 제어합니다. 설정하지 않거나 `None`으로 설정한 경우, truncation/padding 매개변수 중 하나가 최대 길이를 요구하면 미리 정의된 모델 최대 길이를 사용합니다. 모델에 특정 최대 입력 길이가 없는 경우(XLNet 등) 최대 길이로 truncation/padding하는 기능이 비활성화됩니다.

is_split_into_words (`bool`, *선택 사항*, 기본값 `False`) : 입력이 이미 사전 토큰화(예: 단어 단위로 분리)되었는지 여부입니다. `True`로 설정하면, 토크나이저는 입력이 이미 단어 단위로 분리되어 있다고 가정하고(예: 공백 기준으로 분리) 이를 토큰화합니다. 이는 NER 또는 토큰 분류에 유용합니다.

pad_to_multiple_of (`int`, *선택 사항*) : 설정된 경우, 시퀀스를 제공된 값의 배수로 패딩합니다. 이는 NVIDIA 하드웨어에서 Volta(컴퓨트 캐피빌리티 `>= 7.5`)와 같은 환경에서 Tensor Cores 사용을 활성화하는 데 특히 유용합니다.

return_tensors (`str` 또는 [TensorType](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.TensorType), *optional*) : 설정된 경우, python 정수 목록 대신 텐서를 반환합니다. 허용되는 값은 다음과 같습니다:  - `'pt'`: PyTorch `torch.Tensor` 객체를 반환합니다. - `'np'`: Numpy `np.ndarray` 객체를 반환합니다.

테이블과 관련된 하나 이상의 시퀀스를 토큰화하여 모델에 맞게 준비하는 주요 메서드입니다.

#### 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/v5.23.0/src/transformers/models/tapas/tokenization_tapas.py#L1885)

**매개변수:**

data (`dict`) : 특징을 실제 값으로 매핑하는 사전. [TapasTokenizer](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasTokenizer)를 사용하여 생성해야 합니다.

logits (`torch.Tensor`, shape `(batch_size, sequence_length)`) : 토큰 레벨의 logits를 포함하는 Tensor.

logits_agg (`torch.Tensor`, shape `(batch_size, num_aggregation_labels)`, *선택 사항*) : aggregation logits를 포함하는 Tensor.

cell_classification_threshold (`float`, *선택 사항*, 기본값 0.5) : 셀 선택에 사용할 임계값입니다. 이 임계값보다 확률이 큰 모든 테이블 셀이 선택됩니다.

**반환값:** 입력에 따라 다양한 요소로 구성된 `tuple`

- predicted_answer_coordinates (`list[list[[tuple]]`, 길이 `batch_size`): 튜플의 리스트로 이루어진 리스트의 리스트 형태의 예측된 답변 좌표. 리스트의 각 요소는 배치 내 단일 예시의 예측된 답변 좌표를 튜플의 리스트로 포함합니다. 각 튜플은 셀, 즉 (행 인덱스, 열 인덱스)입니다.
- predicted_aggregation_indices (`list[int]`, 길이 `batch_size`, *선택 사항*, `logits_aggregation`이 제공될 때 반환됨): aggregation head의 예측된 aggregation operator 인덱스입니다.

[TapasForQuestionAnswering](/docs/transformers/v5.23.0/ko/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/v5.23.0/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/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L510)

**매개변수:**

config ([TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

add_pooling_layer (`bool`, *선택 사항*, 기본값 `True`) : 풀링 레이어를 추가할지 여부

특정 헤드가 위에 없는 상태에서 원시 hidden-states를 출력하는 기본 Tapas Model입니다.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/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.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L543)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length, 7)`, *선택 사항*) : 테이블 구조를 인코딩하는 토큰 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 이 클래스를 참조하세요. [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스 토큰의 위치 인덱스입니다. [TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig)의 `reset_position_index_per_cell`이 `True`로 설정되어 있으면 상대 위치 임베딩이 사용됩니다. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

encoder_hidden_states (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스입니다. 모델이 디코더로 구성된 경우 cross-attention에 사용됩니다.

encoder_attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 인코더 입력의 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 하는 마스크입니다. 모델이 디코더로 구성된 경우 크로스 어텐션에서 이 마스크가 사용됩니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 또는 `tuple(torch.Tensor)`

구성([TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig))과 입력에 따라 다양한 요소를 포함하는 [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[TapasModel](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasModel)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 마지막 레이어 출력에서 생성된 hidden-state 시퀀스입니다.
- **pooler_output** (`torch.Tensor`, shape `(batch_size, hidden_size)`) -- 시퀀스의 첫 번째 토큰(분류 토큰)의 마지막 레이어 hidden-state입니다. 보조 사전학습 작업을 위해 사용되는 레이어들을 통해 추가 처리된 값입니다. 예를 들어 BERT 계열 모델의 경우, 선형 레이어와 tanh 활성화 함수를 통해 처리된 분류 토큰을 반환합니다. 선형 레이어의 가중치는 사전학습 단계에서 다음 문장 예측(분류) 목적 함수를 통해 학습됩니다.
- **hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 형태는 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L660)

**매개변수:**

config ([TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

`language modeling` 헤드가 위에 있는 Tapas 모델입니다.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/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.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = 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/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L684)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length, 7)`, *선택 사항*) : 테이블 구조를 인코딩하는 토큰 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 이 클래스를 참조하세요. [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스 토큰의 위치 인덱스입니다. [TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig)의 `reset_position_index_per_cell`이 `True`로 설정되어 있으면 상대 위치 임베딩이 사용됩니다. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

encoder_hidden_states (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스입니다. 모델이 디코더로 구성된 경우 cross-attention에 사용됩니다.

encoder_attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 인코더 입력의 패딩 토큰 인덱스에 대한 어텐션을 수행하지 않도록 하는 마스크입니다. 모델이 디코더로 구성된 경우 크로스 어텐션에서 이 마스크가 사용됩니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0.

labels (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : masked language modeling loss를 계산하기 위한 라벨. 인덱스는 `[-100, 0, ..., config.vocab_size]` 범위여야 합니다(`input_ids` docstring 참조). 인덱스가 `-100`로 설정된 토큰은 무시(마스크)되며, loss는 `[0, ..., config.vocab_size]` 범위의 라벨을 가진 토큰에 대해서만 계산됩니다.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** [MaskedLMOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 또는 `tuple(torch.Tensor)`

구성([TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig))과 입력에 따라 다양한 요소를 포함하는 [MaskedLMOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[TapasForMaskedLM](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasForMaskedLM)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- Masked language modeling(MLM) loss.
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length, config.vocab_size)`) -- 언어 모델링 헤드에서 생성된 예측 점수(SoftMax 적용 전 각 어휘 토큰에 대한 점수).
- **hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 형태는 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L1119)

**매개변수:**

config ([TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

pooling output 위에 linear layer를 올려놓은 sequence classification head를 갖춘 Tapas Model, 예: TabFact(Chen et al., 2020)와 같은 table entailment 작업에 사용됩니다.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/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.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = 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/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L1131)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length, 7)`, *선택 사항*) : 테이블 구조를 인코딩하는 토큰 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 이 클래스를 참조하세요. [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스 토큰의 위치 인덱스입니다. [TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig)의 `reset_position_index_per_cell`이 `True`로 설정되어 있으면 상대 위치 임베딩이 사용됩니다. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

labels (`torch.LongTensor`, shape `(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/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 또는 `tuple(torch.Tensor)`

구성([TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig))과 입력에 따라 다양한 요소를 포함하는 [SequenceClassifierOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[TapasForSequenceClassification](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasForSequenceClassification)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택*, `labels`이 제공될 때 반환됨) -- 분류(또는 config.num_labels==1인 경우 회귀) 손실.
- **logits** (`torch.Tensor`, shape `(batch_size, config.num_labels)`) -- SoftMax 적용 전 분류(또는 config.num_labels==1인 경우 회귀) 점수.
- **hidden_states** (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개)로, 형태는 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L781)

**매개변수:**

config ([TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

에 대한 질의응답 작업(예: SQA, WTQ 또는 WikiSQL 기반 작업)을 위해 셀 선택 헤드와 선택적 집계 헤드를 최상단에 갖춘 Tapas 모델(숨겨진 상태 출력을 기반으로 `logits` 및 선택적 `logits_aggregation`을 계산하기 위한 선형 레이어를 최상단에 배치)

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/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.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = 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.Tensor] = None, numeric_values: typing.Optional[torch.Tensor] = None, numeric_values_scale: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L804)

**매개변수:**

input_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 어휘(input sequence tokens)의 인덱스입니다. 기본적으로 패딩은 무시됩니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 및 [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)를 참조하세요. [입력 ID란 무엇인가요?](../glossary#input-ids)

attention_mask (`torch.Tensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크입니다. `[0, 1]`에서 선택된 마스크 값: - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0. [attention 마스크란?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`, shape `(batch_size, sequence_length, 7)`, *선택 사항*) : 테이블 구조를 인코딩하는 토큰 인덱스입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 이 클래스를 참조하세요. [토큰 타입 ID란 무엇인가요?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, shape `(batch_size, sequence_length)`, *선택 사항*) : 각 입력 시퀀스 토큰의 위치 인덱스입니다. [TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig)의 `reset_position_index_per_cell`이 `True`로 설정되어 있으면 상대 위치 임베딩이 사용됩니다. `[0, config.max_position_embeddings - 1]` 범위에서 선택됩니다.  [위치 ID란 무엇인가요?](../glossary#position-ids)

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : `input_ids`를 전달하는 대신 임베디드 표현을 직접 전달할 수 있습니다. 이는 모델의 내부 임베딩 조회 행렬보다 `input_ids` 인덱스를 관련 벡터로 변환하는 방식에 대해 더 많은 제어가 필요한 경우 유용합니다.

table_mask (`torch.LongTensor`, shape `(batch_size, seq_length)`, *선택 사항*) : 테이블용 마스크입니다. 테이블에 속하는 토큰(1)을 나타냅니다. 질문 토큰, 테이블 헤더 및 패딩은 0입니다.

labels (`torch.LongTensor`, shape `(batch_size, seq_length)`, *선택 사항*) : 계층적 셀 선택 손실을 계산하기 위한 토큰별 라벨. 이는 테이블에 나타나는 답변의 위치를 인코딩합니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 얻을 수 있습니다. **답변의 일부인** 토큰은 -1, **답변의 일부가 아닌** 토큰은 -0입니다.

aggregation_labels (`torch.LongTensor`, shape `(batch_size, )`, *선택 사항*) : 집계 손실을 계산하기 위해 배치의 각 예시에 대한 집계 함수 인덱스. 인덱스는 `[0, ..., config.num_aggregation_labels - 1]` 범위여야 합니다. 집계용 강한 지도(WikiSQL-supervised)의 경우에만 필요합니다.

float_answer (`torch.Tensor`, shape `(batch_size, )`, *선택 사항*) : 배치 내 각 예시에 대한 Float 답변. 셀 선택 질문의 경우 *float('nan')*으로 설정합니다. 약한 지도 학습(WTQ)의 경우에만 집계 마스크와 회귀 손실을 계산하기 위해 필요합니다.

numeric_values (`torch.Tensor`, shape `(batch_size, seq_length)`, *선택 사항*) : 모든 토큰의 수치 값이며, 수치 값이 아닌 토큰은 NaN입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 얻을 수 있습니다. 집계(AGGREGATION)의 약한 지도 학습(WTQ)에서 회귀 손실을 계산할 때만 필요합니다.

numeric_values_scale (`torch.Tensor`, shape `(batch_size, seq_length)`, *선택 사항*) : 각 토큰의 수치 값 스케일입니다. [AutoTokenizer](/docs/transformers/v5.23.0/ko/model_doc/auto#transformers.AutoTokenizer)를 사용하여 얻을 수 있습니다. 집계용 약한 지도 학습(WTQ)의 경우 회귀 손실을 계산하는 데에만 필요합니다.

output_attentions (`bool`, *선택 사항*) : 모든 어텐션 레이어의 어텐션 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 `attentions`를 참조하세요.

output_hidden_states (`bool`, *선택 사항*) : 모든 레이어의 hidden states를 반환할지 여부. 자세한 내용은 반환되는 텐서 중 `hidden_states` 항목을 참조하세요.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

**반환값:** [TableQuestionAnsweringOutput](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) 또는 `tuple(torch.Tensor)`

구성([TapasConfig](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasConfig))과 입력에 따라 다양한 요소를 포함하는 [TableQuestionAnsweringOutput](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`가 전달되거나 `config.return_dict=False`인 경우).

[TapasForQuestionAnswering](/docs/transformers/v5.23.0/ko/model_doc/tapas#transformers.TapasForQuestionAnswering)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`(그리고 경우에 따라 `answer`, `aggregation_labels`, `numeric_values`, `numeric_values_scale`)가 제공될 때 반환됨) -- 계층적 셀 선택 로그 우도 손실의 합으로 계산된 총 손실이며, 선택적으로 반지도 학습 회귀 손실 및 집계용 지도 학습 손실이 포함될 수 있습니다.
- **logits** (`torch.Tensor`, shape `(batch_size, sequence_length)`) -- 모든 토큰에 대한 셀 선택 헤드의 예측 점수.
- **logits_aggregation** (`torch.Tensor`, *선택 사항*, shape `(batch_size, num_aggregation_labels)`) -- 모든 aggregation operator에 대한 aggregation head의 예측 점수.
- **hidden_states** (`tuple[torch.Tensor]`, *선택*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) -- `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩 출력용 1개 + 각 레이어의 출력용 1개)로, 모양은 `(batch_size, sequence_length, hidden_size)`입니다.

  각 레이어의 출력에서 모델의 Hidden-states와 선택적 초기 임베딩 출력을 포함합니다.
- **attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, 모양은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치입니다.

예:

```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
```