# TAPAS

## Aperçu

Le modèle TAPAS a été proposé dans [TAPAS: Weakly Supervised Table Parsing via Pre-training](https://huggingface.co/papers/2004.02349) 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](https://www.microsoft.com/en-us/download/details.aspx?id=54253) (Réponse à des questions séquentielles par Microsoft)
- [WTQ](https://github.com/ppasupat/WikiTableQuestions) (Wiki Table Questions, par l'Université Stanford)
- [WikiSQL](https://github.com/salesforce/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 réduire 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ération 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 les 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 menons des expériences 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](https://github.com/wenhuchen/Table-Fact-Checking), 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](https://www.aclweb.org/anthology/2020.findings-emnlp.27/) de Julian Martin Eisenschlos, Syrine Krichene et Thomas Müller.

<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/tapas_architecture.png"
alt="drawing" width="600"/>

 Architecture de TAPAS. Issue du billet de blog original.

Ce modèle a été contribué par [nielsr](https://huggingface.co/nielsr). Le code d'origine peut être trouvé [ici](https://github.com/google-research/tapas).

## 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). Il est à noter que cette fonctionnalité a été 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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasConfig), qui est défini sur `True` par défaut. Les versions par défaut des modèles disponibles sur le [hub](https://huggingface.co/models?search=tapas) utilisent toutes des embeddings de position relative. Vous pouvez néanmoins utiliser ceux qui emploient des embeddings de position absolue en transmettant l'argument supplémentaire `revision="no_reset"` lors de l'appel de la méthode `from_pretrained()`. Il est généralement conseillé d'effectuer le 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](https://github.com/google-research/tapas).
- 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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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 cellule).
2. WTQ : si vous n’êtes pas intéressé par la pose de questions dans un cadre 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 sommation des valeurs des cellules ou le calcul de 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âche**                            | **Jeu de données d’exemple** | **Description**                                                                                         |
|-------------------------------------|---------------------|---------------------------------------------------------------------------------------------------------|
| Conversationnel                      | SQA                 | Conversational, questions de sélection de cellule uniquement                                                           |
| Supervision faible pour l'agrégation    | WTQ                 | Les 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égation  | Supervisé par WikiSQL  | Les 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.

```python
from transformers import TapasConfig, TapasForQuestionAnswering

# for example, the base sized model with default SQA configuration
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", device_map="auto")

# or, the base sized model with WTQ configuration
config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq")
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto")

# or, the base sized model with WikiSQL configuration
config = TapasConfig("google-base-finetuned-wikisql-supervised")
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto")
```

Bien sûr, vous n'êtes pas obligé de suivre l'une des 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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasConfig), puis créer un [TapasForQuestionAnswering](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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 impliquant potentiellement une agrégation, vous pouvez procéder ainsi. Voici un exemple :

```python
from transformers import TapasConfig, TapasForQuestionAnswering

# you can initialize the classification heads any way you want (see docs of TapasConfig)
config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True)
# initializing the pre-trained base sized model with our custom classification heads
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto")
```

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](https://github.com/google-research/tapas/issues/91#issuecomment-735719340) 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](https://huggingface.co/models?search=tapas).

**É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](https://www.microsoft.com/en-us/download/details.aspx?id=54253). 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) dans le format SQA. L'auteur explique cela [ici](https://github.com/google-research/tapas/issues/50#issuecomment-705465960). Une conversion de ce script qui fonctionne avec l'implémentation de HuggingFace peut être trouvée [ici](https://github.com/NielsRogge/tapas_utils). 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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasTokenizer) pour convertir les paires table-question en `input_ids`, `attention_mask`, `token_type_ids`, etc. Là encore, selon le cas parmi les trois présentés ci-dessus que vous avez choisi, [TapasForQuestionAnswering](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasForQuestionAnswering) nécessite des entrées différentes pour l'ajustement fin :

| **Tâche**                           | **Entrées requises**                                                                                                 |
|------------------------------------|---------------------------------------------------------------------------------------------------------------------|
| Conversationnel                     | `input_ids`, `attention_mask`, `token_type_ids`, `labels`                                                           |
|  Supervision faible pour l'agrégation  | `input_ids`, `attention_mask`, `token_type_ids`, `labels`, `numeric_values`, `numeric_values_scale`, `float_answer` |
| Supervision forte pour l'agrégation | `input ids`, `attention mask`, `token type ids`, `labels`, `aggregation_labels`                                     |

[TapasTokenizer](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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 :

```py
from transformers import TapasTokenizer
import pandas as pd

model_name = "google/tapas-base"
tokenizer = TapasTokenizer.from_pretrained(model_name)

data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
queries = [
    "What is the name of the first actor?",
    "How many movies has George Clooney played in?",
    "What is the total number of movies?",
]
answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]]
answer_text = [["Brad Pitt"], ["69"], ["209"]]
table = pd.DataFrame.from_dict(data)
inputs = tokenizer(
    table=table,
    queries=queries,
    answer_coordinates=answer_coordinates,
    answer_text=answer_text,
    padding="max_length",
    return_tensors="pt",
)
inputs
{'input_ids': tensor([[ ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]),
'numeric_values': tensor([[ ]]), 'numeric_values_scale: tensor([[ ]]), labels: tensor([[ ]])}
```

Notez que [TapasTokenizer](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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 :

```python
import pandas as pd
import torch

tsv_path = "your_path_to_the_tsv_file"
table_csv_path = "your_path_to_a_directory_containing_all_csv_files"

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

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

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

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

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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasTokenizer)) sont définis correctement. Consultez [ce notebook](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb) pour plus d’informations.

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

Vous pouvez ensuite effectuer l’ajustement fin de [TapasForQuestionAnswering](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasForQuestionAnswering) comme suit (illustré ici pour le cas de supervision faible pour l’agrégation) :

```python
from transformers import AdamW, TapasConfig, TapasForQuestionAnswering

# this is the default WTQ configuration
config = TapasConfig(
    num_aggregation_labels=4,
    use_answer_as_supervision=True,
    answer_loss_cutoff=0.664694,
    cell_selection_preference=0.207951,
    huber_loss_delta=0.121194,
    init_cell_selection_weights_to_zero=True,
    select_one_column=True,
    allow_empty_column_selection=False,
    temperature=0.0352513,
)
model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config, device_map="auto")

optimizer = AdamW(model.parameters(), lr=5e-5)

model.train()
for epoch in range(2):  # loop over the dataset multiple times
    for batch in train_dataloader:
        # get the inputs;
        input_ids = batch["input_ids"]
        attention_mask = batch["attention_mask"]
        token_type_ids = batch["token_type_ids"]
        labels = batch["labels"]
        numeric_values = batch["numeric_values"]
        numeric_values_scale = batch["numeric_values_scale"]
        float_answer = batch["float_answer"]

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = model(
            input_ids=input_ids,
            attention_mask=attention_mask,
            token_type_ids=token_type_ids,
            labels=labels,
            numeric_values=numeric_values,
            numeric_values_scale=numeric_values_scale,
            float_answer=float_answer,
        )
        loss = outputs.loss
        loss.backward()
        optimizer.step()
```

## Utilisation : inférence

Ici, nous expliquons comment utiliser [TapasForQuestionAnswering](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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 :

```py
from transformers import TapasTokenizer, TapasForQuestionAnswering
import pandas as pd

model_name = "google/tapas-base-finetuned-wtq"
model = TapasForQuestionAnswering.from_pretrained(model_name, device_map="auto")
tokenizer = TapasTokenizer.from_pretrained(model_name)

data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
queries = [
    "What is the name of the first actor?",
    "How many movies has George Clooney played in?",
    "What is the total number of movies?",
]
table = pd.DataFrame.from_dict(data)
inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt").to(model.device)
outputs = model(**inputs)
predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions(
    inputs, outputs.logits.detach(), outputs.logits_aggregation.detach()
)

# let's print out the results:
id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices]

answers = []
for coordinates in predicted_answer_coordinates:
    if len(coordinates) == 1:
        # only a single cell:
        answers.append(table.iat[coordinates[0]])
    else:
        # multiple cells
        cell_values = []
        for coordinate in coordinates:
            cell_values.append(table.iat[coordinate])
        answers.append(", ".join(cell_values))

display(table)
print("")
for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string):
    print(query)
    if predicted_agg == "NONE":
        print("Predicted answer: " + answer)
    else:
        print("Predicted answer: " + predicted_agg + " > " + answer)
What is the name of the first actor?
Predicted answer: Brad Pitt
How many movies has George Clooney played in?
Predicted answer: COUNT > 69
What is the total number of movies?
Predicted answer: SUM > 87, 53, 69
```

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](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/TAPAS/Fine_tuning_TapasForQuestionAnswering_on_SQA.ipynb).

## Ressources

- [Guide de la tâche de classification de texte](../tasks/sequence_classification)
- [Guide de la tâche de modélisation de langage masqué](../tasks/masked_language_modeling)

## Sorties spécifiques à TAPAS[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]]

#### transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput[[transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput]]

```python
transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, logits_aggregation: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L49)

**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, le cas échéant, de la perte de régression semi-supervisée et 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’embedding 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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasForQuestionAnswering).

