Transformers documentation

TAPAS

Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Este modelo foi publicado no HF papers em 2020-04-05 e contribuído para o Hugging Face Transformers em 2020-12-15.

TAPAS

Visão geral

O modelo TAPAS foi proposto em TAPAS: Weakly Supervised Table Parsing via Pre-training por Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno e Julian Martin Eisenschlos. Trata-se de um modelo baseado em BERT, projetado (e pré-treinado) especificamente para responder perguntas sobre dados tabulares. Em comparação com o BERT, o TAPAS usa embeddings de posição relativa e possui 7 tipos de tokens que codificam a estrutura tabular. O TAPAS é pré-treinado no objetivo de modelagem de linguagem mascarada (MLM) em um grande conjunto de dados composto por milhões de tabelas da Wikipédia em inglês e os textos correspondentes.

Para a tarefa de resposta a perguntas, o TAPAS possui 2 cabeças no topo: uma cabeça de seleção de células e uma cabeça de agregação, para (opcionalmente) realizar agregações (como contagem ou soma) entre as células selecionadas. O TAPAS foi ajustado em vários conjuntos de dados:

SQA (Sequential Question Answering da Microsoft)
WTQ (Wiki Table Questions, da Universidade de Stanford)
WikiSQL (da Salesforce).

Ele atinge o estado da arte tanto no SQA quanto no WTQ, apresentando desempenho comparável ao SOTA no WikiSQL, com uma arquitetura muito mais simples.

O resumo do artigo é o seguinte:

Responder a perguntas em linguagem natural sobre tabelas é geralmente visto como uma tarefa de análise semântica. Para reduzir o custo de coleta de formas lógicas completas, uma abordagem popular foca em supervisão fraca consistindo em denotações em vez de formas lógicas. No entanto, treinar analisadores semânticos a partir de supervisão fraca apresenta dificuldades, e, além disso, as formas lógicas geradas são usadas apenas como uma etapa intermediária antes de recuperar a denotação. Neste artigo, apresentamos o TAPAS, uma abordagem para responder perguntas sobre tabelas sem gerar formas lógicas. O TAPAS é treinado a partir de supervisão fraca e prevê a denotação selecionando células da tabela e, opcionalmente, aplicando um operador de agregação correspondente a essa seleção. O TAPAS estende a arquitetura do BERT para codificar tabelas como entrada, é inicializado a partir de um pré-treinamento conjunto eficaz de segmentos de texto e tabelas coletadas da Wikipédia e é treinado de ponta a ponta. Experimentamos com três conjuntos de dados diferentes de análise semântica e constatamos que o TAPAS supera ou rivaliza com modelos de análise semântica, melhorando a precisão do estado da arte no SQA de 55,1 para 67,2 e obtendo desempenho equivalente ao estado da arte no WIKISQL e no WIKITQ, mas com uma arquitetura de modelo mais simples. Além disso, constatamos que o aprendizado por transferência, que é trivial em nosso cenário, do WIKISQL para o WIKITQ, resulta em uma precisão de 48,7, 4,2 pontos acima do estado da arte.

Além disso, os autores pré-treinaram ainda mais o TAPAS para reconhecer table entailment, criando um conjunto de dados balanceado com milhões de exemplos de treinamento criados automaticamente, que são aprendidos em uma etapa intermediária antes do fine-tuning. Os autores do TAPAS chamam esse pré-treinamento adicional de pré-treinamento intermediário (uma vez que o TAPAS é primeiro pré-treinado em MLM e, em seguida, em outro conjunto de dados). Eles descobriram que o pré-treinamento intermediário melhora ainda mais o desempenho no SQA, alcançando um novo state-of-the-art, bem como state-of-the-art no TabFact, um conjunto de dados em larga escala com 16k tabelas da Wikipedia para table entailment (uma tarefa de classificação binária). Para mais detalhes, veja seu artigo de acompanhamento: Understanding tables with intermediate pre-training, de Julian Martin Eisenschlos, Syrine Krichene e Thomas Müller.

TAPAS architecture. Taken from the original blog post.

Este modelo foi contribuído por nielsr. O código original pode ser encontrado aqui.

Dicas de uso

