Transformers documentation

TAPAS

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

이 모델은 2020-04-05에 HF papers에 게시되었으며, 2020-12-15에 Hugging Face Transformers에 기여되었습니다.

TAPAS

개요

TAPAS 모델은 Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno, Julian Martin Eisenschlos가 TAPAS: Weakly Supervised Table Parsing via Pre-training에서 제안했습니다. 이는 표 형식 데이터에 대한 질문을 답변하기 위해 특별히 설계(및 사전 학습)된 BERT 기반 모델입니다. BERT와 비교할 때, TAPAS는 상대 위치 임베딩을 사용하며 표 구조를 인코딩하는 7가지 토큰 유형을 갖추고 있습니다. TAPAS는 영어 Wikipedia의 수백만 개 표와 해당 텍스트로 구성된 대규모 데이터셋에서 마스킹 언어 모델링(MLM) 목적 함수를 통해 사전 학습되었습니다.

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

SQA (Microsoft의 순차적 질문 응답)
WTQ(Stanford University의 Wiki Table Questions)
WikiSQL(Salesforce).

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

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

테이블에 대한 자연어 질문 응답은 일반적으로 의미론적 파싱(semantic parsing) 작업으로 간주됩니다. 완전한 논리 형식(logical form)을 수집하는 비용을 줄이기 위해, 논리 형식 대신 의미(denotation)로 구성된 약한 지도(weak supervision)에 초점을 맞춘 접근법이 널리 사용됩니다. 그러나 약한 지도를 기반으로 의미론적 파서를 학습시키는 것은 어려움이 있으며, 또한 생성된 논리 형식은 의미(denotation)를 검색하기 전의 중간 단계로만 사용됩니다. 본 논문에서는 논리 형식을 생성하지 않고 테이블에 대한 질문 응답을 수행하는 TAPAS 접근법을 제시합니다. TAPAS는 약한 지도를 기반으로 학습되며, 테이블 셀을 선택하고 해당 선택에 해당하는 집계 연산자를 선택적으로 적용하여 의미(denotation)를 예측합니다. TAPAS는 BERT의 아키텍처를 확장하여 테이블을 입력으로 인코딩하고, Wikipedia에서 수집한 텍스트 세그먼트와 테이블에 대한 효과적인 결합 사전 학습(joint pre-training)으로 초기화되며, 끝에서 끝(end-to-end)으로 학습됩니다. 세 가지 다른 의미론적 파싱 데이터셋으로 실험한 결과, TAPAS는 SQA에서 최신 정확도를 55.1에서 67.2로 향상시켜 의미론적 파싱 모델보다 우수한 성능을 보이거나, WIKISQL과 WIKITQ에서 최신 성능과 동등한 결과를 보여주며, 더 단순한 모델 아키텍처를 사용합니다. 또한, 우리의 설정에서 자명한(트라이벌)인 WIKISQL에서 WIKITQ로의 전이 학습(transfer learning)이 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에서도 최첨단 성능을 달성했습니다. 자세한 내용은 Julian Martin Eisenschlos, Syrine Krichene, Thomas Müller의 후속 논문 Understanding tables with intermediate pre-training을 참고하세요.

TAPAS architecture. Taken from the original blog post.

이 모델은 nielsr에 의해 기여되었습니다. 원본 코드는 여기에서 찾을 수 있습니다.

사용 팁