## TapasConfig[[transformers.TapasConfig]]

#### transformers.TapasConfig[[transformers.TapasConfig]]

```python
transformers.TapasConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 1024, type_vocab_sizes: list[int] | tuple[int, ...] = (3, 256, 256, 2, 256, 256, 10), initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, positive_label_weight: float = 10.0, num_aggregation_labels: int = 0, aggregation_loss_weight: float = 1.0, use_answer_as_supervision: bool | None = None, answer_loss_importance: float = 1.0, use_normalized_answer_loss: bool = False, huber_loss_delta: float | None = None, temperature: float = 1.0, aggregation_temperature: float = 1.0, use_gumbel_for_cells: bool = False, use_gumbel_for_aggregation: bool = False, average_approximation_function: str = 'ratio', cell_selection_preference: float | None = None, answer_loss_cutoff: float | int | None = None, max_num_rows: int = 64, max_num_columns: int = 32, average_logits_per_cell: bool = False, select_one_column: bool = True, allow_empty_column_selection: bool = False, init_cell_selection_weights_to_zero: bool = False, reset_position_index_per_cell: bool = True, disable_per_token_loss: bool = False, aggregation_labels: dict | None = None, no_aggregation_label_index: int | None = None, is_decoder: bool = False, add_cross_attention: bool = False, tie_word_embeddings: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/configuration_tapas.py#L32)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur 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 MLP.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *facultatif*, valeur 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*, valeur par défaut `0.1`) : Le taux de dropout appliqué aux probabilités d'attention.

max_position_embeddings (`int`, *facultatif*, valeur 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]`) : Les tailles de vocabulaire des `token_type_ids` passées lors de l'appel de [TapasModel](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasModel).

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