O TAPAS é um modelo que usa embeddings de posição relativa por padrão (reiniciando os embeddings de posição em cada célula da tabela). Observe que isso foi adicionado após a publicação do artigo original do TAPAS. Segundo os autores, isso geralmente resulta em um desempenho ligeiramente melhor e permite codificar sequências mais longas sem esgotar os embeddings. Isso é refletido no parâmetro reset_position_index_per_cell de TapasConfig, que é definido como True por padrão. As versões padrão dos modelos disponíveis no hub usam embeddings de posição relativa. Você ainda pode usar os que possuem embeddings de posição absoluta passando um argumento adicional revision="no_reset" ao chamar o método from_pretrained(). Observe que geralmente é recomendado fazer o padding das entradas à direita, em vez de à esquerda.
O TAPAS é baseado no BERT, portanto, por exemplo, o TAPAS-base corresponde a uma arquitetura BERT-base. Claro, o TAPAS-large resultará no melhor desempenho (os resultados relatados no artigo são do TAPAS-large). Os resultados dos modelos de vários tamanhos estão mostrados no repositório original do GitHub.
O TAPAS possui checkpoints ajustados no SQA, capazes de responder a perguntas relacionadas a uma tabela em um contexto conversacional. Isso significa que você pode fazer perguntas de acompanhamento, como “qual é a idade dele?”, relacionadas à pergunta anterior. Observe que a passagem direta do TAPAS é um pouco diferente no caso de um contexto conversacional: nesse caso, você deve alimentar cada par tabela-pergunta um por um para o modelo, de modo que os ids de tipo de token prev_labels possam ser sobrescritos pelos labels previstos pelo modelo para a pergunta anterior. Consulte a seção “Uso” para mais informações.
O TAPAS é semelhante ao BERT e, portanto, depende do objetivo de modelagem de linguagem mascarada (MLM). Assim, ele é eficiente na previsão de tokens mascarados e em NLU em geral, mas não é ideal para geração de texto. Modelos treinados com um objetivo de modelagem de linguagem causal (CLM) são melhores nesse aspecto. Observe que o TAPAS pode ser usado como um codificador no framework EncoderDecoderModel, para combiná-lo com um decodificador de texto autoregressivo, como o GPT-2.

Uso: ajuste fino

Aqui explicamos como você pode fazer o ajuste fino de TapasForQuestionAnswering no seu próprio conjunto de dados.

ETAPA 1: Escolha uma das 3 formas de usar o TAPAS - ou experimente

Basicamente, existem 3 maneiras diferentes de fazer o fine-tuning de TapasForQuestionAnswering, correspondentes aos diferentes conjuntos de dados nos quais o Tapas foi ajustado:

SQA: se você estiver interessado em fazer perguntas de acompanhamento relacionadas a uma tabela, em um contexto conversacional. Por exemplo, se você primeiro perguntar "qual é o nome do primeiro ator?", em seguida, pode fazer uma pergunta de acompanhamento como "quantos anos ele tem?". Aqui, as perguntas não envolvem nenhuma agregação (todas as perguntas são de seleção de células).
WTQ: caso você não tenha interesse em fazer perguntas em um contexto conversacional, mas sim em fazer perguntas relacionadas a uma tabela, que podem envolver agregação, como contar o número de linhas, somar valores de células ou calcular a média dos valores das células. Nesse caso, por exemplo, você pode perguntar “qual é o total de gols que Cristiano Ronaldo marcou em sua carreira?”. Esse caso também é chamado de supervisão fraca, pois o próprio modelo deve aprender o operador de agregação adequado (SUM/COUNT/AVERAGE/NONE) tendo apenas a resposta à pergunta como supervisão.
WikiSQL-supervised: este conjunto de dados é baseado no WikiSQL, com o modelo recebendo o operador de agregação correto durante o treinamento. Isso também é chamado de supervisão forte. Aqui, aprender o operador de agregação adequado é muito mais fácil.

Para resumir:

Tarefa	Conjunto de dados de exemplo	Descrição
Conversacional	SQA	Conversacional, apenas perguntas de seleção de célula
Supervisão fraca para agregação	WTQ	As perguntas podem envolver agregação, e o modelo deve aprender isso tendo apenas a resposta como supervisão
Supervisão forte para agregação	Supervisionado por WikiSQL	As perguntas podem envolver agregação, e o modelo deve aprender isso com base no operador de agregação de referência.

A inicialização de um modelo com uma base pré-treinada e cabeças de classificação inicializadas aleatoriamente a partir do hub pode ser feita conforme mostrado abaixo.

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

Claro, você não precisa necessariamente seguir uma dessas três maneiras pelas quais o TAPAS foi ajustado. Você também pode experimentar definindo quaisquer hiperparâmetros que desejar ao inicializar TapasConfig e, em seguida, criar um TapasForQuestionAnswering com base nessa configuração. Por exemplo, se você tiver um conjunto de dados que contém tanto perguntas conversacionais quanto perguntas que podem envolver agregação, você pode fazer da seguinte maneira. Aqui está um exemplo:

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

O que você também pode fazer é começar a partir de um checkpoint já ajustado. Uma observação aqui é que o checkpoint já ajustado no WTQ apresenta alguns problemas devido à perda L2, que é um pouco frágil. Veja aqui para mais informações.

Para uma lista de todos os checkpoints pré-treinados e ajustados do TAPAS disponíveis no hub do HuggingFace, veja aqui.

ETAPA 2: Prepare seus dados no formato SQA

Em segundo lugar, independentemente da opção escolhida acima, você deve preparar seu conjunto de dados no formato SQA. Esse formato é um arquivo TSV/CSV com as seguintes colunas:

id: opcional, id do par tabela-pergunta, para fins de controle.
annotator: opcional, id da pessoa que anotou o par tabela-pergunta, para fins de controle.
position: inteiro que indica se a pergunta é a primeira, a segunda, a terceira, relacionada à tabela. Obrigatório apenas em caso de configuração conversacional (SQA). Você não precisa desta coluna caso vá usar WTQ/WikiSQL-supervised.
question: string
table_file: string, nome de um arquivo csv contendo os dados tabulares
answer_coordinates: lista de uma ou mais tuplas (cada tupla sendo uma coordenada de célula, ou seja, um par de linha e coluna que faz parte da resposta)
answer_text: lista de uma ou mais strings (cada string sendo um valor de célula que faz parte da resposta)
aggregation_label: índice do operador de agregação. Obrigatório apenas no caso de supervisão forte para agregação (o caso supervisionado do WikiSQL)
float_answer: a resposta em ponto flutuante para a pergunta, caso exista (np.nan caso não exista). Obrigatório apenas em caso de supervisão fraca para agregação (como WTQ e WikiSQL)

As próprias tabelas devem estar presentes em uma pasta, com cada tabela sendo um arquivo csv separado. Observe que os autores do algoritmo TAPAS usaram scripts de conversão com alguma lógica automatizada para converter os outros conjuntos de dados (WTQ, WikiSQL) para o formato SQA. O autor explica isso aqui. Uma conversão desse script que funciona com a implementação do HuggingFace pode ser encontrada aqui. Curiosamente, esses scripts de conversão não são perfeitos (os campos answer_coordinates e float_answer são preenchidos com base no answer_text), o que significa que os resultados de WTQ e WikiSQL poderiam, na verdade, ser melhorados.

ETAPA 3: Converta seus dados em tensors usando TapasTokenizer

Em terceiro lugar, dado que você preparou seus dados nesse formato TSV/CSV (e os arquivos CSV correspondentes contendo os dados tabulares), você pode então usar TapasTokenizer para converter pares de tabela-pergunta em input_ids, attention_mask, token_type_ids e assim por diante. Novamente, com base em qual dos três casos você escolheu acima, TapasForQuestionAnswering requer entradas diferentes para ser ajustado:

Tarefa	Entradas obrigatórias
Conversacional	`input_ids`, `attention_mask`, `token_type_ids`, `labels`
Supervisão fraca para agregação	`input_ids`, `attention_mask`, `token_type_ids`, `labels`, `numeric_values`, `numeric_values_scale`, `float_answer`
Supervisão forte para agregação	`input ids`, `attention mask`, `token type ids`, `labels`, `aggregation_labels`

TapasTokenizer cria os labels, numeric_values e numeric_values_scale com base nas colunas answer_coordinates e answer_text do arquivo TSV. Os float_answer e aggregation_labels já estão no arquivo TSV da etapa 2. Aqui está um exemplo:

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

Observe que o TapasTokenizer espera que os dados da tabela sejam apenas texto. Você pode usar .astype(str) em um dataframe para convertê-lo em dados apenas de texto. Claro, isso apenas mostra como codificar um único exemplo de treinamento. É recomendável criar um dataloader para iterar sobre lotes:

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)

Observe que, aqui, cada par tabela-pergunta é codificado de forma independente. Isso é adequado desde que seu conjunto de dados não seja conversacional. Caso seu conjunto de dados envolva perguntas conversacionais (como no SQA), você deve primeiro agrupar queries, answer_coordinates e answer_text por tabela (na ordem do índice de position) e codificar em lote cada tabela com suas perguntas. Isso garantirá que os tipos de token prev_labels (veja a documentação de TapasTokenizer) sejam definidos corretamente. Consulte este notebook para mais informações.

**ETAPA 4: Treinar (ajustar finamente) o modelo

Em seguida, você pode fazer o ajuste fino de TapasForQuestionAnswering da seguinte forma (mostrado aqui para o caso de supervisão fraca para agregação):

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

Uso: inferência

Aqui explicamos como você pode usar TapasForQuestionAnswering para inferência (ou seja, fazer previsões em novos dados). Para a inferência, apenas input_ids, attention_mask e token_type_ids (que você pode obter usando TapasTokenizer) precisam ser fornecidos ao modelo para obter os logits. Em seguida, você pode usar o conveniente método ~models.tapas.tokenization_tapas.convert_logits_to_predictions para convertê-los em coordenadas previstas e índices de agregação opcionais.

No entanto, observe que a inferência é diferente dependendo de a configuração ser conversacional ou não. Em uma configuração não conversacional, a inferência pode ser executada em paralelo para todos os pares de tabela e pergunta de um lote. Aqui está um exemplo disso:

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

No caso de uma configuração conversacional, cada par tabela-pergunta deve ser fornecido sequencialmente ao modelo, de modo que os tipos de token prev_labels possam ser sobrescritos pelos labels previstos do par tabela-pergunta anterior. Novamente, mais informações podem ser encontradas em este notebook.

