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

Model ini dipublikasikan di HF papers pada 2020-04-05 dan disumbangkan ke Hugging Face Transformers pada 2020-12-15.

TAPAS

Ikhtisar

Model TAPAS diusulkan dalam TAPAS: Weakly Supervised Table Parsing via Pre-training oleh Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno, dan Julian Martin Eisenschlos. Ini adalah model berbasis BERT yang dirancang secara khusus (dan telah dilatih sebelumnya) untuk menjawab pertanyaan tentang data tabular. Dibandingkan dengan BERT, TAPAS menggunakan relative position embeddings dan memiliki 7 token types yang mengkodekan struktur tabular. TAPAS dilatih sebelumnya pada tujuan masked language modeling (MLM) menggunakan dataset besar yang terdiri dari jutaan tabel dari Wikipedia berbahasa Inggris dan teks yang bersesuaian.

Untuk question answering, TAPAS memiliki 2 head di atasnya: cell selection head dan aggregation head, untuk (secara opsional) melakukan agregasi (seperti penghitungan atau penjumlahan) di antara sel-sel yang dipilih. TAPAS telah di-fine-tune pada beberapa dataset:

SQA (Sequential Question Answering oleh Microsoft)
WTQ (Wiki Table Questions oleh Stanford University)
WikiSQL (oleh Salesforce).

Model ini mencapai state-of-the-art pada SQA dan WTQ, sekaligus memiliki performa yang sebanding dengan SOTA pada WikiSQL, dengan arsitektur yang jauh lebih sederhana.

Abstrak dari makalah tersebut adalah sebagai berikut:

Menjawab pertanyaan bahasa alami atas tabel biasanya dipandang sebagai tugas semantic parsing. Untuk mengurangi biaya pengumpulan logical forms yang lengkap, satu pendekatan populer berfokus pada weak supervision yang terdiri dari denotations alih-alih logical forms. Namun, melatih semantic parsers dari weak supervision menimbulkan kesulitan, dan selain itu, logical forms yang dihasilkan hanya digunakan sebagai langkah perantara sebelum mengambil denotation. Dalam makalah ini, kami menyajikan TAPAS, sebuah pendekatan untuk question answering atas tabel tanpa menghasilkan logical forms. TAPAS dilatih dari weak supervision, dan memprediksi denotation dengan memilih sel tabel dan secara opsional menerapkan operator agregasi yang sesuai pada seleksi tersebut. TAPAS memperluas arsitektur BERT untuk mengkodekan tabel sebagai input, diinisialisasi dari pre-training gabungan yang efektif untuk segmen teks dan tabel yang diambil dari Wikipedia, dan dilatih secara end-to-end. Kami bereksperimen dengan tiga dataset semantic parsing yang berbeda, dan menemukan bahwa TAPAS melampaui atau setara dengan model semantic parsing dengan meningkatkan akurasi state-of-the-art pada SQA dari 55,1 menjadi 67,2 dan berkinerja setara dengan state-of-the-art pada WIKISQL dan WIKITQ, tetapi dengan arsitektur model yang lebih sederhana. Kami juga menemukan bahwa transfer learning, yang sederhana dalam pengaturan kami, dari WIKISQL ke WIKITQ, menghasilkan akurasi 48,7, 4,2 poin di atas state-of-the-art.

Selain itu, para penulis telah melakukan pra-pelatihan lebih lanjut pada TAPAS untuk mengenali table entailment, dengan membuat dataset seimbang yang terdiri dari jutaan contoh pelatihan yang dibuat secara otomatis dan dipelajari dalam langkah perantara sebelum fine-tuning. Para penulis TAPAS menyebut pra-pelatihan lanjutan ini sebagai intermediate pre-training (karena TAPAS pertama kali dipra-latih pada MLM, lalu pada dataset lain). Mereka menemukan bahwa intermediate pre-training semakin meningkatkan kinerja pada SQA, mencapai state-of-the-art baru serta state-of-the-art pada TabFact, sebuah dataset berskala besar dengan 16k tabel Wikipedia untuk table entailment (tugas klasifikasi biner). Untuk detail lebih lanjut, lihat paper lanjutan mereka: Understanding tables with intermediate pre-training oleh Julian Martin Eisenschlos, Syrine Krichene, dan Thomas Müller.

TAPAS architecture. Taken from the original blog post.

Model ini disumbangkan oleh nielsr. Kode aslinya dapat ditemukan di sini.

Tips penggunaan

TAPAS adalah model yang secara default menggunakan relative position embeddings (menyiapkan ulang position embeddings di setiap sel tabel). Perhatikan bahwa ini adalah hal yang ditambahkan setelah publikasi paper TAPAS asli. Menurut para penulis, hal ini biasanya menghasilkan performa yang sedikit lebih baik, dan memungkinkan Anda untuk meng-encode sequence yang lebih panjang tanpa kehabisan embeddings. Hal ini tercermin pada parameter reset_position_index_per_cell dari TapasConfig, yang secara default diatur ke True. Versi default dari model-model yang tersedia di hub semuanya menggunakan relative position embeddings. Anda tetap dapat menggunakan model dengan absolute position embeddings dengan menambahkan argumen revision="no_reset" saat memanggil metode from_pretrained(). Perhatikan bahwa biasanya disarankan untuk melakukan padding input di sisi kanan, bukan di sisi kiri.
TAPAS didasarkan pada BERT, sehingga misalnya TAPAS-base sesuai dengan arsitektur BERT-base. Tentu saja, TAPAS-large akan menghasilkan kinerja terbaik (hasil yang dilaporkan dalam makalah berasal dari TAPAS-large). Hasil dari berbagai model berukuran berbeda ditampilkan di repositori GitHub asli.
TAPAS memiliki checkpoint yang telah dihaluskan (fine-tuned) pada SQA, yang mampu menjawab pertanyaan terkait tabel dalam konteks percakapan. Artinya, Anda dapat mengajukan pertanyaan lanjutan seperti “berapa usianya?” yang berkaitan dengan pertanyaan sebelumnya. Perhatikan bahwa forward pass dari TAPAS sedikit berbeda dalam konteks percakapan: dalam kasus tersebut, Anda harus memasangkan setiap pasangan tabel-pertanyaan satu per satu ke model, sehingga token type ids prev_labels dapat ditimpa oleh labels yang diprediksi model untuk pertanyaan sebelumnya. Lihat bagian “Usage” untuk informasi lebih lanjut.
TAPAS mirip dengan BERT dan karenanya bergantung pada tujuan pemodelan bahasa tersembunyi (masked language modeling/MLM). Oleh karena itu, model ini efisien dalam memprediksi token yang tersembunyi dan dalam NLU secara umum, tetapi tidak optimal untuk generasi teks. Model yang dilatih dengan tujuan pemodelan bahasa kausal (causal language modeling/CLM) lebih baik dalam hal tersebut. Perlu dicatat bahwa TAPAS dapat digunakan sebagai encoder dalam kerangka EncoderDecoderModel, untuk menggabungkannya dengan decoder teks autoregresif seperti GPT-2.

