Transformers documentation

TAPAS

Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Эта модель была опубликована в HF papers 05.04.2020 и добавлена в Hugging Face Transformers 15.12.2020.

TAPAS

Обзор

Модель TAPAS была предложена в работе TAPAS: Weakly Supervised Table Parsing via Pre-training авторами 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 (Sequential Question Answering от Microsoft)
WTQ (Wiki Table Questions, Стэнфордский университет)
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 — крупномасштабном датасете, содержащем 16k таблиц из Wikipedia для задачи table entailment (бинарная классификация). Дополнительные сведения см. в их последующей статье: Understanding tables with intermediate pre-training авторов Julian Martin Eisenschlos, Syrine Krichene и Thomas Müller.

TAPAS architecture. Taken from the original blog post.

Эта модель была предоставлена пользователем nielsr. Исходный код можно найти здесь.

Советы по использованию

TAPAS — это модель, которая по умолчанию использует относительные позиционные эмбеддинги (позиционные эмбеддинги сбрасываются для каждой ячейки таблицы). Обратите внимание, что эта возможность была добавлена после публикации оригинальной статьи о TAPAS. По словам авторов, это обычно приводит к немного лучшей производительности и позволяет кодировать более длинные последовательности, не исчерпывая лимит эмбеддингов. Это отражено в параметре reset_position_index_per_cell класса TapasConfig, который по умолчанию установлен в значение True. Все версии моделей по умолчанию, доступные на hub, используют относительные позиционные эмбеддинги. Вы по-прежнему можете использовать модели с абсолютными позиционными эмбеддингами, передав дополнительный аргумент revision="no_reset" при вызове метода from_pretrained(). Обратите внимание, что обычно рекомендуется дополнять (pad) входные данные справа, а не слева.
TAPAS основан на BERT, поэтому, например, TAPAS-base соответствует архитектуре BERT-base. Разумеется, TAPAS-large обеспечивает наилучшие результаты (результаты, приведённые в статье, получены с TAPAS-large). Результаты для моделей разного размера представлены в оригинальном репозитории на GitHub.
У TAPAS есть контрольные точки, дообученные на SQA, которые позволяют отвечать на вопросы, связанные с таблицей, в диалоговом режиме. Это означает, что вы можете задавать уточняющие вопросы, например «сколько ему лет?», относящиеся к предыдущему вопросу. Обратите внимание, что прямой проход TAPAS немного отличается в случае диалогового режима: в этом случае необходимо подавать каждую пару «таблица–вопрос» в модель по одному, чтобы токены типов prev_labels могли быть заменены предсказанными моделью labels для предыдущего вопроса. Подробнее см. в разделе «Использование».
TAPAS похож на BERT и, следовательно, опирается на задачу маскированного языкового моделирования (MLM). Поэтому он эффективен для предсказания замаскированных токенов и для задач NLU в целом, но не оптимален для генерации текста. В этом отношении лучше подходят модели, обученные с использованием задачи каузального языкового моделирования (CLM). Обратите внимание, что TAPAS можно использовать в качестве энкодера в рамках фреймворка EncoderDecoderModel, чтобы объединить его с авторегрессионным текстовым декодером, таким как GPT-2.

Использование: дообучение

Здесь мы объясняем, как можно дообучить TapasForQuestionAnswering на собственном наборе данных.

ШАГ 1: Выберите один из трёх способов использования TAPAS — или поэкспериментируйте

По сути, существует три различных способа дообучения TapasForQuestionAnswering, соответствующих различным наборам данных, на которых Tapas был дообучен:

SQA: если вам интересно задавать уточняющие вопросы, связанные с таблицей, в рамках диалога. Например, если сначала вы спросите «Как зовут первого актёра?», затем можно задать уточняющий вопрос, например «Сколько ему лет?». Здесь вопросы не предполагают агрегации (все вопросы являются вопросами на выбор ячейки).
WTQ: если вам не интересен сценарий диалога, а нужно задавать вопросы, связанные с таблицей, которые могут включать агрегацию, например подсчёт количества строк, суммирование значений ячеек или вычисление среднего значения. В таком случае, например, можно спросить: «Каково общее количество голов, забитых Криштиану Роналду за карьеру?». Этот случай также называется weak supervision, поскольку сама модель должна научиться выбирать подходящий оператор агрегации (SUM/COUNT/AVERAGE/NONE), имея в качестве сигнала обучения только ответ на вопрос.
WikiSQL-supervised: этот датасет основан на WikiSQL, при обучении модели предоставляется истинный оператор агрегации. Это также называется сильным надзором. Здесь обучение подходящего оператора агрегации значительно проще.