Recursos

Saídas específicas do TAPAS

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

Parâmetros

loss (torch.Tensor de forma (1,), opcional, retornado quando labels (e possivelmente answer, aggregation_labels, numeric_values e numeric_values_scale são fornecidos)) — Perda total como a soma da perda de log-verossimilhança da seleção hierárquica de células e (opcionalmente) da perda de regressão semi-supervisionada e (opcionalmente) da perda supervisionada para agregações.
logits (torch.Tensor de forma (batch_size, sequence_length)) — Pontuações de previsão da cabeça de seleção de células, para cada token.
logits_aggregation (torch.Tensor, opcional, de forma (batch_size, num_aggregation_labels)) — Pontuações de previsão da cabeça de agregação, para cada operador de agregação.
hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).
Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com a forma (batch_size, num_heads, sequence_length, sequence_length).
Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Tipo de saída de TapasForQuestionAnswering.

TapasConfig

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

Parâmetros

vocab_size (int, opcional, padrão 30522) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
hidden_size (int, opcional, padrão 768) — Dimensão das representações ocultas.
num_hidden_layers (int, opcional, padrão 12) — Número de camadas ocultas no decodificador do Transformer.
num_attention_heads (int, opcional, padrão 12) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
intermediate_size (int, opcional, padrão 3072) — Dimensão das representações do MLP.
hidden_act (str, opcional, padrão gelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
hidden_dropout_prob (Union[float, int], opcional, padrão 0.1) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no codificador e no pooler.
attention_probs_dropout_prob (Union[float, int], opcional, padrão 0.1) — A taxa de dropout para as probabilidades de atenção.
max_position_embeddings (int, opcional, padrão 1024) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
type_vocab_sizes (list[int], opcional, padrão [3, 256, 256, 2, 256, 256, 10]) — Os tamanhos do vocabulário dos token_type_ids passados ao chamar TapasModel.
initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
layer_norm_eps (float, opcional, padrão 1e-12) — O epsilon usado pelas camadas de normalização de camada.
pad_token_id (int, opcional, padrão 0) — ID do token usado para preenchimento no vocabulário.
bos_token_id (int, opcional) — ID do token usado para o início do fluxo no vocabulário.
eos_token_id (Union[int, list[int]], opcional) — ID do token usado para o fim do fluxo no vocabulário.
positive_label_weight (float, opcional, padrão 10.0) — Peso para rótulos positivos.
num_aggregation_labels (int, opcional, padrão 0) — O número de operadores de agregação a prever.
aggregation_loss_weight (float, opcional, padrão 1.0) — Peso de importância para a perda de agregação.
use_answer_as_supervision (bool, opcional) — Se deve usar a resposta como a única supervisão para exemplos de agregação.
answer_loss_importance (float, opcional, padrão 1.0) — Peso de importância para a perda de regressão.
use_normalized_answer_loss (bool, opcional, padrão False) — Se a perda da resposta deve ser normalizada pelo máximo entre o valor previsto e o valor esperado.
huber_loss_delta (float, opcional) — Parâmetro delta usado para calcular a perda de regressão.
temperature (float, opcional, padrão 1.0) — Valor usado para controlar (ou alterar) a assimetria das probabilidades dos logits das células.
aggregation_temperature (float, opcional, padrão 1.0) — Escala os logits de agregação para controlar a assimetria das probabilidades.
use_gumbel_for_cells (bool, opcional, padrão False) — Se deve aplicar Gumbel-Softmax à seleção de células.
use_gumbel_for_aggregation (bool, opcional, padrão False) — Se deve aplicar Gumbel-Softmax à seleção de agregação.
average_approximation_function (string, opcional, padrão "ratio") — Método para calcular a média esperada das células no caso de supervisão fraca. Um de "ratio", "first_order" ou "second_order".
cell_selection_preference (float, opcional) — Preferência para a seleção de células em casos ambíguos. Aplicável apenas no caso de supervisão fraca para agregação (WTQ, WikiSQL). Se a massa total das probabilidades de agregação (excluindo o operador “NONE”) for maior que este hiperparâmetro, a agregação será prevista para um exemplo.
answer_loss_cutoff (float, opcional) — Ignora exemplos com perda de resposta maior que o limite.
max_num_rows (int, opcional, padrão 64) — Número máximo de linhas.
max_num_columns (int, opcional, padrão 32) — Número máximo de colunas.
average_logits_per_cell (bool, opcional, padrão False) — Se deve calcular a média dos logits por célula.
select_one_column (bool, opcional, padrão True) — Se deve restringir o modelo a selecionar apenas células de uma única coluna.
allow_empty_column_selection (bool, opcional, padrão False) — Se permite não selecionar nenhuma coluna.
init_cell_selection_weights_to_zero (bool, opcional, padrão False) — Se as pesos de seleção de células devem ser inicializados com 0, de modo que as probabilidades iniciais sejam de 50%.
reset_position_index_per_cell (bool, opcional, padrão True) — Se reiniciar os índices de posição em cada célula (ou seja, usar embeddings de posição relativa).
disable_per_token_loss (bool, opcional, padrão False) — Se deve desabilitar qualquer supervisão (forte ou fraca) nas células.
aggregation_labels (dict[int, label], opcional) — Os rótulos de agregação usados para agregar os resultados. Por exemplo, os modelos WTQ possuem os seguintes rótulos de agregação: {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
no_aggregation_label_index (int, opcional) — Se os rótulos de agregação estiverem definidos e um desses rótulos representar “Sem agregação”, este valor deve ser configurado com o índice correspondente. Por exemplo, os modelos WTQ possuem o rótulo de agregação “NONE” no índice 0, portanto, esse valor deve ser definido como 0 para esses modelos.
is_decoder (bool, opcional, padrão False) — Indica se o modelo é usado como decodificador ou não. Se False, o modelo é usado como codificador.
add_cross_attention (bool, opcional, padrão False) — Se camadas de atenção cruzada devem ser adicionadas ao modelo.
tie_word_embeddings (bool, opcional, padrão True) — Se deve vincular as embeddings de pesos de acordo com o mapeamento tied_weights_keys do modelo.

Esta é a classe de configuração para armazenar a configuração de um TapasModel. Ela é usada para instanciar um modelo Tapas de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do google/tapas-base-finetuned-sqa

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

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

Parâmetros

vocab_file (str) — Arquivo contendo o vocabulário.
do_lower_case (bool, opcional, padrão True) — Se deve ou não converter a entrada para minúsculas ao tokenizar.
do_basic_tokenize (bool, opcional, padrão True) — Indica se a tokenização básica deve ser realizada antes do WordPiece.
never_split (Iterable, opcional) — Coleção de tokens que nunca serão divididos durante a tokenização. Tem efeito apenas quando do_basic_tokenize=True
unk_token (str, opcional, padrão "[UNK]") — O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.
sep_token (str, opcional, padrão "[SEP]") — O token separador, usado ao construir uma sequência a partir de múltiplas sequências, por exemplo, duas sequências para classificação de sequência ou um texto e uma pergunta para question answering. Também é usado como o último token de uma sequência construída com tokens especiais.
pad_token (str, opcional, padrão "[PAD]") — O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes.
cls_token (str, opcional, padrão "[CLS]") — O token de classificador usado na classificação de sequência (classificação da sequência inteira, em vez da classificação por token). É o primeiro token da sequência quando esta é construída com tokens especiais.
mask_token (str, opcional, padrão "[MASK]") — O token usado para mascarar valores. Este é o token utilizado ao treinar este modelo com modelagem de linguagem mascarada. É o token que o modelo tentará prever.
empty_token (str, opcional, padrão "[EMPTY]") — O token usado para valores de células vazias em uma tabela. Os valores de células vazias incluem "", “n/a”, “nan” e ”?“.
tokenize_chinese_chars (bool, opcional, padrão True) — Se os caracteres chineses devem ser tokenizados. Isso provavelmente deve ser desativado para o japonês (veja esta issue).
strip_accents (bool, opcional) — Indica se todos os acentos devem ser removidos. Se essa opção não for especificada, o valor será determinado pelo valor de lowercase (como no BERT original).
cell_trim_length (int, opcional, padrão -1) — Se > 0: Recorta as células para que o comprimento seja <= a este valor. Também desativa o recorte adicional de células, portanto, deve ser usado com truncation definido como True.
max_column_id (int, opcional) — ID máximo da coluna a ser extraído.
max_row_id (int, opcional) — ID máximo da linha a ser extraído.
strip_column_names (bool, opcional, padrão False) — Se deve adicionar strings vazias em vez dos nomes das colunas.
update_answer_coordinates (bool, opcional, padrão False) — Se as coordenadas da resposta devem ser recalculadas a partir do texto da resposta.
min_question_length (int, opcional) — Comprimento mínimo de cada pergunta em termos de tokens (caso contrário, será ignorada).
max_question_length (int, opcional) — Comprimento máximo de cada pergunta em termos de tokens (caso contrário, será ignorada).
clean_up_tokenization_spaces (bool, opcional, padrão True) — Indica se os espaços devem ser limpos após a decodificação. A limpeza consiste em remover possíveis artefatos, como espaços extras.

Constrói um tokenizador TAPAS. Baseado em WordPiece. Achata uma tabela e uma ou mais frases relacionadas para uso em modelos TAPAS.

Este tokenizer herda de PreTrainedTokenizer, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos. TapasTokenizer cria vários token type ids para codificar a estrutura tabular. Mais precisamente, ele adiciona 7 token type ids, na seguinte ordem: segment_ids, column_ids, row_ids, prev_labels, column_ranks, inv_column_ranks e numeric_relations:

segment_ids: indica se um token pertence à pergunta (0) ou à tabela (1). 0 para tokens especiais e padding.
column_ids: indica a qual coluna da tabela um token pertence (começando em 1). É 0 para todos os tokens de pergunta, tokens especiais e padding.
row_ids: indica a qual linha da tabela um token pertence (começando em 1). É 0 para todos os tokens de pergunta, tokens especiais e padding. Os tokens dos cabeçalhos de coluna também são 0.
prev_labels: indica se um token fazia parte (ou não) da resposta à pergunta anterior (1) ou não (0). Útil em um contexto conversacional (como o SQA).
column_ranks: indica a posição de um token da tabela em relação a uma coluna, quando aplicável. Por exemplo, se você tiver uma coluna "número de filmes" com os valores 87, 53 e 69, então as posições da coluna desses tokens são 3, 1 e 2, respectivamente. 0 para todos os tokens de pergunta, tokens especiais e padding.
inv_column_ranks: indica o rank inverso de um token de tabela em relação a uma coluna, quando aplicável. Por exemplo, se você tiver uma coluna “number of movies” com os valores 87, 53 e 69, então os ranks inversos de coluna desses tokens são 1, 3 e 2, respectivamente. 0 para todos os tokens de pergunta, tokens especiais e padding.
numeric_relations: indica relações numéricas entre a pergunta e os tokens da tabela. 0 para todos os tokens da pergunta, tokens especiais e padding.

TapasTokenizer executa a tokenização de ponta a ponta em uma tabela e nas frases associadas: divisão por pontuação e wordpiece.

call

< source >

Parâmetros

table (pd.DataFrame ou str ou list[str]) — Tabela contendo dados tabulares. Observe que todos os valores das células devem ser texto. Use .astype(str) em um dataframe do Pandas para convertê-lo em string. Ao passar uma string ou uma lista de strings, elas serão interpretadas como consultas com uma tabela vazia (para suportar testes genéricos de tokenizers).
queries (str ou list[str]) — Pergunta ou lote de perguntas relacionadas a uma tabela a ser codificada. Observe que, no caso de um lote, todas as perguntas devem se referir à mesma tabela.
answer_coordinates (list[Tuple] ou list[list[Tuple]], opcional) — Coordenadas da resposta de cada par tabela-pergunta no lote. Caso apenas um único par tabela-pergunta seja fornecido, o answer_coordinates deve ser uma única lista contendo uma ou mais tuplas. Cada tupla deve ser um par (row_index, column_index). A primeira linha de dados (não a linha de cabeçalho das colunas) tem índice 0. A primeira coluna tem índice 0. Caso um lote de pares tabela-pergunta seja fornecido, o answer_coordinates deve ser uma lista de listas de tuplas (cada lista correspondendo a um único par tabela-pergunta).
answer_text (list[str] ou list[list[str]], opcional) — Texto da resposta de cada par tabela-pergunta no lote. Caso apenas um único par tabela-pergunta seja fornecido, o answer_text deve ser uma única lista com uma ou mais strings. Cada string deve ser o texto da resposta de uma coordenada de resposta correspondente. Caso um lote de pares tabela-pergunta seja fornecido, então o answer_coordinates deve ser uma lista de listas de strings (cada lista correspondendo a um único par tabela-pergunta).
add_special_tokens (bool, opcional, padrão True) — Indica se as sequências devem ser codificadas com os tokens especiais relativos ao seu modelo.
padding (bool, str ou PaddingStrategy, opcional, padrão é False) — Ativa e controla o padding. Aceita os seguintes valores:
- True ou 'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).
- 'max_length': Preenche até o comprimento máximo especificado com o argumento max_length ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.
- False ou 'do_not_pad' (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
truncation (bool, str ou TapasTruncationStrategy, opcional, padrão é False) — Ativa e controla a truncagem. Aceita os seguintes valores:
- True ou 'drop_rows_to_fit': Trunca para um comprimento máximo especificado com o argumento max_length ou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. Isso trunca linha por linha, removendo linhas da tabela.
- False ou 'do_not_truncate' (padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
max_length (int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.
Se não for definido ou for definido como None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado.
is_split_into_words (bool, opcional, padrão False) — Indica se a entrada já está pré-tokenizada (por exemplo, dividida em palavras). Se definido como True, o tokenizer assume que a entrada já foi dividida em palavras (por exemplo, separando por espaços em branco) e a tokeniza. Isso é útil para NER ou classificação de tokens.
pad_to_multiple_of (int, opcional) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação >= 7.5 (Volta).
return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:
- 'pt': Retorna objetos torch.Tensor do PyTorch.
- 'np': Retorna objetos np.ndarray do Numpy.

Método principal para tokenizar e preparar para o modelo uma ou várias sequências relacionadas a uma tabela.

convert_logits_to_predictions

< source >

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

Parâmetros

data (dict) — Dicionário que mapeia recursos para valores reais. Deve ser criado usando TapasTokenizer.
logits (torch.Tensor de forma (batch_size, sequence_length)) — Tensor contendo os logits no nível de token.
logits_agg (torch.Tensor de forma (batch_size, num_aggregation_labels), opcional) — Tensor contendo os logits de agregação.
cell_classification_threshold (float, opcional, padrão 0.5) — Limiar a ser usado para a seleção de células. Todas as células da tabela cuja probabilidade for maior que este limiar serão selecionadas.

Retorna

tuple composta por vários elementos, dependendo das entradas

predicted_answer_coordinates (list[list[[tuple]] de comprimento batch_size): Coordenadas da resposta prevista como uma lista de listas de tuplas. Cada elemento da lista contém as coordenadas da resposta prevista de um único exemplo no lote, como uma lista de tuplas. Cada tupla é uma célula, ou seja, (índice da linha, índice da coluna).
predicted_aggregation_indices (list[int]de comprimento batch_size, opcional, retornado quando logits_aggregation é fornecido): Índices dos operadores de agregação previstos pela cabeça de agregação.

Converte os logits de TapasForQuestionAnswering em coordenadas de resposta previstas e índices de agregação opcionais.

A implementação original, na qual esta função se baseia, pode ser encontrada aqui.

save_vocabulary

< source >

( save_directory: strfilename_prefix: str | None = None )

TapasModel

classe transformers.TapasModel

< source >

( config: TapasConfigadd_pooling_layer = True )

Parâmetros

config (TapasConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
add_pooling_layer (bool, opcional, padrão True) — Se deve adicionar uma camada de pooling

O modelo Tapas puro, que produz estados ocultos brutos sem nenhum cabeçalho específico no topo.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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)

Parâmetros

input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.
Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

O que são IDs de entrada?
attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
O que são máscaras de atenção?
token_type_ids (torch.LongTensor de forma (batch_size, sequence_length, 7), opcional) — Índices de tokens que codificam a estrutura tabular. Os índices podem ser obtidos usando AutoTokenizer. Veja esta class para mais informações.
O que são IDs de tipo de token?
position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Se reset_position_index_per_cell de TapasConfig estiver definido como True, embeddings de posição relativos serão usados. Selecionados no intervalo [0, config.max_position_embeddings - 1].
O que são IDs de posição?
inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
encoder_hidden_states (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de hidden-states na saída da última camada do encoder. Usada na cross-attention se o modelo estiver configurado como um decoder.
encoder_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento da entrada do codificador. Essa máscara é usada na atenção cruzada se o modelo estiver configurado como um decodificador. Valores da máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
output_attentions (bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions nos tensores retornados para mais detalhes.
output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Um BaseModelOutputWithPooling ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (TapasConfig) e das entradas.

O método forward do TapasModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.
pooler_output (torch.Tensor de forma (batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.
hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplos:

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

classe transformers.TapasForMaskedLM

< source >

( config: TapasConfig )

Parâmetros

config (TapasConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Tapas com uma cabeça de language modeling no topo.”

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)

Parâmetros

input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.
Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

O que são IDs de entrada?
attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
O que são máscaras de atenção?
token_type_ids (torch.LongTensor de forma (batch_size, sequence_length, 7), opcional) — Índices de tokens que codificam a estrutura tabular. Os índices podem ser obtidos usando AutoTokenizer. Veja esta class para mais informações.
O que são IDs de tipo de token?
position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Se reset_position_index_per_cell de TapasConfig estiver definido como True, embeddings de posição relativos serão usados. Selecionados no intervalo [0, config.max_position_embeddings - 1].
O que são IDs de posição?
inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
encoder_hidden_states (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de hidden-states na saída da última camada do encoder. Usada na cross-attention se o modelo estiver configurado como um decoder.
encoder_attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento da entrada do codificador. Essa máscara é usada na atenção cruzada se o modelo estiver configurado como um decodificador. Valores da máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [-100, 0, ..., config.vocab_size] (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size].
output_attentions (bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions nos tensores retornados para mais detalhes.
output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

MaskedLMOutput ou tuple(torch.Tensor)

Um MaskedLMOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (TapasConfig) e das entradas.

O método forward de TapasForMaskedLM sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem mascarada (MLM).
logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplos:

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

classe transformers.TapasForSequenceClassification

< source >

( config: TapasConfig )

Parâmetros

config (TapasConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo Tapas com uma cabeça de classificação de sequência no topo (uma camada linear sobre a saída agregada), por exemplo, para tarefas de inferência em tabelas, como TabFact (Chen et al., 2020).

forward

< source >

Parâmetros

input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.
Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

O que são IDs de entrada?
attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
O que são máscaras de atenção?
token_type_ids (torch.LongTensor de forma (batch_size, sequence_length, 7), opcional) — Índices de tokens que codificam a estrutura tabular. Os índices podem ser obtidos usando AutoTokenizer. Veja esta class para mais informações.
O que são IDs de tipo de token?
position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Se reset_position_index_per_cell de TapasConfig estiver definido como True, embeddings de posição relativos serão usados. Selecionados no intervalo [0, config.max_position_embeddings - 1].
O que são IDs de posição?
inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
labels (torch.LongTensor de forma (batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em [0, ..., config.num_labels - 1]. Se config.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio); se config.num_labels > 1, uma perda de classificação é calculada (entropia cruzada). Observação: isso é chamado de “classification_class_index” na implementação original.
output_attentions (bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions nos tensores retornados para mais detalhes.
output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

SequenceClassifierOutput ou tuple(torch.Tensor)

Um SequenceClassifierOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (TapasConfig) e das entradas.

O método forward de TapasForSequenceClassification sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de classificação (ou regressão se config.num_labels==1).
logits (torch.Tensor de forma (batch_size, config.num_labels)) — Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplos:

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

classe transformers.TapasForQuestionAnswering

< source >

( config: TapasConfig )

Parâmetros

config (TapasConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo Tapas com uma cabeça de seleção de células e uma cabeça de agregação opcional no topo para tarefas de resposta a perguntas em tabelas (camadas lineares no topo da saída dos estados ocultos para calcular logits e logits_aggregation opcionais), por exemplo, para tarefas supervisionadas SQA, WTQ ou 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)

Parâmetros

input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.
Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

O que são IDs de entrada?
attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
O que são máscaras de atenção?
token_type_ids (torch.LongTensor de forma (batch_size, sequence_length, 7), opcional) — Índices de tokens que codificam a estrutura tabular. Os índices podem ser obtidos usando AutoTokenizer. Veja esta class para mais informações.
O que são IDs de tipo de token?
position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Se reset_position_index_per_cell de TapasConfig estiver definido como True, embeddings de posição relativos serão usados. Selecionados no intervalo [0, config.max_position_embeddings - 1].
O que são IDs de posição?
inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
table_mask (torch.LongTensor de forma (batch_size, seq_length), opcional) — Máscara para a tabela. Indica quais tokens pertencem à tabela (1). Tokens de pergunta, cabeçalhos da tabela e padding são 0.
labels (torch.LongTensor de forma (batch_size, seq_length), opcional) — Rótulos por token para o cálculo da perda de seleção hierárquica de células. Isso codifica as posições da resposta na tabela. Pode ser obtido usando AutoTokenizer.
- 1 para tokens que são parte da resposta,
- 0 para tokens que não fazem parte da resposta.
aggregation_labels (torch.LongTensor de forma (batch_size, ), opcional) — Índice da função de agregação para cada exemplo do lote, usado para calcular a perda de agregação. Os índices devem estar em [0, ..., config.num_aggregation_labels - 1]. Necessário apenas no caso de supervisão forte para agregação (supervisionado por WikiSQL).
float_answer (torch.Tensor de forma (batch_size, ), opcional) — Resposta em ponto flutuante para cada exemplo do lote. Defina como float(‘nan’) para perguntas de seleção de célula. Obrigatório apenas no caso de supervisão fraca (WTQ) para calcular a máscara agregada e a perda de regressão.
numeric_values (torch.Tensor de forma (batch_size, seq_length), opcional) — Valores numéricos de cada token, NaN para tokens que não são valores numéricos. Pode ser obtido usando AutoTokenizer. Necessário apenas no caso de supervisão fraca para agregação (WTQ) para calcular a perda de regressão.
numeric_values_scale (torch.Tensor de forma (batch_size, seq_length), opcional) — Escala dos valores numéricos de cada token. Pode ser obtida usando AutoTokenizer. Necessário apenas no caso de supervisão fraca para agregação (WTQ) para calcular a perda de regressão.
output_attentions (bool, opcional) — Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte attentions nos tensores retornados para mais detalhes.
output_hidden_states (bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consulte hidden_states em tensors retornados para mais detalhes.
return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

TableQuestionAnsweringOutput ou tuple(torch.Tensor)

Um TableQuestionAnsweringOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (TapasConfig) e das entradas.

O método forward de TapasForQuestionAnswering substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

loss (torch.Tensor de forma (1,), opcional, retornado quando labels (e possivelmente answer, aggregation_labels, numeric_values e numeric_values_scale são fornecidos)) — Perda total como a soma da perda de log-verossimilhança da seleção hierárquica de células e (opcionalmente) da perda de regressão semissupervisionada e (opcionalmente) da perda supervisionada para agregações.
logits (torch.Tensor de forma (batch_size, sequence_length)) — Pontuações de previsão da cabeça de seleção de células, para cada token.
logits_aggregation (torch.Tensor, opcional, de forma (batch_size, num_aggregation_labels)) — Pontuações de previsão da cabeça de agregação, para cada operador de agregação.
hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplos:

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

←Modelos Encoder-Decoder de Fala TIPSv2→