Hugging Face's logo

Transformers documentation

TAPAS

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).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2020-04-05 et ajouté à Hugging Face Transformers le 2020-12-15.

TAPAS

Aperçu

Le modèle TAPAS a été proposé dans TAPAS: Weakly Supervised Table Parsing via Pre-training par Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno et Julian Martin Eisenschlos. C’est un modèle basé sur BERT, spécifiquement conçu (et pré-entraîné) pour répondre à des questions sur des données tabulaires. Par rapport à BERT, TAPAS utilise des embeddings de position relative et possède 7 types de jetons qui encodent la structure tabulaire. TAPAS est pré-entraîné sur l’objectif de modélisation de langage masquée (MLM) sur un grand jeu de données comprenant des millions de tables issues de Wikipédia en anglais et des textes correspondants.

Pour le question answering, TAPAS comporte deux têtes en amont : une tête de sélection de cellules et une tête d’agrégation, permettant (facultativement) d’effectuer des agrégations (telles que le comptage ou la sommation) sur les cellules sélectionnées. TAPAS a été affiné sur plusieurs jeux de données :

  • SQA (Réponse à des questions séquentielles par Microsoft)
  • WTQ (Wiki Table Questions, par l'Université Stanford)
  • WikiSQL (par Salesforce).

Il atteint l'état de l'art sur SQA et WTQ, tout en offrant des performances comparables à l'état de l'art sur WikiSQL, avec une architecture beaucoup plus simple.

L'abstract de l'article est le suivant :

Répondre à des questions en langage naturel sur des tableaux est généralement considéré comme une tâche d’analyse sémantique. Pour alléger le coût de collecte de formes logiques complètes, une approche populaire se concentre sur une supervision faible consistant en des dénotations plutôt qu’en des formes logiques. Toutefois, l’entraînement d’analyseurs sémantiques à partir d’une supervision faible pose des difficultés, et de plus, les formes logiques générées ne sont utilisées que comme étape intermédiaire avant la récupération de la dénotation. Dans cet article, nous présentons TAPAS, une approche de réponse à des questions sur des tableaux sans générer de formes logiques. TAPAS s’entraîne à partir d’une supervision faible et prédit la dénotation en sélectionnant des cellules du tableau et, le cas échéant, en appliquant un opérateur d’agrégation correspondant à cette sélection. TAPAS étend l’architecture de BERT pour encoder des tableaux en entrée, est initialisé à partir d’un pré-entraînement conjoint efficace de segments de texte et de tableaux extraits de Wikipédia, et est entraîné de bout en bout. Nous expérimentons sur trois jeux de données d’analyse sémantique différents et constatons que TAPAS surpasse ou rivalise avec les modèles d’analyse sémantique en améliorant la précision de l’état de l’art sur SQA de 55,1 à 67,2 et en obtenant des performances comparables à l’état de l’art sur WIKISQL et WIKITQ, mais avec une architecture de modèle plus simple. Nous constatons également que l’apprentissage par transfert, qui est trivial dans notre contexte, de WIKISQL vers WIKITQ, donne une précision de 48,7, soit 4,2 points au-dessus de l’état de l’art.

En outre, les auteurs ont effectué un pré-entraînement supplémentaire de TAPAS pour reconnaître l'entailment de table, en créant un jeu de données équilibré de millions d'exemples d'entraînement générés automatiquement, appris lors d'une étape intermédiaire avant l'ajustement fin. Les auteurs de TAPAS appellent ce pré-entraînement supplémentaire « pré-entraînement intermédiaire » (puisque TAPAS est d'abord pré-entraîné sur MLM, puis sur un autre jeu de données). Ils ont constaté que le pré-entraînement intermédiaire améliore encore les performances sur SQA, atteignant un nouvel état de l'art, ainsi qu'un état de l'art sur TabFact, un jeu de données à grande échelle composé de 16 k tables Wikipédia pour l'entailment de table (une tâche de classification binaire). Pour plus de détails, consultez leur article de suivi : Understanding tables with intermediate pre-training de Julian Martin Eisenschlos, Syrine Krichene et Thomas Müller.

drawing TAPAS architecture. Taken from the original blog post.

Ce modèle a été contribué par nielsr. Le code d'origine peut être trouvé ici.