Подводя итог:

Задача	Пример датасета	Описание
Диалоговый	SQA	Вопросы только с выбором ячейки
Слабый надзор для агрегации	WTQ	Вопросы могут включать агрегацию, и модели необходимо научиться этому, имея в качестве сигнала обучения только ответ
Сильная супервизия для агрегации	WikiSQL-supervised	Вопросы могут включать агрегацию, и модели необходимо научиться этому, учитывая эталонный оператор агрегации

Инициализация модели с предобученной базой и случайно инициализированными классификационными головами из хаба может быть выполнена, как показано ниже.

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, а затем создавать TapasForQuestionAnswering на основе этой конфигурации. Например, если у вас есть набор данных, содержащий как диалоговые вопросы, так и вопросы, предполагающие агрегацию, вы можете поступить следующим образом. Вот пример:

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-потери, которая в какой-то степени хрупка. Подробнее см. здесь.

Список всех предобученных и дообученных контрольных точек TAPAS, доступных на хабе HuggingFace, можно найти здесь.

ШАГ 2: Подготовьте данные в формате SQA

Во-вторых, независимо от того, что вы выбрали выше, вам следует подготовить набор данных в формате SQA. Этот формат представляет собой файл 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. Автор объясняет это здесь. Конвертация этого скрипта, работающая с реализацией HuggingFace, доступна здесь. Интересно, что эти скрипты конвертации не идеальны (поля answer_coordinates и float_answer заполняются на основе answer_text), что означает, что результаты для WTQ и WikiSQL могли бы быть улучшены.

ШАГ 3: Преобразование данных в тензоры с помощью TapasTokenizer

Во-третьих, если вы подготовили данные в формате TSV/CSV (а также соответствующие CSV-файлы с табличными данными), вы можете использовать TapasTokenizer для преобразования пар «таблица-вопрос» в input_ids, attention_mask, token_type_ids и так далее. Как и прежде, в зависимости от того, какой из трёх случаев вы выбрали выше, для дообучения 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 создаёт labels, numeric_values и numeric_values_scale на основе столбцов answer_coordinates и answer_text в TSV-файле. Значения float_answer и aggregation_labels уже присутствуют в TSV-файле, полученном на шаге 2. Пример:

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 ожидает, чтобы данные таблицы были только текстовыми. Вы можете использовать .astype(str) для датафрейма, чтобы преобразовать его в данные, содержащие только текст. Разумеется, здесь показано лишь то, как закодировать один пример для обучения. Рекомендуется создать загрузчик данных (dataloader) для итерации по батчам:

import pandas as pd
import torch


tsv_path = "your_path_to_the_tsv_file"
table_csv_path = "your_path_to_a_directory_containing_all_csv_files"


class TableDataset(torch.utils.data.Dataset):
    def __init__(self, data, tokenizer):
        self.data = data
        self.tokenizer = tokenizer

    def __getitem__(self, idx):
        item = data.iloc[idx]
        table = pd.read_csv(table_csv_path + item.table_file).astype(
            str
        )  # be sure to make your table data text only
        encoding = self.tokenizer(
            table=table,
            queries=item.question,
            answer_coordinates=item.answer_coordinates,
            answer_text=item.answer_text,
            truncation=True,
            padding="max_length",
            return_tensors="pt",
        )
        # remove the batch dimension which the tokenizer adds by default
        encoding = {key: val.squeeze(0) for key, val in encoding.items()}
        # add the float_answer which is also required (weak supervision for aggregation case)
        encoding["float_answer"] = torch.tensor(item.float_answer)
        return encoding

    def __len__(self):
        return len(self.data)


data = pd.read_csv(tsv_path, sep="\t")
train_dataset = TableDataset(data, tokenizer)
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=32)

Обратите внимание, что здесь каждая пара «таблица-вопрос» кодируется независимо. Это допустимо, пока ваш датасет не является диалоговым. Если же ваш датасет содержит диалоговые вопросы (например, в SQA), сначала сгруппируйте queries, answer_coordinates и answer_text по каждой таблице (в порядке их индекса position) и кодируйте каждую таблицу вместе с её вопросами пакетом. Это гарантирует, что типы токенов prev_labels (см. документацию TapasTokenizer) будут установлены корректно. Подробнее — в этом ноутбуке.