Penggunaan: fine-tuning

Di sini kami menjelaskan cara Anda dapat melakukan fine-tuning pada TapasForQuestionAnswering menggunakan dataset Anda sendiri.

LANGKAH 1: Pilih salah satu dari 3 cara penggunaan TAPAS - atau bereksperimen

Pada dasarnya, ada 3 cara berbeda untuk melakukan fine-tuning pada TapasForQuestionAnswering, yang sesuai dengan dataset berbeda tempat Tapas di-fine-tune:

SQA: jika Anda tertarik untuk mengajukan pertanyaan lanjutan yang terkait dengan tabel, dalam pengaturan percakapan. Misalnya, jika Anda pertama kali bertanya “apa nama aktor pertama?” lalu Anda dapat mengajukan pertanyaan lanjutan seperti “berapa usianya?”. Di sini, pertanyaan tidak melibatkan agregasi apa pun (semua pertanyaan adalah pertanyaan seleksi sel).
WTQ: jika Anda tidak tertarik untuk mengajukan pertanyaan dalam format percakapan, melainkan hanya mengajukan pertanyaan yang berkaitan dengan tabel, yang mungkin melibatkan agregasi, seperti menghitung jumlah baris, menjumlahkan nilai sel, atau menghitung rata-rata nilai sel. Anda kemudian dapat, misalnya, bertanya “berapa total jumlah gol yang dicetak Cristiano Ronaldo sepanjang kariernya?”. Kasus ini juga disebut weak supervision, karena model itu sendiri harus mempelajari operator agregasi yang tepat (SUM/COUNT/AVERAGE/NONE) dengan hanya menggunakan jawaban atas pertanyaan tersebut sebagai supervisi.
WikiSQL-supervised: dataset ini didasarkan pada WikiSQL, di mana model diberikan operator agregasi ground truth selama pelatihan. Hal ini juga disebut sebagai strong supervision. Di sini, mempelajari operator agregasi yang tepat menjadi jauh lebih mudah.

Sebagai ringkasan:

Tugas	Contoh dataset	Deskripsi
Konversasional	SQA	Konversasi, hanya pertanyaan pemilihan sel
Supervisi lemah untuk agregasi	WTQ	Pertanyaan mungkin melibatkan agregasi, dan model harus mempelajari hal ini hanya dengan jawaban sebagai supervisi
Supervisi kuat untuk agregasi	Supervised WikiSQL	Pertanyaan mungkin melibatkan agregasi, dan model harus mempelajari hal ini berdasarkan operator agregasi emas

Inisialisasi model dengan basis terlatih sebelumnya dan kepala klasifikasi yang diinisialisasi secara acak dari hub dapat dilakukan seperti yang ditunjukkan di bawah ini.

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

Tentu saja, Anda tidak harus mengikuti salah satu dari tiga cara di mana TAPAS telah di-*fine-tune*. Anda juga dapat bereksperimen dengan mendefinisikan hiperparameter apa pun yang Anda inginkan saat menginisialisasi TapasConfig, lalu membuat TapasForQuestionAnswering berdasarkan konfigurasi tersebut. Misalnya, jika Anda memiliki dataset yang berisi pertanyaan konversasi dan pertanyaan yang mungkin melibatkan agregasi, Anda dapat melakukannya dengan cara ini. Berikut adalah contohnya:

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

Anda juga dapat memulai dari checkpoint yang sudah di-fine-tune. Perlu dicatat bahwa checkpoint yang sudah di-fine-tune pada WTQ memiliki beberapa masalah akibat L2-loss yang cukup rapuh. Lihat di sini untuk informasi lebih lanjut.

Untuk daftar semua checkpoint TAPAS yang telah dilatih sebelumnya dan disempurnakan yang tersedia di hub HuggingFace, lihat di sini.

LANGKAH 2: Siapkan data Anda dalam format SQA

Kedua, apa pun pilihan Anda di atas, Anda harus menyiapkan dataset Anda dalam format SQA. Format ini adalah file TSV/CSV dengan kolom-kolom berikut:

id: opsional, id dari pasangan tabel-pertanyaan, untuk keperluan pencatatan.
annotator: opsional, id orang yang meng anotasi pasangan tabel-pertanyaan, untuk keperluan pencatatan.
position: bilangan bulat yang menunjukkan apakah pertanyaan tersebut merupakan pertanyaan pertama, kedua, ketiga, yang terkait dengan tabel. Hanya diperlukan dalam kasus setup percakapan (SQA). Anda tidak perlu kolom ini jika Anda menggunakan supervised WTQ/WikiSQL.
question: string
table_file: string, nama file csv yang berisi data tabular
answer_coordinates: daftar satu atau lebih tuple (masing-masing tuple berupa koordinat sel, yaitu pasangan baris dan kolom yang merupakan bagian dari jawaban)
answer_text: daftar satu atau lebih string (masing-masing string adalah nilai sel yang merupakan bagian dari jawaban)
aggregation_label: indeks dari operator agregasi. Hanya diperlukan dalam kasus supervisi kuat untuk agregasi (kasus WikiSQL-supervised)
float_answer: jawaban float untuk pertanyaan tersebut, jika ada (np.nan jika tidak ada). Hanya diperlukan dalam kasus supervisi lemah untuk agregasi (seperti WTQ dan WikiSQL)

