# TAPAS ## Tổng quan Mô hình TAPAS được đề xuất trong [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://huggingface.co/papers/2004.02349) bởi Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno và Julian Martin Eisenschlos. Đây là một mô hình dựa trên BERT, được thiết kế (và huấn luyện trước) đặc biệt để trả lời các câu hỏi về dữ liệu bảng. So với BERT, TAPAS sử dụng nhúng vị trí tương đối và có 7 loại token mã hóa cấu trúc bảng. TAPAS được huấn luyện trước trên mục tiêu mô hình hóa ngôn ngữ có che (MLM) trên một tập dữ liệu lớn bao gồm hàng triệu bảng từ Wikipedia tiếng Anh và các văn bản tương ứng. Đối với câu hỏi trả lời, TAPAS có 2 đầu (heads) phía trên: một đầu chọn ô (cell selection head) và một đầu tổng hợp (aggregation head), để (tuỳ chọn) thực hiện các phép tổng hợp (như đếm hoặc cộng) giữa các ô đã chọn. TAPAS đã được tinh chỉnh (fine-tuned) trên một số bộ dữ liệu: - [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253) (Trả lời câu hỏi tuần tự của Microsoft) - [WTQ](https://github.com/ppasupat/WikiTableQuestions) (Wiki Table Questions do Đại học Stanford) - [WikiSQL](https://github.com/salesforce/WikiSQL) (do Salesforce phát triển). Mô hình đạt hiệu suất tiên tiến trên cả SQA và WTQ, đồng thời có hiệu suất tương đương với SOTA trên WikiSQL, với kiến trúc đơn giản hơn nhiều. Tóm tắt từ bài báo như sau: *Việc trả lời các câu hỏi ngôn ngữ tự nhiên trên bảng thường được xem là một bài toán phân tích ngữ nghĩa. Để giảm chi phí thu thập các dạng logic đầy đủ, một cách tiếp cận phổ biến tập trung vào giám sát yếu bao gồm các chỉ định (denotation) thay vì các dạng logic. Tuy nhiên, việc huấn luyện các bộ phân tích ngữ nghĩa từ giám sát yếu đặt ra những khó khăn, và hơn nữa, các dạng logic được tạo ra chỉ được sử dụng như một bước trung gian trước khi truy xuất chỉ định. Trong bài báo này, chúng tôi giới thiệu TAPAS, một cách tiếp cận để trả lời câu hỏi trên bảng mà không cần tạo ra các dạng logic. TAPAS được huấn luyện từ giám sát yếu và dự đoán chỉ định bằng cách chọn các ô bảng và tùy chọn áp dụng một toán tử tổng hợp tương ứng cho lựa chọn đó. TAPAS mở rộng kiến trúc của BERT để mã hóa bảng như đầu vào, khởi tạo từ việc tiền huấn luyện liên hợp hiệu quả giữa các đoạn văn bản và các bảng được thu thập từ Wikipedia, và được huấn luyện end-to-end. Chúng tôi thử nghiệm với ba bộ dữ liệu phân tích ngữ nghĩa khác nhau và nhận thấy rằng TAPAS vượt trội hoặc ngang bằng với các mô hình phân tích ngữ nghĩa bằng cách cải thiện độ chính xác state-of-the-art trên SQA từ 55.1 lên 67.2 và đạt hiệu suất ngang bằng state-of-the-art trên WIKISQL và WIKITQ, nhưng với kiến trúc mô hình đơn giản hơn. Chúng tôi cũng nhận thấy rằng transfer learning, vốn đơn giản trong bối cảnh của chúng tôi, từ WIKISQL sang WIKITQ, cho ra độ chính xác 48.7, cao hơn 4.2 điểm so với state-of-the-art.* Ngoài ra, các tác giả đã tiếp tục huấn luyện trước TAPAS để nhận diện **table entailment**, bằng cách tạo ra một bộ dữ liệu cân bằng gồm hàng triệu ví dụ huấn luyện được tạo tự động, được học trong một bước trung gian trước khi tinh chỉnh. Các tác giả của TAPAS gọi quá trình huấn luyện trước bổ sung này là huấn luyện trước trung gian (vì TAPAS trước tiên được huấn luyện trước trên MLM, sau đó trên một bộ dữ liệu khác). Họ nhận thấy rằng huấn luyện trước trung gian tiếp tục cải thiện hiệu suất trên SQA, đạt được một mức tiên tiến mới cũng như mức tiên tiến trên [TabFact](https://github.com/wenhuchen/Table-Fact-Checking), một bộ dữ liệu quy mô lớn với 16k bảng Wikipedia cho table entailment (một tác vụ phân loại nhị phân). Để biết thêm chi tiết, hãy xem bài báo tiếp theo của họ: [Understanding tables with intermediate pre-training](https://www.aclweb.org/anthology/2020.findings-emnlp.27/) của Julian Martin Eisenschlos, Syrine Krichene và Thomas Müller. drawing Kiến trúc TAPAS. Được trích từ bài đăng blog gốc. Mô hình này được đóng góp bởi [nielsr](https://huggingface.co/nielsr). Mã gốc có thể được tìm thấy [tại đây](https://github.com/google-research/tapas). ## Mẹo sử dụng - TAPAS là một mô hình sử dụng nhúng vị trí tương đối theo mặc định (khởi động lại nhúng vị trí tại mỗi ô của bảng). Lưu ý rằng đây là tính năng được thêm vào sau khi công bố bài báo TAPAS gốc. Theo các tác giả, điều này thường dẫn đến hiệu suất hơi tốt hơn và cho phép mã hóa các chuỗi dài hơn mà không bị hết nhúng. Điều này được phản ánh trong tham số `reset_position_index_per_cell` của [TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig), được đặt thành `True` theo mặc định. Các phiên bản mặc định của các mô hình có sẵn trên [hub](https://huggingface.co/models?search=tapas) đều sử dụng nhúng vị trí tương đối. Bạn vẫn có thể sử dụng các phiên bản với nhúng vị trí tuyệt đối bằng cách truyền thêm đối số `revision="no_reset"` khi gọi phương thức `from_pretrained()`. Lưu ý rằng thường được khuyến nghị đệm (pad) đầu vào bên phải thay vì bên trái. - TAPAS được xây dựng dựa trên BERT, do đó `TAPAS-base` chẳng hạn tương ứng với kiến trúc `BERT-base`. Tất nhiên, `TAPAS-large` sẽ cho hiệu suất tốt nhất (các kết quả được báo cáo trong bài báo là từ `TAPAS-large`). Kết quả của các mô hình có kích thước khác nhau được hiển thị trên [kho GitHub gốc](https://github.com/google-research/tapas). - TAPAS có các checkpoint được fine-tune trên SQA, có khả năng trả lời các câu hỏi liên quan đến bảng trong một bối hội thoại. Điều này có nghĩa là bạn có thể đặt các câu hỏi tiếp nối như "tuổi của anh ấy là bao nhiêu?" liên quan đến câu hỏi trước đó. Lưu ý rằng forward pass của TAPAS hơi khác trong trường hợp bối hội thoại: trong trường hợp đó, bạn phải đưa từng cặp bảng-câu hỏi vào mô hình một cách tuần tự, sao cho các token type ids của `prev_labels` có thể được ghi đè bởi các `labels` dự đoán của mô hình cho câu hỏi trước đó. Xem phần "Usage" để biết thêm thông tin. - TAPAS tương tự BERT và do đó dựa vào mục tiêu mô hình hóa ngôn ngữ có che (masked language modeling - MLM). Vì vậy, nó hiệu quả trong việc dự đoán các token bị che và trong NLU nói chung, nhưng không tối ưu cho việc tạo văn bản. Các mô hình được huấn luyện với mục tiêu mô hình hóa ngôn ngữ nhân quả (causal language modeling - CLM) sẽ tốt hơn về mặt này. Lưu ý rằng TAPAS có thể được sử dụng như một encoder trong framework EncoderDecoderModel, để kết hợp nó với một decoder văn bản tự hồi quy như GPT-2. ## Cách sử dụng: tinh chỉnh Ở đây, chúng tôi giải thích cách bạn có thể tinh chỉnh [TapasForQuestionAnswering](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForQuestionAnswering) trên bộ dữ liệu của riêng mình. **BƯỚC 1: Chọn một trong 3 cách sử dụng TAPAS - hoặc thử nghiệm** Về cơ bản, có 3 cách khác nhau để tinh chỉnh [TapasForQuestionAnswering](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForQuestionAnswering), tương ứng với các bộ dữ liệu khác nhau mà Tapas đã được tinh chỉnh: 1. SQA: nếu bạn quan tâm đến việc đặt các câu hỏi tiếp nối liên quan đến một bảng, trong một bối hội thoại. Ví dụ, nếu bạn hỏi trước tiên “tên của diễn viên đầu tiên là gì?” thì bạn có thể hỏi một câu tiếp nối như “anh ấy bao nhiêu tuổi?”. Ở đây, các câu hỏi không liên quan đến bất kỳ phép tổng hợp nào (tất cả các câu hỏi đều là câu hỏi chọn ô). 2. WTQ: nếu bạn không quan tâm đến việc đặt câu hỏi trong một bối hội thoại, mà chỉ muốn đặt các câu hỏi liên quan đến một bảng, có thể bao gồm các phép tổng hợp, chẳng hạn như đếm số dòng, cộng tổng giá trị các ô hoặc tính trung bình giá trị các ô. Khi đó, bạn có thể hỏi, ví dụ, “tổng số bàn thắng mà Cristiano Ronaldo ghi được trong sự nghiệp là bao nhiêu?”. Trường hợp này cũng được gọi là **weak supervision**, vì chính mô hình phải học được toán tử tổng hợp phù hợp (SUM/COUNT/AVERAGE/NONE) khi chỉ có câu trả lời cho câu hỏi làm tín hiệu giám sát. 3. WikiSQL-supervised: bộ dữ liệu này dựa trên WikiSQL, trong đó mô hình được cung cấp toán tử tổng hợp đúng (ground truth) trong quá trình huấn luyện. Cách này còn được gọi là **giám sát mạnh**. Ở đây, việc học toán tử tổng hợp phù hợp dễ dàng hơn nhiều. Tóm lại: | **Nhiệm vụ** | **Dataset mẫu** | **Mô tả** | |-------------------------------------|---------------------|---------------------------------------------------------------------------------------------------------| | Đối thoại | SQA | Các câu hỏi chỉ chọn ô, dạng hội thoại | | Giám sát yếu cho việc tổng hợp | WTQ | Các câu hỏi có thể liên quan đến việc tổng hợp, và mô hình phải học được điều này khi chỉ có đáp án làm tín hiệu giám sát | | Giám sát mạnh cho việc tổng hợp | Giám sát bởi WikiSQL | Các câu hỏi có thể liên quan đến thao tác tổng hợp, và mô hình phải học được điều này dựa trên toán tử tổng hợp chuẩn | Việc khởi tạo một mô hình với một cơ sở được huấn luyện trước và các đầu phân loại được khởi tạo ngẫu nhiên từ hub có thể được thực hiện như minh họa bên dưới. ```python from transformers import TapasConfig, TapasForQuestionAnswering # for example, the base sized model with default SQA configuration model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", device_map="auto") # or, the base sized model with WTQ configuration config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq") model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") # or, the base sized model with WikiSQL configuration config = TapasConfig("google-base-finetuned-wikisql-supervised") model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") ``` Tất nhiên, bạn không nhất thiết phải tuân theo một trong ba cách mà TAPAS đã được tinh chỉnh. Bạn cũng có thể thử nghiệm bằng cách định nghĩa bất kỳ siêu tham số nào bạn muốn khi khởi tạo [TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig), sau đó tạo một [TapasForQuestionAnswering](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForQuestionAnswering) dựa trên cấu hình đó. Ví dụ, nếu bạn có một tập dữ liệu chứa cả các câu hỏi hội thoại và các câu hỏi có thể liên quan đến tổng hợp, thì bạn có thể thực hiện theo cách này. Dưới đây là một ví dụ: ```python from transformers import TapasConfig, TapasForQuestionAnswering # you can initialize the classification heads any way you want (see docs of TapasConfig) config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True) # initializing the pre-trained base sized model with our custom classification heads model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") ``` Bạn cũng có thể bắt đầu từ một checkpoint đã được fine-tune. Lưu ý rằng checkpoint đã được fine-tune trên WTQ có một số vấn đề do L2-loss, vốn khá nhạy cảm. Xem [tại đây](https://github.com/google-research/tapas/issues/91#issuecomment-735719340) để biết thêm thông tin. Để xem danh sách tất cả các checkpoint TAPAS đã được huấn luyện trước và tinh chỉnh có sẵn trên hub của HuggingFace, hãy xem [tại đây](https://huggingface.co/models?search=tapas). **BƯỚC 2: Chuẩn bị dữ liệu của bạn ở định dạng SQA** Thứ hai, bất kể bạn đã chọn gì ở trên, bạn nên chuẩn bị bộ dữ liệu của mình ở định dạng [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253). Định dạng này là một tệp TSV/CSV với các cột sau: - `id`: tùy chọn, id của cặp bảng-câu hỏi, phục vụ mục đích ghi sổ. - `annotator`: tùy chọn, id của người đã chú thích cặp bảng-câu hỏi, phục vụ mục đích ghi sổ. - `position`: số nguyên chỉ ra câu hỏi là câu thứ nhất, thứ hai, thứ ba, liên quan đến bảng. Chỉ bắt buộc trong trường hợp thiết lập hội thoại (SQA). Bạn không cần cột này nếu bạn hướng tới WTQ/WikiSQL-supervised. - `question`: string - `table_file`: string, tên tệp csv chứa dữ liệu bảng - `answer_coordinates`: danh sách một hoặc nhiều bộ ba (mỗi bộ ba là một tọa độ ô, tức là cặp hàng, cột nằm trong câu trả lời) - `answer_text`: danh sách một hoặc nhiều chuỗi (mỗi chuỗi là một giá trị ô thuộc phần trả lời) - `aggregation_label`: chỉ số của toán tử tổng hợp. Chỉ bắt buộc trong trường hợp giám sát mạnh cho việc tổng hợp (trường hợp được giám sát bởi WikiSQL) - `float_answer`: câu trả lời dạng số thực cho câu hỏi, nếu có (np.nan nếu không có). Chỉ bắt buộc trong trường hợp giám sát yếu cho việc tổng hợp (chẳng hạn như WTQ và WikiSQL) Bản thân các bảng nên được đặt trong một thư mục, mỗi bảng là một tệp csv riêng biệt. Lưu ý rằng các tác giả của thuật toán TAPAS đã sử dụng các script chuyển đổi với một số logic tự động để chuyển đổi các bộ dữ liệu khác (WTQ, WikiSQL) sang định dạng SQA. Tác giả giải thích điều này [tại đây](https://github.com/google-research/tapas/issues/50#issuecomment-705465960). Một phiên bản chuyển đổi của script này hoạt động với triển khai của HuggingFace có thể được tìm thấy [tại đây](https://github.com/NielsRogge/tapas_utils). Thú vị là, các script chuyển đổi này không hoàn hảo (các trường `answer_coordinates` và `float_answer` được điền dựa trên `answer_text`), điều này có nghĩa là kết quả của WTQ và WikiSQL thực sự có thể được cải thiện. **BƯỚC 3: Chuyển đổi dữ liệu của bạn thành tensor bằng TapasTokenizer** Thứ ba, khi bạn đã chuẩn bị dữ liệu ở định dạng TSV/CSV này (và các tệp CSV tương ứng chứa dữ liệu bảng), bạn có thể sử dụng [TapasTokenizer](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasTokenizer) để chuyển đổi các cặp bảng-câu hỏi thành `input_ids`, `attention_mask`, `token_type_ids` và các thành phần tương tự. Một lần nữa, tùy thuộc vào trường hợp nào trong ba trường hợp ở trên mà bạn đã chọn, [TapasForQuestionAnswering](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForQuestionAnswering) sẽ yêu cầu các đầu vào khác nhau để tinh chỉnh: | **Nhiệm vụ** | **Đầu vào bắt buộc** | |------------------------------------|---------------------------------------------------------------------------------------------------------------------| | Đối thoại | `input_ids`, `attention_mask`, `token_type_ids`, `labels` | | Giám sát yếu cho việc tổng hợp | `input_ids`, `attention_mask`, `token_type_ids`, `labels`, `numeric_values`, `numeric_values_scale`, `float_answer` | | Giám sát mạnh cho việc tổng hợp | `input ids`, `attention mask`, `token type ids`, `labels`, `aggregation_labels` | [TapasTokenizer](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasTokenizer) tạo ra `labels`, `numeric_values` và `numeric_values_scale` dựa trên các cột `answer_coordinates` và `answer_text` của tệp TSV. `float_answer` và `aggregation_labels` đã có sẵn trong tệp TSV của bước 2. Dưới đây là một ví dụ: ```py from transformers import TapasTokenizer import pandas as pd model_name = "google/tapas-base" tokenizer = TapasTokenizer.from_pretrained(model_name) data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]} queries = [ "What is the name of the first actor?", "How many movies has George Clooney played in?", "What is the total number of movies?", ] answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]] answer_text = [["Brad Pitt"], ["69"], ["209"]] table = pd.DataFrame.from_dict(data) inputs = tokenizer( table=table, queries=queries, answer_coordinates=answer_coordinates, answer_text=answer_text, padding="max_length", return_tensors="pt", ) inputs {'input_ids': tensor([[ ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]), 'numeric_values': tensor([[ ]]), 'numeric_values_scale: tensor([[ ]]), labels: tensor([[ ]])} ``` Lưu ý rằng [TapasTokenizer](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasTokenizer) yêu cầu dữ liệu của bảng phải là **chỉ chứa văn bản**. Bạn có thể sử dụng `.astype(str)` trên một dataframe để chuyển nó thành dữ liệu chỉ chứa văn bản. Tất nhiên, điều này chỉ cho thấy cách mã hóa một ví dụ huấn luyện đơn lẻ. Nên tạo một dataloader để lặp qua các batch: ```python import pandas as pd import torch tsv_path = "your_path_to_the_tsv_file" table_csv_path = "your_path_to_a_directory_containing_all_csv_files" class TableDataset(torch.utils.data.Dataset): def __init__(self, data, tokenizer): self.data = data self.tokenizer = tokenizer def __getitem__(self, idx): item = data.iloc[idx] table = pd.read_csv(table_csv_path + item.table_file).astype( str ) # be sure to make your table data text only encoding = self.tokenizer( table=table, queries=item.question, answer_coordinates=item.answer_coordinates, answer_text=item.answer_text, truncation=True, padding="max_length", return_tensors="pt", ) # remove the batch dimension which the tokenizer adds by default encoding = {key: val.squeeze(0) for key, val in encoding.items()} # add the float_answer which is also required (weak supervision for aggregation case) encoding["float_answer"] = torch.tensor(item.float_answer) return encoding def __len__(self): return len(self.data) data = pd.read_csv(tsv_path, sep="\t") train_dataset = TableDataset(data, tokenizer) train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=32) ``` Lưu ý rằng ở đây, chúng ta mã hóa từng cặp bảng-câu hỏi một cách độc lập. Điều này hoàn toàn ổn miễn là tập dữ liệu của bạn **không mang tính hội thoại**. Trong trường hợp tập dữ liệu của bạn bao gồm các câu hỏi hội thoại (chẳng hạn như trong SQA), thì bạn nên nhóm các `queries`, `answer_coordinates` và `answer_text` theo từng bảng (theo thứ tự chỉ số `position` của chúng) và mã hóa theo lô mỗi bảng cùng với các câu hỏi của nó. Điều này sẽ đảm bảo rằng các kiểu token `prev_labels` (xem tài liệu của [TapasTokenizer](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasTokenizer)) được đặt đúng. Xem [notebook này](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb) để biết thêm thông tin. **BƯỚC 4: Huấn luyện (điều chỉnh tinh) mô hình Sau đó, bạn có thể tinh chỉnh [TapasForQuestionAnswering](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForQuestionAnswering) như sau (được minh họa ở đây cho trường hợp giám sát yếu đối với phép tổng hợp): ```python from transformers import AdamW, TapasConfig, TapasForQuestionAnswering # this is the default WTQ configuration config = TapasConfig( num_aggregation_labels=4, use_answer_as_supervision=True, answer_loss_cutoff=0.664694, cell_selection_preference=0.207951, huber_loss_delta=0.121194, init_cell_selection_weights_to_zero=True, select_one_column=True, allow_empty_column_selection=False, temperature=0.0352513, ) model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") optimizer = AdamW(model.parameters(), lr=5e-5) model.train() for epoch in range(2): # loop over the dataset multiple times for batch in train_dataloader: # get the inputs; input_ids = batch["input_ids"] attention_mask = batch["attention_mask"] token_type_ids = batch["token_type_ids"] labels = batch["labels"] numeric_values = batch["numeric_values"] numeric_values_scale = batch["numeric_values_scale"] float_answer = batch["float_answer"] # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = model( input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, labels=labels, numeric_values=numeric_values, numeric_values_scale=numeric_values_scale, float_answer=float_answer, ) loss = outputs.loss loss.backward() optimizer.step() ``` ## Cách sử dụng: suy luận Ở đây chúng tôi giải thích cách bạn có thể sử dụng [TapasForQuestionAnswering](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForQuestionAnswering) để suy luận (tức là đưa ra dự đoán trên dữ liệu mới). Đối với suy luận, chỉ cần cung cấp cho mô hình `input_ids`, `attention_mask` và `token_type_ids` (mà bạn có thể lấy bằng cách sử dụng [TapasTokenizer](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasTokenizer)) để nhận được logits. Tiếp theo, bạn có thể sử dụng phương thức tiện lợi `~models.tapas.tokenization_tapas.convert_logits_to_predictions` để chuyển đổi chúng thành các tọa độ dự đoán và các chỉ số tổng hợp tùy chọn. Tuy nhiên, hãy lưu ý rằng suy luận **khác nhau** tùy thuộc vào việc cấu hình có mang tính hội thoại hay không. Trong cấu hình không mang tính hội thoại, suy luận có thể được thực hiện song song trên tất cả các cặp bảng-câu hỏi của một lô. Dưới đây là một ví dụ: ```py from transformers import TapasTokenizer, TapasForQuestionAnswering import pandas as pd model_name = "google/tapas-base-finetuned-wtq" model = TapasForQuestionAnswering.from_pretrained(model_name, device_map="auto") tokenizer = TapasTokenizer.from_pretrained(model_name) data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]} queries = [ "What is the name of the first actor?", "How many movies has George Clooney played in?", "What is the total number of movies?", ] table = pd.DataFrame.from_dict(data) inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt").to(model.device) outputs = model(**inputs) predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions( inputs, outputs.logits.detach(), outputs.logits_aggregation.detach() ) # let's print out the results: id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"} aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices] answers = [] for coordinates in predicted_answer_coordinates: if len(coordinates) == 1: # only a single cell: answers.append(table.iat[coordinates[0]]) else: # multiple cells cell_values = [] for coordinate in coordinates: cell_values.append(table.iat[coordinate]) answers.append(", ".join(cell_values)) display(table) print("") for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string): print(query) if predicted_agg == "NONE": print("Predicted answer: " + answer) else: print("Predicted answer: " + predicted_agg + " > " + answer) What is the name of the first actor? Predicted answer: Brad Pitt How many movies has George Clooney played in? Predicted answer: COUNT > 69 What is the total number of movies? Predicted answer: SUM > 87, 53, 69 ``` Trong trường hợp thiết lập hội thoại, mỗi cặp bảng-câu hỏi phải được cung cấp **theo trình tự** cho mô hình, sao cho các loại token `prev_labels` có thể bị ghi đè bởi các `labels` dự đoán của cặp bảng-câu hỏi trước đó. Một lần nữa, thêm thông tin có thể tìm thấy trong [notebook này](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb). ## Tài nguyên - [Hướng dẫn cho tác vụ phân loại văn bản](../tasks/sequence_classification) - [Hướng dẫn cho tác vụ mô hình hóa ngôn ngữ có mặt nạ](../tasks/masked_language_modeling) ## Đầu ra cụ thể của TAPAS[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] #### transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] ```python transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_aggregation: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L49) **Tham số:** loss (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `labels` (và có thể cả `answer`, `aggregation_labels`, `numeric_values` và `numeric_values_scale` được cung cấp)) : Tổng loss là tổng của loss log-likelihood cho việc chọn cell phân cấp và (tùy chọn) loss hồi quy bán giám sát và (tùy chọn) loss giám sát cho các phép tổng hợp. logits (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) : Điểm dự đoán của đầu chọn ô, cho từng token. logits_aggregation (`torch.Tensor`, *tùy chọn*, có hình dạng `(batch_size, num_aggregation_labels)`) : Điểm dự đoán của đầu tổng hợp, cho từng toán tử tổng hợp. hidden_states (`tuple[torch.Tensor]`, *tùy chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) : Tuple của `torch.Tensor` (một cho đầu ra của embeddings, nếu model có lớp embedding, + một cho đầu ra của mỗi lớp) có shape `(batch_size, sequence_length, hidden_size)`. Hidden-states của model tại đầu ra của mỗi lớp cùng với đầu ra embedding ban đầu tùy chọn. attentions (`tuple[torch.Tensor]`, *tùy chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) : Tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`. Trọng số chú ý sau softmax chú ý, được sử dụng để tính trung bình có trọng số trong các đầu chú ý tự (self-attention). Loại đầu ra của [TapasForQuestionAnswering](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForQuestionAnswering). ## TapasConfig[[transformers.TapasConfig]] #### transformers.TapasConfig[[transformers.TapasConfig]] ```python transformers.TapasConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 1024, type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10), initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, positive_label_weight: float = 10.0, num_aggregation_labels: int = 0, aggregation_loss_weight: float = 1.0, use_answer_as_supervision: bool | None = None, answer_loss_importance: float = 1.0, use_normalized_answer_loss: bool = False, huber_loss_delta: float | None = None, temperature: float = 1.0, aggregation_temperature: float = 1.0, use_gumbel_for_cells: bool = False, use_gumbel_for_aggregation: bool = False, average_approximation_function: str = 'ratio', cell_selection_preference: float | None = None, answer_loss_cutoff: float | int | None = None, max_num_rows: int = 64, max_num_columns: int = 32, average_logits_per_cell: bool = False, select_one_column: bool = True, allow_empty_column_selection: bool = False, init_cell_selection_weights_to_zero: bool = False, reset_position_index_per_cell: bool = True, disable_per_token_loss: bool = False, aggregation_labels: dict | None = None, no_aggregation_label_index: int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, tie_word_embeddings: bool = True) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/configuration_tapas.py#L32) **Tham số:** vocab_size (`int`, *tùy chọn*, mặc định là `30522`) : Kích thước từ vựng của mô hình. Xác định số lượng token khác nhau có thể được biểu diễn bởi `input_ids`. hidden_size (`int`, *optional*, mặc định là `768`) : Kích thước của các biểu diễn ẩn. num_hidden_layers (`int`, *tuỳ chọn*, mặc định là `12`) : Số lượng lớp ẩn trong bộ giải mã Transformer. num_attention_heads (`int`, *tùy chọn*, mặc định là `12`) : Số lượng đầu chú ý cho mỗi lớp chú ý trong bộ giải mã Transformer. intermediate_size (`int`, *tuỳ chọn*, mặc định là `3072`) : Kích thước của các biểu diễn MLP. hidden_act (`str`, *tùy chọn*, mặc định là `gelu`) : Hàm kích hoạt phi tuyến (hàm hoặc chuỗi) trong bộ giải mã. Ví dụ, `"gelu"`, `"relu"`, `"silu"`, v.v. hidden_dropout_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Xác suất dropout cho tất cả các lớp fully connected trong embeddings, encoder và pooler. attention_probs_dropout_prob (`Union[float, int]`, *tùy chọn*, mặc định là `0.1`) : Tỷ lệ dropout cho các xác suất chú ý. max_position_embeddings (`int`, *tuỳ chọn*, mặc định là `1024`) : Độ dài chuỗi tối đa mà mô hình này có thể được sử dụng. type_vocab_sizes (`list[int]`, *tuỳ chọn*, mặc định là `[3, 256, 256, 2, 256, 256, 10]`) : Kích thước từ vựng của `token_type_ids` được truyền khi gọi [TapasModel](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasModel). initializer_range (`float`, *optional*, mặc định là `0.02`) : Độ lệch chuẩn của truncated_normal_initializer để khởi tạo tất cả các ma trận trọng số. layer_norm_eps (`float`, *tuỳ chọn*, mặc định là `1e-12`) : Epsilon được sử dụng bởi các lớp chuẩn hóa lớp (layer normalization). pad_token_id (`int`, *tùy chọn*, mặc định là `0`) : Id của token được sử dụng để đệm (padding) trong từ vựng. bos_token_id (`int`, *tùy chọn*) : Id của token được sử dụng cho đầu luồng trong bảng từ vựng. eos_token_id (`Union[int, list[int]]`, *tùy chọn*) : Id của token được sử dụng cho end-of-stream trong bảng từ vựng. positive_label_weight (`float`, *tùy chọn*, mặc định là 10.0) : Trọng số cho các nhãn dương. num_aggregation_labels (`int`, *tuỳ chọn*, mặc định là 0) : Số lượng toán tử tổng hợp cần dự đoán. aggregation_loss_weight (`float`, *tuỳ chọn*, mặc định là 1.0) : Trọng số quan trọng cho tổn thất tổng hợp. use_answer_as_supervision (`bool`, *tùy chọn*) : Có sử dụng câu trả lời làm giám sát duy nhất cho các ví dụ tổng hợp hay không. answer_loss_importance (`float`, *tuỳ chọn*, mặc định là 1.0) : Trọng số quan trọng cho tổn thất hồi quy. use_normalized_answer_loss (`bool`, *tùy chọn*, mặc định là `False`) : Có nên chuẩn hóa loss của câu trả lời bằng giá trị lớn nhất giữa giá trị dự đoán và giá trị mong đợi hay không. huber_loss_delta (`float`, *tuỳ chọn*) : Tham số Delta được sử dụng để tính toán tổn thất hồi quy. temperature (`float`, *tuỳ chọn*, mặc định là 1.0) : Giá trị được sử dụng để kiểm soát (hoặc thay đổi) độ lệch của xác suất logits ô. aggregation_temperature (`float`, *tuỳ chọn*, mặc định là 1.0) : Thang đo logits tổng hợp để kiểm soát độ lệch của xác suất. use_gumbel_for_cells (`bool`, *tùy chọn*, mặc định là `False`) : Có áp dụng Gumbel-Softmax cho việc chọn ô hay không. use_gumbel_for_aggregation (`bool`, *tùy chọn*, mặc định là `False`) : Có áp dụng Gumbel-Softmax cho việc lựa chọn tổng hợp hay không. average_approximation_function (`string`, *tùy chọn*, mặc định là `"ratio"`) : Phương pháp để tính giá trị trung bình kỳ vọng của các ô trong trường hợp giám sát yếu. Một trong số `"ratio"`, `"first_order"` hoặc `"second_order"`. cell_selection_preference (`float`, *optional*) : Ưu tiên lựa chọn ô trong các trường hợp mơ hồ. Chỉ áp dụng trong trường hợp giám sát yếu cho việc tổng hợp (WTQ, WikiSQL). Nếu tổng khối lượng của các xác suất tổng hợp (không bao gồm toán tử "NONE") cao hơn siêu tham số này, thì việc tổng hợp sẽ được dự đoán cho một ví dụ. answer_loss_cutoff (`float`, *tuỳ chọn*) : Bỏ qua các ví dụ có loss câu trả lời lớn hơn cutoff. max_num_rows (`int`, *tuỳ chọn*, mặc định là 64) : Số dòng tối đa. max_num_columns (`int`, *tuỳ chọn*, mặc định là 32) : Số cột tối đa. average_logits_per_cell (`bool`, *tùy chọn*, mặc định là `False`) : Có trung bình hóa logits trên mỗi ô hay không. select_one_column (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem có giới hạn mô hình chỉ chọn các ô từ một cột duy nhất hay không. allow_empty_column_selection (`bool`, *tùy chọn*, mặc định là `False`) : Cho phép không chọn bất kỳ cột nào hay không. init_cell_selection_weights_to_zero (`bool`, *tùy chọn*, mặc định là `False`) : Có nên khởi tạo trọng số chọn ô thành 0 để xác suất ban đầu là 50% hay không. reset_position_index_per_cell (`bool`, *tùy chọn*, mặc định là `True`) : Có nên khởi động lại các chỉ số vị trí ở mỗi ô (tức là sử dụng nhúng vị trí tương đối) hay không. disable_per_token_loss (`bool`, *tùy chọn*, mặc định là `False`) : Có vô hiệu hóa bất kỳ sự giám sát nào (mạnh hay yếu) trên các ô hay không. aggregation_labels (`dict[int, label]`, *tùy chọn*) : Các nhãn tổng hợp được sử dụng để tổng hợp kết quả. Ví dụ, các mô hình WTQ có các nhãn tổng hợp sau: `{0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}` no_aggregation_label_index (`int`, *optional*) : Nếu các nhãn tổng hợp được định nghĩa và một trong các nhãn này đại diện cho "Không tổng hợp", giá trị này nên được đặt thành chỉ số của nhãn đó. Ví dụ, các mô hình WTQ có nhãn tổng hợp "NONE" ở chỉ số 0, do đó giá trị này nên được đặt thành 0 cho các mô hình này. is_decoder (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem mô hình có được sử dụng như một bộ giải mã (decoder) hay không. Nếu `False`, mô hình sẽ được sử dụng như một bộ mã hóa (encoder). add_cross_attention (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có nên thêm các lớp cross-attention vào mô hình hay không. tie_word_embeddings (`bool`, *tùy chọn*, mặc định là `True`) : Có nên gắn kết các nhúng trọng số theo ánh xạ `tied_weights_keys` của mô hình hay không. Đây là lớp cấu hình để lưu trữ cấu hình của một TapasModel. Nó được sử dụng để khởi tạo một mô hình Tapas theo các đối số được chỉ định, xác định kiến trúc của mô hình. Khởi tạo một cấu hình với các giá trị mặc định sẽ tạo ra một cấu hình tương tự như cấu hình của [google/tapas-base-finetuned-sqa](https://huggingface.co/google/tapas-base-finetuned-sqa) Các đối tượng cấu hình kế thừa từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) và có thể được sử dụng để kiểm soát đầu ra của mô hình. Đọc tài liệu từ [PreTrainedConfig](/docs/transformers/main/vi/main_classes/configuration#transformers.PreTrainedConfig) để biết thêm thông tin. Ví dụ: ```python >>> from transformers import TapasModel, TapasConfig >>> # Initializing a default (SQA) Tapas configuration >>> configuration = TapasConfig() >>> # Initializing a model from the configuration >>> model = TapasModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## TapasTokenizer[[transformers.TapasTokenizer]] #### transformers.TapasTokenizer[[transformers.TapasTokenizer]] ```python transformers.TapasTokenizer(vocab_file, do_lower_case = True, do_basic_tokenize = True, never_split = None, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', empty_token = '[EMPTY]', tokenize_chinese_chars = True, strip_accents = None, cell_trim_length: int = -1, max_column_id: int | None = None, max_row_id: int | None = None, strip_column_names: bool = False, update_answer_coordinates: bool = False, min_question_length = None, max_question_length = None, model_max_length: int = 512, additional_special_tokens: list[str] | None = None, clean_up_tokenization_spaces = True, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L149) **Tham số:** vocab_file (`str`) : Tệp chứa từ vựng. do_lower_case (`bool`, *tùy chọn*, mặc định là `True`) : Có nên chuyển đầu vào sang chữ thường khi phân tách token hay không. do_basic_tokenize (`bool`, *tùy chọn*, mặc định là `True`) : Có thực hiện phân tách token cơ bản trước WordPiece hay không. never_split (`Iterable`, *tùy chọn*) : Tập hợp các token sẽ không bao giờ bị tách trong quá trình token hóa. Chỉ có hiệu lực khi `do_basic_tokenize=True` unk_token (`str`, *tùy chọn*, mặc định là `"[UNK]"`) : Token không xác định. Một token không có trong từ vựng sẽ không thể được chuyển đổi thành ID và sẽ được gán thành token này thay thế. sep_token (`str`, *tùy chọn*, mặc định là `"[SEP]"`) : Token phân cách, được sử dụng khi xây dựng một chuỗi từ nhiều chuỗi, ví dụ như hai chuỗi cho phân loại chuỗi hoặc một văn bản và một câu hỏi cho trả lời câu hỏi. Nó cũng được sử dụng làm token cuối cùng của một chuỗi được xây dựng với các token đặc biệt. pad_token (`str`, *tùy chọn*, mặc định là `"[PAD]"`) : Token được sử dụng để đệm, chẳng hạn khi xử lý các lô (batch) các chuỗi có độ dài khác nhau. cls_token (`str`, *tùy chọn*, mặc định là `"[CLS]"`) : Token phân loại được sử dụng khi thực hiện phân loại chuỗi (phân loại toàn bộ chuỗi thay vì phân loại theo từng token). Đây là token đầu tiên của chuỗi khi được xây dựng với các token đặc biệt. mask_token (`str`, *tùy chọn*, mặc định là `"[MASK]"`) : Token được sử dụng để che các giá trị. Đây là token được dùng khi huấn luyện mô hình này với mô hình hóa ngôn ngữ có che (masked language modeling). Đây là token mà mô hình sẽ cố gắng dự đoán. empty_token (`str`, *tùy chọn*, mặc định là `"[EMPTY]"`) : Token được sử dụng cho các giá trị ô trống trong bảng. Các giá trị ô trống bao gồm "", "n/a", "nan" và "?". tokenize_chinese_chars (`bool`, *tùy chọn*, mặc định là `True`) : Có nên phân tách ký tự tiếng Trung hay không. Nên tắt tính năng này cho tiếng Nhật (xem [vấn đề](https://github.com/huggingface/transformers/issues/328) này). strip_accents (`bool`, *tùy chọn*) : Có loại bỏ tất cả các dấu thanh hay không. Nếu không chỉ định tùy chọn này, giá trị sẽ được xác định bởi giá trị của `lowercase` (giống như trong BERT gốc). cell_trim_length (`int`, *optional*, mặc định là -1) : Nếu > 0: Cắt các ô để độ dài <= giá trị này. Đồng thời vô hiệu hóa việc cắt thêm các ô, do đó nên sử dụng cùng với `truncation` được đặt thành `True`. max_column_id (`int`, *tùy chọn*) : Id cột tối đa để trích xuất. max_row_id (`int`, *tùy chọn*) : Id hàng tối đa cần trích xuất. strip_column_names (`bool`, *tùy chọn*, mặc định là `False`) : Có thêm các chuỗi rỗng thay vì tên cột hay không. update_answer_coordinates (`bool`, *tùy chọn*, mặc định là `False`) : Có tính lại tọa độ câu trả lời từ văn bản câu trả lời hay không. min_question_length (`int`, *tuỳ chọn*) : Độ dài tối thiểu của mỗi câu hỏi tính bằng số token (nếu không đạt sẽ bị bỏ qua). max_question_length (`int`, *tuỳ chọn*) : Độ dài tối đa của mỗi câu hỏi tính bằng số token (nếu vượt quá sẽ bị bỏ qua). clean_up_tokenization_spaces (`bool`, *tùy chọn*, mặc định là `True`) : Có dọn dẹp khoảng trắng sau khi giải mã hay không; việc dọn dẹp bao gồm việc loại bỏ các sản phẩm phụ tiềm ẩn như khoảng trắng thừa. Xây dựng một tokenizer TAPAS. Dựa trên WordPiece. Dàn phẳng một bảng và một hoặc nhiều câu liên quan để được sử dụng bởi các mô hình TAPAS. Tokenizer này kế thừa từ [PreTrainedTokenizer](/docs/transformers/main/vi/main_classes/tokenizer#transformers.PythonBackend), lớp chứa hầu hết các phương thức chính. Người dùng nên tham khảo siêu lớp này để biết thêm thông tin về các phương thức đó. [TapasTokenizer](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasTokenizer) tạo ra một số token type id để mã hóa cấu trúc bảng. Cụ thể hơn, nó thêm 7 token type id theo thứ tự sau: `segment_ids`, `column_ids`, `row_ids`, `prev_labels`, `column_ranks`, `inv_column_ranks` và `numeric_relations`: - segment_ids: chỉ ra xem một token thuộc về câu hỏi (0) hay bảng (1). 0 cho các token đặc biệt và padding. - column_ids: chỉ ra cột nào trong bảng mà một token thuộc về (bắt đầu từ 1). Bằng 0 cho tất cả các token câu hỏi, token đặc biệt và padding. - row_ids: chỉ ra hàng của bảng mà một token thuộc về (bắt đầu từ 1). Bằng 0 cho tất cả các token câu hỏi, token đặc biệt và padding. Các token của tiêu đề cột cũng bằng 0. - prev_labels: chỉ ra xem một token có phải (một phần của) câu trả lời cho câu hỏi trước đó (1) hay không (0). Hữu ích trong một cấu hình hội thoại (chẳng hạn như SQA). - column_ranks: chỉ định thứ hạng của một token bảng so với một cột, nếu có. Ví dụ, nếu bạn có một cột "số lượng phim" với các giá trị 87, 53 và 69, thì thứ hạng cột của các token này lần lượt là 3, 1 và 2. Giá trị 0 cho tất cả các token câu hỏi, token đặc biệt và padding. - inv_column_ranks: chỉ định bậc nghịch đảo của một token bảng so với một cột, nếu có. Ví dụ, nếu bạn có một cột "số lượng phim" với các giá trị 87, 53 và 69, thì bậc cột nghịch đảo của các token này lần lượt là 1, 3 và 2. Giá trị 0 cho tất cả các token câu hỏi, token đặc biệt và padding. - numeric_relations: chỉ ra các quan hệ số giữa câu hỏi và các token của bảng. 0 cho tất cả các token của câu hỏi, các token đặc biệt và padding. [TapasTokenizer](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasTokenizer) thực hiện tokenization từ đầu đến cuối trên một bảng và các câu liên quan: tách dấu câu và wordpiece. #### __call__[[transformers.TapasTokenizer.__call__]] ```python __call__(table: typing.Union[ForwardRef('pd.DataFrame'), str, list[str], NoneType], queries: str | list[str] | list[int] | list[list[str]] | list[list[int]] | None = None, answer_coordinates: list[tuple] | list[list[tuple]] | None = None, answer_text: list[str] | list[list[str]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.models.tapas.tokenization_tapas.TapasTruncationStrategy = False, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L518) **Tham số:** table (`pd.DataFrame` hoặc `str` hoặc `list[str]`) : Bảng chứa dữ liệu dạng bảng. Lưu ý rằng tất cả giá trị ô phải là văn bản. Sử dụng *.astype(str)* trên một dataframe Pandas để chuyển đổi nó thành chuỗi. Khi truyền một chuỗi hoặc danh sách các chuỗi, chúng sẽ được diễn giải là các truy vấn với một bảng trống (để hỗ trợ các bài kiểm tra tokenizer tổng quát). queries (`str` hoặc `list[str]`) : Câu hỏi hoặc lô các câu hỏi liên quan đến một bảng cần được mã hóa. Lưu ý rằng trong trường hợp là một lô, tất cả các câu hỏi phải tham chiếu đến **cùng một** bảng. answer_coordinates (`list[Tuple]` hoặc `list[list[Tuple]]`, *tùy chọn*) : Tọa độ câu trả lời của mỗi cặp bảng-câu hỏi trong lô. Nếu chỉ cung cấp một cặp bảng-câu hỏi duy nhất, thì answer_coordinates phải là một danh sách duy nhất chứa một hoặc nhiều bộ. Mỗi bộ phải là một cặp (row_index, column_index). Hàng dữ liệu đầu tiên (không phải hàng tiêu đề cột) có chỉ số 0. Cột đầu tiên có chỉ số 0. Nếu cung cấp một lô các cặp bảng-câu hỏi, thì answer_coordinates phải là một danh sách các danh sách bộ (mỗi danh sách tương ứng với một cặp bảng-câu hỏi duy nhất). answer_text (`list[str]` hoặc `list[list[str]]`, *tùy chọn*) : Văn bản câu trả lời của mỗi cặp bảng-câu hỏi trong lô. Nếu chỉ cung cấp một cặp bảng-câu hỏi duy nhất, thì answer_text phải là một danh sách chứa một hoặc nhiều chuỗi. Mỗi chuỗi phải là văn bản câu trả lời của một tọa độ câu trả lời tương ứng. Nếu cung cấp một lô các cặp bảng-câu hỏi, thì answer_coordinates phải là một danh sách các danh sách chuỗi (mỗi danh sách tương ứng với một cặp bảng-câu hỏi duy nhất). add_special_tokens (`bool`, *tùy chọn*, mặc định là `True`) : Có mã hóa các chuỗi với các token đặc biệt tương ứng với mô hình của chúng hay không. padding (`bool`, `str` hoặc [PaddingStrategy](/docs/transformers/main/vi/internal/file_utils#transformers.utils.PaddingStrategy), *tuỳ chọn*, mặc định là `False`) : Kích hoạt và kiểm soát việc đệm. Chấp nhận các giá trị sau: - `True` hoặc `'longest'`: Đệm đến độ dài của chuỗi dài nhất trong lô (hoặc không đệm nếu chỉ có một chuỗi duy nhất được cung cấp). - `'max_length'`: Đệm đến độ dài tối đa được chỉ định bằng tham số `max_length` hoặc đến độ dài đầu vào tối đa mà mô hình chấp nhận được nếu tham số đó không được cung cấp. - `False` hoặc `'do_not_pad'` (mặc định): Không đệm (tức là có thể xuất ra một lô với các chuỗi có độ dài khác nhau). truncation (`bool`, `str` hoặc `TapasTruncationStrategy`, *optional*, mặc định là `False`) : Kích hoạt và kiểm soát việc cắt bớt. Chấp nhận các giá trị sau: - `True` hoặc `'drop_rows_to_fit'`: Cắt bớt xuống độ dài tối đa được chỉ định bằng tham số `max_length` hoặc xuống độ dài đầu vào tối đa chấp nhận được của mô hình nếu tham số đó không được cung cấp. Thao tác này sẽ cắt bớt theo từng hàng, loại bỏ các hàng khỏi bảng. - `False` hoặc `'do_not_truncate'` (mặc định): Không cắt bớt (tức là có thể xuất ra batch với độ dài chuỗi lớn hơn kích thước đầu vào tối đa chấp nhận được của mô hình). max_length (`int`, *optional*) : Kiểm soát độ dài tối đa được sử dụng bởi một trong các tham số cắt/giữ chỗ. Nếu không được đặt hoặc được đặt thành `None`, tham số này sẽ sử dụng độ dài tối đa định trước của mô hình nếu một trong các tham số cắt/giữ chỗ yêu cầu độ dài tối đa. Nếu mô hình không có độ dài đầu vào tối đa cụ thể (như XLNet), việc cắt/giữ chỗ đến độ dài tối đa sẽ bị vô hiệu hóa. is_split_into_words (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem đầu vào đã được tiền xử lý token hay chưa (ví dụ: đã được tách thành các từ). Nếu đặt thành `True`, bộ phân từ sẽ giả định rằng đầu vào đã được tách thành các từ (chẳng hạn, bằng cách tách theo khoảng trắng) và sẽ tiến hành phân từ chúng. Điều này hữu ích cho NER hoặc phân loại token. pad_to_multiple_of (`int`, *optional*) : Nếu được đặt, sẽ đệm chuỗi đến bội số của giá trị được cung cấp. Điều này đặc biệt hữu ích để cho phép sử dụng Tensor Cores trên phần cứng NVIDIA có khả năng tính toán `>= 7.5` (Volta). return_tensors (`str` hoặc [TensorType](/docs/transformers/main/vi/internal/file_utils#transformers.TensorType), *optional*) : Nếu được đặt, sẽ trả về các tensor thay vì danh sách các số nguyên python. Các giá trị chấp nhận được là: - `'pt'`: Trả về các đối tượng `torch.Tensor` của PyTorch. - `'np'`: Trả về các đối tượng `np.ndarray` của Numpy. Phương thức chính để mã hóa và chuẩn bị một hoặc nhiều chuỗi liên quan đến một bảng cho mô hình. #### convert_logits_to_predictions[[transformers.TapasTokenizer.convert_logits_to_predictions]] ```python convert_logits_to_predictions(data, logits, logits_agg = None, cell_classification_threshold = 0.5) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L1885) **Tham số:** data (`dict`) : Từ điển ánh xạ các đặc trưng sang giá trị thực tế. Nên được tạo bằng [TapasTokenizer](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasTokenizer). logits (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) : Tensor chứa các logits ở cấp độ token. logits_agg (`torch.Tensor` có hình dạng `(batch_size, num_aggregation_labels)`, *tùy chọn*) : Tensor chứa các logits tổng hợp. cell_classification_threshold (`float`, *optional*, mặc định là 0.5) : Ngưỡng được sử dụng để chọn ô. Tất cả các ô bảng có xác suất lớn hơn ngưỡng này sẽ được chọn. **Trả về:** `tuple` bao gồm các phần tử khác nhau tùy thuộc vào đầu vào - predicted_answer_coordinates (`list[list[[tuple]]` có độ dài `batch_size`): Tọa độ câu trả lời dự đoán dưới dạng danh sách các danh sách tuple. Mỗi phần tử trong danh sách chứa tọa độ câu trả lời dự đoán của một ví dụ duy nhất trong batch, dưới dạng danh sách các tuple. Mỗi tuple là một ô, tức là (chỉ số hàng, chỉ số cột). - predicted_aggregation_indices (`list[int]` có độ dài `batch_size`, *tùy chọn*, được trả về khi `logits_aggregation` được cung cấp): Các chỉ số toán tử tổng hợp dự đoán của đầu tổng hợp. Chuyển đổi logits của [TapasForQuestionAnswering](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForQuestionAnswering) thành các tọa độ câu trả lời dự đoán thực tế và các chỉ số tổng hợp tùy chọn. Cài đặt gốc, mà hàm này dựa trên, có thể được tìm thấy [tại đây](https://github.com/google-research/tapas/blob/4908213eb4df7aa988573350278b44c4dbe3f71b/tapas/experiments/prediction_utils.py#L288). #### save_vocabulary[[transformers.TapasTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/tokenization_tapas.py#L386) ## TapasModel[[transformers.TapasModel]] #### transformers.TapasModel[[transformers.TapasModel]] ```python transformers.TapasModel(config: TapasConfig, add_pooling_layer = True) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L510) **Tham số:** config ([TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình. add_pooling_layer (`bool`, *tùy chọn*, mặc định là `True`) : Có thêm một lớp pooling hay không Mô hình Tapas cơ bản, xuất ra các hidden-state thô mà không có bất kỳ head cụ thể nào ở phía trên. Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.) Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung. #### forward[[transformers.TapasModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L543) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids) attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các token **không bị che**, - 0 cho các token **bị che**. [Mặt nạ chú ý là gì?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length, 7)`, *tùy chọn*) : Các chỉ số token mã hóa cấu trúc bảng. Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem lớp này để biết thêm thông tin. [Token type IDs là gì?](../glossary#token-type-ids) position_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các position embeddings. Nếu `reset_position_index_per_cell` của [TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig) được đặt thành `True`, các relative position embeddings sẽ được sử dụng. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`. [Position IDs là gì?](../glossary#position-ids) inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. encoder_hidden_states (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Chuỗi các hidden-states tại đầu ra của lớp cuối cùng của encoder. Được sử dụng trong cross-attention nếu mô hình được cấu hình như một decoder. encoder_attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm của đầu vào bộ mã hóa. Mặt nạ này được sử dụng trong chú ý chéo nếu mô hình được cấu hình như một bộ giải mã. Các giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các token **không bị che**, - 0 cho các token **bị che**. output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết. output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết. return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không. **Trả về:** [BaseModelOutputWithPooling](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) hoặc `tuple(torch.Tensor)` Một [BaseModelOutputWithPooling](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các thành phần khác nhau tùy thuộc vào cấu hình ([TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig)) và đầu vào. Phương thức forward của [TapasModel](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasModel) ghi đè lên phương thức đặc biệt `__call__`. Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng. - **last_hidden_state** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`) -- Chuỗi các hidden-state tại đầu ra của lớp cuối cùng của mô hình. - **pooler_output** (`torch.Tensor` có hình dạng `(batch_size, hidden_size)`) -- Trạng thái ẩn của lớp cuối cùng cho token đầu tiên của chuỗi (token phân loại) sau khi được xử lý thêm thông qua các lớp dùng cho tác vụ tiền huấn luyện bổ trợ. Ví dụ, đối với các mô hình thuộc họ BERT, giá trị này trả về token phân loại sau khi được xử lý qua một lớp tuyến tính và một hàm kích hoạt tanh. Trọng số của lớp tuyến tính được huấn luyện từ mục tiêu dự đoán câu tiếp theo (phân loại) trong quá trình tiền huấn luyện. - **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`. Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn. - **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`. Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention. Ví dụ: ```python >>> from transformers import AutoTokenizer, TapasModel >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base") >>> model = TapasModel.from_pretrained("google/tapas-base") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state ``` ## TapasForMaskedLM[[transformers.TapasForMaskedLM]] #### transformers.TapasForMaskedLM[[transformers.TapasForMaskedLM]] ```python transformers.TapasForMaskedLM(config: TapasConfig) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L660) **Tham số:** config ([TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình. Mô hình Tapas với đầu `language modeling` ở trên." Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.) Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung. #### forward[[transformers.TapasForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L684) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids) attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các token **không bị che**, - 0 cho các token **bị che**. [Mặt nạ chú ý là gì?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length, 7)`, *tùy chọn*) : Các chỉ số token mã hóa cấu trúc bảng. Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem lớp này để biết thêm thông tin. [Token type IDs là gì?](../glossary#token-type-ids) position_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các position embeddings. Nếu `reset_position_index_per_cell` của [TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig) được đặt thành `True`, các relative position embeddings sẽ được sử dụng. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`. [Position IDs là gì?](../glossary#position-ids) inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. encoder_hidden_states (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Chuỗi các hidden-states tại đầu ra của lớp cuối cùng của encoder. Được sử dụng trong cross-attention nếu mô hình được cấu hình như một decoder. encoder_attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm của đầu vào bộ mã hóa. Mặt nạ này được sử dụng trong chú ý chéo nếu mô hình được cấu hình như một bộ giải mã. Các giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các token **không bị che**, - 0 cho các token **bị che**. labels (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Nhãn để tính toán tổn thất mô hình hóa ngôn ngữ có che (masked language modeling loss). Chỉ số phải nằm trong `[-100, 0, ..., config.vocab_size]` (xem docstring của `input_ids`). Các token có chỉ số được đặt thành `-100` sẽ bị bỏ qua (che), tổn thất chỉ được tính cho các token có nhãn nằm trong `[0, ..., config.vocab_size]`. output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết. output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết. return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không. **Trả về:** [MaskedLMOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) hoặc `tuple(torch.Tensor)` Một [MaskedLMOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig)) và đầu vào. Phương thức forward của [TapasForMaskedLM](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForMaskedLM) ghi đè lên phương thức đặc biệt `__call__`. Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng. - **loss** (`torch.Tensor` có hình dạng `(1,)`, *tùy chọn*, được trả về khi `labels` được cung cấp) -- Tổn thất mô hình hóa ngôn ngữ có mặt nạ (MLM). - **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length, config.vocab_size)`) -- Điểm dự đoán của đầu mô hình hóa ngôn ngữ (điểm cho mỗi token từ vựng trước SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`. Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn. - **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`. Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention. Ví dụ: ```python >>> from transformers import AutoTokenizer, TapasForMaskedLM >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base") >>> model = TapasForMaskedLM.from_pretrained("google/tapas-base") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> inputs = tokenizer( ... table=table, queries="How many [MASK] has George [MASK] played in?", return_tensors="pt" ... ) >>> labels = tokenizer( ... table=table, queries="How many movies has George Clooney played in?", return_tensors="pt" ... )["input_ids"] >>> outputs = model(**inputs, labels=labels) >>> logits = outputs.logits ``` ## TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] #### transformers.TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] ```python transformers.TapasForSequenceClassification(config: TapasConfig) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L1119) **Tham số:** config ([TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình. Mô hình Tapas với một đầu phân loại chuỗi phía trên (một lớp tuyến tính phía trên đầu ra đã được pool), ví dụ cho các tác vụ suy luận bảng, chẳng hạn như TabFact (Chen et al., 2020). Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.) Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung. #### forward[[transformers.TapasForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L1131) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids) attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các token **không bị che**, - 0 cho các token **bị che**. [Mặt nạ chú ý là gì?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length, 7)`, *tùy chọn*) : Các chỉ số token mã hóa cấu trúc bảng. Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem lớp này để biết thêm thông tin. [Token type IDs là gì?](../glossary#token-type-ids) position_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các position embeddings. Nếu `reset_position_index_per_cell` của [TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig) được đặt thành `True`, các relative position embeddings sẽ được sử dụng. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`. [Position IDs là gì?](../glossary#position-ids) inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. labels (`torch.LongTensor` có hình dạng `(batch_size,)`, *tùy chọn*) : Nhãn để tính toán tổn thất phân loại/hồi quy chuỗi. Chỉ số phải nằm trong `[0, ..., config.num_labels - 1]`. Nếu `config.num_labels == 1`, tổn thất hồi quy sẽ được tính toán (tổn thất Mean-Square). Nếu `config.num_labels > 1`, tổn thất phân loại sẽ được tính toán (Cross-Entropy). Lưu ý: trong cài đặt gốc, tham số này được gọi là "classification_class_index". output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết. output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết. return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không. **Trả về:** [SequenceClassifierOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) hoặc `tuple(torch.Tensor)` Một [SequenceClassifierOutput](/docs/transformers/main/vi/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig)) và đầu vào. Phương thức forward của [TapasForSequenceClassification](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForSequenceClassification) ghi đè lên phương thức đặc biệt `__call__`. Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng. - **loss** (`torch.Tensor` có shape `(1,)`, *optional*, được trả về khi `labels` được cung cấp) -- Loss phân loại (hoặc hồi quy nếu config.num_labels==1). - **logits** (`torch.Tensor` có hình dạng `(batch_size, config.num_labels)`) -- Điểm phân loại (hoặc hồi quy nếu config.num_labels==1) (trước SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple của `torch.Tensor` (một cho đầu ra của các embedding, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`. Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn. - **attentions** (`tuple(torch.Tensor)`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`. Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention. Ví dụ: ```python >>> from transformers import AutoTokenizer, TapasForSequenceClassification >>> import torch >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-tabfact") >>> model = TapasForSequenceClassification.from_pretrained("google/tapas-base-finetuned-tabfact") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = [ ... "There is only one actor who is 45 years old", ... "There are 3 actors which played in more than 60 movies", ... ] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> labels = torch.tensor([1, 0]) # 1 means entailed, 0 means refuted >>> outputs = model(**inputs, labels=labels) >>> loss = outputs.loss >>> logits = outputs.logits ``` ## TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] #### transformers.TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] ```python transformers.TapasForQuestionAnswering(config: TapasConfig) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L781) **Tham số:** config ([TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig)) : Lớp cấu hình mô hình chứa tất cả các tham số của mô hình. Khởi tạo bằng tệp cấu hình sẽ không tải trọng số liên quan đến mô hình, chỉ tải cấu hình. Xem phương thức [from_pretrained()](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để tải trọng số mô hình. Mô hình Tapas với đầu chọn ô và tùy chọn đầu tổng hợp phía trên cho các tác vụ trả lời câu hỏi trên bảng (các lớp tuyến tính phía trên đầu ra hidden-states để tính toán `logits` và tùy chọn `logits_aggregation`), ví dụ cho các tác vụ có giám sát như SQA, WTQ hoặc WikiSQL. Mô hình này kế thừa từ [PreTrainedModel](/docs/transformers/main/vi/main_classes/model#transformers.PreTrainedModel). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình của nó (chẳng hạn như tải xuống hoặc lưu trữ, thay đổi kích thước các nhúng đầu vào, cắt tỉa các đầu ra, v.v.) Mô hình này cũng là một lớp con của [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) trong PyTorch. Hãy sử dụng nó như một Module PyTorch thông thường và tham khảo tài liệu PyTorch cho mọi vấn đề liên quan đến cách sử dụng và hành vi chung. #### forward[[transformers.TapasForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, table_mask: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, aggregation_labels: typing.Optional[torch.LongTensor] = None, float_answer: typing.Optional[torch.Tensor] = None, numeric_values: typing.Optional[torch.Tensor] = None, numeric_values_scale: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/models/tapas/modeling_tapas.py#L804) **Tham số:** input_ids (`torch.LongTensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của các token trong chuỗi đầu vào theo từ vựng. Mặc định, các token đệm (padding) sẽ bị bỏ qua. Có thể lấy chỉ số bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem [PreTrainedTokenizer.encode()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) và [PreTrainedTokenizer.__call__()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) để biết chi tiết. [ID đầu vào là gì?](../glossary#input-ids) attention_mask (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ để tránh thực hiện chú ý trên các chỉ số token đệm. Các giá trị mặt nạ được chọn trong `[0, 1]`: - 1 cho các token **không bị che**, - 0 cho các token **bị che**. [Mặt nạ chú ý là gì?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` có shape `(batch_size, sequence_length, 7)`, *tùy chọn*) : Các chỉ số token mã hóa cấu trúc bảng. Các chỉ số này có thể được lấy bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Xem lớp này để biết thêm thông tin. [Token type IDs là gì?](../glossary#token-type-ids) position_ids (`torch.LongTensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Chỉ số của vị trí các token trong mỗi chuỗi đầu vào trong các position embeddings. Nếu `reset_position_index_per_cell` của [TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig) được đặt thành `True`, các relative position embeddings sẽ được sử dụng. Được chọn trong khoảng `[0, config.max_position_embeddings - 1]`. [Position IDs là gì?](../glossary#position-ids) inputs_embeds (`torch.Tensor` có hình dạng `(batch_size, sequence_length, hidden_size)`, *tùy chọn*) : Tùy chọn, thay vì truyền `input_ids`, bạn có thể chọn cách truyền trực tiếp một biểu diễn nhúng. Điều này hữu ích nếu bạn muốn kiểm soát nhiều hơn cách chuyển đổi các chỉ số `input_ids` thành các vector liên quan so với ma trận tra cứu nhúng nội bộ của mô hình. table_mask (`torch.LongTensor` có hình dạng `(batch_size, seq_length)`, *tùy chọn*) : Mặt nạ cho bảng. Chỉ ra các token nào thuộc về bảng (1). Các token câu hỏi, tiêu đề bảng và padding là 0. labels (`torch.LongTensor` có shape `(batch_size, seq_length)`, *tùy chọn*) : Nhãn cho từng token để tính toán tổn thất lựa chọn tế bào phân cấp. Điều này mã hóa các vị trí của câu trả lời xuất hiện trong bảng. Có thể lấy được bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). - 1 cho các token **thuộc phần câu trả lời**, - 0 cho các token **không thuộc phần câu trả lời**. aggregation_labels (`torch.LongTensor` có shape `(batch_size, )`, *tùy chọn*) : Chỉ số hàm tổng hợp cho mỗi ví dụ trong batch để tính toán tổn thất tổng hợp. Các chỉ số phải nằm trong `[0, ..., config.num_aggregation_labels - 1]`. Chỉ bắt buộc trong trường hợp giám sát mạnh cho tổng hợp (WikiSQL-supervised). float_answer (`torch.Tensor` có shape `(batch_size, )`, *tùy chọn*) : Trả lời dạng số thực cho từng ví dụ trong batch. Đặt thành *float('nan')* cho các câu hỏi chọn ô. Chỉ bắt buộc trong trường hợp giám sát yếu (WTQ) để tính toán aggregate mask và regression loss. numeric_values (`torch.Tensor` có shape `(batch_size, seq_length)`, *tùy chọn*) : Giá trị số của từng token, NaN cho các token không phải là giá trị số. Có thể lấy được bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Chỉ bắt buộc trong trường hợp weak supervision cho aggregation (WTQ) để tính toán regression loss. numeric_values_scale (`torch.Tensor` có shape `(batch_size, seq_length)`, *tùy chọn*) : Thang đo của các giá trị số của từng token. Có thể lấy được bằng cách sử dụng [AutoTokenizer](/docs/transformers/main/vi/model_doc/auto#transformers.AutoTokenizer). Chỉ bắt buộc trong trường hợp giám sát yếu cho việc tổng hợp (WTQ) để tính toán regression loss. output_attentions (`bool`, *tùy chọn*) : Có trả về các tensor chú ý của tất cả các lớp chú ý hay không. Xem `attentions` trong phần tensor trả về để biết thêm chi tiết. output_hidden_states (`bool`, *tuỳ chọn*) : Có trả về trạng thái ẩn của tất cả các lớp hay không. Xem `hidden_states` trong phần tensor trả về để biết thêm chi tiết. return_dict (`bool`, *tùy chọn*) : Có trả về [ModelOutput](/docs/transformers/main/vi/main_classes/output#transformers.utils.ModelOutput) thay vì một tuple thông thường hay không. **Trả về:** [TableQuestionAnsweringOutput](/docs/transformers/main/vi/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) hoặc `tuple(torch.Tensor)` Một [TableQuestionAnsweringOutput](/docs/transformers/main/vi/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) hoặc một tuple của `torch.Tensor` (nếu `return_dict=False` được truyền hoặc khi `config.return_dict=False`) bao gồm các phần tử khác nhau tùy thuộc vào cấu hình ([TapasConfig](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasConfig)) và đầu vào. Phương thức forward của [TapasForQuestionAnswering](/docs/transformers/main/vi/model_doc/tapas#transformers.TapasForQuestionAnswering) ghi đè lên phương thức đặc biệt `__call__`. Mặc dù công thức cho bước truyền tiến cần được định nghĩa bên trong hàm này, bạn nên gọi instance của `Module` sau đó thay vì gọi hàm này, vì instance `Module` sẽ đảm nhận việc thực hiện các bước tiền xử lý và hậu xử lý, trong khi hàm này sẽ bỏ qua chúng một cách im lặng. - **loss** (`torch.Tensor` có shape `(1,)`, *tùy chọn*, được trả về khi `labels` (và có thể cả `answer`, `aggregation_labels`, `numeric_values` và `numeric_values_scale`) được cung cấp) -- Tổng loss là tổng của log-likelihood loss cho việc chọn cell phân cấp và (tùy chọn) loss hồi quy bán giám sát và (tùy chọn) loss giám sát cho các phép tổng hợp. - **logits** (`torch.Tensor` có hình dạng `(batch_size, sequence_length)`) -- Điểm dự đoán của đầu chọn ô (cell selection head), cho từng token. - **logits_aggregation** (`torch.Tensor`, *tuỳ chọn*, có hình dạng `(batch_size, num_aggregation_labels)`) -- Điểm dự đoán của đầu tổng hợp, cho từng toán tử tổng hợp. - **hidden_states** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_hidden_states=True` được truyền vào hoặc khi `config.output_hidden_states=True`) -- Bộ tuple các `torch.Tensor` (một cho đầu ra của embeddings, nếu mô hình có lớp embedding, + một cho đầu ra của mỗi lớp) có hình dạng `(batch_size, sequence_length, hidden_size)`. Trạng thái ẩn của mô hình tại đầu ra của mỗi lớp cùng với các đầu ra embedding ban đầu tùy chọn. - **attentions** (`tuple[torch.Tensor]`, *tuỳ chọn*, được trả về khi `output_attentions=True` được truyền vào hoặc khi `config.output_attentions=True`) -- Bộ tuple của `torch.Tensor` (một cho mỗi lớp) có hình dạng `(batch_size, num_heads, sequence_length, sequence_length)`. Trọng số chú ý sau softmax của attention, được sử dụng để tính trung bình có trọng số trong các đầu self-attention. Ví dụ: ```python >>> from transformers import AutoTokenizer, TapasForQuestionAnswering >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-wtq") >>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base-finetuned-wtq") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> logits = outputs.logits >>> logits_aggregation = outputs.logits_aggregation ```