**ШАГ 4: Обучение (дообучение) модели

Затем можно выполнить дообучение TapasForQuestionAnswering следующим образом (здесь показан пример для слабого надзора в случае агрегации):

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 для инференса (то есть для получения предсказаний на новых данных). Для инференса модели необходимо передать только input_ids, attention_mask и token_type_ids (их можно получить с помощью TapasTokenizer), чтобы получить логиты. Далее вы можете использовать удобный метод ~models.tapas.tokenization_tapas.convert_logits_to_predictions, чтобы преобразовать их в предсказанные координаты и необязательные индексы агрегации.

Однако обратите внимание, что процесс вывода отличается в зависимости от того, является ли сценарий диалоговым. В недialogовом сценарии вывод можно выполнять параллельно для всех пар «таблица–вопрос» в батче. Пример:

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 предыдущей пары «таблица — вопрос». Подробнее можно узнать в этом ноутбуке.

Ресурсы

Специфические выходные данные TAPAS

class transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput

< source >

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

Параметры

loss (torch.Tensor формы (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.

TapasConfig

класс transformers.TapasConfig

< source >

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

Параметры

vocab_size (int, необязательный, по умолчанию 30522) — Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в input_ids.
hidden_size (int, необязательный, по умолчанию 768) — Размерность скрытых представлений.
num_hidden_layers (int, необязательный, по умолчанию 12) — Количество скрытых слоев в декодере Transformer.
num_attention_heads (int, необязательный, по умолчанию 12) — Количество головок внимания в каждом слое внимания декодера Transformer.
intermediate_size (int, необязательный, по умолчанию 3072) — Размерность представлений MLP.
hidden_act (str, необязательный, по умолчанию gelu) — Нелинейная функция активации (функция или строка) в декодере. Например, "gelu", "relu", "silu" и т. д.
hidden_dropout_prob (Union[float, int], необязательный, по умолчанию 0.1) — Вероятность dropout для всех полносвязных слоёв в блоках эмбеддингов, энкодера и пулера.
attention_probs_dropout_prob (Union[float, int], необязательный, по умолчанию 0.1) — Коэффициент dropout для вероятностей внимания.
max_position_embeddings (int, необязательный, по умолчанию 1024) — Максимальная длина последовательности, с которой может использоваться эта модель.
type_vocab_sizes (list[int], необязательный, по умолчанию [3, 256, 256, 2, 256, 256, 10]) — Размеры словарей для token_type_ids, передаваемых при вызове TapasModel.
initializer_range (float, необязательный, по умолчанию 0.02) — Стандартное отклонение truncated_normal_initializer, используемое для инициализации всех матриц весов.
layer_norm_eps (float, необязательный, по умолчанию 1e-12) — Значение epsilon, используемое слоями нормализации.
pad_token_id (int, необязательный, по умолчанию 0) — Идентификатор токена, используемого для дополнения (padding) в словаре.
bos_token_id (int, необязательный) — Идентификатор токена, используемого для обозначения начала потока в словаре.
eos_token_id (Union[int, list[int]], необязательный) — Идентификатор токена, используемого для обозначения конца потока в словаре.
positive_label_weight (float, необязательный, по умолчанию 10.0) — Вес для положительных меток.
num_aggregation_labels (int, необязательный, по умолчанию 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, необязательный) — Параметр Delta, используемый для вычисления функции потерь регрессии.
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, необязательный) — Предпочтение при выборе ячейки в неоднозначных случаях. Применимо только в случае слабого надзора для агрегации (WTQ, WikiSQL). Если общая масса вероятностей агрегации (за исключением оператора “NONE”) превышает значение этого гиперпараметра, для примера предсказывается агрегация.
answer_loss_cutoff (float, необязательный) — Игнорировать примеры, у которых loss ответа превышает 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, необязательный) — Если метки агрегации определены и одна из них обозначает «Нет агрегации», здесь следует указать её индекс. Например, у моделей 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

Объекты конфигурации наследуются от PreTrainedConfig и могут использоваться для управления выводами модели. Подробнее читайте в документации PreTrainedConfig.

Пример:

>>> from transformers import TapasModel, TapasConfig

>>> # Initializing a default (SQA) Tapas configuration
>>> configuration = TapasConfig()
>>> # Initializing a model from the configuration
>>> model = TapasModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

TapasTokenizer