Tabel-tabel tersebut seharusnya berada dalam sebuah folder, di mana setiap tabel merupakan file csv terpisah. Perhatikan bahwa para penulis algoritma TAPAS menggunakan skrip konversi dengan beberapa logika otomatis untuk mengonversi dataset lain (WTQ, WikiSQL) ke format SQA. Penulis menjelaskan hal ini di sini. Konversi dari skrip ini yang bekerja dengan implementasi HuggingFace dapat ditemukan di sini. Menariknya, skrip konversi ini tidak sempurna (field answer_coordinates dan float_answer diisi berdasarkan answer_text), yang berarti hasil WTQ dan WikiSQL sebenarnya bisa ditingkatkan.

LANGKAH 3: Konversi data Anda menjadi tensor menggunakan TapasTokenizer

Ketiga, mengingat Anda telah menyiapkan data dalam format TSV/CSV ini (dan file CSV yang sesuai yang berisi data tabular), Anda kemudian dapat menggunakan TapasTokenizer untuk mengubah pasangan tabel-pertanyaan menjadi input_ids, attention_mask, token_type_ids, dan seterusnya. Sekali lagi, berdasarkan kasus mana dari tiga kasus di atas yang Anda pilih, TapasForQuestionAnswering memerlukan input yang berbeda untuk fine-tuning:

Tugas	Input yang diperlukan
Konversasional	`input_ids`, `attention_mask`, `token_type_ids`, `labels`
Supervisi lemah untuk agregasi	`input_ids`, `attention_mask`, `token_type_ids`, `labels`, `numeric_values`, `numeric_values_scale`, `float_answer`
Supervisi kuat untuk agregasi	`input ids`, `attention mask`, `token type ids`, `labels`, `aggregation_labels`

TapasTokenizer membuat labels, numeric_values, dan numeric_values_scale berdasarkan kolom answer_coordinates dan answer_text dari file TSV. float_answer dan aggregation_labels sudah ada di file TSV dari langkah 2. Berikut adalah contohnya:

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([[ ]])}

Perhatikan bahwa TapasTokenizer mengharapkan data tabel berupa teks saja. Anda dapat menggunakan .astype(str) pada dataframe untuk mengubahnya menjadi data teks saja. Tentu saja, ini hanya menunjukkan cara meng-encode satu contoh pelatihan. Disarankan untuk membuat dataloader untuk mengiterasi batch:

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)

Perhatikan bahwa di sini, setiap pasangan tabel-pertanyaan dikodekan secara independen. Hal ini tidak masalah selama dataset Anda bukan bersifat percakapan. Jika dataset Anda melibatkan pertanyaan percakapan (seperti pada SQA), maka Anda harus terlebih dahulu mengelompokkan queries, answer_coordinates, dan answer_text per tabel (sesuai urutan indeks position) dan melakukan batch encoding untuk setiap tabel beserta pertanyaannya. Hal ini akan memastikan bahwa tipe token prev_labels (lihat dokumentasi TapasTokenizer) diset dengan benar. Lihat notebook ini untuk informasi lebih lanjut.

**LANGKAH 4: Latih (fine-tune) model

Anda kemudian dapat melakukan fine-tuning pada TapasForQuestionAnswering sebagai berikut (ditampilkan di sini untuk kasus weak supervision pada agregasi):

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

Penggunaan: inferensi

Di sini kami menjelaskan cara Anda dapat menggunakan TapasForQuestionAnswering untuk inferensi (yaitu membuat prediksi pada data baru). Untuk inferensi, hanya input_ids, attention_mask, dan token_type_ids (yang dapat Anda peroleh menggunakan TapasTokenizer) yang perlu diberikan ke model untuk mendapatkan logits. Selanjutnya, Anda dapat menggunakan metode ~models.tapas.tokenization_tapas.convert_logits_to_predictions yang praktis untuk mengonversi logits tersebut menjadi koordinat prediksi dan indeks agregasi opsional.

Namun, perhatikan bahwa inferensi berbeda tergantung pada apakah setup bersifat konversasional atau tidak. Pada setup non-konversasional, inferensi dapat dilakukan secara paralel pada semua pasangan tabel-pertanyaan dalam sebuah batch. Berikut adalah contohnya:

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

Dalam kasus konfigurasi percakapan, setiap pasangan tabel-pertanyaan harus diberikan secara berurutan ke model, sehingga tipe token prev_labels dapat ditimpa oleh labels yang diprediksi dari pasangan tabel-pertanyaan sebelumnya. Sekali lagi, informasi lebih lanjut dapat ditemukan di notebook ini.

Sumber daya

Output khusus TAPAS

kelas transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput

< source >

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

Parameter

loss (torch.FloatTensor dengan bentuk (1,), opsional, dikembalikan ketika labels (dan mungkin answer, aggregation_labels, numeric_values dan numeric_values_scale disediakan)) — Total loss sebagai jumlah dari log-likelihood loss untuk seleksi sel hierarkis dan (secara opsional) semi-supervised regression loss dan (secara opsional) supervised loss untuk agregasi.
logits (torch.FloatTensor dengan bentuk (batch_size, sequence_length)) — Skor prediksi dari kepala seleksi sel, untuk setiap token.
logits_aggregation (torch.FloatTensor, opsional, dengan bentuk (batch_size, num_aggregation_labels)) — Skor prediksi dari kepala agregasi, untuk setiap operator agregasi.
hidden_states (tuple[torch.FloatTensor], opsional, dikembalikan ketika output_hidden_states=True dilewatkan atau ketika config.output_hidden_states=True) — Tuple dari torch.FloatTensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk (batch_size, sequence_length, hidden_size).
Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (tuple[torch.FloatTensor], opsional, dikembalikan ketika output_attentions=True dilewatkan atau ketika config.output_attentions=True) — Tuple dari torch.FloatTensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).
Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

Jenis output dari TapasForQuestionAnswering.

TapasConfig

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

Parameter