Conseils d'utilisation

  • TAPAS est un modèle qui utilise par défaut des embeddings de position relative (les embeddings de position sont réinitialisés à chaque cellule du tableau). Notez qu’il s’agit d’une fonctionnalité ajoutée après la publication de l’article original sur TAPAS. Selon les auteurs, cela entraîne généralement une légère amélioration des performances et permet d’encoder des séquences plus longues sans épuiser les embeddings. Cela se reflète dans le paramètre reset_position_index_per_cell de TapasConfig, qui est défini sur True par défaut. Les versions par défaut des modèles disponibles sur le hub utilisent toutes des embeddings de position relative. Vous pouvez toujours utiliser ceux avec des embeddings de position absolue en passant l’argument supplémentaire revision="no_reset" lors de l’appel de la méthode from_pretrained(). Notez qu’il est généralement conseillé de faire du padding des entrées à droite plutôt qu’à gauche.
  • TAPAS est basé sur BERT, ainsi TAPAS-base correspond par exemple à une architecture BERT-base. Bien entendu, TAPAS-large offre les meilleures performances (les résultats rapportés dans l’article proviennent de TAPAS-large). Les résultats des modèles de différentes tailles sont présentés sur le dépôt GitHub original.
  • TAPAS dispose de points de contrôle affinés sur SQA, capables de répondre à des questions relatives à un tableau dans un contexte conversationnel. Cela signifie que vous pouvez poser des questions de suivi, telles que « quel est son âge ? », en lien avec la question précédente. Notez que le passage avant de TAPAS est légèrement différent dans le cas d’un contexte conversationnel : dans ce cas, vous devez fournir chaque paire tableau-question au modèle une par une, afin que les identifiants de type de jeton prev_labels puissent être remplacés par les labels prédits par le modèle pour la question précédente. Consultez la section « Utilisation » pour plus d’informations.
  • TAPAS est similaire à BERT et repose donc sur l'objectif de modélisation de langage masqué (MLM). Il est donc efficace pour prédire les jetons masqués et pour le NLU en général, mais il n'est pas optimal pour la génération de texte. Les modèles entraînés avec un objectif de modélisation de langage causal (CLM) sont meilleurs à cet égard. Notez que TAPAS peut être utilisé comme encodeur dans le cadre EncoderDecoderModel, afin de le combiner avec un décodeur de texte autorégressif tel que GPT-2.

Utilisation : fine-tuning

Ici, nous vous expliquons comment vous pouvez effectuer le fine-tuning de TapasForQuestionAnswering sur votre propre jeu de données.

ÉTAPE 1 : Choisissez l’une des 3 façons d’utiliser TAPAS - ou expérimentez

En gros, il existe trois façons différentes de faire l’ajustement fin de TapasForQuestionAnswering, correspondant aux différents jeux de données sur lesquels Tapas a été ajusté :

  1. SQA : si vous souhaitez poser des questions de suivi liées à un tableau, dans un contexte conversationnel. Par exemple, si vous demandez d'abord « what's the name of the first actor? », vous pouvez ensuite poser une question de suivi telle que « how old is he? ». Ici, les questions n'impliquent aucune agrégation (toutes les questions sont des questions de sélection de cellules).
  2. WTQ : si vous n’êtes pas intéressé par la pose de questions dans un contexte conversationnel, mais plutôt par la pose de questions liées à un tableau, ce qui peut impliquer des opérations d’agrégation, telles que le comptage du nombre de lignes, la somme des valeurs des cellules ou la moyenne des valeurs des cellules. Vous pouvez alors, par exemple, demander « Quel est le nombre total de buts marqués par Cristiano Ronaldo au cours de sa carrière ? ». Ce cas est également appelé supervision faible, car le modèle lui-même doit apprendre l’opérateur d’agrégation approprié (SUM/COUNT/AVERAGE/NONE) en ne disposant que de la réponse à la question comme signal de supervision.
  3. WikiSQL-supervised : ce jeu de données est basé sur WikiSQL, le modèle recevant l'opérateur d'agrégation de référence pendant l'entraînement. On parle également de supervision forte. Ici, l'apprentissage de l'opérateur d'agrégation approprié est beaucoup plus facile.

Pour résumer :

TâcheJeu de données d’exempleDescription
ConversationnelSQAConversational, questions de sélection de cellule uniquement
Supervision faible pour l'agrégationWTQLes questions peuvent impliquer une agrégation, et le modèle doit l’apprendre en ne disposant que de la réponse comme signal de supervision
Supervision forte pour l'agrégationSupervisé par WikiSQLLes questions peuvent impliquer une agrégation, et le modèle doit l'apprendre à partir de l'opérateur d'agrégation de référence.

L’initialisation d’un modèle à partir d’une base pré-entraînée et de têtes de classification initialisées aléatoirement depuis le hub peut être réalisée comme indiqué ci-dessous.

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

Bien sûr, vous n’êtes pas obligé de suivre l’une de ces trois méthodes de fine-tuning de TAPAS. Vous pouvez également expérimenter en définissant les hyperparamètres de votre choix lors de l’initialisation de TapasConfig, puis créer un TapasForQuestionAnswering basé sur cette configuration. Par exemple, si vous disposez d’un jeu de données contenant à la fois des questions conversationnelles et des questions pouvant impliquer une agrégation, vous pouvez procéder ainsi. Voici un exemple :

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

Vous pouvez également partir d’un point de contrôle déjà affiné. À noter que le point de contrôle déjà affiné sur WTQ présente certains problèmes liés à la perte L2, qui est quelque peu fragile. Consultez ici pour plus d’informations.

Pour obtenir la liste de tous les points de contrôle TAPAS pré-entraînés et affinés disponibles sur le hub de HuggingFace, voir ici.

ÉTAPE 2 : Préparez vos données au format SQA