класс transformers.TapasTokenizer

< source >

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

Параметры

vocab_file (str) — Файл, содержащий словарь.
do_lower_case (bool, необязательный, по умолчанию True) — Определяет, нужно ли приводить входные данные к нижнему регистру при токенизации.
do_basic_tokenize (bool, необязательный, по умолчанию True) — Выполнять ли базовую токенизацию перед WordPiece.
never_split (Iterable, необязательный) — Список токенов, которые никогда не будут разбиваться при токенизации. Параметр действует только при do_basic_tokenize=True
unk_token (str, необязательный, по умолчанию "[UNK]") — Токен неизвестного слова. Токен, отсутствующий в словаре, не может быть преобразован в ID, поэтому вместо него используется этот токен.
sep_token (str, необязательный, по умолчанию "[SEP]") — Токен-разделитель, который используется при построении последовательности из нескольких последовательностей, например, двух последовательностей для классификации последовательностей или текста и вопроса для ответа на вопросы. Он также используется в качестве последнего токена в последовательности, построенной со специальными токенами.
pad_token (str, необязательный, по умолчанию "[PAD]") — Токен, используемый для выравнивания, например, при пакетной обработке последовательностей разной длины.
cls_token (str, необязательный, по умолчанию "[CLS]") — Токен классификатора, используемый при классификации последовательности (классификация всей последовательности, а не посимвольная классификация). Это первый токен последовательности, если она построена со специальными токенами.
mask_token (str, необязательный, по умолчанию "[MASK]") — Токен, используемый для маскирования значений. Это тот токен, который применяется при обучении модели с использованием masked language modeling. Именно этот токен модель будет пытаться предсказать.
empty_token (str, необязательный, по умолчанию "[EMPTY]") — Токен, используемый для пустых значений ячеек в таблице. К пустым значениям относятся "", «n/a», «nan» и «?».
tokenize_chinese_chars (bool, необязательный, по умолчанию True) — Определяет, следует ли токенизировать китайские иероглифы. Для японского языка эту опцию, вероятно, следует отключить (см. эту проблему).
strip_accents (bool, необязательный) — Удалять ли все диакритические знаки. Если этот параметр не указан, его значение определяется по значению параметра lowercase (как в оригинальном BERT).
cell_trim_length (int, необязательный, по умолчанию -1) — Если > 0: обрезать ячейки так, чтобы их длина была <= этому значению. Также отключает дальнейшую обрезку ячеек, поэтому следует использовать с параметром truncation, установленным в True.
max_column_id (int, необязательный) — Максимальный идентификатор столбца для извлечения.
max_row_id (int, необязательный) — Максимальный идентификатор строки для извлечения.
strip_column_names (bool, необязательный, по умолчанию False) — Указывает, следует ли добавлять пустые строки вместо имён столбцов.
update_answer_coordinates (bool, необязательный, по умолчанию False) — Определяет, следует ли пересчитывать координаты ответа на основе текста ответа.
min_question_length (int, необязательный) — Минимальная длина каждого вопроса в токенах (иначе он будет пропущен).
max_question_length (int, необязательный) — Максимальная длина каждого вопроса в токенах (иначе будет пропущен).
clean_up_tokenization_spaces (bool, необязательный, по умолчанию True) — Указывает, следует ли очищать пробелы после декодирования. Очистка заключается в удалении возможных артефактов, например, лишних пробелов.

Создаёт токенизатор TAPAS. Основан на WordPiece. Разворачивает таблицу и одно или несколько связанных предложений для использования в моделях TAPAS.

Этот токенизатор наследуется от PreTrainedTokenizer, который содержит большинство основных методов. За дополнительной информацией об этих методах пользователям следует обращаться к этому суперклассу. TapasTokenizer создаёт несколько идентификаторов типов токенов для кодирования табличной структуры. Более точно, он добавляет 7 идентификаторов типов токенов в следующем порядке: segment_ids, column_ids, row_ids, prev_labels, column_ranks, inv_column_ranks и numeric_relations:

segment_ids: указывает, к какому фрагменту относится токен — к вопросу (0) или к таблице (1). Для специальных токенов и заполнителей (padding) значение равно 0.
column_ids: указывает, к какому столбцу таблицы относится токен (нумерация начинается с 1). Для всех токенов вопроса, специальных токенов и заполнителей значение равно 0.
row_ids: указывает, к какой строке таблицы относится токен (нумерация начинается с 1). Для всех токенов вопроса, специальных токенов и заполнителей значение равно 0. Для токенов заголовков столбцов также равно 0.
prev_labels: указывает, являлся ли токен (частью) ответа на предыдущий вопрос (1) или нет (0). Полезно в диалоговых сценариях (например, SQA).
column_ranks: указывает ранг токена таблицы относительно столбца, если применимо. Например, если у вас есть столбец «number of movies» со значениями 87, 53 и 69, то ранги столбца для этих токенов равны 3, 1 и 2 соответственно. Для всех токенов вопроса, специальных токенов и заполнителей значение равно 0.
inv_column_ranks: указывает обратный ранг токена таблицы относительно столбца, если применимо. Например, если у вас есть столбец «количество фильмов» со значениями 87, 53 и 69, то обратные ранги столбца для этих токенов равны 1, 3 и 2 соответственно. Для всех токенов вопроса, специальных токенов и заполнителей значение равно 0.
numeric_relations: указывает числовые отношения между вопросом и токенами таблицы. 0 для всех токенов вопроса, специальных токенов и заполнителей.

TapasTokenizer выполняет сквозную токенизацию таблицы и связанных с ней предложений: разбиение по знакам препинания и wordpiece.

call

< source >

Параметры

table (pd.DataFrame или str или list[str]) — Таблица, содержащая табличные данные. Обратите внимание, что все значения ячеек должны быть текстом. Используйте .astype(str) для Pandas-датафрейма, чтобы преобразовать его в строки. При передаче строки или списка строк они будут интерпретированы как запросы с пустой таблицей (для поддержки общих тестов токенизатора).
queries (str или list[str]) — Вопрос или пакет вопросов, связанных с таблицей, для кодирования. Обратите внимание, что в случае пакета все вопросы должны относиться к одной и той же таблице.
answer_coordinates (list[Tuple] or list[list[Tuple]], необязательный) — Координаты ответа для каждой пары «таблица-вопрос» в батче. Если предоставлена только одна пара «таблица-вопрос», то answer_coordinates должен представлять собой один список из одного или нескольких кортежей. Каждый кортеж должен быть парой (row_index, column_index). У первой строки данных (не строки заголовка столбцов) индекс 0. У первого столбца индекс 0. Если предоставлен батч пар «таблица-вопрос», то answer_coordinates должен быть списком списков кортежей (каждый список соответствует одной паре «таблица-вопрос»).
answer_text (list[str] или list[list[str]], необязательный) — Текст ответа для каждой пары «таблица-вопрос» в батче. Если предоставлена только одна пара «таблица-вопрос», то answer_text должен быть единственным списком из одной или нескольких строк. Каждая строка должна содержать текст ответа, соответствующий координате ответа. Если предоставлен батч пар «таблица-вопрос», то answer_coordinates должен быть списком списков строк (каждый список соответствует одной паре «таблица-вопрос»).
add_special_tokens (bool, необязательный, по умолчанию True) — Указывает, следует ли кодировать последовательности с использованием специальных токенов, соответствующих их модели.
padding (bool, str или PaddingStrategy, необязательный, по умолчанию False) — Включает и управляет выравниванием. Принимает следующие значения:
- True или 'longest': дополнить до самой длинной последовательности в батче (или не дополнять, если предоставлена только одна последовательность).
- 'max_length': Дополнить до максимальной длины, указанной аргументом max_length, или до максимально допустимой длины входных данных для модели, если этот аргумент не указан.
- False или 'do_not_pad' (по умолчанию): без дополнения нулями (т. е. может выводить батч с последовательностями разной длины).
truncation (bool, str или TapasTruncationStrategy, необязательный, по умолчанию False) — Включает и управляет усечением. Принимает следующие значения:
- True или 'drop_rows_to_fit': обрезать до максимальной длины, указанной аргументом max_length, или до максимально допустимой длины входа для модели, если этот аргумент не указан. Это приведёт к построчному обрезанию с удалением строк из таблицы.
- False или 'do_not_truncate' (по умолчанию): без усечения (т.е. может выдать батч с длиной последовательности, превышающей максимальный допустимый размер входа модели).
max_length (int, необязательный) — Управляет максимальной длиной, используемой одним из параметров усечения/дополнения.
Если параметр не задан или установлен в None, будет использована предопределённая максимальная длина модели, если одна из параметров усечения/дополнения требует указания максимальной длины. Если у модели нет конкретной максимальной длины входных данных (как у XLNet), усечение/дополнение до максимальной длины будет отключено.
is_split_into_words (bool, необязательный, по умолчанию False) — Указывает, является ли вход уже предтокенизированным (например, разбитым на слова). Если установлено в True, токенизатор предполагает, что вход уже разбит на слова (например, по пробелам), и токенизирует их. Это полезно для NER или классификации токенов.
pad_to_multiple_of (int, необязательный) — Если задано, последовательность будет дополнена до кратного указанного значения. Это особенно полезно для использования Tensor Cores на оборудовании NVIDIA с вычислительной способностью >= 7.5 (Volta).
return_tensors (str или TensorType, необязательный) — Если задано, возвращает тензоры вместо списка целых чисел Python. Допустимые значения:
- 'pt': возвращает объекты torch.Tensor PyTorch.
- 'np': возвращает объекты Numpy np.ndarray.