vocab_size (int, opsional, default 30522) — Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh input_ids.
hidden_size (int, opsional, default 768) — Dimensi dari representasi tersembunyi.
num_hidden_layers (int, opsional, default 12) — Jumlah lapisan tersembunyi dalam decoder Transformer.
num_attention_heads (int, opsional, default 12) — Jumlah attention head untuk setiap lapisan attention di decoder Transformer.
intermediate_size (int, opsional, default 3072) — Dimensi representasi MLP.
hidden_act (str, opsional, defaultnya gelu) — Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, "gelu", "relu", "silu", dan sebagainya.
hidden_dropout_prob (Union[float, int], opsional, default 0.1) — Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler.
attention_probs_dropout_prob (Union[float, int], opsional, default 0.1) — Rasio dropout untuk probabilitas perhatian.
max_position_embeddings (int, opsional, default 1024) — Panjang maksimum urutan yang mungkin digunakan dengan model ini.
type_vocab_sizes (list[int], opsional, default [3, 256, 256, 2, 256, 256, 10]) — Ukuran kosakata dari token_type_ids yang diteruskan saat memanggil TapasModel.
initializer_range (float, opsional, defaultnya 0.02) — Standar deviasi dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.
layer_norm_eps (float, opsional, defaultnya 1e-12) — Epsilon yang digunakan oleh lapisan normalisasi lapisan.
pad_token_id (int, opsional, default 0) — ID token yang digunakan untuk padding dalam kosakata.
bos_token_id (int, opsional) — ID token yang digunakan untuk awal aliran (beginning-of-stream) dalam kosakata.
eos_token_id (Union[int, list[int]], opsional) — ID token yang digunakan untuk akhir aliran dalam kosakata.
positive_label_weight (float, opsional, default 10.0) — Bobot untuk label positif.
num_aggregation_labels (int, opsional, default 0) — Jumlah operator agregasi yang akan diprediksi.
aggregation_loss_weight (float, opsional, default 1.0) — Bobot kepentingan untuk loss agregasi.
use_answer_as_supervision (bool, opsional) — Apakah akan menggunakan jawaban sebagai satu-satunya supervisi untuk contoh agregasi.
answer_loss_importance (float, opsional, default 1.0) — Bobot kepentingan untuk regresi loss.
use_normalized_answer_loss (bool, opsional, default False) — Apakah akan menormalisasi loss jawaban berdasarkan nilai maksimum dari prediksi dan nilai yang diharapkan.
huber_loss_delta (float, opsional) — Parameter delta yang digunakan untuk menghitung loss regresi.
temperature (float, opsional, default 1.0) — Nilai yang digunakan untuk mengontrol (atau mengubah) kemiringan probabilitas logits sel.
aggregation_temperature (float, opsional, default 1.0) — Menskala logits agregasi untuk mengendalikan kemiringan probabilitas.
use_gumbel_for_cells (bool, opsional, default False) — Apakah akan menerapkan Gumbel-Softmax pada pemilihan sel.
use_gumbel_for_aggregation (bool, opsional, default False) — Apakah akan menerapkan Gumbel-Softmax pada pemilihan agregasi.
average_approximation_function (string, opsional, default "ratio") — Metode untuk menghitung rata-rata yang diharapkan dari sel dalam kasus supervisi lemah. Salah satu dari "ratio", "first_order" atau "second_order".
cell_selection_preference (float, opsional) — Preferensi untuk pemilihan sel dalam kasus yang ambigu. Hanya berlaku untuk kasus supervisi lemah pada agregasi (WTQ, WikiSQL). Jika total massa probabilitas agregasi (mengabaikan operator “NONE”) lebih tinggi dari hiperparameter ini, maka agregasi diprediksi untuk contoh tersebut.
answer_loss_cutoff (float, opsional) — Abaikan contoh dengan answer loss yang lebih besar dari cutoff.
max_num_rows (int, opsional, default 64) — Jumlah baris maksimum.
max_num_columns (int, opsional, default 32) — Jumlah maksimum kolom.
average_logits_per_cell (bool, opsional, default False) — Apakah logits akan dirata-rata per sel.
select_one_column (bool, opsional, default True) — Apakah model dibatasi untuk hanya memilih sel dari satu kolom.
allow_empty_column_selection (bool, opsional, default False) — Apakah mengizinkan tidak memilih kolom apa pun.
init_cell_selection_weights_to_zero (bool, opsional, default False) — Apakah akan menginisialisasi bobot seleksi sel ke 0 sehingga probabilitas awalnya menjadi 50%.
reset_position_index_per_cell (bool, opsional, default True) — Apakah indeks posisi akan direset di setiap sel (yaitu menggunakan relative position embeddings).
disable_per_token_loss (bool, opsional, default False) — Apakah akan menonaktifkan pengawasan (kuat atau lemah) pada sel.
aggregation_labels (dict[int, label], opsional) — Label agregasi yang digunakan untuk mengagregasi hasil. Sebagai contoh, model WTQ memiliki label agregasi berikut: {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
no_aggregation_label_index (int, opsional) — Jika label agregasi didefinisikan dan salah satu label tersebut mewakili “No aggregation”, nilai ini harus diatur ke indeksnya. Misalnya, model WTQ memiliki label agregasi “NONE” pada indeks 0, sehingga nilai tersebut harus diatur ke 0 untuk model-model ini.
is_decoder (bool, opsional, default False) — Apakah model digunakan sebagai decoder atau tidak. Jika False, model digunakan sebagai encoder.
add_cross_attention (bool, opsional, default False) — Apakah lapisan cross-attention harus ditambahkan ke model.
tie_word_embeddings (bool, opsional, default True) — Apakah akan mengikat bobot embedding sesuai dengan pemetaan tied_weights_keys model.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari TapasModel. Kelas ini digunakan untuk membuat instans model Tapas berdasarkan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari google/tapas-base-finetuned-sqa

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Contoh:

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

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

Parameter

vocab_file (str) — File yang berisi kosakata.
do_lower_case (bool, opsional, default True) — Apakah akan mengubah input menjadi huruf kecil saat melakukan tokenisasi.
do_basic_tokenize (bool, opsional, default True) — Apakah akan melakukan tokenisasi dasar sebelum WordPiece.
never_split (Iterable, opsional) — Kumpulan token yang tidak akan pernah dipecah selama tokenisasi. Hanya memiliki efek ketika do_basic_tokenize=True
unk_token (str, opsional, default "[UNK]") — Token yang tidak diketahui. Token yang tidak ada dalam kosakata tidak dapat dikonversi menjadi ID dan akan diset sebagai token ini sebagai gantinya.
sep_token (str, opsional, default "[SEP]") — Token pemisah, yang digunakan saat membangun urutan dari beberapa urutan, misalnya dua urutan untuk klasifikasi urutan atau untuk teks dan pertanyaan untuk penjawaban pertanyaan. Token ini juga digunakan sebagai token terakhir dari urutan yang dibangun dengan token khusus.
pad_token (str, opsional, defaultnya "[PAD]") — Token yang digunakan untuk padding, misalnya saat membatching urutan dengan panjang yang berbeda.
cls_token (str, opsional, default "[CLS]") — Token klasifikator yang digunakan saat melakukan klasifikasi sekuens (klasifikasi seluruh sekuens, bukan klasifikasi per-token). Token ini merupakan token pertama dari sekuens ketika dibangun dengan token khusus.
mask_token (str, opsional, default "[MASK]") — Token yang digunakan untuk memask nilai. Ini adalah token yang digunakan saat melatih model ini dengan masked language modeling. Ini adalah token yang akan diprediksi oleh model.
empty_token (str, opsional, default "[EMPTY]") — Token yang digunakan untuk nilai sel kosong dalam tabel. Nilai sel kosong mencakup "", “n/a”, “nan”, dan ”?“.
tokenize_chinese_chars (bool, opsional, default True) — Apakah akan melakukan tokenisasi karakter Tionghoa. Opsi ini sebaiknya dinonaktifkan untuk bahasa Jepang (lihat isu ini).
strip_accents (bool, opsional) — Apakah akan menghapus semua aksen. Jika opsi ini tidak ditentukan, maka nilainya akan ditentukan oleh nilai lowercase (seperti pada BERT asli).
cell_trim_length (int, opsional, default -1) — Jika > 0: Potong sel agar panjangnya <= nilai ini. Juga menonaktifkan pemotongan sel lebih lanjut, sehingga sebaiknya digunakan dengan truncation diatur ke True.
max_column_id (int, opsional) — ID kolom maksimum yang akan diekstrak.
max_row_id (int, opsional) — ID baris maksimum yang akan diekstrak.
strip_column_names (bool, opsional, default False) — Apakah akan menambahkan string kosong alih-alih nama kolom.
update_answer_coordinates (bool, opsional, default False) — Apakah akan menghitung ulang koordinat jawaban dari teks jawaban.
min_question_length (int, opsional) — Panjang minimum setiap pertanyaan dalam satuan token (akan dilewati jika tidak memenuhi).
max_question_length (int, opsional) — Panjang maksimum setiap pertanyaan dalam satuan token (akan dilewati jika tidak).
clean_up_tokenization_spaces (bool, opsional, default True) — Apakah akan membersihkan spasi setelah decoding. Pembersihan terdiri dari menghapus artefak potensial seperti spasi berlebih.

Membangun tokenizer TAPAS. Berbasis pada WordPiece. Meratakan tabel dan satu atau beberapa kalimat terkait untuk digunakan oleh model TAPAS.

Tokenizer ini mewarisi dari PreTrainedTokenizer yang berisi sebagian besar metode utama. Pengguna sebaiknya merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut. TapasTokenizer membuat beberapa token type id untuk mengkodekan struktur tabel. Lebih tepatnya, ia menambahkan 7 token type id, dalam urutan berikut: segment_ids, column_ids, row_ids, prev_labels, column_ranks, inv_column_ranks dan numeric_relations:

segment_ids: menunjukkan apakah sebuah token termasuk ke dalam pertanyaan (0) atau tabel (1). 0 untuk token khusus dan padding.
column_ids: menunjukkan kolom tabel mana yang dimiliki oleh sebuah token (dimulai dari 1). Nilainya 0 untuk semua token pertanyaan, token khusus, dan padding.
row_ids: menunjukkan baris tabel mana yang dimiliki oleh sebuah token (dimulai dari 1). Nilainya 0 untuk semua token pertanyaan, token khusus, dan padding. Token dari header kolom juga bernilai 0.
prev_labels: menunjukkan apakah sebuah token merupakan (bagian dari) jawaban untuk pertanyaan sebelumnya (1) atau tidak (0). Berguna dalam pengaturan percakapan (seperti SQA).
column_ranks: menunjukkan peringkat token tabel relatif terhadap kolom, jika berlaku. Misalnya, jika Anda memiliki kolom “number of movies” dengan nilai 87, 53, dan 69, maka peringkat kolom token-token tersebut masing-masing adalah 3, 1, dan 2. Nilai 0 untuk semua token pertanyaan, token khusus, dan padding.
inv_column_ranks: menunjukkan peringkat invers dari token tabel relatif terhadap kolom, jika berlaku. Misalnya, jika Anda memiliki kolom “number of movies” dengan nilai 87, 53, dan 69, maka peringkat invers kolom dari token-token ini adalah 1, 3, dan 2 masing-masing. 0 untuk semua token pertanyaan, token khusus, dan padding.
numeric_relations: menunjukkan hubungan numerik antara pertanyaan dan token dari tabel. 0 untuk semua token pertanyaan, token khusus, dan padding.

TapasTokenizer menjalankan tokenisasi end-to-end pada tabel dan kalimat terkait: pemisahan tanda baca dan wordpiece.

call

< source >

Parameter

table (pd.DataFrame atau str atau list[str]) — Tabel yang berisi data tabular. Perhatikan bahwa semua nilai sel harus berupa teks. Gunakan .astype(str) pada dataframe Pandas untuk mengonversinya menjadi string. Ketika string atau daftar string diberikan, nilai-nilai tersebut akan diinterpretasikan sebagai query dengan tabel kosong (untuk mendukung pengujian tokenizer generik).
queries (str atau list[str]) — Pertanyaan atau kumpulan pertanyaan terkait tabel yang akan di-encode. Perhatikan bahwa dalam kasus kumpulan, semua pertanyaan harus merujuk ke tabel yang sama.
answer_coordinates (list[Tuple] atau list[list[Tuple]], opsional) — Koordinat jawaban untuk setiap pasangan tabel-pertanyaan dalam batch. Jika hanya satu pasangan tabel-pertanyaan yang diberikan, maka answer_coordinates harus berupa satu list yang berisi satu atau lebih tuple. Setiap tuple harus berupa pasangan (row_index, column_index). Baris data pertama (bukan baris header kolom) memiliki indeks 0. Kolom pertama memiliki indeks 0. Jika batch pasangan tabel-pertanyaan diberikan, maka answer_coordinates harus berupa list of lists of tuples (setiap list sesuai dengan satu pasangan tabel-pertanyaan).
answer_text (list[str] atau list[list[str]], opsional) — Teks jawaban untuk setiap pasangan tabel-pertanyaan dalam batch. Jika hanya satu pasangan tabel-pertanyaan yang diberikan, maka answer_text harus berupa satu list yang berisi satu atau lebih string. Setiap string harus merupakan teks jawaban dari koordinat jawaban yang bersesuaian. Jika batch pasangan tabel-pertanyaan diberikan, maka answer_coordinates harus berupa list of lists of strings (setiap list bersesuaian dengan satu pasangan tabel-pertanyaan).
add_special_tokens (bool, opsional, default True) — Apakah akan mengkodekan urutan dengan token khusus yang relatif terhadap modelnya.
padding (bool, str atau PaddingStrategy, opsional, defaultnya False) — Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:
- True atau 'longest': Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan).
- 'max_length': Pad hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan.
- False atau 'do_not_pad' (default): Tidak ada padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda).
truncation (bool, str atau TapasTruncationStrategy, opsional, defaultnya False) — Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:
- True atau 'drop_rows_to_fit': Memotong hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Hal ini akan memotong baris per baris, dengan menghapus baris dari tabel.
- False atau 'do_not_truncate' (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang sekuens yang lebih besar dari ukuran input maksimum yang diizinkan model).
max_length (int, opsional) — Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding.
Jika tidak disetel atau disetel ke None, ini akan menggunakan panjang maksimum model yang telah didefinisikan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan.
is_split_into_words (bool, opsional, default False) — Apakah input sudah di-pre-tokenisasi (misalnya, dipecah menjadi kata). Jika disetel ke True, tokenizer mengasumsikan input sudah dipecah menjadi kata (misalnya, dengan memisahkannya berdasarkan spasi) yang akan ditokenisasi. Ini berguna untuk NER atau klasifikasi token.
pad_to_multiple_of (int, opsional) — Jika diset, akan melakukan padding pada urutan hingga menjadi kelipatan dari nilai yang diberikan. Ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan kemampuan komputasi >= 7.5 (Volta).
return_tensors (str atau TensorType, opsional) — Jika diset, akan mengembalikan tensor alih-alih daftar integer Python. Nilai yang dapat diterima adalah:
- 'pt': Mengembalikan objek PyTorch torch.Tensor.
- 'np': Mengembalikan objek Numpy np.ndarray.

