# TAPAS ## Обзор Модель TAPAS была предложена в работе [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://huggingface.co/papers/2004.02349) авторами Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno и Julian Martin Eisenschlos. Это модель на основе BERT, специально разработанная (и предварительно обученная) для ответов на вопросы о табличных данных. В отличие от BERT, TAPAS использует относительные позиционные эмбеддинги и имеет 7 типов токенов, кодирующих структуру таблицы. Предобучение TAPAS выполняется на задаче masked language modeling (MLM) на большом наборе данных, включающем миллионы таблиц из англоязычной Википедии и соответствующие тексты. Для задачи вопрос-ответ в TAPAS используются два дополнительных слоя: слой выбора ячеек и слой агрегации, который (опционально) выполняет агрегацию (например, подсчёт или суммирование) по выбранным ячейкам. TAPAS был дообучен на нескольких наборах данных: - [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253) (Sequential Question Answering от Microsoft) - [WTQ](https://github.com/ppasupat/WikiTableQuestions) (Wiki Table Questions, Стэнфордский университет) - [WikiSQL](https://github.com/salesforce/WikiSQL) (от Salesforce). Он демонстрирует наилучшие результаты как на SQA, так и на WTQ, при этом показывая сопоставимую с SOTA производительность на WikiSQL, но с гораздо более простой архитектурой. Аннотация из статьи следующая: *Ответы на вопросы на естественном языке по таблицам обычно рассматриваются как задача семантического разбора. Для снижения затрат на сбор полных логических форм один из популярных подходов использует слабое обучение на основе денотаций вместо логических форм. Однако обучение семантических парсеров с использованием слабого обучения сопряжено с трудностями, а также сгенерированные логические формы используются лишь как промежуточный этап перед извлечением денотации. В данной статье мы представляем TAPAS — подход к ответам на вопросы по таблицам без генерации логических форм. TAPAS обучается с использованием слабого обучения и предсказывает денотацию, выбирая ячейки таблицы и при необходимости применяя к такому выбору соответствующий оператор агрегации. TAPAS расширяет архитектуру BERT для кодирования таблиц в качестве входных данных, инициализируется с помощью эффективного совместного предварительного обучения на сегментах текста и таблицах, извлечённых из Wikipedia, и обучается сквозным методом. Мы проводим эксперименты на трёх различных наборах данных для семантического разбора и обнаруживаем, что TAPAS превосходит или не уступает моделям семантического разбора, улучшая наилучшую известную точность на SQA с 55,1 до 67,2 и демонстрируя результаты на уровне наилучших известных на WIKISQL и WIKITQ, но с более простой архитектурой модели. Кроме того, мы обнаруживаем, что перенос обучения, который в нашем случае тривиален, с WIKISQL на WIKITQ даёт точность 48,7, что на 4,2 пункта выше наилучшей известной.* Кроме того, авторы дополнительно дообучили TAPAS для распознавания **table entailment**, создав сбалансированный датасет из миллионов автоматически сгенерированных обучающих примеров, которые используются на промежуточном этапе перед дообучением. Авторы TAPAS называют это дополнительное дообучение промежуточным дообучением (поскольку TAPAS сначала дообучается на MLM, а затем на другом датасете). Они обнаружили, что промежуточное дообучение дополнительно улучшает результаты на SQA, обеспечивая новый state-of-the-art, а также state-of-the-art на [TabFact](https://github.com/wenhuchen/Table-Fact-Checking) — крупномасштабном датасете, содержащем 16k таблиц из Wikipedia для задачи table entailment (бинарная классификация). Дополнительные сведения см. в их последующей статье: [Understanding tables with intermediate pre-training](https://www.aclweb.org/anthology/2020.findings-emnlp.27/) авторов Julian Martin Eisenschlos, Syrine Krichene и Thomas Müller. drawing Архитектура TAPAS. Взято из оригинальной статьи в блоге. Эта модель была предоставлена пользователем [nielsr](https://huggingface.co/nielsr). Исходный код можно найти [здесь](https://github.com/google-research/tapas). ## Советы по использованию - TAPAS — это модель, которая по умолчанию использует относительные позиционные эмбеддинги (сброс позиционных эмбеддингов для каждой ячейки таблицы). Обратите внимание, что эта возможность была добавлена после публикации оригинальной статьи о TAPAS. По словам авторов, это обычно приводит к немного лучшей производительности и позволяет кодировать более длинные последовательности, не исчерпывая запас эмбеддингов. Это отражено в параметре `reset_position_index_per_cell` класса [TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig), который по умолчанию установлен в `True`. Все версии моделей по умолчанию, доступные на [hub](https://huggingface.co/models?search=tapas), используют относительные позиционные эмбеддинги. Вы по-прежнему можете использовать модели с абсолютными позиционными эмбеддингами, передав дополнительный аргумент `revision="no_reset"` при вызове метода `from_pretrained()`. Обратите внимание, что обычно рекомендуется дополнять входные данные справа, а не слева. - TAPAS основан на BERT, поэтому, например, `TAPAS-base` соответствует архитектуре `BERT-base`. Разумеется, `TAPAS-large` обеспечивает наилучшие результаты (результаты, приведённые в статье, получены с `TAPAS-large`). Результаты для моделей разного размера представлены в [оригинальном репозитории на GitHub](https://github.com/google-research/tapas). - У TAPAS есть контрольные точки, дообученные на SQA, которые способны отвечать на вопросы, связанные с таблицей, в диалоговом режиме. Это означает, что вы можете задавать уточняющие вопросы, например «сколько ему лет?», относящиеся к предыдущему вопросу. Обратите внимание, что прямой проход TAPAS немного отличается в случае диалогового режима: в этом случае необходимо подавать каждую пару «таблица-вопрос» в модель по одному, чтобы токены типов `prev_labels` могли быть заменены предсказанными моделью `labels` для предыдущего вопроса. Подробнее см. в разделе «Использование». - TAPAS похож на BERT и, следовательно, опирается на задачу маскированного языкового моделирования (MLM). Поэтому он эффективен для предсказания замаскированных токенов и для задач NLU в целом, но не оптимален для генерации текста. В этом отношении лучше подходят модели, обученные с использованием задачи каузального языкового моделирования (CLM). Обратите внимание, что TAPAS можно использовать в качестве энкодера в рамках фреймворка EncoderDecoderModel, чтобы объединить его с авторегрессионным текстовым декодером, таким как GPT-2. ## Использование: дообучение Здесь мы объясняем, как можно дообучить [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForQuestionAnswering) на собственном наборе данных. **ШАГ 1: Выберите один из трёх способов использования TAPAS — или поэкспериментируйте** По сути, существует три различных способа дообучения [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForQuestionAnswering), соответствующих различным наборам данных, на которых Tapas был дообучен: 1. SQA: если вам интересен сценарий, в котором вы задаете уточняющие вопросы, связанные с таблицей, в рамках диалога. Например, если сначала вы спросите «Как зовут первого актера?», затем можно задать уточняющий вопрос, например «Сколько ему лет?». Здесь вопросы не предполагают агрегации (все вопросы являются вопросами на выбор ячейки). 2. WTQ: если вам не интересен сценарий диалога, а нужно задавать вопросы, связанные с таблицей, которые могут включать агрегацию, например подсчёт количества строк, суммирование значений ячеек или вычисление среднего значения. В таком случае, например, можно спросить: «Каково общее количество голов, забитых Криштиану Роналду за карьеру?». Этот случай также называется **weak supervision**, поскольку сама модель должна научиться выбирать подходящий оператор агрегации (SUM/COUNT/AVERAGE/NONE), имея в качестве надзора только ответ на вопрос. 3. WikiSQL-supervised: этот датасет основан на WikiSQL, при обучении модели предоставляется истинный оператор агрегации. Это также называется **сильным надзором**. Здесь обучение подходящего оператора агрегации значительно проще. Подводя итог: | **Задача** | **Пример датасета** | **Описание** | |-------------------------------------|---------------------|---------------------------------------------------------------------------------------------------------| | Диалоговый | SQA | Вопросы только с выбором ячейки | | Слабый надзор для агрегации | WTQ | Вопросы могут включать агрегацию, и модели необходимо научиться этому, имея в качестве сигнала обучения только ответ | | Сильная супервизия для агрегации | WikiSQL-supervised | Вопросы могут включать агрегацию, и модели необходимо научиться этому, учитывая эталонный оператор агрегации | Инициализация модели с предобученной базой и случайно инициализированными классификационными головами из хаба может быть выполнена, как показано ниже. ```python from transformers import TapasConfig, TapasForQuestionAnswering # for example, the base sized model with default SQA configuration model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", device_map="auto") # or, the base sized model with WTQ configuration config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq") model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") # or, the base sized model with WikiSQL configuration config = TapasConfig("google-base-finetuned-wikisql-supervised") model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") ``` Конечно, не обязательно следовать одному из трёх способов, с помощью которых TAPAS был дообучен. Вы также можете экспериментировать, задавая любые гиперпараметры при инициализации [TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig), а затем создавать [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForQuestionAnswering) на основе этой конфигурации. Например, если у вас есть набор данных, содержащий как диалоговые вопросы, так и вопросы, предполагающие агрегацию, вы можете поступить следующим образом. Вот пример: ```python from transformers import TapasConfig, TapasForQuestionAnswering # you can initialize the classification heads any way you want (see docs of TapasConfig) config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True) # initializing the pre-trained base sized model with our custom classification heads model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") ``` Также можно начать с уже дообученного контрольного пункта. Обратите внимание, что дообученный контрольный пункт на WTQ имеет некоторые проблемы из-за L2-потери, которая в какой-то степени хрупка. Подробнее см. [здесь](https://github.com/google-research/tapas/issues/91#issuecomment-735719340). Список всех предобученных и дообученных контрольных точек TAPAS, доступных на хабе HuggingFace, см. [здесь](https://huggingface.co/models?search=tapas). **ШАГ 2: Подготовьте данные в формате SQA** Во-вторых, независимо от того, что вы выбрали выше, вам следует подготовить набор данных в формате [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253). Этот формат представляет собой файл TSV/CSV со следующими столбцами: - `id`: необязательный параметр, идентификатор пары «таблица-вопрос», используется для учёта. - `annotator`: необязательный параметр, идентификатор человека, разметившего пару «таблица-вопрос», для целей учёта. - `position`: целое число, указывающее, является ли вопрос первым, вторым, третьим и т. д. в контексте таблицы. Требуется только в случае диалогового режима (SQA). Эта колонка не нужна, если вы используете обучение с учителем для WTQ/WikiSQL. - `question`: string - `table_file`: строка, имя csv-файла, содержащего табличные данные - `answer_coordinates`: список из одного или нескольких кортежей (каждый кортеж представляет собой координату ячейки, то есть пару «строка, столбец», входящую в состав ответа) - `answer_text`: список из одной или нескольких строк (каждая строка — значение ячейки, входящее в состав ответа) - `aggregation_label`: индекс оператора агрегации. Требуется только в случае сильного обучения для агрегации (сценарий с надзором WikiSQL) - `float_answer`: числовой ответ на вопрос, если он есть (np.nan, если нет). Обязателен только в случае слабого надзора для агрегации (например, WTQ и WikiSQL) Сами таблицы должны находиться в папке, при этом каждая таблица представляет собой отдельный файл csv. Обратите внимание, что авторы алгоритма TAPAS использовали скрипты конвертации с некоторой автоматизированной логикой для преобразования других наборов данных (WTQ, WikiSQL) в формат SQA. Автор объясняет это [здесь](https://github.com/google-research/tapas/issues/50#issuecomment-705465960). Конвертация этого скрипта, работающая с реализацией HuggingFace, доступна [здесь](https://github.com/NielsRogge/tapas_utils). Интересно, что эти скрипты конвертации не идеальны (поля `answer_coordinates` и `float_answer` заполняются на основе `answer_text`), что означает, что результаты для WTQ и WikiSQL могли бы быть улучшены. **ШАГ 3: Преобразование данных в тензоры с помощью TapasTokenizer** Во-третьих, если вы подготовили данные в формате TSV/CSV (и соответствующие файлы CSV, содержащие табличные данные), вы можете использовать [TapasTokenizer](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasTokenizer) для преобразования пар «таблица-вопрос» в `input_ids`, `attention_mask`, `token_type_ids` и так далее. Снова в зависимости от того, какой из трех случаев вы выбрали выше, для дообучения [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForQuestionAnswering) требуются разные входные данные: | **Задача** | **Обязательные входные данные** | |------------------------------------|---------------------------------------------------------------------------------------------------------------------| | Диалоговый | `input_ids`, `attention_mask`, `token_type_ids`, `labels` | | Слабый надзор для агрегации | `input_ids`, `attention_mask`, `token_type_ids`, `labels`, `numeric_values`, `numeric_values_scale`, `float_answer` | | Сильная супервизия для агрегации | `input ids`, `attention mask`, `token type ids`, `labels`, `aggregation_labels` | [TapasTokenizer](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasTokenizer) создаёт `labels`, `numeric_values` и `numeric_values_scale` на основе столбцов `answer_coordinates` и `answer_text` в файле TSV. Значения `float_answer` и `aggregation_labels` уже присутствуют в файле TSV из шага 2. Пример: ```py from transformers import TapasTokenizer import pandas as pd model_name = "google/tapas-base" tokenizer = TapasTokenizer.from_pretrained(model_name) data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]} queries = [ "What is the name of the first actor?", "How many movies has George Clooney played in?", "What is the total number of movies?", ] answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]] answer_text = [["Brad Pitt"], ["69"], ["209"]] table = pd.DataFrame.from_dict(data) inputs = tokenizer( table=table, queries=queries, answer_coordinates=answer_coordinates, answer_text=answer_text, padding="max_length", return_tensors="pt", ) inputs {'input_ids': tensor([[ ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]), 'numeric_values': tensor([[ ]]), 'numeric_values_scale: tensor([[ ]]), labels: tensor([[ ]])} ``` Обратите внимание, что [TapasTokenizer](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasTokenizer) ожидает, что данные таблицы будут **только текстовыми**. Вы можете использовать `.astype(str)` для датафрейма, чтобы преобразовать его в текстовые данные. Разумеется, здесь показано только то, как закодировать один пример обучения. Рекомендуется создать dataloader для итерации по батчам: ```python import pandas as pd import torch tsv_path = "your_path_to_the_tsv_file" table_csv_path = "your_path_to_a_directory_containing_all_csv_files" class TableDataset(torch.utils.data.Dataset): def __init__(self, data, tokenizer): self.data = data self.tokenizer = tokenizer def __getitem__(self, idx): item = data.iloc[idx] table = pd.read_csv(table_csv_path + item.table_file).astype( str ) # be sure to make your table data text only encoding = self.tokenizer( table=table, queries=item.question, answer_coordinates=item.answer_coordinates, answer_text=item.answer_text, truncation=True, padding="max_length", return_tensors="pt", ) # remove the batch dimension which the tokenizer adds by default encoding = {key: val.squeeze(0) for key, val in encoding.items()} # add the float_answer which is also required (weak supervision for aggregation case) encoding["float_answer"] = torch.tensor(item.float_answer) return encoding def __len__(self): return len(self.data) data = pd.read_csv(tsv_path, sep="\t") train_dataset = TableDataset(data, tokenizer) train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=32) ``` Обратите внимание, что здесь каждая пара «таблица-вопрос» кодируется независимо. Это допустимо, пока ваш датасет **не является диалоговым**. Если же ваш датасет содержит диалоговые вопросы (например, в SQA), сначала сгруппируйте `queries`, `answer_coordinates` и `answer_text` по каждой таблице (в порядке их индекса `position`) и кодируйте каждую таблицу вместе с её вопросами пакетом. Это гарантирует, что типы токенов `prev_labels` (см. документацию [TapasTokenizer](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasTokenizer)) будут установлены корректно. Подробнее — в [этом ноутбуке](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb). **ШАГ 4: Обучение (дообучение) модели Затем можно выполнить дообучение [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForQuestionAnswering) следующим образом (здесь показан пример для слабого надзора в случае агрегации): ```python from transformers import AdamW, TapasConfig, TapasForQuestionAnswering # this is the default WTQ configuration config = TapasConfig( num_aggregation_labels=4, use_answer_as_supervision=True, answer_loss_cutoff=0.664694, cell_selection_preference=0.207951, huber_loss_delta=0.121194, init_cell_selection_weights_to_zero=True, select_one_column=True, allow_empty_column_selection=False, temperature=0.0352513, ) model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto") optimizer = AdamW(model.parameters(), lr=5e-5) model.train() for epoch in range(2): # loop over the dataset multiple times for batch in train_dataloader: # get the inputs; input_ids = batch["input_ids"] attention_mask = batch["attention_mask"] token_type_ids = batch["token_type_ids"] labels = batch["labels"] numeric_values = batch["numeric_values"] numeric_values_scale = batch["numeric_values_scale"] float_answer = batch["float_answer"] # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = model( input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, labels=labels, numeric_values=numeric_values, numeric_values_scale=numeric_values_scale, float_answer=float_answer, ) loss = outputs.loss loss.backward() optimizer.step() ``` ## Использование: inference Здесь мы объясняем, как использовать [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForQuestionAnswering) для инференса (то есть для получения предсказаний на новых данных). Для инференса модели необходимо передать только `input_ids`, `attention_mask` и `token_type_ids` (их можно получить с помощью [TapasTokenizer](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasTokenizer)), чтобы получить логиты. Далее вы можете использовать удобный метод `~models.tapas.tokenization_tapas.convert_logits_to_predictions`, чтобы преобразовать их в предсказанные координаты и необязательные индексы агрегации. Однако обратите внимание, что процесс вывода **отличается** в зависимости от того, является ли сценарий диалоговым. В недialogовом сценарии вывод можно выполнять параллельно для всех пар «таблица–вопрос» в батче. Вот пример: ```py from transformers import TapasTokenizer, TapasForQuestionAnswering import pandas as pd model_name = "google/tapas-base-finetuned-wtq" model = TapasForQuestionAnswering.from_pretrained(model_name, device_map="auto") tokenizer = TapasTokenizer.from_pretrained(model_name) data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]} queries = [ "What is the name of the first actor?", "How many movies has George Clooney played in?", "What is the total number of movies?", ] table = pd.DataFrame.from_dict(data) inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt").to(model.device) outputs = model(**inputs) predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions( inputs, outputs.logits.detach(), outputs.logits_aggregation.detach() ) # let's print out the results: id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"} aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices] answers = [] for coordinates in predicted_answer_coordinates: if len(coordinates) == 1: # only a single cell: answers.append(table.iat[coordinates[0]]) else: # multiple cells cell_values = [] for coordinate in coordinates: cell_values.append(table.iat[coordinate]) answers.append(", ".join(cell_values)) display(table) print("") for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string): print(query) if predicted_agg == "NONE": print("Predicted answer: " + answer) else: print("Predicted answer: " + predicted_agg + " > " + answer) What is the name of the first actor? Predicted answer: Brad Pitt How many movies has George Clooney played in? Predicted answer: COUNT > 69 What is the total number of movies? Predicted answer: SUM > 87, 53, 69 ``` В случае диалогового сценария каждая пара «таблица — вопрос» должна передаваться модели **последовательно**, чтобы типы токенов `prev_labels` могли быть заменены предсказанными `labels` предыдущей пары «таблица — вопрос». Подробнее можно узнать в [этом ноутбуке](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb). ## Ресурсы - [Руководство по задаче классификации текста](../tasks/sequence_classification) - [Руководство по задаче маскированного языкового моделирования](../tasks/masked_language_modeling) ## Специфические выходные данные TAPAS[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] #### transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]] ```python transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_aggregation: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L49) **Параметры:** loss (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если предоставлены `labels` (и, возможно, `answer`, `aggregation_labels`, `numeric_values` и `numeric_values_scale`)) : Суммарная функция потерь, представляющая собой сумму иерархической потери логарифмической правдоподобности выбора ячеек, (необязательно) потери полунепосредственного регрессионного обучения и (необязательно) потери надзорного обучения для агрегаций. logits (`torch.Tensor` формы `(batch_size, sequence_length)`) : Оценки предсказаний для каждого токена, полученные головой выбора ячеек. logits_aggregation (`torch.Tensor`, *необязательный*, формы `(batch_size, num_aggregation_labels)`) : Оценки предсказаний агрегирующей головы для каждого оператора агрегации. hidden_states (`tuple[torch.Tensor]`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода эмбеддингов, если у модели есть слой эмбеддингов, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные начальные выводы эмбеддингов. attentions (`tuple[torch.Tensor]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному для каждого слоя) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax-функции внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Тип результата [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForQuestionAnswering). ## TapasConfig[[transformers.TapasConfig]] #### transformers.TapasConfig[[transformers.TapasConfig]] ```python transformers.TapasConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 1024, type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10), initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, positive_label_weight: float = 10.0, num_aggregation_labels: int = 0, aggregation_loss_weight: float = 1.0, use_answer_as_supervision: bool | None = None, answer_loss_importance: float = 1.0, use_normalized_answer_loss: bool = False, huber_loss_delta: float | None = None, temperature: float = 1.0, aggregation_temperature: float = 1.0, use_gumbel_for_cells: bool = False, use_gumbel_for_aggregation: bool = False, average_approximation_function: str = 'ratio', cell_selection_preference: float | None = None, answer_loss_cutoff: float | int | None = None, max_num_rows: int = 64, max_num_columns: int = 32, average_logits_per_cell: bool = False, select_one_column: bool = True, allow_empty_column_selection: bool = False, init_cell_selection_weights_to_zero: bool = False, reset_position_index_per_cell: bool = True, disable_per_token_loss: bool = False, aggregation_labels: dict | None = None, no_aggregation_label_index: int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, tie_word_embeddings: bool = True) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/configuration_tapas.py#L32) **Параметры:** vocab_size (`int`, *необязательный*, по умолчанию `30522`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`. hidden_size (`int`, *optional*, по умолчанию `768`) : Размерность скрытых представлений. num_hidden_layers (`int`, *необязательный*, по умолчанию `12`) : Количество скрытых слоев в декодере Transformer. num_attention_heads (`int`, *необязательный*, по умолчанию `12`) : Количество головок внимания для каждого слоя внимания в декодере Transformer. intermediate_size (`int`, *optional*, по умолчанию `3072`) : Размерность представлений MLP. hidden_act (`str`, *необязательный*, по умолчанию `gelu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д. hidden_dropout_prob (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Вероятность dropout для всех полносвязных слоев в эмбеддингах, энкодере и пулере. attention_probs_dropout_prob (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля dropout для вероятностей внимания. max_position_embeddings (`int`, *необязательный*, по умолчанию `1024`) : Максимальная длина последовательности, с которой может использоваться данная модель. type_vocab_sizes (`list[int]`, *необязательный*, по умолчанию `[3, 256, 256, 2, 256, 256, 10]`) : Размеры словаря для `token_type_ids`, передаваемых при вызове [TapasModel](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasModel). initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов. layer_norm_eps (`float`, *необязательный*, по умолчанию `1e-12`) : Значение epsilon, используемое слоями нормализации. pad_token_id (`int`, *необязательный*, по умолчанию `0`) : Идентификатор токена, используемый для выравнивания в словаре. bos_token_id (`int`, *optional*) : Идентификатор токена, используемый для обозначения начала потока в словаре. eos_token_id (`Union[int, list[int]]`, *необязательный*) : Идентификатор токена, используемый для обозначения конца потока в словаре. positive_label_weight (`float`, *необязательный*, по умолчанию 10.0) : Вес для положительных меток. num_aggregation_labels (`int`, *optional*, по умолчанию 0) : Количество операторов агрегации, которые необходимо предсказать. aggregation_loss_weight (`float`, *необязательный*, по умолчанию 1.0) : Вес важности для функции потерь агрегации. use_answer_as_supervision (`bool`, *необязательный*) : Использовать ли ответ в качестве единственного надзора для примеров агрегации. answer_loss_importance (`float`, *необязательный*, по умолчанию 1.0) : Вес важности для функции потерь регрессии. use_normalized_answer_loss (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли нормализовать потерю ответа по максимуму предсказанного и ожидаемого значений. huber_loss_delta (`float`, *необязательный*) : Параметр дельта, используемый для вычисления функции потерь регрессии. temperature (`float`, *необязательный*, по умолчанию 1.0) : Значение, используемое для управления (или изменения) асимметрией вероятностей логитов ячеек. aggregation_temperature (`float`, *необязательный*, по умолчанию 1.0) : Масштабирует логиты агрегации для управления асимметрией вероятностей. use_gumbel_for_cells (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли применять Gumbel-Softmax для выбора ячеек. use_gumbel_for_aggregation (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли применять Gumbel-Softmax для выбора агрегации. average_approximation_function (`string`, *необязательный*, по умолчанию `"ratio"`) : Метод для расчёта ожидаемого среднего значения ячеек в случае слабого надзора. Одно из значений `"ratio"`, `"first_order"` или `"second_order"`. cell_selection_preference (`float`, *optional*) : Предпочтение при выборе ячейки в неоднозначных случаях. Применимо только в случае слабого надзора для агрегации (WTQ, WikiSQL). Если общая масса вероятностей агрегации (за исключением оператора "NONE") выше этого гиперпараметра, то для примера предсказывается агрегация. answer_loss_cutoff (`float`, *необязательный*) : Игнорировать примеры, у которых потеря ответа превышает cutoff. max_num_rows (`int`, *необязательный*, по умолчанию 64) : Максимальное количество строк. max_num_columns (`int`, *необязательный*, по умолчанию 32) : Максимальное количество столбцов. average_logits_per_cell (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли усреднять логиты по каждой ячейке. select_one_column (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли ограничивать модель так, чтобы она выбирала ячейки только из одного столбца. allow_empty_column_selection (`bool`, *необязательный*, по умолчанию `False`) : Разрешает ли не выбирать ни одного столбца. init_cell_selection_weights_to_zero (`bool`, *необязательный*, по умолчанию `False`) : Инициализировать ли веса выбора ячеек нулём, чтобы начальные вероятности составляли 50%. reset_position_index_per_cell (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли сбрасывать индексы позиций в каждой ячейке (то есть использовать относительные эмбеддинги позиций). disable_per_token_loss (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли отключать любое (сильное или слабое) управление ячейками. aggregation_labels (`dict[int, label]`, *необязательный*) : Метки агрегации, используемые для агрегирования результатов. Например, модели WTQ имеют следующие метки агрегации: `{0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}` no_aggregation_label_index (`int`, *optional*) : Если метки агрегации определены и одна из них обозначает «Нет агрегации», здесь следует указать её индекс. Например, у моделей WTQ метка агрегации «NONE» находится по индексу 0, поэтому для этих моделей значение должно быть установлено в 0. is_decoder (`bool`, *необязательный*, по умолчанию `False`) : Указывает, используется ли модель в качестве декодера. Если `False`, модель используется как энкодер. add_cross_attention (`bool`, *необязательный*, по умолчанию `False`) : Следует ли добавлять слои кросс-внимания в модель. tie_word_embeddings (`bool`, *необязательный*, по умолчанию `True`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели. Это класс конфигурации для хранения настроек модели TapasModel. Он используется для создания модели Tapas в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [google/tapas-base-finetuned-sqa](https://huggingface.co/google/tapas-base-finetuned-sqa) Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig). Пример: ```python >>> from transformers import TapasModel, TapasConfig >>> # Initializing a default (SQA) Tapas configuration >>> configuration = TapasConfig() >>> # Initializing a model from the configuration >>> model = TapasModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## TapasTokenizer[[transformers.TapasTokenizer]] #### transformers.TapasTokenizer[[transformers.TapasTokenizer]] ```python transformers.TapasTokenizer(vocab_file, do_lower_case = True, do_basic_tokenize = True, never_split = None, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', empty_token = '[EMPTY]', tokenize_chinese_chars = True, strip_accents = None, cell_trim_length: int = -1, max_column_id: int | None = None, max_row_id: int | None = None, strip_column_names: bool = False, update_answer_coordinates: bool = False, min_question_length = None, max_question_length = None, model_max_length: int = 512, additional_special_tokens: list[str] | None = None, clean_up_tokenization_spaces = True, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/tokenization_tapas.py#L149) **Параметры:** vocab_file (`str`) : Файл, содержащий словарь. do_lower_case (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли приводить входные данные к нижнему регистру при токенизации. do_basic_tokenize (`bool`, *необязательный*, по умолчанию `True`) : Выполнять ли базовую токенизацию перед WordPiece. never_split (`Iterable`, *необязательный*) : Коллекция токенов, которые никогда не будут разделены при токенизации. Имеет значение только при `do_basic_tokenize=True` unk_token (`str`, *необязательный*, по умолчанию `"[UNK]"`) : Неизвестный токен. Токен, отсутствующий в словаре, не может быть преобразован в идентификатор, поэтому вместо него устанавливается этот токен. sep_token (`str`, *необязательный*, по умолчанию `"[SEP]"`) : Токен-разделитель, который используется при построении последовательности из нескольких последовательностей, например, двух последовательностей для классификации последовательностей или текста и вопроса для ответа на вопросы. Он также используется в качестве последнего токена последовательности, построенной с помощью специальных токенов. pad_token (`str`, *необязательный*, по умолчанию `"[PAD]"`) : Токен, используемый для выравнивания, например, при пакетной обработке последовательностей разной длины. cls_token (`str`, *необязательный*, по умолчанию `"[CLS]"`) : Токен классификатора, используемый при классификации последовательности (классификация всей последовательности, а не посимвольная классификация). Это первый токен последовательности, если она построена со специальными токенами. mask_token (`str`, *необязательный*, по умолчанию `"[MASK]"`) : Токен, используемый для маскирования значений. Это токен, применяемый при обучении данной модели с использованием маскированного языкового моделирования. Именно этот токен модель будет пытаться предсказать. empty_token (`str`, *необязательный*, по умолчанию `"[EMPTY]"`) : Токен, используемый для пустых значений ячеек в таблице. К пустым значениям ячеек относятся "", "n/a", "nan" и "?". tokenize_chinese_chars (`bool`, *необязательный*, по умолчанию `True`) : Токенизировать ли китайские иероглифы. Для японского языка это, вероятно, следует отключить (см. эту [проблему](https://github.com/huggingface/transformers/issues/328)). strip_accents (`bool`, *необязательный*) : Нужно ли удалять все диакритические знаки. Если этот параметр не указан, его значение определяется по значению `lowercase` (как в оригинальном BERT). cell_trim_length (`int`, *optional*, по умолчанию -1) : Если > 0: обрезать ячейки так, чтобы их длина была <= этому значению. Также отключает дальнейшую обрезку ячеек, поэтому следует использовать с `truncation`, установленным в `True`. max_column_id (`int`, *необязательный*) : Максимальный идентификатор столбца для извлечения. max_row_id (`int`, *необязательный*) : Максимальный идентификатор строки для извлечения. strip_column_names (`bool`, *необязательный*, по умолчанию `False`) : Добавлять ли пустые строки вместо имён столбцов. update_answer_coordinates (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли пересчитывать координаты ответа из текста ответа. min_question_length (`int`, *optional*) : Минимальная длина каждого вопроса в токенах (иначе будет пропущен). max_question_length (`int`, *optional*) : Максимальная длина каждого вопроса в токенах (иначе будет пропущен). clean_up_tokenization_spaces (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли очищать пробелы после декодирования. Очистка заключается в удалении возможных артефактов, таких как лишние пробелы. Создаёт токенизатор TAPAS. Основан на WordPiece. Разворачивает таблицу и одно или несколько связанных предложений для использования в моделях TAPAS. Этот токенизатор наследуется от [PreTrainedTokenizer](/docs/transformers/v5.23.0/ru/main_classes/tokenizer#transformers.PythonBackend), который содержит большинство основных методов. За дополнительной информацией об этих методах пользователям следует обращаться к этому суперклассу. [TapasTokenizer](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasTokenizer) создаёт несколько идентификаторов типов токенов для кодирования табличной структуры. Более точно, он добавляет 7 идентификаторов типов токенов в следующем порядке: `segment_ids`, `column_ids`, `row_ids`, `prev_labels`, `column_ranks`, `inv_column_ranks` и `numeric_relations`: - segment_ids: указывает, к какому сегменту относится токен — к вопросу (0) или к таблице (1). Для специальных токенов и заполнителей значение равно 0. - column_ids: указывает, к какому столбцу таблицы относится токен (нумерация начинается с 1). Для всех токенов вопроса, специальных токенов и заполнителей значение равно 0. - row_ids: указывает, к какой строке таблицы относится токен (нумерация начинается с 1). Для всех токенов вопроса, специальных токенов и заполнителей значение равно 0. Для токенов заголовков столбцов также равно 0. - prev_labels: указывает, являлся ли токен (частью) ответа на предыдущий вопрос (1) или нет (0). Полезно в диалоговых сценариях (например, SQA). - column_ranks: указывает ранг токена таблицы относительно столбца, если применимо. Например, если у вас есть столбец «количество фильмов» со значениями 87, 53 и 69, то ранги столбца для этих токенов равны 3, 1 и 2 соответственно. 0 для всех токенов вопроса, специальных токенов и заполнителей. - inv_column_ranks: указывает обратный ранг токена таблицы относительно столбца, если применимо. Например, если у вас есть столбец «количество фильмов» со значениями 87, 53 и 69, то обратные ранги столбца для этих токенов равны 1, 3 и 2 соответственно. 0 для всех токенов вопроса, специальных токенов и заполнителей. - numeric_relations: указывает числовые отношения между вопросами и токенами таблицы. 0 для всех токенов вопроса, специальных токенов и заполнителей. [TapasTokenizer](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasTokenizer) выполняет сквозную токенизацию таблицы и связанных с ней предложений: разбиение по знакам препинания и wordpiece. #### __call__[[transformers.TapasTokenizer.__call__]] ```python __call__(table: typing.Union[ForwardRef('pd.DataFrame'), str, list[str], NoneType], queries: str | list[str] | list[int] | list[list[str]] | list[list[int]] | None = None, answer_coordinates: list[tuple] | list[list[tuple]] | None = None, answer_text: list[str] | list[list[str]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.models.tapas.tokenization_tapas.TapasTruncationStrategy = False, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/tokenization_tapas.py#L518) **Параметры:** table (`pd.DataFrame` или `str` или `list[str]`) : Таблица, содержащая табличные данные. Обратите внимание, что все значения ячеек должны быть текстом. Используйте *.astype(str)* для Pandas-датафрейма, чтобы преобразовать его в строки. При передаче строки или списка строк они будут интерпретироваться как запросы с пустой таблицей (для поддержки универсальных тестов токенизатора). queries (`str` или `list[str]`) : Вопрос или пакет вопросов, связанных с таблицей, для кодирования. Обратите внимание, что в случае пакета все вопросы должны относиться к **одной и той же** таблице. answer_coordinates (`list[Tuple]` или `list[list[Tuple]]`, *необязательный*) : Координаты ответов для каждой пары «таблица-вопрос» в батче. Если предоставлена только одна пара «таблица-вопрос», то answer_coordinates должен представлять собой один список из одного или нескольких кортежей. Каждый кортеж должен быть парой (row_index, column_index). У первой строки данных (не строки заголовка столбцов) индекс 0. У первого столбца индекс 0. Если предоставлен батч пар «таблица-вопрос», то answer_coordinates должен представлять собой список списков кортежей (каждый список соответствует одной паре «таблица-вопрос»). answer_text (`list[str]` или `list[list[str]]`, *необязательный*) : Текст ответа для каждой пары «таблица-вопрос» в батче. Если предоставлена только одна пара «таблица-вопрос», то answer_text должен быть единственным списком из одной или нескольких строк. Каждая строка должна содержать текст ответа, соответствующий координате ответа. Если предоставлен батч пар «таблица-вопрос», то answer_coordinates должен быть списком списков строк (каждый список соответствует одной паре «таблица-вопрос»). add_special_tokens (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли кодировать последовательности со специальными токенами в соответствии с их моделью. padding (`bool`, `str` или [PaddingStrategy](/docs/transformers/v5.23.0/ru/internal/file_utils#transformers.utils.PaddingStrategy), *необязательный*, по умолчанию `False`) : Включает и управляет выравниванием. Принимает следующие значения: - `True` или `'longest'`: Выравнивание до самой длинной последовательности в батче (или без выравнивания, если предоставлена только одна последовательность). - `'max_length'`: Выравнивание до максимальной длины, указанной в аргументе `max_length`, или до максимально допустимой входной длины для модели, если этот аргумент не указан. - `False` или `'do_not_pad'` (по умолчанию): Без выравнивания (т. е. может выдать батч с последовательностями разной длины). truncation (`bool`, `str` или `TapasTruncationStrategy`, *optional*, по умолчанию `False`) : Включает и управляет усечением. Принимает следующие значения: - `True` или `'drop_rows_to_fit'`: Усечение до максимальной длины, указанной аргументом `max_length`, или до максимально допустимой длины входных данных для модели, если этот аргумент не указан. Усечение выполняется построчно, удаляя строки из таблицы. - `False` или `'do_not_truncate'` (по умолчанию): Усечение не выполняется (т. е. может быть выведен батч с длиной последовательности, превышающей максимально допустимый размер входных данных модели). max_length (`int`, *optional*) : Управляет максимальной длиной, используемой одним из параметров усечения/дополнения. Если значение не задано или равно `None`, будет использована предопределённая максимальная длина модели, если один из параметров усечения/дополнения требует указания максимальной длины. Если у модели нет конкретной максимальной длины входных данных (как у XLNet), усечение/дополнение до максимальной длины будет отключено. is_split_into_words (`bool`, *необязательный*, по умолчанию `False`) : Указывает, является ли вход уже предтокенизированным (например, разбитым на слова). Если установлено в `True`, токенизатор предполагает, что вход уже разбит на слова (например, по пробелам), и токенизирует их. Это полезно для NER или классификации токенов. pad_to_multiple_of (`int`, *optional*) : Если задано, последовательность будет дополнена нулями до кратного указанного значения. Это особенно полезно для использования Tensor Cores на аппаратных платформах NVIDIA с вычислительной способностью `>= 7.5` (Volta). return_tensors (`str` или [TensorType](/docs/transformers/v5.23.0/ru/internal/file_utils#transformers.TensorType), *optional*) : Если задано, возвращает тензоры вместо списка целых чисел Python. Допустимые значения: - `'pt'`: Возвращает объекты `torch.Tensor` PyTorch. - `'np'`: Возвращает объекты `np.ndarray` Numpy. Основной метод для токенизации и подготовки одной или нескольких последовательностей, связанных с таблицей, для модели. #### convert_logits_to_predictions[[transformers.TapasTokenizer.convert_logits_to_predictions]] ```python convert_logits_to_predictions(data, logits, logits_agg = None, cell_classification_threshold = 0.5) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/tokenization_tapas.py#L1885) **Параметры:** data (`dict`) : Словарь, сопоставляющий признаки с фактическими значениями. Должен создаваться с помощью [TapasTokenizer](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasTokenizer). logits (`torch.Tensor` формы `(batch_size, sequence_length)`) : тензор, содержащий логиты на уровне токенов. logits_agg (`torch.Tensor` формы `(batch_size, num_aggregation_labels)`, *необязательный*) : Тензор, содержащий логиты агрегации. cell_classification_threshold (`float`, *optional*, по умолчанию 0.5) : Порог, используемый для выбора ячеек. Будут выбраны все ячейки таблицы, вероятность которых превышает этот порог. **Возвращает:** `tuple`, содержащий различные элементы в зависимости от входных данных - predicted_answer_coordinates (`list[list[[tuple]]` длины `batch_size`): Предсказанные координаты ответа в виде списка списков кортежей. Каждый элемент списка содержит предсказанные координаты ответа для одного примера в батче, представленные в виде списка кортежей. Каждый кортеж представляет собой ячейку, то есть (индекс строки, индекс столбца). - predicted_aggregation_indices (`list[int]`длиной `batch_size`, *необязательный*, возвращается, если задан `logits_aggregation`): Предсказанные индексы операторов агрегации для головы агрегации. Преобразует логиты [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForQuestionAnswering) в фактические координаты предсказанного ответа и необязательные индексы агрегации. Первоначальная реализация, на которой основана эта функция, доступна [здесь](https://github.com/google-research/tapas/blob/4908213eb4df7aa988573350278b44c4dbe3f71b/tapas/experiments/prediction_utils.py#L288). #### save_vocabulary[[transformers.TapasTokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/tokenization_tapas.py#L386) ## TapasModel[[transformers.TapasModel]] #### transformers.TapasModel[[transformers.TapasModel]] ```python transformers.TapasModel(config: TapasConfig, add_pooling_layer = True) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L510) **Параметры:** config ([TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. add_pooling_layer (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли добавлять слой пулинга Модель Tapas без дополнительных слоёв, выводящая необработанные скрытые состояния. Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.TapasModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L543) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length, 7)`, *необязательный*) : Индексы токенов, кодирующие табличную структуру. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробнее об этом классе см. здесь. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Если `reset_position_index_per_cell` в [TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig) установлено в `True`, будут использоваться относительные позиционные эмбеддинги. Выбраны в диапазоне `[0, config.max_position_embeddings - 1]`. [Что такое позиционные идентификаторы?](../glossary#position-ids) inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. encoder_hidden_states (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании, если модель настроена как декодер. encoder_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отступов во входных данных кодировщика. Эта маска используется в кросс-внимании, если модель настроена как декодер. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или `tuple(torch.Tensor)` Объект [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig)) и входных данных. Метод forward модели [TapasModel](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasModel) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели. - **pooler_output** (`torch.Tensor` формы `(batch_size, hidden_size)`) -- Скрытое состояние последнего слоя для первого токена последовательности (токен классификации) после дополнительной обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки линейным слоем и функцией активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения. - **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Примеры: ```python >>> from transformers import AutoTokenizer, TapasModel >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base") >>> model = TapasModel.from_pretrained("google/tapas-base") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state ``` ## TapasForMaskedLM[[transformers.TapasForMaskedLM]] #### transformers.TapasForMaskedLM[[transformers.TapasForMaskedLM]] ```python transformers.TapasForMaskedLM(config: TapasConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L660) **Параметры:** config ([TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Tapas с головкой `language modeling`." Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.TapasForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L684) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length, 7)`, *необязательный*) : Индексы токенов, кодирующие табличную структуру. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробнее об этом классе см. здесь. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Если `reset_position_index_per_cell` в [TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig) установлено в `True`, будут использоваться относительные позиционные эмбеддинги. Выбраны в диапазоне `[0, config.max_position_embeddings - 1]`. [Что такое позиционные идентификаторы?](../glossary#position-ids) inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. encoder_hidden_states (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательный*) : Последовательность скрытых состояний на выходе последнего слоя кодировщика. Используется в кросс-внимании, если модель настроена как декодер. encoder_attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отступов во входных данных кодировщика. Эта маска используется в кросс-внимании, если модель настроена как декодер. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. labels (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[-100, 0, ..., config.vocab_size]` (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`. output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [MaskedLMOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) или `tuple(torch.Tensor)` Объект [MaskedLMOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig)) и входных данных. Метод forward класса [TapasForMaskedLM](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForMaskedLM) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери маскированного языкового моделирования (MLM). - **logits** (`torch.Tensor` формы `(batch_size, sequence_length, config.vocab_size)`) — Оценки предсказаний языковой модели (оценки для каждого токена словаря до применения SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Примеры: ```python >>> from transformers import AutoTokenizer, TapasForMaskedLM >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base") >>> model = TapasForMaskedLM.from_pretrained("google/tapas-base") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> inputs = tokenizer( ... table=table, queries="How many [MASK] has George [MASK] played in?", return_tensors="pt" ... ) >>> labels = tokenizer( ... table=table, queries="How many movies has George Clooney played in?", return_tensors="pt" ... )["input_ids"] >>> outputs = model(**inputs, labels=labels) >>> logits = outputs.logits ``` ## TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] #### transformers.TapasForSequenceClassification[[transformers.TapasForSequenceClassification]] ```python transformers.TapasForSequenceClassification(config: TapasConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L1119) **Параметры:** config ([TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Tapas с головой последовательной классификации сверху (линейный слой поверх пул-вывода), например, для задач entailment таблиц, таких как TabFact (Chen et al., 2020). Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.TapasForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L1131) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length, 7)`, *необязательный*) : Индексы токенов, кодирующие табличную структуру. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробнее об этом классе см. здесь. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Если `reset_position_index_per_cell` в [TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig) установлено в `True`, будут использоваться относительные позиционные эмбеддинги. Выбраны в диапазоне `[0, config.max_position_embeddings - 1]`. [Что такое позиционные идентификаторы?](../glossary#position-ids) inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления функции потерь классификации/регрессии последовательности. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. Если `config.num_labels == 1`, вычисляется функция потерь регрессии (среднеквадратичная ошибка). Если `config.num_labels > 1`, вычисляется функция потерь классификации (кросс-энтропия). Примечание: в исходной реализации это называется "classification_class_index". output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [SequenceClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) или `tuple(torch.Tensor)` Объект [SequenceClassifierOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig)) и входных данных. Метод forward класса [TapasForSequenceClassification](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForSequenceClassification) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации (или регрессии, если config.num_labels==1). - **logits** (`torch.Tensor` формы `(batch_size, config.num_labels)`) — Оценки классификации (или регрессии, если config.num_labels==1) до применения SoftMax. - **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Примеры: ```python >>> from transformers import AutoTokenizer, TapasForSequenceClassification >>> import torch >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-tabfact") >>> model = TapasForSequenceClassification.from_pretrained("google/tapas-base-finetuned-tabfact") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = [ ... "There is only one actor who is 45 years old", ... "There are 3 actors which played in more than 60 movies", ... ] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> labels = torch.tensor([1, 0]) # 1 means entailed, 0 means refuted >>> outputs = model(**inputs, labels=labels) >>> loss = outputs.loss >>> logits = outputs.logits ``` ## TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] #### transformers.TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]] ```python transformers.TapasForQuestionAnswering(config: TapasConfig) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L781) **Параметры:** config ([TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели. Модель Tapas с головой для выбора ячеек и необязательной головой агрегации сверху для задач вопросно-ответных систем на таблицах (линейные слои поверх выходных скрытых состояний для вычисления `logits` и необязательных `logits_aggregation`), например, для задач SQA, WTQ или WikiSQL с учителем. Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса. Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением. #### forward[[transformers.TapasForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, table_mask: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, aggregation_labels: typing.Optional[torch.LongTensor] = None, float_answer: typing.Optional[torch.Tensor] = None, numeric_values: typing.Optional[torch.Tensor] = None, numeric_values_scale: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L804) **Параметры:** input_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы токенов входной последовательности в словаре. По умолчанию заполнение (padding) игнорируется. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробности см. в [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) и [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). [Что такое входные идентификаторы?](../glossary#input-ids) attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`: - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**. [Что такое маски внимания?](../glossary#attention-mask) token_type_ids (`torch.LongTensor` формы `(batch_size, sequence_length, 7)`, *необязательный*) : Индексы токенов, кодирующие табличную структуру. Индексы можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Подробнее об этом классе см. здесь. [Что такое идентификаторы типов токенов?](../glossary#token-type-ids) position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Если `reset_position_index_per_cell` в [TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig) установлено в `True`, будут использоваться относительные позиционные эмбеддинги. Выбраны в диапазоне `[0, config.max_position_embeddings - 1]`. [Что такое позиционные идентификаторы?](../glossary#position-ids) inputs_embeds (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`, *необязательно*) : По желанию, вместо передачи `input_ids` можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы `input_ids` преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели. table_mask (`torch.LongTensor` формы `(batch_size, seq_length)`, *необязательный*) : Маска для таблицы. Указывает, какие токены принадлежат таблице (1). Токены вопросов, заголовки таблицы и заполнители равны 0. labels (`torch.LongTensor` формы `(batch_size, seq_length)`, *необязательный*) : Метки для каждого токена для вычисления иерархической функции потерь выбора ячеек. Это кодирует позиции ответа, присутствующего в таблице. Можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). - 1 для токенов, которые **являются частью ответа**, - 0 для токенов, которые **не являются частью ответа**. aggregation_labels (`torch.LongTensor` формы `(batch_size, )`, *необязательный*) : Индекс функции агрегации для каждого примера в батче для вычисления потерь агрегации. Индексы должны находиться в диапазоне `[0, ..., config.num_aggregation_labels - 1]`. Требуется только в случае сильного надзора для агрегации (WikiSQL-supervised). float_answer (`torch.Tensor` формы `(batch_size, )`, *необязательный*) : Числовой ответ для каждого примера в батче. Установите *float('nan')* для вопросов по выбору ячейки. Требуется только в случае слабого обучения (WTQ) для вычисления агрегированной маски и функции потерь регрессии. numeric_values (`torch.Tensor` формы `(batch_size, seq_length)`, *необязательный*) : Числовые значения каждого токена, NaN для токенов, которые не являются числовыми значениями. Можно получить с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Требуется только в случае слабого надзора для агрегации (WTQ) для вычисления функции потерь регрессии. numeric_values_scale (`torch.Tensor` формы `(batch_size, seq_length)`, *необязательный*) : Масштаб числовых значений каждого токена. Может быть получен с помощью [AutoTokenizer](/docs/transformers/v5.23.0/ru/model_doc/auto#transformers.AutoTokenizer). Требуется только в случае слабого надзора для агрегации (WTQ) для вычисления функции потерь регрессии. output_attentions (`bool`, *необязательный*) : Нужно ли возвращать тензоры внимания всех слоев внимания. Подробнее см. `attentions` в разделе возвращаемых тензоров. output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров. return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа. **Возвращает:** [TableQuestionAnsweringOutput](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) или `tuple(torch.Tensor)` Объект [TableQuestionAnsweringOutput](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([TapasConfig](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasConfig)) и входных данных. Метод forward класса [TapasForQuestionAnswering](/docs/transformers/v5.23.0/ru/model_doc/tapas#transformers.TapasForQuestionAnswering) переопределяет специальный метод `__call__`. Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует. - **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если переданы `labels` (и, возможно, `answer`, `aggregation_labels`, `numeric_values` и `numeric_values_scale`)) -- Суммарная потеря, равная сумме иерархической потери логарифмической правдоподобности выбора ячеек, (опционально) потери полунепосредственного регрессионного обучения и (опционально) потери надзорного обучения для агрегаций. - **logits** (`torch.Tensor` формы `(batch_size, sequence_length)`) -- Оценки предсказаний головы выбора ячеек для каждого токена. - **logits_aggregation** (`torch.Tensor`, *необязательный*, формы `(batch_size, num_aggregation_labels)`) -- Оценки предсказаний агрегирующей головы для каждого оператора агрегации. - **hidden_states** (`tuple[torch.Tensor]`, *необязательный*, возвращается, если передано `output_hidden_states=True` или если `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания. - **attentions** (`tuple[torch.Tensor]`, *необязательный*, возвращается при передаче `output_attentions=True` или когда `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания. Примеры: ```python >>> from transformers import AutoTokenizer, TapasForQuestionAnswering >>> import pandas as pd >>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-wtq") >>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base-finetuned-wtq") >>> data = { ... "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], ... "Age": ["56", "45", "59"], ... "Number of movies": ["87", "53", "69"], ... } >>> table = pd.DataFrame.from_dict(data) >>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"] >>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> logits = outputs.logits >>> logits_aggregation = outputs.logits_aggregation ```