Основной метод для токенизации и подготовки одной или нескольких последовательностей, связанных с таблицей, для модели.

convert_logits_to_predictions

< source >

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

Параметры

data (dict) — Словарь, сопоставляющий признаки с фактическими значениями. Должен создаваться с помощью TapasTokenizer.
logits (torch.Tensor формы (batch_size, sequence_length)) — Тензор, содержащий логиты на уровне токенов.
logits_agg (torch.Tensor формы (batch_size, num_aggregation_labels), необязательный) — Тензор, содержащий логиты агрегации.
cell_classification_threshold (float, необязательный, по умолчанию 0.5) — Порог, используемый для выбора ячеек. Будут выбраны все ячейки таблицы, вероятность для которых превышает этот порог.

Возвращает

tuple, содержащий различные элементы в зависимости от входных данных

predicted_answer_coordinates (list[list[[tuple]] длины batch_size): Предсказанные координаты ответа в виде списка списков кортежей. Каждый элемент списка содержит предсказанные координаты ответа для одного примера в батче, в виде списка кортежей. Каждый кортеж представляет собой ячейку, то есть (индекс строки, индекс столбца).
predicted_aggregation_indices (list[int]длиной batch_size, необязательный, возвращается, если logits_aggregation задан): Предсказанные индексы операторов агрегации для агрегирующей головы.

Преобразует логиты TapasForQuestionAnswering в фактические координаты предсказанного ответа и необязательные индексы агрегирования.

Первоначальная реализация, на которой основана эта функция, доступна здесь.

save_vocabulary

< source >

( save_directory: strfilename_prefix: str | None = None )

TapasModel

класс transformers.TapasModel

< source >

( config: TapasConfigadd_pooling_layer = True )

Параметры

config (TapasConfig) — Класс конфигурации модели, содержащий все параметры модели. Инициализация с помощью файла конфигурации не загружает веса, связанные с моделью, а только конфигурацию. Чтобы загрузить веса модели, используйте метод from_pretrained().
add_pooling_layer (bool, необязательный, по умолчанию True) — Добавлять ли слой пулинга

Модель Tapas без дополнительных слоёв, выводящая необработанные скрытые состояния.

Эта модель наследуется от PreTrainedModel. См. документацию родительского класса для общих методов, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка голов и т. д.)

Эта модель также является подклассом torch.nn.Module в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

forward

< source >

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

Параметры

input_ids (torch.LongTensor формы (batch_size, sequence_length), , необязательный) — Индексы токенов входной последовательности в словаре. По умолчанию токены отсечки (padding) игнорируются.
Индексы можно получить с помощью AutoTokenizer. Подробности см. в PreTrainedTokenizer.encode() и PreTrainedTokenizer.call().

Что такое входные идентификаторы?
attention_mask (torch.Tensor формы (batch_size, sequence_length), , необязательный) — Маска для исключения токенов-заполнителей из внимания. Значения маски из диапазона [0, 1]:
- 1 для токенов, которые не замаскированы,
- 0 для токенов, которые замаскированы.
Что такое маски внимания?
token_type_ids (torch.LongTensor формы (batch_size, sequence_length, 7), необязательный) — Индексы токенов, кодирующие табличную структуру. Индексы можно получить с помощью AutoTokenizer. См. этот класс для получения дополнительной информации.
Что такое идентификаторы типов токенов?
position_ids (torch.LongTensor формы (batch_size, sequence_length), необязательный) — Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Если reset_position_index_per_cell параметр TapasConfig установлен в значение True, относительные позиционные эмбеддинги будут использоваться. Значения выбираются из диапазона [0, config.max_position_embeddings - 1].
Что такое идентификаторы позиций?
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 вместо обычного кортежа.