Metode utama untuk melakukan tokenisasi dan persiapan satu atau beberapa sekuens yang terkait dengan tabel untuk model.

convert_logits_to_predictions

< source >

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

Parameter

data (dict) — Kamus yang memetakan fitur ke nilai sebenarnya. Seharusnya dibuat menggunakan TapasTokenizer.
logits (torch.Tensor dengan bentuk (batch_size, sequence_length)) — Tensor yang berisi logits pada tingkat token.
logits_agg (torch.Tensor dengan bentuk (batch_size, num_aggregation_labels), opsional) — Tensor yang berisi logits agregasi.
cell_classification_threshold (float, opsional, default 0.5) — Ambang batas yang digunakan untuk pemilihan sel. Semua sel tabel yang probabilitasnya lebih besar dari ambang batas ini akan dipilih.

Mengembalikan

tuple yang terdiri dari berbagai elemen tergantung pada input

predicted_answer_coordinates (list[list[[tuple]] dengan panjang batch_size): Koordinat jawaban yang diprediksi sebagai daftar dari daftar tuple. Setiap elemen dalam daftar berisi koordinat jawaban yang diprediksi untuk satu contoh dalam batch, sebagai daftar tuple. Setiap tuple adalah sel, yaitu (indeks baris, indeks kolom).
predicted_aggregation_indices (list[int]berpanjang batch_size, opsional, dikembalikan saat logits_aggregation disediakan): Indeks operator agregasi yang diprediksi oleh kepala agregasi.

Mengonversi logits dari TapasForQuestionAnswering menjadi koordinat jawaban prediksi yang sebenarnya dan indeks agregasi opsional.

Implementasi asli, yang menjadi dasar fungsi ini, dapat ditemukan di sini.

save_vocabulary

< source >

( save_directory: strfilename_prefix: str | None = None )

TapasModel

kelas transformers.TapasModel

< source >

( config: TapasConfigadd_pooling_layer = True )

Parameter

config (TapasConfig) — Kelas konfigurasi model yang berisi semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya saja. Lihat metode from_pretrained() untuk memuat bobot model.
add_pooling_layer (bool, opsional, default True) — Apakah akan menambahkan lapisan pooling

Model Tapas polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)