TAPAS는 기본적으로 상대 위치 임베딩을 사용하는 모델입니다(테이블의 각 셀마다 위치 임베딩을 다시 시작). 이는 원래 TAPAS 논문이 발표된 후에 추가된 사항입니다. 저자들의 설명에 따르면, 이 방식은 일반적으로 약간 더 나은 성능을 내며, 임베딩이 부족해지지 않고 더 긴 시퀀스를 인코딩할 수 있게 해줍니다. 이는 TapasConfig의 reset_position_index_per_cell 파라미터에 반영되어 있으며, 기본값은 True입니다. hub에서 사용할 수 있는 기본 모델 버전들은 모두 상대 위치 임베딩을 사용합니다. from_pretrained() 메서드를 호출할 때 revision="no_reset"라는 추가 인수를 전달하면 절대 위치 임베딩을 사용하는 모델을 사용할 수도 있습니다. 일반적으로 입력은 왼쪽이 아닌 오른쪽으로 패딩하는 것이 권장됩니다.
TAPAS는 BERT를 기반으로 하므로, 예를 들어 TAPAS-base은 BERT-base 아키텍처에 해당합니다. 물론 TAPAS-large가 가장 좋은 성능을 내며(논문에서 보고된 결과는 TAPAS-large에서 나온 것입니다). 다양한 크기의 모델에 대한 결과는 원본 GitHub 저장소에서 확인할 수 있습니다.
TAPAS에는 SQA로 fine-tuning된 checkpoint가 포함되어 있으며, 대화형 설정에서 표와 관련된 질문에 답할 수 있습니다. 이는 이전 질문과 관련된 “그의 나이는 얼마인가요?”와 같은 후속 질문을 할 수 있음을 의미합니다. 대화형 설정의 경우 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를 사용자 데이터셋으로 fine-tune하는 방법을 설명합니다.

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

기본적으로 TapasForQuestionAnswering를 fine-tune하는 방법은 3가지가 있으며, 이는 Tapas가 fine-tune된 서로 다른 데이터셋에 해당합니다:

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

요약하면:

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

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

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를 초기화할 때 원하는 하이퍼파라미터를 자유롭게 정의하여 실험한 후, 해당 구성을 기반으로 TapasForQuestionAnswering를 생성할 수도 있습니다. 예를 들어, 대화형 질문과 집계(aggregation)가 포함된 질문이 모두 있는 데이터셋을 가지고 있다면 다음과 같이 할 수 있습니다. 아래는 예시입니다:

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로 인해 일부 문제가 있습니다. 자세한 내용은 여기를 참조하세요.

HuggingFace 허브에서 사용할 수 있는 모든 사전 학습 및 미세 조정된 TAPAS 체크포인트 목록은 여기에서 확인하세요.

2단계: SQA 형식으로 데이터를 준비합니다

둘째, 위에서 무엇을 선택했든 데이터셋을 SQA 형식으로 준비해야 합니다. 이 형식은 다음 컬럼을 가진 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과 같은 집계용 약한 지도 학습(weak supervision)의 경우에만 필요합니다.

테이블 자체는 폴더에 존재해야 하며, 각 테이블은 별도의 csv 파일이어야 합니다. 참고로 TAPAS 알고리즘의 저자들은 다른 데이터셋(WTQ, WikiSQL)을 SQA 형식으로 변환하기 위해 일부 자동화 로직이 포함된 변환 스크립트를 사용했습니다. 저자는 이를 여기서 설명합니다. HuggingFace의 구현과 호환되는 이 스크립트의 변환 버전은 여기서 찾을 수 있습니다. 흥미롭게도 이러한 변환 스크립트는 완벽하지 않습니다(answer_coordinates와 float_answer 필드는 answer_text를 기반으로 채워짐) 즉, WTQ와 WikiSQL의 결과를 실제로 개선할 수 있을 것입니다.

3단계: TapasTokenizer를 사용하여 데이터를 텐서로 변환

세 번째로, 데이터를 이러한 TSV/CSV 형식(및 해당 테이블 데이터를 포함하는 CSV 파일)으로 준비했다면, TapasTokenizer를 사용하여 테이블-질문 쌍을 input_ids, attention_mask, token_type_ids 등으로 변환할 수 있습니다. 마찬가지로, 위에서 선택한 세 가지 경우 중 어느 것이냐에 따라 TapasForQuestionAnswering의 fine-tuning에 필요한 입력이 다릅니다:

작업	필수 입력
대화형	`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는 TSV 파일의 answer_coordinates 및 answer_text 컬럼을 기반으로 labels, numeric_values, numeric_values_scale를 생성합니다. float_answer와 aggregation_labels는 2단계의 TSV 파일에 이미 포함되어 있습니다. 예시는 다음과 같습니다:

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는 테이블 데이터가 텍스트 전용이어야 한다고 가정합니다. dataframe에 .astype(str)를 적용하여 텍스트 전용 데이터로 변환할 수 있습니다. 물론 이는 단일 학습 예시를 인코딩하는 방법만 보여줍니다. 배치에 대해 반복하기 위해 dataloader를 생성하는 것이 권장됩니다:

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 문서 참조)이 올바르게 설정됩니다. 자세한 내용은 이 노트북을 참고하세요.

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

이후 TapasForQuestionAnswering를 다음과 같이 fine-tune할 수 있습니다(여기서는 집계 작업에 대한 weak supervision 사례를 보여 줍니다):

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를 사용하여 추론(즉, 새로운 데이터에 대한 예측)을 수행하는 방법을 설명합니다. 추론을 위해 모델에 로짓을 얻기 위해 input_ids, attention_mask, token_type_ids(TapasTokenizer를 사용하여 얻을 수 있음)만 제공하면 됩니다. 다음으로, 편리한 ~models.tapas.tokenization_tapas.convert_logits_to_predictions 메서드를 사용하여 이를 예측된 좌표 및 선택적 집계 인덱스로 변환할 수 있습니다.

다만, 세팅이 대화형인지 여부에 따라 추론 방식이 다릅니다. 비대화형 세팅에서는 배치 내 모든 테이블-질문 쌍에 대해 병렬로 추론을 수행할 수 있습니다. 아래는 그 예시입니다:

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 토큰 유형이 덮어쓰기됩니다. 자세한 내용은 이 노트북에서 확인할 수 있습니다.

리소스

TAPAS 전용 출력

class transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput

< source >

( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonelogits_aggregation: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = None )

매개변수

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 (각 레이어당 하나씩, 모양이 (batch_size, num_heads, sequence_length, sequence_length).
self-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention softmax 이후의 attention 가중치.

TapasForQuestionAnswering의 출력 유형.

TapasConfig

클래스 transformers.TapasConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 30522hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 1024type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10)initializer_range: float = 0.02layer_norm_eps: float = 1e-12pad_token_id: int | None = 0bos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonepositive_label_weight: float = 10.0num_aggregation_labels: int = 0aggregation_loss_weight: float = 1.0use_answer_as_supervision: bool | None = Noneanswer_loss_importance: float = 1.0use_normalized_answer_loss: bool = Falsehuber_loss_delta: float | None = Nonetemperature: float = 1.0aggregation_temperature: float = 1.0use_gumbel_for_cells: bool = Falseuse_gumbel_for_aggregation: bool = Falseaverage_approximation_function: str = 'ratio'cell_selection_preference: float | None = Noneanswer_loss_cutoff: float | int | None = Nonemax_num_rows: int = 64max_num_columns: int = 32average_logits_per_cell: bool = Falseselect_one_column: bool = Trueallow_empty_column_selection: bool = Falseinit_cell_selection_weights_to_zero: bool = Falsereset_position_index_per_cell: bool = Truedisable_per_token_loss: bool = Falseaggregation_labels: dict | None = Noneno_aggregation_label_index: int | None = Noneis_decoder: bool = Falseadd_cross_attention: bool = Falsetie_word_embeddings: bool = True )

매개변수

vocab_size (int, 선택 사항, 기본값 30522) — 모델의 어휘 크기입니다. input_ids로 표현할 수 있는 서로 다른 토큰의 수를 정의합니다.
hidden_size (int, 선택 사항, 기본값 768) — 숨겨진 표현의 차원입니다.
num_hidden_layers (int, 선택 사항, 기본값 12) — Transformer 디코더의 숨겨진 레이어 수.
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) — 임베딩, 인코더, 풀러의 모든 완전 연결 계층에 적용되는 드롭아웃 확률입니다.
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을 호출할 때 전달하는 token_type_ids의 어휘 크기입니다.
initializer_range (float, 선택 사항, 기본값 0.02) — 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.
layer_norm_eps (float, 선택 사항, 기본값 1e-12) — 레이어 정규화 레이어에서 사용되는 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, 선택 사항) — aggregation 예제에 대해 답을 유일한 supervision으로 사용할지 여부입니다.
answer_loss_importance (float, 선택 사항, 기본값 1.0) — 회귀 손실의 중요도 가중치입니다.
use_normalized_answer_loss (bool, 선택 사항, 기본값 False) — 예측 값과 기대 값 중 최대값으로 answer loss를 정규화할지 여부입니다.
huber_loss_delta (float, 선택 사항) — 회귀 손실을 계산하는 데 사용되는 Delta 매개변수입니다.
temperature (float, 선택 사항, 기본값 1.0) — 셀 로짓 확률의 왜곡을 제어(또는 변경)하는 데 사용되는 값.
aggregation_temperature (float, 선택 사항, 기본값 1.0) — 확률의 왜곡도를 제어하기 위해 aggregation logits를 스케일링합니다.
use_gumbel_for_cells (bool, 선택 사항, 기본값 False) — 셀 선택에 Gumbel-Softmax를 적용할지 여부입니다.
use_gumbel_for_aggregation (bool, 선택 사항, 기본값 False) — aggregation 선택에 Gumbel-Softmax를 적용할지 여부입니다.
average_approximation_function (string, 선택 사항, 기본값 "ratio") — weak supervision 상황에서 셀의 예상 평균을 계산하는 방법. "ratio", "first_order" 또는 "second_order" 중 하나입니다.
cell_selection_preference (float, 선택 사항) — 모호한 경우의 셀 선택에 대한 선호도. 집계(AGGREGATION)에 대한 약한 지도 학습(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) — 셀 선택 가중치를 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, 선택 사항) — 집계 라벨이 정의되어 있고 그중 하나가 “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와 유사한 구성이 생성됩니다.

Configuration 객체는 PreTrainedConfig를 상속하며 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 PreTrainedConfig의 문서를 참고하세요.

예:

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

class transformers.TapasTokenizer

< source >

( vocab_filedo_lower_case = Truedo_basic_tokenize = Truenever_split = Noneunk_token = '[UNK]'sep_token = '[SEP]'pad_token = '[PAD]'cls_token = '[CLS]'mask_token = '[MASK]'empty_token = '[EMPTY]'tokenize_chinese_chars = Truestrip_accents = Nonecell_trim_length: int = -1max_column_id: int | None = Nonemax_row_id: int | None = Nonestrip_column_names: bool = Falseupdate_answer_coordinates: bool = Falsemin_question_length = Nonemax_question_length = Nonemodel_max_length: int = 512additional_special_tokens: list[str] | None = Noneclean_up_tokenization_spaces = True**kwargs )

매개변수

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]") — 패딩에 사용되는 토큰입니다. 예를 들어, 길이가 다른 시퀀스를 배치(batching)할 때 사용됩니다.
cls_token (str, 선택 사항, 기본값 "[CLS]") — 시퀀스 분류(토큰별 분류가 아닌 전체 시퀀스에 대한 분류)를 수행할 때 사용되는 분류기 토큰입니다. 특수 토큰을 사용하여 시퀀스를 구성할 경우 시퀀스의 첫 번째 토큰입니다.
mask_token (str, 선택 사항, 기본값 "[MASK]") — 값을 마스킹하는 데 사용되는 토큰입니다. 이는 masked language modeling으로 이 모델을 학습시킬 때 사용되는 토큰이며, 모델이 예측을 시도하는 대상이 되는 토큰입니다.
empty_token (str, 선택 사항, 기본값 "[EMPTY]") — 테이블에서 빈 셀 값에 사용되는 토큰입니다. 빈 셀 값에는 "", “n/a”, “nan”, ”?“가 포함됩니다.
tokenize_chinese_chars (bool, 선택, 기본값 True) — 한자 문자를 토큰화할지 여부입니다. 일본어에는 비활성화하는 것이 좋습니다(이 이슈 참조).
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를 상속받습니다. 해당 메서드에 대한 자세한 내용은 이 상위 클래스를 참고하세요. TapasTokenizer는 표 구조를 인코딩하기 위해 여러 token type id를 생성합니다. 구체적으로, 다음 순서로 7개의 token type 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는 표와 관련 문장에 대해 구두점 분할 및 wordpiece를 포함한 end-to-end 토큰화를 수행합니다.

call

< source >

매개변수

table (pd.DataFrame 또는 str 또는 list[str]) — 테이블 데이터를 포함하는 테이블. 모든 셀 값은 텍스트여야 합니다. Pandas dataframe을 문자열로 변환하려면 .astype(str)를 사용하세요. 문자열 또는 문자열 목록을 전달하는 경우, 이는 빈 테이블을 가진 쿼리로 해석됩니다(일반적인 tokenizer 테스트를 지원하기 위함).
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, 선택 사항, 기본값은 False) — 패딩을 활성화하고 제어합니다. 다음 값을 받을 수 있습니다: True 또는 'longest': 배치 내 가장 긴 시퀀스 길이로 패딩합니다(단일 시퀀스만 제공된 경우 패딩하지 않음). 'max_length': max_length 인수로 지정된 최대 길이로 패딩하거나, 해당 인수가 제공되지 않은 경우 모델이 허용하는 최대 입력 길이로 패딩합니다. False 또는 'do_not_pad' (기본값): 패딩하지 않음(즉, 서로 다른 길이의 시퀀스로 구성된 배치 출력 가능).
- 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, 선택 사항) — 설정된 경우, Python 정수 목록 대신 텐서를 반환합니다. 허용되는 값은 다음과 같습니다:
- 'pt': PyTorch torch.Tensor 객체를 반환합니다.
- 'np': Numpy np.ndarray 객체를 반환합니다.

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

convert_logits_to_predictions

< source >

( datalogitslogits_agg = Nonecell_classification_threshold = 0.5 ) → tuple comprising various elements depending on the inputs

매개변수

data (dict) — 특징을 실제 값으로 매핑하는 사전. 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의 logits를 실제 예측된 답변 좌표 및 선택적 집계 인덱스로 변환합니다.

이 함수의 기반이 되는 원래 구현은 여기에서 확인할 수 있습니다.

save_vocabulary

< source >

( save_directory: strfilename_prefix: str | None = None )

TapasModel

class transformers.TapasModel

< source >

( config: TapasConfigadd_pooling_layer = True )

매개변수

config (TapasConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.
add_pooling_layer (bool, 선택 사항, 기본값 True) — pooling layer를 추가할지 여부

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

이 모델은 PreTrainedModel에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대한 세부 사항은 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch torch.nn.Module의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법 및 동작과 관련된 모든 사항은 PyTorch 문서를 참조하세요.

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

매개변수

input_ids (torch.LongTensor 형상이 (batch_size, sequence_length), 선택 사항) — 어휘(input vocabulary)에서 입력 시퀀스 토큰의 인덱스입니다. 기본적으로 패딩은 무시됩니다.
AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

입력 ID란 무엇인가요?
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
어텐션 마스크란 무엇인가요?
token_type_ids (torch.LongTensor 다음 형식의 (batch_size, sequence_length, 7), 선택 사항) — 테이블 구조를 인코딩하는 토큰 인덱스입니다. 인덱스는 AutoTokenizer. 을(를) 사용하여 얻을 수 있습니다. 자세한 내용은 이 클래스를 참조하세요.
토큰 타입 ID란 무엇인가요?
position_ids (torch.LongTensor 의 shape (batch_size, sequence_length), , 선택 사항) — 입력 시퀀스 토큰의 위치 임베딩에서 각 토큰의 위치 인덱스입니다. reset_position_index_per_cell 의 TapasConfig 이 True, 로 설정되어 있으면 상대 위치 임베딩이 사용됩니다. 범위는 [0, config.max_position_embeddings - 1].
포지션 ID란 무엇인가요?
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 시퀀스입니다. 모델이 decoder로 구성된 경우 cross-attention에 사용됩니다.
encoder_attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 인코더 입력의 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 하는 마스크입니다. 모델이 decoder로 구성된 경우 cross-attention에 이 마스크가 사용됩니다. [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
output_attentions (bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 attentions 항목을 참조하세요.
output_hidden_states (bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중 hidden_states 항목을 참고하세요.
return_dict (bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.

반환값

BaseModelOutputWithPooling 또는 tuple(torch.Tensor)

torch.Tensor의 튜플 또는 BaseModelOutputWithPooling (return_dict=False가 전달되었거나 config.return_dict=False인 경우)로, 구성(TapasConfig)과 입력에 따라 다양한 요소를 포함합니다.

TapasModel의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 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 가중치.

예:

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

class transformers.TapasForMaskedLM

< source >

( config: TapasConfig )

매개변수

config (TapasConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MaskedLMOutput or tuple(torch.Tensor)

매개변수

input_ids (torch.LongTensor 형상이 (batch_size, sequence_length), 선택 사항) — 어휘(input vocabulary)에서 입력 시퀀스 토큰의 인덱스입니다. 기본적으로 패딩은 무시됩니다.
AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

입력 ID란 무엇인가요?
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
어텐션 마스크란 무엇인가요?
token_type_ids (torch.LongTensor 다음 형식의 (batch_size, sequence_length, 7), 선택 사항) — 테이블 구조를 인코딩하는 토큰 인덱스입니다. 인덱스는 AutoTokenizer. 을(를) 사용하여 얻을 수 있습니다. 자세한 내용은 이 클래스를 참조하세요.
토큰 타입 ID란 무엇인가요?
position_ids (torch.LongTensor 의 shape (batch_size, sequence_length), , 선택 사항) — 입력 시퀀스 토큰의 위치 임베딩에서 각 토큰의 위치 인덱스입니다. reset_position_index_per_cell 의 TapasConfig 이 True, 로 설정되어 있으면 상대 위치 임베딩이 사용됩니다. 범위는 [0, config.max_position_embeddings - 1].
포지션 ID란 무엇인가요?
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 시퀀스입니다. 모델이 decoder로 구성된 경우 cross-attention에 사용됩니다.
encoder_attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 인코더 입력의 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 하는 마스크입니다. 모델이 decoder로 구성된 경우 cross-attention에 이 마스크가 사용됩니다. [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
labels (torch.LongTensor, shape (batch_size, sequence_length), 선택 사항) — 마스크 언어 모델링 손실을 계산하는 데 사용되는 라벨입니다. 인덱스는 [-100, 0, ..., config.vocab_size] 범위여야 합니다(input_ids docstring 참조). 인덱스가 -100으로 설정된 토큰은 무시(마스크)되며, 손실은 라벨이 [0, ..., config.vocab_size] 범위에 있는 토큰에 대해서만 계산됩니다.
output_attentions (bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 attentions 항목을 참조하세요.
output_hidden_states (bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중 hidden_states 항목을 참고하세요.
return_dict (bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.

반환값

MaskedLMOutput 또는 tuple(torch.Tensor)

torch.Tensor의 튜플 또는 MaskedLMOutput (return_dict=False가 전달되었거나 config.return_dict=False인 경우). 구성(TapasConfig)과 입력에 따라 다양한 요소를 포함합니다.

TapasForMaskedLM의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 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 가중치.

예:

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

class transformers.TapasForSequenceClassification

< source >

( config: TapasConfig )

매개변수

config (TapasConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

시퀀스 분류 헤드가 위에 있는 Tapas 모델(풀링된 출력 위에 선형 레이어가 있는 형태)로, TabFact(Chen et al., 2020)와 같은 테이블 함의(entailment) 작업에 사용할 수 있습니다.

forward

< source >

매개변수

input_ids (torch.LongTensor 형상이 (batch_size, sequence_length), 선택 사항) — 어휘(input vocabulary)에서 입력 시퀀스 토큰의 인덱스입니다. 기본적으로 패딩은 무시됩니다.
AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

입력 ID란 무엇인가요?
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
어텐션 마스크란 무엇인가요?
token_type_ids (torch.LongTensor 다음 형식의 (batch_size, sequence_length, 7), 선택 사항) — 테이블 구조를 인코딩하는 토큰 인덱스입니다. 인덱스는 AutoTokenizer. 을(를) 사용하여 얻을 수 있습니다. 자세한 내용은 이 클래스를 참조하세요.
토큰 타입 ID란 무엇인가요?
position_ids (torch.LongTensor 의 shape (batch_size, sequence_length), , 선택 사항) — 입력 시퀀스 토큰의 위치 임베딩에서 각 토큰의 위치 인덱스입니다. reset_position_index_per_cell 의 TapasConfig 이 True, 로 설정되어 있으면 상대 위치 임베딩이 사용됩니다. 범위는 [0, config.max_position_embeddings - 1].
포지션 ID란 무엇인가요?
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, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 attentions 항목을 참조하세요.
output_hidden_states (bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중 hidden_states 항목을 참고하세요.
return_dict (bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.

반환값

SequenceClassifierOutput 또는 tuple(torch.Tensor)

torch.Tensor의 튜플 또는 SequenceClassifierOutput입니다. return_dict=False가 전달되었거나 config.return_dict=False인 경우를 포함하며, 구성(TapasConfig)과 입력에 따라 다양한 요소를 포함합니다.

TapasForSequenceClassification의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 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 가중치.

예:

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

class transformers.TapasForQuestionAnswering

< source >

( config: TapasConfig )

매개변수

config (TapasConfig) — 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 from_pretrained() 메서드를 확인하세요.

형식 질문 답변 작업을 위해 셀 선택 헤드와 선택적 집계 헤드를 상단에 갖춘 Tapas 모델(숨겨진 상태 출력 위에 선형 레이어를 올려 logits와 선택적 logits_aggregation을 계산), 예: SQA, WTQ 또는 WikiSQL 기반 작업

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonetable_mask: typing.Optional[torch.LongTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneaggregation_labels: typing.Optional[torch.LongTensor] = Nonefloat_answer: typing.Optional[torch.Tensor] = Nonenumeric_values: typing.Optional[torch.Tensor] = Nonenumeric_values_scale: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → TableQuestionAnsweringOutput or tuple(torch.Tensor)

매개변수

input_ids (torch.LongTensor 형상이 (batch_size, sequence_length), 선택 사항) — 어휘(input vocabulary)에서 입력 시퀀스 토큰의 인덱스입니다. 기본적으로 패딩은 무시됩니다.
AutoTokenizer를 사용하여 인덱스를 얻을 수 있습니다. 자세한 내용은 PreTrainedTokenizer.encode() 및 PreTrainedTokenizer.call()를 참조하세요.

입력 ID란 무엇인가요?
attention_mask (torch.Tensor 형상이 (batch_size, sequence_length), 선택 사항) — 패딩 토큰 인덱스에 대한 attention을 수행하지 않도록 방지하는 마스크. [0, 1]에서 선택된 마스크 값: 마스크되지 않은 토큰은 1, 마스크된 토큰은 0. attention mask란 무엇인가요? [0, 1]:
- 마스크되지 않은 토큰에 대해 1
- 마스크된 토큰에 대해 0
어텐션 마스크란 무엇인가요?
token_type_ids (torch.LongTensor 다음 형식의 (batch_size, sequence_length, 7), 선택 사항) — 테이블 구조를 인코딩하는 토큰 인덱스입니다. 인덱스는 AutoTokenizer. 을(를) 사용하여 얻을 수 있습니다. 자세한 내용은 이 클래스를 참조하세요.
토큰 타입 ID란 무엇인가요?
position_ids (torch.LongTensor 의 shape (batch_size, sequence_length), , 선택 사항) — 입력 시퀀스 토큰의 위치 임베딩에서 각 토큰의 위치 인덱스입니다. reset_position_index_per_cell 의 TapasConfig 이 True, 로 설정되어 있으면 상대 위치 임베딩이 사용됩니다. 범위는 [0, config.max_position_embeddings - 1].
포지션 ID란 무엇인가요?
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 형상 (batch_size, seq_length), 선택 사항) — 계층적 셀 선택 손실을 계산하기 위한 토큰별 라벨입니다. 이는 테이블 내에서 답변이 나타나는 위치를 인코딩합니다. 을(를) 사용하여 얻을 수 있습니다. 답변의 일부인 토큰은 1, 답변의 일부가 아닌 토큰은 0입니다..
- 1은 답의 일부인 토큰에 대해
- 답변의 일부가 아닌 토큰에 대해 0
aggregation_labels (torch.LongTensor, shape (batch_size, ), 선택 사항) — aggregation loss를 계산하기 위해 배치 내 각 예시에 대한 aggregation function 인덱스입니다. 인덱스는 [0, ..., config.num_aggregation_labels - 1] 범위에 있어야 합니다. aggregation에 대한 strong supervision(WikiSQL-supervised)을 사용하는 경우에만 필요합니다.
float_answer (torch.Tensor, shape (batch_size, ), 선택) — 배치의 각 예제에 대한 float 답변. 셀 선택 질문의 경우 float(‘nan’)으로 설정합니다. 약한 지도(WTQ)의 경우에만 집계 마스크와 회귀 손실을 계산하기 위해 필요합니다.
numeric_values (torch.Tensor, shape (batch_size, seq_length), 선택 사항) — 각 토큰의 수치 값이며, 수치 값이 아닌 토큰은 NaN입니다. AutoTokenizer를 사용하여 얻을 수 있습니다. 집계(WTQ)에 대한 약한 지도 학습의 경우 회귀 손실을 계산하기 위해만 필요합니다.
numeric_values_scale (torch.Tensor, shape (batch_size, seq_length), 선택 사항) — 각 토큰의 수치 값 스케일입니다. AutoTokenizer를 사용하여 얻을 수 있습니다. 집계용 약한 지도 학습(WTQ)의 경우 회귀 손실을 계산하기 위해만 필요합니다.
output_attentions (bool, 선택 사항) — 모든 attention 레이어의 attentions 텐서를 반환할지 여부. 자세한 내용은 반환 텐서 섹션의 attentions 항목을 참조하세요.
output_hidden_states (bool, 선택 사항) — 모든 레이어의 hidden states를 반환할지 여부입니다. 자세한 내용은 반환되는 텐서 중 hidden_states 항목을 참고하세요.
return_dict (bool, 선택) — 일반 튜플 대신 ModelOutput를 반환할지 여부.

반환값

TableQuestionAnsweringOutput 또는 tuple(torch.Tensor)

torch.Tensor의 튜플 또는 TableQuestionAnsweringOutput(return_dict=False가 전달되었거나 config.return_dict=False인 경우)로, 구성(TapasConfig)과 입력에 따라 다양한 요소를 포함합니다.

TapasForQuestionAnswering의 forward 메서드는 __call__ 특수 메서드를 오버라이드합니다.

이 함수 내에서 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)) — 모든 토큰에 대한 셀 선택 헤드(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의 튜플로, 모양은 (batch_size, num_heads, sequence_length, sequence_length)입니다.

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

예:

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

Update on GitHub

←음성 인코더 디코더 모델 TIPSv2→