Возвращает

BaseModelOutputWithPooling или tuple(torch.Tensor)

Объект BaseModelOutputWithPooling или кортеж из torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные элементы в зависимости от конфигурации (TapasConfig) и входных данных.

Метод forward модели 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), optional, возвращается, если передано 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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Примеры:

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

< source >

( config: TapasConfig )

Параметры

config (TapasConfig) — Класс конфигурации модели, содержащий все параметры модели. Инициализация с помощью файла конфигурации не загружает веса, связанные с моделью, а только конфигурацию. Чтобы загрузить веса модели, используйте метод from_pretrained().

Модель Tapas с головой language modeling наверху.”

forward

< source >

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

Параметры

input_ids (torch.LongTensor формы (batch_size, sequence_length), , необязательный) — Индексы токенов входной последовательности в словаре. По умолчанию токены отсечки (padding) игнорируются.
Индексы можно получить с помощью AutoTokenizer. Подробности см. в PreTrainedTokenizer.encode() и PreTrainedTokenizer.call().

Что такое входные идентификаторы?
attention_mask (torch.Tensor формы (batch_size, sequence_length), , необязательный) — Маска для исключения токенов-заполнителей из внимания. Значения маски из диапазона [0, 1]:
- 1 для токенов, которые не замаскированы,
- 0 для токенов, которые замаскированы.
Что такое маски внимания?
token_type_ids (torch.LongTensor формы (batch_size, sequence_length, 7), необязательный) — Индексы токенов, кодирующие табличную структуру. Индексы можно получить с помощью AutoTokenizer. См. этот класс для получения дополнительной информации.
Что такое идентификаторы типов токенов?
position_ids (torch.LongTensor формы (batch_size, sequence_length), необязательный) — Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Если reset_position_index_per_cell параметр TapasConfig установлен в значение True, относительные позиционные эмбеддинги будут использоваться. Значения выбираются из диапазона [0, config.max_position_embeddings - 1].
Что такое идентификаторы позиций?
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 вместо обычного кортежа.

Возвращает

MaskedLMOutput или tuple(torch.Tensor)

Объект MaskedLMOutput или кортеж torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные элементы в зависимости от конфигурации (TapasConfig) и входных данных.

Метод forward класса 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), optional, возвращается, если передано 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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Примеры:

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

< source >

( config: TapasConfig )

Параметры

config (TapasConfig) — Класс конфигурации модели, содержащий все параметры модели. Инициализация с помощью файла конфигурации не загружает веса, связанные с моделью, а только конфигурацию. Чтобы загрузить веса модели, используйте метод from_pretrained().

Модель Tapas с головой последовательной классификации сверху (линейный слой поверх пуллинг-выхода), например, для задач импликации в таблицах, таких как TabFact (Chen et al., 2020).

forward

< source >

Параметры

input_ids (torch.LongTensor формы (batch_size, sequence_length), , необязательный) — Индексы токенов входной последовательности в словаре. По умолчанию токены отсечки (padding) игнорируются.
Индексы можно получить с помощью AutoTokenizer. Подробности см. в PreTrainedTokenizer.encode() и PreTrainedTokenizer.call().

Что такое входные идентификаторы?
attention_mask (torch.Tensor формы (batch_size, sequence_length), , необязательный) — Маска для исключения токенов-заполнителей из внимания. Значения маски из диапазона [0, 1]:
- 1 для токенов, которые не замаскированы,
- 0 для токенов, которые замаскированы.
Что такое маски внимания?
token_type_ids (torch.LongTensor формы (batch_size, sequence_length, 7), необязательный) — Индексы токенов, кодирующие табличную структуру. Индексы можно получить с помощью AutoTokenizer. См. этот класс для получения дополнительной информации.
Что такое идентификаторы типов токенов?
position_ids (torch.LongTensor формы (batch_size, sequence_length), необязательный) — Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Если reset_position_index_per_cell параметр TapasConfig установлен в значение True, относительные позиционные эмбеддинги будут использоваться. Значения выбираются из диапазона [0, config.max_position_embeddings - 1].
Что такое идентификаторы позиций?
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 вместо обычного кортежа.

Возвращает

SequenceClassifierOutput или tuple(torch.Tensor)