Model ini juga merupakan subclass dari torch.nn.Module PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

forward

< source >

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

Parameter

input_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.
Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.

Apa itu input ID?
attention_mask (torch.FloatTensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari [0, 1]:
- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
Apa itu attention mask?
token_type_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length, 7), opsional) — Indeks token yang mengkodekan struktur tabular. Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat kelas ini untuk informasi lebih lanjut.
Apa itu token type ID?
position_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks posisi dari setiap token dalam urutan input pada position embeddings. Jika reset_position_index_per_cell dari diatur ke True, position embeddings relatif akan digunakan. Dipilih dalam rentang [0, config.max_position_embeddings - 1].
Apa itu ID posisi?
inputs_embeds (torch.FloatTensor dengan bentuk (batch_size, sequence_length, hidden_size), opsional) — Secara opsional, alih-alih meneruskan input_ids, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Hal ini berguna jika Anda ingin memiliki kendali lebih atas cara mengonversi indeks input_ids menjadi vektor terkait, dibandingkan dengan matriks pencarian penanaman internal model.
encoder_hidden_states (torch.FloatTensor dengan bentuk (batch_size, sequence_length, hidden_size), opsional) — Urutan hidden-states pada keluaran lapisan terakhir encoder. Digunakan dalam cross-attention jika model dikonfigurasi sebagai decoder.
encoder_attention_mask (torch.FloatTensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding dari input encoder. Mask ini digunakan dalam cross-attention jika model dikonfigurasi sebagai decoder. Nilai mask dipilih dari [0, 1]:
- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
output_attentions (bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihat attentions di bawah tensor yang dikembalikan untuk detail lebih lanjut.
output_hidden_states (bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihat hidden_states di bawah tensor yang dikembalikan untuk detail lebih lanjut.
return_dict (bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa.

Mengembalikan

BaseModelOutputWithPooling atau tuple(torch.FloatTensor)

Sebuah BaseModelOutputWithPooling atau tuple dari torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (TapasConfig) dan input.

Metode forward dari TapasModel menimpa metode khusus __call__.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance Module setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

last_hidden_state (torch.FloatTensor dengan bentuk (batch_size, sequence_length, hidden_size)) — Urutan hidden-states pada keluaran lapisan terakhir model.
pooler_output (torch.FloatTensor dengan bentuk (batch_size, hidden_size)) — State tersembunyi dari lapisan terakhir untuk token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
hidden_states (tuple(torch.FloatTensor), opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.FloatTensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk (batch_size, sequence_length, hidden_size).

Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (tuple(torch.FloatTensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.FloatTensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

Contoh:

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

kelas transformers.TapasForMaskedLM

< source >

( config: TapasConfig )

Parameter

config (TapasConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.

Model Tapas dengan kepala language modeling di atasnya.”

forward

< source >

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

Parameter

input_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.
Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.

Apa itu input ID?
attention_mask (torch.FloatTensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari [0, 1]:
- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
Apa itu attention mask?
token_type_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length, 7), opsional) — Indeks token yang mengkodekan struktur tabular. Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat kelas ini untuk informasi lebih lanjut.
Apa itu token type ID?
position_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks posisi token dari setiap urutan input dalam position embeddings. Jika reset_position_index_per_cell dari diatur ke True, position embeddings relatif akan digunakan. Dipilih dalam rentang [0, config.max_position_embeddings - 1].
Apa itu ID posisi?
inputs_embeds (torch.FloatTensor dengan bentuk (batch_size, sequence_length, hidden_size), opsional) — Secara opsional, alih-alih meneruskan input_ids, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Hal ini berguna jika Anda ingin memiliki kendali lebih atas cara mengonversi indeks input_ids menjadi vektor terkait, dibandingkan dengan matriks pencarian penanaman internal model.
encoder_hidden_states (torch.FloatTensor dengan bentuk (batch_size, sequence_length, hidden_size), opsional) — Urutan hidden-states pada keluaran lapisan terakhir encoder. Digunakan dalam cross-attention jika model dikonfigurasi sebagai decoder.
encoder_attention_mask (torch.FloatTensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding dari input encoder. Mask ini digunakan dalam cross-attention jika model dikonfigurasi sebagai decoder. Nilai mask dipilih dari [0, 1]:
- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
labels (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Label untuk menghitung kerugian pemodelan bahasa yang disamarkan (masked language modeling). Indeks harus berada dalam [-100, 0, ..., config.vocab_size] (lihat docstring input_ids). Token dengan indeks yang disetel ke -100 diabaikan (disamarkan), kerugian hanya dihitung untuk token dengan label dalam [0, ..., config.vocab_size].
output_attentions (bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihat attentions di bawah tensor yang dikembalikan untuk detail lebih lanjut.
output_hidden_states (bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihat hidden_states di bawah tensor yang dikembalikan untuk detail lebih lanjut.
return_dict (bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa.

Mengembalikan

MaskedLMOutput atau tuple(torch.FloatTensor)

MaskedLMOutput atau tuple dari torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (TapasConfig) dan input.

Metode forward dari TapasForMaskedLM menimpa metode khusus __call__.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance Module setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

loss (torch.FloatTensor dengan bentuk (1,), opsional, dikembalikan ketika labels disediakan) — Masked language modeling (MLM) loss.
logits (torch.FloatTensor dengan bentuk (batch_size, sequence_length, config.vocab_size)) — Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).
hidden_states (tuple(torch.FloatTensor), opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.FloatTensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk (batch_size, sequence_length, hidden_size).

Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (tuple(torch.FloatTensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.FloatTensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

Contoh:

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

kelas transformers.TapasForSequenceClassification

< source >

( config: TapasConfig )

Parameter

config (TapasConfig) — Kelas konfigurasi model yang berisi semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya saja. Lihat metode from_pretrained() untuk memuat bobot model.

Model Tapas dengan kepala klasifikasi urutan di atasnya (lapisan linear di atas output yang dipooling), misalnya untuk tugas entailment tabel, seperti TabFact (Chen et al., 2020).

forward

< source >

Parameter

input_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.
Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.

Apa itu input ID?
attention_mask (torch.FloatTensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari [0, 1]:
- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
Apa itu attention mask?
token_type_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length, 7), opsional) — Indeks token yang mengkodekan struktur tabular. Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat kelas ini untuk informasi lebih lanjut.
Apa itu token type ID?
position_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks posisi dari setiap token dalam urutan input pada position embeddings. Jika reset_position_index_per_cell dari diatur ke True, position embeddings relatif akan digunakan. Dipilih dalam rentang [0, config.max_position_embeddings - 1].
Apa itu ID posisi?
inputs_embeds (torch.FloatTensor dengan bentuk (batch_size, sequence_length, hidden_size), opsional) — Secara opsional, alih-alih meneruskan input_ids, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Hal ini berguna jika Anda ingin memiliki kendali lebih atas cara mengonversi indeks input_ids menjadi vektor terkait, dibandingkan dengan matriks pencarian penanaman internal model.
labels (torch.LongTensor dengan bentuk (batch_size,), opsional) — Label untuk menghitung loss klasifikasi/regresi urutan. Indeks harus berada dalam [0, ..., config.num_labels - 1]. Jika config.num_labels == 1, loss regresi dihitung (Mean-Square loss). Jika config.num_labels > 1, loss klasifikasi dihitung (Cross-Entropy). Catatan: ini disebut “classification_class_index” dalam implementasi aslinya.
output_attentions (bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihat attentions di bawah tensor yang dikembalikan untuk detail lebih lanjut.
output_hidden_states (bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihat hidden_states di bawah tensor yang dikembalikan untuk detail lebih lanjut.
return_dict (bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa.

Mengembalikan

SequenceClassifierOutput atau tuple(torch.FloatTensor)

SequenceClassifierOutput atau tuple dari torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (TapasConfig) dan input.

Metode forward dari TapasForSequenceClassification menimpa metode khusus __call__.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance Module setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

loss (torch.FloatTensor dengan bentuk (1,), opsional, dikembalikan saat labels disediakan) — Loss klasifikasi (atau regresi jika config.num_labels==1).
logits (torch.FloatTensor dengan bentuk (batch_size, config.num_labels)) — Skor klasifikasi (atau regresi jika config.num_labels==1) (sebelum SoftMax).
hidden_states (tuple(torch.FloatTensor), opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.FloatTensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk (batch_size, sequence_length, hidden_size).

Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (tuple(torch.FloatTensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.FloatTensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

Contoh:

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

kelas transformers.TapasForQuestionAnswering

< source >

( config: TapasConfig )

Parameter

config (TapasConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.

Model Tapas dengan kepala seleksi sel dan kepala agregasi opsional di atasnya untuk tugas menjawab pertanyaan pada tabel (lapisan linear di atas keluaran hidden-states untuk menghitung logits dan logits_aggregation opsional), misalnya untuk tugas yang diawasi SQA, WTQ, atau WikiSQL.

forward

< source >

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

Parameter

input_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default.
Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.

Apa itu input ID?
attention_mask (torch.FloatTensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari [0, 1]:
- 1 untuk token yang tidak dimasker,
- 0 untuk token yang dimasker.
Apa itu attention mask?
token_type_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length, 7), opsional) — Indeks token yang mengkodekan struktur tabular. Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat kelas ini untuk informasi lebih lanjut.
Apa itu token type ID?
position_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Indeks posisi token dari setiap urutan input dalam position embeddings. Jika reset_position_index_per_cell dari diatur ke True, position embeddings relatif akan digunakan. Dipilih dalam rentang [0, config.max_position_embeddings - 1].
Apa itu ID posisi?
inputs_embeds (torch.FloatTensor dengan bentuk (batch_size, sequence_length, hidden_size), opsional) — Secara opsional, alih-alih meneruskan input_ids, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Hal ini berguna jika Anda ingin memiliki kendali lebih atas cara mengonversi indeks input_ids menjadi vektor terkait, dibandingkan dengan matriks pencarian penanaman internal model.
table_mask (torch.LongTensor dengan bentuk (batch_size, seq_length), opsional) — Mask untuk tabel. Menunjukkan token mana yang termasuk dalam tabel (1). Token pertanyaan, header tabel, dan padding bernilai 0.
labels (torch.LongTensor dengan bentuk (batch_size, seq_length), opsional) — Label per token untuk menghitung kerugian seleksi sel hierarkis. Ini mengkodekan posisi jawaban yang muncul dalam tabel. Dapat diperoleh menggunakan AutoTokenizer.
- 1 untuk token yang merupakan bagian dari jawaban,
- 0 untuk token yang bukan bagian dari jawaban.
aggregation_labels (torch.LongTensor dengan bentuk (batch_size, ), opsional) — Indeks fungsi agregasi untuk setiap contoh dalam batch untuk menghitung kerugian agregasi. Indeks harus berada dalam [0, ..., config.num_aggregation_labels - 1]. Hanya diperlukan dalam kasus supervisi kuat untuk agregasi (WikiSQL-supervised).
float_answer (torch.FloatTensor dengan bentuk (batch_size, ), opsional) — Jawaban float untuk setiap contoh dalam batch. Atur ke float(‘nan’) untuk pertanyaan seleksi sel. Hanya diperlukan dalam kasus supervisi lemah (WTQ) untuk menghitung aggregate mask dan regression loss.
numeric_values (torch.FloatTensor dengan bentuk (batch_size, seq_length), opsional) — Nilai numerik dari setiap token, NaN untuk token yang bukan nilai numerik. Dapat diperoleh menggunakan AutoTokenizer. Hanya diperlukan dalam kasus weak supervision untuk agregasi (WTQ) untuk menghitung regression loss.
numeric_values_scale (torch.FloatTensor dengan bentuk (batch_size, seq_length), opsional) — Skala dari nilai numerik setiap token. Dapat diperoleh menggunakan AutoTokenizer. Hanya diperlukan dalam kasus supervisi lemah untuk agregasi (WTQ) untuk menghitung kerugian regresi.
output_attentions (bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihat attentions di bawah tensor yang dikembalikan untuk detail lebih lanjut.
output_hidden_states (bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihat hidden_states di bawah tensor yang dikembalikan untuk detail lebih lanjut.
return_dict (bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa.

Mengembalikan

TableQuestionAnsweringOutput atau tuple(torch.FloatTensor)

Sebuah TableQuestionAnsweringOutput atau tuple dari torch.FloatTensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (TapasConfig) dan input.

Metode forward dari TapasForQuestionAnswering menimpa metode khusus __call__.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance Module setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

loss (torch.FloatTensor dengan bentuk (1,), opsional, dikembalikan ketika labels (dan mungkin answer, aggregation_labels, numeric_values dan numeric_values_scale disediakan)) — Total loss sebagai jumlah dari log-likelihood loss untuk seleksi sel hierarkis dan (secara opsional) semi-supervised regression loss serta (secara opsional) supervised loss untuk agregasi.
logits (torch.FloatTensor dengan bentuk (batch_size, sequence_length)) — Skor prediksi dari kepala seleksi sel, untuk setiap token.
logits_aggregation (torch.FloatTensor, opsional, dengan bentuk (batch_size, num_aggregation_labels)) — Skor prediksi dari kepala agregasi, untuk setiap operator agregasi.
hidden_states (tuple[torch.FloatTensor], opsional, dikembalikan saat output_hidden_states=True dilewatkan atau saat config.output_hidden_states=True) — Tuple dari torch.FloatTensor (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk (batch_size, sequence_length, hidden_size).

Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
attentions (tuple[torch.FloatTensor], opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.FloatTensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala perhatian diri (self-attention).

Contoh:

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

←Model Speech Encoder Decoder TIPSv2→