layer_norm_eps (`float`, *facultatif*, par défaut `1e-12`) : L'épsilon utilisé par les couches de normalisation par couche.

pad_token_id (`int`, *facultatif*, valeur par défaut `0`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.

bos_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*) : Identifiant de 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 la valeur maximale entre la valeur prédite et 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) : Échelle appliquée aux logits d'agrégation pour contrôler l'asymétrie des probabilités.

use_gumbel_for_cells (`bool`, *facultatif*, valeur 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*, 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 la cellule en cas d'ambiguïté. 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 un exemple.

answer_loss_cutoff (`float`, *facultatif*) : Ignorer les exemples dont la perte de réponse est supérieure à la valeur de coupure.

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*, par défaut `True`) : Indique si le modèle doit être contraint à ne sélectionner des cellules que 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 « Aucune agrégation », 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, donc cette valeur doit être définie sur 0 pour ces modèles.

is_decoder (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le modèle est utilisé comme décodeur. Si `False`, le modèle est utilisé comme encodeur.

add_cross_attention (`bool`, *facultatif*, par défaut `False`) : Indique si des couches d'attention croisée doivent être ajoutées au modèle.

tie_word_embeddings (`bool`, *facultatif*, valeur 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, définissant ainsi 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](https://huggingface.co/google/tapas-base-finetuned-sqa)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import TapasModel, TapasConfig

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

## TapasTokenizer[[transformers.TapasTokenizer]]

#### transformers.TapasTokenizer[[transformers.TapasTokenizer]]

```python
transformers.TapasTokenizer(vocab_file, do_lower_case = True, do_basic_tokenize = True, never_split = None, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', empty_token = '[EMPTY]', tokenize_chinese_chars = True, strip_accents = None, cell_trim_length: int = -1, max_column_id: int | None = None, max_row_id: int | None = None, strip_column_names: bool = False, update_answer_coordinates: bool = False, min_question_length = None, max_question_length = None, model_max_length: int = 512, additional_special_tokens: list[str] | None = None, clean_up_tokenization_spaces = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/tokenization_tapas.py#L149)

**Paramètres :**

vocab_file (`str`) : Fichier contenant le vocabulaire.

do_lower_case (`bool`, *facultatif*, valeur 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*, valeur 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*, valeur 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 groupement 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*, valeur 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 masquage de langage. C'est le jeton que le modèle cherchera à prédire.

empty_token (`str`, *facultatif*, valeur 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*, valeur 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](https://github.com/huggingface/transformers/issues/328)).

strip_accents (`bool`, *facultatif*) : Indique s'il faut supprimer toutes les accents. Si cette option n'est pas spécifiée, sa valeur est déterminée par celle de `lowercase` (comme dans BERT d'origine).

cell_trim_length (`int`, *facultatif*, valeur par défaut : -1) : Si > 0 : supprime les cellules pour que la 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*, valeur par défaut `False`) : Indique s'il faut ajouter des chaînes vides à la place des noms de colonnes.

update_answer_coordinates (`bool`, *facultatif*, valeur 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 (sinon, elle sera ignorée).

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 afin d’être utilisé par les modèles TAPAS.

Ce tokenizer hérite de [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend), 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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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 par 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. 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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasTokenizer) effectue la tokenisation de bout en bout sur un tableau et les phrases associées : séparation de la ponctuation et wordpiece.

#### __appel__[[transformers.TapasTokenizer.__call__]]

```python
__call__(table: typing.Union[ForwardRef('pd.DataFrame'), str, list[str], NoneType], queries: str | list[str] | list[int] | list[list[str]] | list[list[int]] | None = None, answer_coordinates: list[tuple] | list[list[tuple]] | None = None, answer_text: list[str] | list[list[str]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.models.tapas.tokenization_tapas.TapasTruncationStrategy = False, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/tokenization_tapas.py#L518)

**Paramètres :**

table (`pd.DataFrame` ou `str` ou `list[str]`) : Table 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 une table vide (pour prendre en charge les tests génériques de tokenizers).

queries (`str` ou `list[str]`) : Question ou lot de questions relatives à 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 contenant 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 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 être le texte de réponse d'une coordonnée de réponse correspondante. Si un lot de paires table-question est fourni, answer_coordinates doit être une liste de listes de chaînes (chaque liste correspondant à une seule paire table-question).

add_special_tokens (`bool`, *facultatif*, valeur 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](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes :  - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec 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 bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes).

truncation (`bool`, `str` ou `TapasTruncationStrategy`, *facultatif*, valeur 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 admissible pour le modèle si cet argument n'est pas fourni. La troncature s'effectue 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 dont les longueurs de séquences dépassent la taille d'entrée maximale admissible par le modèle).

max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est 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/remplissage à une longueur maximale sera désactivée.

is_split_into_words (`bool`, *facultatif*, valeur 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 sur `True`, le tokenizer suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et procède à sa tokenisation. 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 (padding) 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](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de Numpy.

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[[transformers.TapasTokenizer.convert_logits_to_predictions]]

```python
convert_logits_to_predictions(data, logits, logits_agg = None, cell_classification_threshold = 0.5)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/tokenization_tapas.py#L1885)

**Paramètres :**

data (`dict`) : Dictionnaire associant les fonctionnalités à leurs valeurs réelles. Doit être créé à l'aide de [TapasTokenizer](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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` composé de divers éléments selon les entrées

- predicted_answer_coordinates (`list[list[[tuple]]` de longueur `batch_size`) : Coordonnées des réponses prédites, 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 exemple unique 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 prédits des opérateurs d'agrégation de la tête d'agrégation.

Convertit les logits de [TapasForQuestionAnswering](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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](https://github.com/google-research/tapas/blob/4908213eb4df7aa988573350278b44c4dbe3f71b/tapas/experiments/prediction_utils.py#L288).

#### save_vocabulary[[transformers.TapasTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/tokenization_tapas.py#L386)

## TapasModel[[transformers.TapasModel]]

#### transformers.TapasModel[[transformers.TapasModel]]

```python
transformers.TapasModel(config: TapasConfig, add_pooling_layer = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L510)

**Paramètres :**

config ([TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

add_pooling_layer (`bool`, *facultatif*, valeur 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](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.TapasModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L543)

**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](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez cette classe pour plus d'informations. [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Si `reset_position_index_per_cell` de [TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

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, par rapport à 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ée 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'appliquer l'attention aux 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 qui sont **masqués**.

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `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` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasConfig)) et les entrées.

La méthode forward de [TapasModel](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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)`.

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

Exemples :

```python
>>> from transformers import AutoTokenizer, TapasModel
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base")
>>> model = TapasModel.from_pretrained("google/tapas-base")

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

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

>>> last_hidden_states = outputs.last_hidden_state
```

## TapasForMaskedLM[[transformers.TapasForMaskedLM]]

#### transformers.TapasForMaskedLM[[transformers.TapasForMaskedLM]]

```python
transformers.TapasForMaskedLM(config: TapasConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L660)

**Paramètres :**

config ([TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.TapasForMaskedLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L684)

**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](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez cette classe pour plus d'informations. [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Si `reset_position_index_per_cell` de [TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

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, par rapport à 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ée 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'appliquer l'attention aux 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 qui sont **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. Voir `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` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** [MaskedLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) ou `tuple(torch.Tensor)`

Un [MaskedLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasConfig)) et des entrées.

La méthode forward de [TapasForMaskedLM](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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)`.

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

Exemples :

```python
>>> from transformers import AutoTokenizer, TapasForMaskedLM
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base")
>>> model = TapasForMaskedLM.from_pretrained("google/tapas-base")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)

>>> inputs = tokenizer(
...     table=table, queries="How many [MASK] has George [MASK] played in?", return_tensors="pt"
... )
>>> labels = tokenizer(
...     table=table, queries="How many movies has George Clooney played in?", return_tensors="pt"
... )["input_ids"]

>>> outputs = model(**inputs, labels=labels)
>>> logits = outputs.logits
```

## TapasForSequenceClassification[[transformers.TapasForSequenceClassification]]

#### transformers.TapasForSequenceClassification[[transformers.TapasForSequenceClassification]]

```python
transformers.TapasForSequenceClassification(config: TapasConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L1119)

**Paramètres :**

config ([TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.TapasForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L1131)

**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](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez cette classe pour plus d'informations. [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Si `reset_position_index_per_cell` de [TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

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, par rapport à 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. Voir `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` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** [SequenceClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou `tuple(torch.Tensor)`

Un [SequenceClassifierOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasConfig)) et les entrées.

La méthode forward de [TapasForSequenceClassification](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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)`.

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

Exemples :

```python
>>> from transformers import AutoTokenizer, TapasForSequenceClassification
>>> import torch
>>> import pandas as pd

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

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = [
...     "There is only one actor who is 45 years old",
...     "There are 3 actors which played in more than 60 movies",
... ]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> labels = torch.tensor([1, 0])  # 1 means entailed, 0 means refuted

>>> outputs = model(**inputs, labels=labels)
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]]

#### transformers.TapasForQuestionAnswering[[transformers.TapasForQuestionAnswering]]

```python
transformers.TapasForQuestionAnswering(config: TapasConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L781)

**Paramètres :**

config ([TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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 pour les tâches de question-réponse sur des tableaux (couches linéaires appliquées à la sortie des états cachés afin de calculer `logits` et, le cas échéant, `logits_aggregation`), par exemple pour les tâches supervisées SQA, WTQ ou WikiSQL.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.TapasForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, table_mask: typing.Optional[torch.LongTensor] = None, labels: typing.Optional[torch.LongTensor] = None, aggregation_labels: typing.Optional[torch.LongTensor] = None, float_answer: typing.Optional[torch.Tensor] = None, numeric_values: typing.Optional[torch.Tensor] = None, numeric_values_scale: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/tapas/modeling_tapas.py#L804)

**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](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez cette classe pour plus d'informations. [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Si `reset_position_index_per_cell` de [TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

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, par rapport à 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 apparaissant dans le tableau. Peut être obtenu à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.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 en nombre à virgule 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](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.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](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.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. Voir `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` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** [TableQuestionAnsweringOutput](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) ou `tuple(torch.Tensor)`

Un [TableQuestionAnsweringOutput](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([TapasConfig](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.TapasConfig)) et les entrées.

La méthode forward de [TapasForQuestionAnswering](/docs/transformers/v5.23.0/fr/model_doc/tapas#transformers.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, le cas échéant, de la perte de régression semi-supervisée et 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)`.

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

Exemples :

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

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

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

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

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