Объект SequenceClassifierOutput или кортеж из torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные элементы в зависимости от конфигурации (TapasConfig) и входных данных.

Метод forward класса 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), optional, возвращается, если передано 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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Примеры:

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

< source >

( config: TapasConfig )

Параметры

config (TapasConfig) — Класс конфигурации модели, содержащий все параметры модели. Инициализация с помощью файла конфигурации не загружает веса, связанные с моделью, а только конфигурацию. Чтобы загрузить веса модели, используйте метод from_pretrained().

Модель Tapas с головой выбора ячеек и необязательной головой агрегации поверх для задач вопросно-ответных на таблицах (линейные слои поверх выходных скрытых состояний для вычисления logits и необязательных logits_aggregation), например, для задач SQA, WTQ или WikiSQL с учителем.

forward

< source >

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

Параметры

input_ids (torch.LongTensor формы (batch_size, sequence_length), , необязательный) — Индексы токенов входной последовательности в словаре. По умолчанию токены отсечки (padding) игнорируются.
Индексы можно получить с помощью AutoTokenizer. Подробности см. в PreTrainedTokenizer.encode() и PreTrainedTokenizer.call().

Что такое входные идентификаторы?
attention_mask (torch.Tensor формы (batch_size, sequence_length), , необязательный) — Маска для исключения токенов-заполнителей из внимания. Значения маски из диапазона [0, 1]:
- 1 для токенов, которые не замаскированы,
- 0 для токенов, которые замаскированы.
Что такое маски внимания?
token_type_ids (torch.LongTensor формы (batch_size, sequence_length, 7), необязательный) — Индексы токенов, кодирующие табличную структуру. Индексы можно получить с помощью AutoTokenizer. См. этот класс для получения дополнительной информации.
Что такое идентификаторы типов токенов?
position_ids (torch.LongTensor формы (batch_size, sequence_length), необязательный) — Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Если reset_position_index_per_cell параметр TapasConfig установлен в значение True, относительные позиционные эмбеддинги будут использоваться. Значения выбираются из диапазона [0, config.max_position_embeddings - 1].
Что такое идентификаторы позиций?
inputs_embeds (torch.Tensor формы (batch_size, sequence_length, hidden_size), необязательный) — При необходимости, вместо передачи input_ids можно напрямую передать встроенное представление. Это полезно, если требуется больший контроль над тем, как индексы input_ids преобразуются в соответствующие векторы, чем это обеспечивает внутренняя матрица поиска встраиваний модели.
table_mask (torch.LongTensor формы (batch_size, seq_length), необязательный) — Маска для таблицы. Указывает, какие токены принадлежат таблице (1). Токены вопроса, заголовки таблицы и padding равны 0.
labels (torch.LongTensor формы (batch_size, seq_length), , необязательный) — Метки для каждого токена для вычисления иерархической функции потерь выбора ячеек. Это кодирует позиции ответа, присутствующего в таблице. Можно получить с помощью 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. Требуется только в случае слабого надзора для агрегации (WTQ) для вычисления потерь регрессии.
numeric_values_scale (torch.Tensor формы (batch_size, seq_length), необязательный) — Масштаб числовых значений каждого токена. Может быть получен с помощью AutoTokenizer. Требуется только в случае слабого надзора для агрегации (WTQ) для вычисления функции потерь регрессии.
output_attentions (bool, необязательный) — Указывает, следует ли возвращать тензоры внимания всех слоев внимания. Подробности см. в описании attentions в разделе возвращаемых тензоров.
output_hidden_states (bool, необязательный) — Указывает, следует ли возвращать скрытые состояния всех слоев. Подробности см. в описании hidden_states среди возвращаемых тензоров.
return_dict (bool, необязательный) — Указывает, следует ли возвращать ModelOutput вместо обычного кортежа.

Возвращает

TableQuestionAnsweringOutput или tuple(torch.Tensor)

Объект TableQuestionAnsweringOutput или кортеж torch.Tensor (если передано return_dict=False или если config.return_dict=False), содержащий различные элементы в зависимости от конфигурации (TapasConfig) и входных данных.

Метод forward класса 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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Примеры:

>>> from transformers import AutoTokenizer, TapasForQuestionAnswering
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-wtq")
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base-finetuned-wtq")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> logits_aggregation = outputs.logits_aggregation

Update on GitHub

←Модели кодировщика-декодировщика для речевых данных TIPSv2→