Deuxièmement, quelle que soit l’option choisie ci-dessus, vous devez préparer votre jeu de données au format SQA. Ce format est un fichier TSV/CSV avec les colonnes suivantes :

  • id : facultatif, identifiant de la paire table-question, à des fins de suivi.
  • annotator : facultatif, identifiant de la personne qui a annoté la paire table-question, à des fins de suivi.
  • position : entier indiquant si la question est la première, la deuxième, la troisième, en relation avec le tableau. Uniquement requis dans le cas d’une configuration conversationnelle (SQA). Cette colonne n’est pas nécessaire si vous visez WTQ/WikiSQL-supervised.
  • question : string
  • table_file : string, nom d'un fichier csv contenant les données tabulaires
  • answer_coordinates : liste d'un ou plusieurs tuples (chaque tuple étant une coordonnée de cellule, c'est-à-dire une paire ligne, colonne qui fait partie de la réponse)
  • answer_text : liste d'une ou plusieurs chaînes de caractères (chaque chaîne étant une valeur de cellule faisant partie de la réponse)
  • aggregation_label : index de l'opérateur d'agrégation. Requis uniquement en cas de supervision forte pour l'agrégation (cas supervisé par WikiSQL)
  • float_answer : la réponse numérique à la question, s'il en existe une (np.nan sinon). Uniquement requis en cas de supervision faible pour l'agrégation (comme WTQ et WikiSQL)

Les tableaux eux-mêmes doivent être présents dans un dossier, chaque tableau étant un fichier csv distinct. Notez que les auteurs de l'algorithme TAPAS ont utilisé des scripts de conversion avec une certaine logique automatisée pour convertir les autres jeux de données (WTQ, WikiSQL) au format SQA. L'auteur explique cela ici. Une conversion de ce script qui fonctionne avec l'implémentation de HuggingFace peut être trouvée ici. Fait intéressant, ces scripts de conversion ne sont pas parfaits (les champs answer_coordinates et float_answer sont remplis sur la base du champ answer_text), ce qui signifie que les résultats sur WTQ et WikiSQL pourraient en réalité être améliorés.

ÉTAPE 3 : Convertir vos données en tenseurs à l'aide de TapasTokenizer

Troisièmement, étant donné que vous avez préparé vos données dans ce format TSV/CSV (et les fichiers CSV correspondants contenant les données tabulaires), vous pouvez ensuite utiliser TapasTokenizer pour convertir les paires table-question en input_ids, attention_mask, token_type_ids, etc. Là encore, selon le cas parmi les trois que vous avez choisi ci-dessus, TapasForQuestionAnswering nécessite des entrées différentes pour l'ajustement fin :

TâcheEntrées requises
Conversationnelinput_ids, attention_mask, token_type_ids, labels
Supervision faible pour l'agrégationinput_ids, attention_mask, token_type_ids, labels, numeric_values, numeric_values_scale, float_answer
Supervision forte pour l'agrégationinput ids, attention mask, token type ids, labels, aggregation_labels

TapasTokenizer crée les labels, numeric_values et numeric_values_scale à partir des colonnes answer_coordinates et answer_text du fichier TSV. Les float_answer et aggregation_labels sont déjà présents dans le fichier TSV de l’étape 2. Voici un exemple :

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

Notez que TapasTokenizer s’attend à ce que les données du tableau soient uniquement du texte. Vous pouvez utiliser .astype(str) sur un dataframe pour le convertir en données textuelles uniquement. Bien sûr, cela ne montre que comment encoder un seul exemple d’entraînement. Il est recommandé de créer un dataloader pour itérer sur les lots :

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)

Notez qu’ici, chaque paire table-question est encodée de manière indépendante. Cela convient tant que votre jeu de données n’est pas conversationnel. Si votre jeu de données comporte des questions conversationnelles (comme dans SQA), vous devez d’abord regrouper les queries, answer_coordinates et answer_text par table (dans l’ordre de leur index position) et encoder par lot chaque table avec ses questions. Cela garantit que les types de jetons prev_labels (voir la documentation de TapasTokenizer) sont définis correctement. Consultez ce notebook pour plus d’informations.

**ÉTAPE 4 : Entraîner (affiner) le modèle

Vous pouvez ensuite effectuer l’ajustement fin de TapasForQuestionAnswering comme suit (illustré ici pour le cas de supervision faible pour l’agrégation) :

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

Utilisation : inférence

Ici, nous expliquons comment utiliser TapasForQuestionAnswering pour l’inférence (c’est-à-dire pour effectuer des prédictions sur de nouvelles données). Pour l’inférence, il suffit de fournir au modèle input_ids, attention_mask et token_type_ids (que vous pouvez obtenir à l’aide de TapasTokenizer) afin d’obtenir les logits. Ensuite, vous pouvez utiliser la méthode pratique ~models.tapas.tokenization_tapas.convert_logits_to_predictions pour les convertir en coordonnées prédites et en indices d’agrégation facultatifs.

Cependant, notez que l’inférence est différente selon que la configuration est conversationnelle ou non. Dans une configuration non conversationnelle, l’inférence peut être effectuée en parallèle sur toutes les paires table-question d’un lot. Voici un exemple :

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

Dans le cas d’une configuration conversationnelle, chaque paire table-question doit être fournie séquentiellement au modèle, de sorte que les types de jetons prev_labels puissent être remplacés par les labels prédits de la paire table-question précédente. Encore une fois, plus d’informations sont disponibles dans ce notebook.

Ressources

Sorties spécifiques à TAPAS

classe transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput

< >

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

Paramètres

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels (et éventuellement answer, aggregation_labels, numeric_values et numeric_values_scale sont fournis)) — Perte totale, définie comme la somme de la perte de log-vraisemblance de sélection hiérarchique de cellules et (facultativement) de la perte de régression semi-supervisée et (facultativement) de la perte supervisée pour les agrégations.
  • logits (torch.Tensor de forme (batch_size, sequence_length)) — Scores de prédiction de la tête de sélection de cellules, pour chaque jeton.
  • logits_aggregation (torch.Tensor, facultatif, de forme (batch_size, num_aggregation_labels)) — Scores de prédiction de la tête d’agrégation, pour chaque opérateur d’agrégation.
  • hidden_states (tuple[torch.Tensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple[torch.Tensor], facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Type de sortie de TapasForQuestionAnswering.

TapasConfig

classe transformers.TapasConfig

< >

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

Paramètres

  • vocab_size (int, facultatif, par défaut 30522) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
  • hidden_size (int, facultatif, par défaut 768) — Dimension des représentations cachées.
  • num_hidden_layers (int, facultatif, par défaut 12) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • intermediate_size (int, facultatif, par défaut 3072) — Dimension des représentations du MLP.
  • hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • hidden_dropout_prob (Union[float, int], facultatif, par défaut 0.1) — La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.
  • attention_probs_dropout_prob (Union[float, int], facultatif, par défaut 0.1) — Le taux de dropout appliqué aux probabilités d'attention.
  • max_position_embeddings (int, facultatif, par défaut 1024) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • type_vocab_sizes (list[int], facultatif, par défaut [3, 256, 256, 2, 256, 256, 10]) — Tailles du vocabulaire des token_type_ids passées lors de l'appel de TapasModel.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-12) — L'épsilon utilisé par les couches de normalisation de couche.
  • pad_token_id (int, facultatif, par défaut 0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • bos_token_id (int, facultatif) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • positive_label_weight (float, facultatif, valeur par défaut 10.0) — Poids appliqué aux étiquettes positives.
  • num_aggregation_labels (int, facultatif, valeur par défaut 0) — Le nombre d'opérateurs d'agrégation à prédire.
  • aggregation_loss_weight (float, facultatif, valeur par défaut 1.0) — Poids d'importance pour la perte d'agrégation.
  • use_answer_as_supervision (bool, facultatif) — Indique s'il faut utiliser la réponse comme seule supervision pour les exemples d'agrégation.
  • answer_loss_importance (float, facultatif, valeur par défaut 1.0) — Poids d'importance pour la perte de régression.
  • use_normalized_answer_loss (bool, facultatif, valeur par défaut False) — Indique s'il faut normaliser la perte de la réponse par le maximum de la valeur prédite et de la valeur attendue.
  • huber_loss_delta (float, facultatif) — Paramètre Delta utilisé pour calculer la perte de régression.
  • temperature (float, facultatif, valeur par défaut 1.0) — Valeur utilisée pour contrôler (ou modifier) l'asymétrie des probabilités des logits des cellules.
  • aggregation_temperature (float, facultatif, valeur par défaut 1.0) — Met à l'échelle les logits d'agrégation pour contrôler l'asymétrie des probabilités.
  • use_gumbel_for_cells (bool, facultatif, par défaut False) — Indique s'il faut appliquer Gumbel-Softmax à la sélection des cellules.
  • use_gumbel_for_aggregation (bool, facultatif, valeur par défaut False) — Indique s'il faut appliquer Gumbel-Softmax à la sélection d'agrégation.
  • average_approximation_function (string, facultatif, valeur par défaut "ratio") — Méthode de calcul de la moyenne attendue des cellules dans le cas de la supervision faible. L'une des valeurs "ratio", "first_order" ou "second_order".
  • cell_selection_preference (float, facultatif) — Préférence pour la sélection de cellules dans les cas ambigus. Applicable uniquement en cas de supervision faible pour l'agrégation (WTQ, WikiSQL). Si la masse totale des probabilités d'agrégation (en excluant l'opérateur « NONE ») est supérieure à ce hyperparamètre, alors une agrégation est prédite pour l'exemple.
  • answer_loss_cutoff (float, facultatif) — Ignore les exemples dont la perte de réponse est supérieure au seuil.
  • max_num_rows (int, facultatif, valeur par défaut : 64) — Nombre maximal de lignes.
  • max_num_columns (int, facultatif, valeur par défaut : 32) — Nombre maximal de colonnes.
  • average_logits_per_cell (bool, facultatif, par défaut False) — Indique s'il faut faire la moyenne des logits par cellule.
  • select_one_column (bool, facultatif, valeur par défaut True) — Indique s'il faut contraindre le modèle à ne sélectionner que des cellules d'une seule colonne.
  • allow_empty_column_selection (bool, facultatif, valeur par défaut False) — Indique s'il est possible de ne sélectionner aucune colonne.
  • init_cell_selection_weights_to_zero (bool, facultatif, valeur par défaut False) — Indique s'il faut initialiser les poids de sélection des cellules à 0 afin que les probabilités initiales soient de 50 %.
  • reset_position_index_per_cell (bool, facultatif, valeur par défaut True) — Indique s'il faut réinitialiser les index de position à chaque cellule (c'est-à-dire utiliser des embeddings de position relatifs).
  • disable_per_token_loss (bool, facultatif, valeur par défaut False) — Indique s'il faut désactiver toute supervision (forte ou faible) sur les cellules.
  • aggregation_labels (dict[int, label], facultatif) — Les étiquettes d'agrégation utilisées pour agréger les résultats. Par exemple, les modèles WTQ ont les étiquettes d'agrégation suivantes : {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
  • no_aggregation_label_index (int, facultatif) — Si les étiquettes d’agrégation sont définies et que l’une d’entre elles représente « No aggregation », cette valeur doit être définie sur son index. Par exemple, les modèles WTQ ont l’étiquette d’agrégation « NONE » à l’index 0, il faut donc définir cette valeur sur 0 pour ces modèles.
  • is_decoder (bool, facultatif, par défaut False) — Indique si le modèle est utilisé comme décodeur ou non. Si False, le modèle est utilisé comme encodeur.
  • add_cross_attention (bool, facultatif, valeur par défaut False) — Indique si des couches d'attention croisée doivent être ajoutées au modèle.
  • tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un TapasModel. Elle est utilisée pour instancier un modèle Tapas en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de google/tapas-base-finetuned-sqa

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

< >

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

Paramètres

  • vocab_file (str) — Fichier contenant le vocabulaire.
  • do_lower_case (bool, facultatif, par défaut True) — Indique s'il faut mettre l'entrée en minuscules lors de la tokenisation.
  • do_basic_tokenize (bool, facultatif, par défaut True) — Indique s'il faut effectuer une tokenisation de base avant WordPiece.
  • never_split (Iterable, facultatif) — Collection de jetons qui ne seront jamais fractionnés lors de la tokenisation. N'a un effet que lorsque do_basic_tokenize=True
  • unk_token (str, facultatif, par défaut "[UNK]") — Le jeton inconnu. Un jeton qui n’est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton.
  • sep_token (str, facultatif, par défaut "[SEP]") — Le jeton séparateur, utilisé lors de la construction d'une séquence à partir de plusieurs séquences, par exemple deux séquences pour la classification de séquences ou un texte et une question pour le question answering. Il est également utilisé comme dernier jeton d'une séquence construite avec des jetons spéciaux.
  • pad_token (str, facultatif, par défaut "[PAD]") — Le jeton utilisé pour le bourrage, par exemple lors du regroupement de séquences de longueurs différentes.
  • cls_token (str, facultatif, par défaut "[CLS]") — Le jeton de classifieur utilisé lors de la classification de séquence (classification de la séquence entière plutôt que la classification par jeton). C'est le premier jeton de la séquence lorsqu'elle est construite avec des jetons spéciaux.
  • mask_token (str, facultatif, par défaut "[MASK]") — Le jeton utilisé pour masquer les valeurs. C'est le jeton utilisé lors de l'entraînement de ce modèle avec le modélisation de langage masquée. C'est le jeton que le modèle cherchera à prédire.
  • empty_token (str, facultatif, par défaut "[EMPTY]") — Le jeton utilisé pour les valeurs de cellules vides dans un tableau. Les valeurs de cellules vides incluent "", « n/a », « nan » et « ? ».
  • tokenize_chinese_chars (bool, facultatif, par défaut True) — Indique s'il faut ou non tokeniser les caractères chinois. Il est probablement préférable de désactiver cette option pour le japonais (voir cette issue).
  • strip_accents (bool, facultatif) — Indique s'il faut supprimer toutes les accents. Si cette option n'est pas spécifiée, elle est déterminée par la valeur de lowercase (comme dans BERT d'origine).
  • cell_trim_length (int, facultatif, valeur par défaut -1) — Si > 0 : supprime les cellules pour que leur longueur soit <= cette valeur. Désactive également toute suppression supplémentaire de cellules ; doit donc être utilisé avec truncation défini sur True.
  • max_column_id (int, facultatif) — Identifiant de colonne maximal à extraire.
  • max_row_id (int, facultatif) — Identifiant de ligne maximal à extraire.
  • strip_column_names (bool, facultatif, par défaut False) — Indique s'il faut ajouter des chaînes vides à la place des noms de colonnes.
  • update_answer_coordinates (bool, facultatif, par défaut False) — Indique s'il faut recalculer les coordonnées de la réponse à partir du texte de la réponse.
  • min_question_length (int, facultatif) — Longueur minimale de chaque question en nombre de jetons (les questions plus courtes seront ignorées).
  • max_question_length (int, facultatif) — Longueur maximale de chaque question en nombre de jetons (les questions plus longues seront ignorées).
  • clean_up_tokenization_spaces (bool, facultatif, valeur par défaut True) — Indique s'il faut nettoyer les espaces après le décodage. Le nettoyage consiste à supprimer les artefacts potentiels, tels que les espaces superflus.

Construit un tokenizer TAPAS. Basé sur WordPiece. Aplati un tableau et une ou plusieurs phrases associées pour être utilisé par les modèles TAPAS.

Ce tokenizer hérite de PreTrainedTokenizer, qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette classe mère pour plus d’informations sur ces méthodes. TapasTokenizer crée plusieurs identifiants de type de jeton pour encoder la structure tabulaire. Plus précisément, il ajoute 7 identifiants de type de jeton, dans l’ordre suivant : segment_ids, column_ids, row_ids, prev_labels, column_ranks, inv_column_ranks et numeric_relations :

  • segment_ids : indique si un jeton appartient à la question (0) ou au tableau (1). 0 pour les jetons spéciaux et le bourrage.
  • column_ids : indique à quelle colonne du tableau appartient un jeton (en commençant à 1). Valeur 0 pour tous les jetons de question, les jetons spéciaux et le bourrage.
  • row_ids : indique à quelle ligne du tableau appartient un jeton (en commençant à 1). Valeur 0 pour tous les jetons de question, les jetons spéciaux et le bourrage. Les jetons des en-têtes de colonnes sont également 0.
  • prev_labels : indique si un jeton faisait (en partie) partie de la réponse à la question précédente (1) ou non (0). Utile dans un contexte conversationnel (tel que SQA).
  • column_ranks : indique le rang d'un jeton de table par rapport à une colonne, le cas échéant. Par exemple, si vous avez une colonne « number of movies » avec les valeurs 87, 53 et 69, les rangs de colonne de ces jetons sont respectivement 3, 1 et 2. La valeur est 0 pour tous les jetons de question, les jetons spéciaux et le bourrage.
  • inv_column_ranks : indique le rang inverse d'un jeton de table par rapport à une colonne, le cas échéant. Par exemple, si vous avez une colonne « number of movies » avec les valeurs 87, 53 et 69, les rangs inverses de colonne de ces jetons sont respectivement 1, 3 et 2. 0 pour tous les jetons de question, les jetons spéciaux et le bourrage.
  • numeric_relations : indique les relations numériques entre la question et les jetons du tableau. 0 pour tous les jetons de la question, les jetons spéciaux et le bourrage.

TapasTokenizer effectue la tokenisation de bout en bout sur un tableau et les phrases associées : séparation de la ponctuation et wordpiece.

__call__

< >

( table: typing.Union[ForwardRef('pd.DataFrame'), str, list[str], NoneType]queries: str | list[str] | list[int] | list[list[str]] | list[list[int]] | None = Noneanswer_coordinates: list[tuple] | list[list[tuple]] | None = Noneanswer_text: list[str] | list[list[str]] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.models.tapas.tokenization_tapas.TapasTruncationStrategy = Falsemax_length: int | None = Nonepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = True**kwargs )

Paramètres

  • table (pd.DataFrame ou str ou list[str]) — Tableau contenant des données tabulaires. Notez que toutes les valeurs des cellules doivent être du texte. Utilisez .astype(str) sur un dataframe Pandas pour le convertir en chaînes de caractères. Lors du passage d'une chaîne de caractères ou d'une liste de chaînes de caractères, celles-ci seront interprétées comme des requêtes avec un tableau vide (pour prendre en charge les tests génériques de tokenizers).
  • queries (str ou list[str]) — Question ou lot de questions liées à un tableau à encoder. Notez que, en cas de lot, toutes les questions doivent se référer au même tableau.
  • answer_coordinates (list[Tuple] ou list[list[Tuple]], facultatif) — Coordonnées de la réponse pour chaque paire table-question du lot. Si une seule paire table-question est fournie, answer_coordinates doit être une liste unique d'un ou plusieurs tuples. Chaque tuple doit être une paire (row_index, column_index). La première ligne de données (et non la ligne d'en-tête des colonnes) a l'index 0. La première colonne a l'index 0. Si un lot de paires table-question est fourni, answer_coordinates doit être une liste de listes de tuples (chaque liste correspondant à une seule paire table-question).
  • answer_text (list[str] ou list[list[str]], facultatif) — Texte de la réponse de chaque paire table-question du lot. Si une seule paire table-question est fournie, answer_text doit être une liste unique d'une ou plusieurs chaînes de caractères. Chaque chaîne doit correspondre au texte de la réponse d'une coordonnée de réponse donnée. Si un lot de paires table-question est fourni, answer_coordinates doit être une liste de listes de chaînes de caractères (chaque liste correspondant à une seule paire table-question).
  • add_special_tokens (bool, facultatif, par défaut True) — Indique s'il faut ou non encoder les séquences avec les jetons spéciaux relatifs à leur modèle.
  • padding (bool, str ou PaddingStrategy, facultatif, défaut : False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TapasTruncationStrategy, facultatif, par défaut False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'drop_rows_to_fit' : tronque à une longueur maximale spécifiée avec l'argument max_length ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque ligne par ligne, en supprimant des lignes du tableau.
    • False ou 'do_not_truncate' (par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).
  • max_length (int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.

    Si non défini ou défini sur None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé.

  • is_split_into_words (bool, facultatif, par défaut False) — Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini à True, le tokeniseur suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et la tokenise. Cela est utile pour la NER ou la classification de tokens.
  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.5 (Volta).
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.

Méthode principale pour tokeniser et préparer pour le modèle une ou plusieurs séquences liées à un tableau.

convert_logits_to_predictions

< >

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

Paramètres

  • data (dict) — Dictionnaire associant les fonctionnalités à leurs valeurs réelles. Doit être créé à l'aide de TapasTokenizer.
  • logits (torch.Tensor de forme (batch_size, sequence_length)) — Tenseur contenant les logits au niveau des jetons.
  • logits_agg (torch.Tensor de forme (batch_size, num_aggregation_labels), facultatif) — Tenseur contenant les logits d'agrégation.
  • cell_classification_threshold (float, facultatif, valeur par défaut 0,5) — Seuil à utiliser pour la sélection des cellules. Toutes les cellules du tableau dont la probabilité est supérieure à ce seuil seront sélectionnées.

Retourne

tuple comprenant divers éléments selon les entrées

  • predicted_answer_coordinates (list[list[[tuple]] de longueur batch_size) : Coordonnées de la réponse prédite, sous forme d'une liste de listes de tuples. Chaque élément de la liste contient les coordonnées de la réponse prédite pour un seul exemple du lot, sous forme d'une liste de tuples. Chaque tuple représente une cellule, c'est-à-dire (indice de ligne, indice de colonne).
  • predicted_aggregation_indices (list[int]de longueur batch_size, facultatif, renvoyé lorsque logits_aggregation est fourni) : Indices des opérateurs d'agrégation prédits par la tête d'agrégation.

Convertit les logits de TapasForQuestionAnswering en coordonnées de réponse prédite et en indices d’agrégation facultatifs.

L’implémentation originale, sur laquelle cette fonction est basée, peut être trouvée ici.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

TapasModel

classe transformers.TapasModel

< >

( config: TapasConfigadd_pooling_layer = True )

Paramètres

  • config (TapasConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
  • add_pooling_layer (bool, facultatif, par défaut True) — Indique s'il faut ajouter une couche de pooling

Le modèle Tapas brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

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

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • token_type_ids (torch.LongTensor de forme (batch_size, sequence_length, 7), facultatif) — Indices de jetons qui encodent la structure tabulaire. Les indices peuvent être obtenus à l'aide de AutoTokenizer. Voir cette class pour plus d'informations.

    Qu'est-ce que les identifiants de type de jeton ?

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices de position des jetons de chaque séquence d'entrée dans les embeddings de position. Si reset_position_index_per_cell de TapasConfig est défini sur True, des embeddings de position relatifs seront utilisés. Sélectionnés dans l'intervalle [0, config.max_position_embeddings - 1].

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • encoder_hidden_states (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée si le modèle est configuré comme un décodeur.
  • encoder_attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'effectuer l'attention sur les indices des jetons de bourrage de l'entrée de l'encodeur. Ce masque est utilisé dans l'attention croisée si le modèle est configuré comme un décodeur. Valeurs du masque sélectionnées dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Un BaseModelOutputWithPooling ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (TapasConfig) et des entrées.

La méthode forward de TapasModel redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

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

< >

( config: TapasConfig )

Paramètres

  • config (TapasConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le modèle Tapas avec une tête de language modeling au sommet.”

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

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

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • token_type_ids (torch.LongTensor de forme (batch_size, sequence_length, 7), facultatif) — Indices de jetons qui encodent la structure tabulaire. Les indices peuvent être obtenus à l'aide de AutoTokenizer. Voir cette class pour plus d'informations.

    Qu'est-ce que les identifiants de type de jeton ?

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices de position des jetons de chaque séquence d'entrée dans les embeddings de position. Si reset_position_index_per_cell de TapasConfig est défini sur True, des embeddings de position relatifs seront utilisés. Sélectionnés dans l'intervalle [0, config.max_position_embeddings - 1].

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • encoder_hidden_states (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée si le modèle est configuré comme un décodeur.
  • encoder_attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'effectuer l'attention sur les indices des jetons de bourrage de l'entrée de l'encodeur. Ce masque est utilisé dans l'attention croisée si le modèle est configuré comme un décodeur. Valeurs du masque sélectionnées dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.
  • labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans [-100, 0, ..., config.vocab_size] (voir la docstring de input_ids). Les jetons dont l'indice est défini sur -100 sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est dans [0, ..., config.vocab_size].
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

MaskedLMOutput ou tuple(torch.Tensor)

Un MaskedLMOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (TapasConfig) et des entrées.

La méthode forward de TapasForMaskedLM redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation de langage masquée (MLM).

  • logits (torch.Tensor de forme (batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

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

< >

( config: TapasConfig )

Paramètres

  • config (TapasConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Modèle Tapas avec une tête de classification de séquences au sommet (une couche linéaire au-dessus de la sortie agrégée), par exemple pour des tâches d'entaillement de table, telles que TabFact (Chen et al., 2020).

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( 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] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SequenceClassifierOutput or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • token_type_ids (torch.LongTensor de forme (batch_size, sequence_length, 7), facultatif) — Indices de jetons qui encodent la structure tabulaire. Les indices peuvent être obtenus à l'aide de AutoTokenizer. Voir cette class pour plus d'informations.

    Qu'est-ce que les identifiants de type de jeton ?

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices de position des jetons de chaque séquence d'entrée dans les embeddings de position. Si reset_position_index_per_cell de TapasConfig est défini sur True, des embeddings de position relatifs seront utilisés. Sélectionnés dans l'intervalle [0, config.max_position_embeddings - 1].

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • labels (torch.LongTensor de forme (batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans [0, ..., config.num_labels - 1]. Si config.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Si config.num_labels > 1, une perte de classification est calculée (entropie croisée). Remarque : dans l’implémentation d’origine, ce paramètre est appelé « classification_class_index ».
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

SequenceClassifierOutput ou tuple(torch.Tensor)

Un SequenceClassifierOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (TapasConfig) et des entrées.

La méthode forward de TapasForSequenceClassification redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de classification (ou de régression si config.num_labels==1).

  • logits (torch.Tensor de forme (batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

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

< >

( config: TapasConfig )

Paramètres

  • config (TapasConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Modèle Tapas doté d'une tête de sélection de cellules et d'une tête d'agrégation facultative en amont, destinée aux tâches de question-réponse sur des tableaux (couches linéaires appliquées à la sortie des états cachés pour calculer les logits et, le cas échéant, les logits_aggregation), par exemple pour les tâches supervisées SQA, WTQ ou WikiSQL.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

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

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • token_type_ids (torch.LongTensor de forme (batch_size, sequence_length, 7), facultatif) — Indices de jetons qui encodent la structure tabulaire. Les indices peuvent être obtenus à l'aide de AutoTokenizer. Voir cette class pour plus d'informations.

    Qu'est-ce que les identifiants de type de jeton ?

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices de position des jetons de chaque séquence d'entrée dans les embeddings de position. Si reset_position_index_per_cell de TapasConfig est défini sur True, des embeddings de position relatifs seront utilisés. Sélectionnés dans l'intervalle [0, config.max_position_embeddings - 1].

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • table_mask (torch.LongTensor de forme (batch_size, seq_length), facultatif) — Masque pour le tableau. Indique quels jetons appartiennent au tableau (1). Les jetons de question, les en-têtes du tableau et le bourrage sont 0.
  • labels (torch.LongTensor de forme (batch_size, seq_length), facultatif) — Étiquettes par jeton pour le calcul de la perte de sélection hiérarchique de cellules. Cela encode les positions de la réponse dans le tableau. Peut être obtenu à l'aide de AutoTokenizer.
    • 1 pour les jetons qui font partie de la réponse,
    • 0 pour les jetons qui ne font pas partie de la réponse.
  • aggregation_labels (torch.LongTensor de forme (batch_size, ), facultatif) — Index de la fonction d'agrégation pour chaque exemple du lot, utilisé pour calculer la perte d'agrégation. Les indices doivent être compris dans [0, ..., config.num_aggregation_labels - 1]. Requis uniquement en cas de supervision forte pour l'agrégation (supervision WikiSQL).
  • float_answer (torch.Tensor de forme (batch_size, ), facultatif) — Réponse flottante pour chaque exemple du lot. À définir sur float(‘nan’) pour les questions de sélection de cellule. Uniquement requis en cas de supervision faible (WTQ) pour calculer le masque agrégé et la perte de régression.
  • numeric_values (torch.Tensor de forme (batch_size, seq_length), facultatif) — Valeurs numériques de chaque jeton, NaN pour les jetons qui ne sont pas des valeurs numériques. Peut être obtenu à l’aide de AutoTokenizer. Uniquement requis en cas de supervision faible pour l’agrégation (WTQ) afin de calculer la perte de régression.
  • numeric_values_scale (torch.Tensor de forme (batch_size, seq_length), facultatif) — Échelle des valeurs numériques de chaque jeton. Peut être obtenue à l’aide de AutoTokenizer. Uniquement requis en cas de supervision faible pour l’agrégation (WTQ) afin de calculer la perte de régression.
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

TableQuestionAnsweringOutput ou tuple(torch.Tensor)

Un TableQuestionAnsweringOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers éléments en fonction de la configuration (TapasConfig) et des entrées.

La méthode forward de TapasForQuestionAnswering redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels (et éventuellement answer, aggregation_labels, numeric_values et numeric_values_scale sont fournis)) — Perte totale, définie comme la somme de la perte de log-vraisemblance de sélection hiérarchique de cellules et (facultativement) de la perte de régression semi-supervisée et (facultativement) de la perte supervisée pour les agrégations.

  • logits (torch.Tensor de forme (batch_size, sequence_length)) — Scores de prédiction de la tête de sélection de cellules, pour chaque jeton.

  • logits_aggregation (torch.Tensor, facultatif, de forme (batch_size, num_aggregation_labels)) — Scores de prédiction de la tête d'agrégation, pour chaque opérateur d'agrégation.

  • hidden_states (tuple[torch.Tensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple[torch.Tensor], facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

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

←Modèles encodeur-décodeur pour la parole TIPSv2→