Recherche de site Web

Résolution des questions-réponses sur les données tabulaires : une comparaison

Introduction

Cet article couvre une étude détaillée sur la résolution du problème de la réponse aux questions en langage naturel sur des données tabulaires. Nous couvrirons quelques approches qui utilisent l'apprentissage profond et approfondirons l'architecture et les ensembles de données utilisés, et comparerons leurs performances en utilisant des métriques d'évaluation appropriées.

Répondre à des questions sur des données tabulaires est un problème de recherche en PNL avec de nombreuses approches pour parvenir à une solution. Certaines impliquent une méthode heuristique pour décomposer l'entrée en langage naturel et la traduire afin qu'elle soit compréhensible par les langages de requête structurés, tandis que d'autres impliquent l'entraînement de modèles d'apprentissage profond.

Une bonne solution couvrirait les éléments suivants :

  • Comprendre les relations entre les colonnes et les valeurs
  • Avoir une bonne compréhension sémantique de la requête en langage naturel
  • Préserver l'efficacité en matière de performance, de mémoire et d'interprétabilité inter-domaines

C'est ce que nous allons essayer d'accomplir dans ce tutoriel. Nous couvrirons également les points suivants :

  • Comprendre les données tabulaires en utilisant des méthodes heuristiques
  • Outils assistés par IA vs modèles pré-entraînés
  • TableQA : un outil assisté par IA pour répondre aux questions sur les données tabulaires
  • Jeux de données populaires pour les modèles pré-entraînés
  • TAPAS
  • Choisir la meilleure solution
  • Conclusion

Prérequis

  • Compréhension de base du TALN : Familiarité avec les concepts de traitement du langage naturel, y compris les systèmes de questions-réponses, la tokenisation et les embeddings.

  • Connaissance des modèles d'apprentissage automatique : Compréhension des modèles d'apprentissage automatique courants tels que les arbres de décision, les forêts aléatoires et les réseaux de neurones, en particulier dans le contexte des données structurées.

  • Familiarité avec les frameworks de Deep Learning : Expérience avec des frameworks de deep learning tels que PyTorch ou TensorFlow pour comprendre comment les modèles sont implémentés et ajustés.

  • Expérience avec les données tabulaires : Maîtrise du travail avec des données tabulaires, y compris la manipulation et l'analyse des données à l'aide d'outils comme pandas en Python.

  • Statistiques et probabilités de base : Une compréhension fondamentale des statistiques et des probabilités pour interpréter les mesures de performance des modèles et les résultats d'évaluation.

Comprendre les données tabulaires en utilisant des méthodes heuristiques

Les données tabulaires sont des données structurées en lignes et en colonnes. Étant donné que les données peuvent être volumineuses, il n’est pas facile d’extraire manuellement la réponse à une requête particulière d’un utilisateur, étant donné une condition ou un ensemble de conditions. Les données tabulaires peuvent également se trouver dans des bases de données relationnelles.

Alors que les requêtes en Structured Query Language (SQL) sont souvent utilisées pour extraire des informations particulières d'une base de données, la connaissance des requêtes SQL par un individu peut être limitée. Une solution plus universelle consiste à interroger les données tabulaires en utilisant le langage naturel.

LN2SQL est une approche qui utilise des méthodes heuristiques pour convertir le langage naturel en requêtes SQL. Un ensemble d'analyseurs est utilisé pour décomposer la construction du langage naturel en ses composants SQL respectifs. Un thésaurus est utilisé pour améliorer le filtrage des mots-clés afin de faciliter la traduction d'entités spécifiques comme les noms de colonnes, les mots-clés SQL, etc. La sortie SQL serait ensuite interrogée pour obtenir les résultats.

Outils assistés par IA vs Modèles pré-entraînés

Les réseaux neuronaux aident à comprendre les données tabulaires de plusieurs manières. Un modèle pré-entraîné, par exemple, peut prédire le schéma qui relie la structure complexe d'une requête en langage naturel aux données tabulaires en les intégrant et en les faisant passer à travers le modèle de réseau neuronal.

D'autres solutions ne sont pas pré-entraînées sur des jeux de données contenant des informations tabulaires, mais utilisent l'IA et certaines heuristiques pour parvenir à la solution. Celles-ci sont connues sous le nom d'outils assistés par l'IA. Nous examinerons un tel outil ci-dessous.

TableQA : un outil assisté par IA pour répondre aux questions sur les données tabulaires

Comme nous l'avons vu plus tôt, une méthode pour décomposer le langage naturel en composants plus petits consiste à les convertir en requêtes SQL. Une requête SQL est construite à partir de plusieurs déclarations composants qui incluent des conditions, des opérations d'agrégation, etc.

TableQA convertit des requêtes en langage naturel en requêtes SQL de cette manière. Voyons une démonstration sur la façon d'utiliser cet outil pour interroger les données sur les décès par cancer obtenues à partir de la plateforme ouverte d'Abu Dhabi.

Tout d'abord, installez le paquet et les dépendances. Installez le module via pip :

!pip install tableqa

Ensuite, nous accéderons aux données d'exemple depuis le dépôt.

!git clone https://github.com/abhijithneilabraham/tableQA/

%cd tableQA/tableqa/

Et maintenant nous allons jeter notre premier regard sur les données.

import pandas as pd

df = pd.read_csv("cleaned_data/Cancer Death - Data.csv")
# A first look at data
df.head()

Données sur les décès par cancer

Vous pouvez voir que le fichier que nous essayons de consulter est un fichier CSV (valeurs séparées par des virgules) avec des colonnes telles que Année, Nationalité, Sexe, Site du cancer, Nombre de décès et âge. Essayons de répondre à quelques questions à partir de ce jeu de données.

from tableqa.agent import Agent

agent = Agent(df)

#Ask a question
agent.query_db("how many deaths of age below 40 had stomach cancer?")
>>> [(24,)]

Nous pourrions également jeter un œil à la requête SQL associée à cela.

agent.get_query("how many deaths of age below 40 had stomach cancer?")
>>> SELECT COUNT(death_count) FROM dataframe WHERE age  < 40 AND cancer_site = "Stomach"

Comme vous pouvez le voir ici, une opération COUNT est effectuée sur la colonne Death Count avec des conditions telles que age<40 et Cancer Site="Stomach".

TableQA utilise une combinaison d'extracteur d'entités activé par l'apprentissage profond et de classificateur de clauses agrégées pour construire la requête SQL. L'extracteur d'entités correspond aux conditions en associant les colonnes à leurs valeurs respectives s'il y en a dans la question. Il utilise un modèle de réponse aux questions pré-entraîné sur SQUAD pour aider à localiser facilement la valeur de la colonne à partir de la question saisie.

Le classificateur de clauses agrégées est un modèle d'apprentissage profond à deux couches qui aide à classer la nature de la question d'entrée dans l'une des catégories suivantes :

  • SÉLECTIONNER
  • COMPTER
  • MAXIMUM
  • MINIMUM
  • MOYEN
  • SOMME

Combiner l'extraction d'entités et la classification de clauses à l'aide de quelques heuristiques générera une requête SQL qui sera ensuite utilisée pour interroger les données. Un avantage possible de cette approche est qu'aucune ré-formation n'est nécessaire pour ajouter toute nouvelle fonctionnalité - certaines corrections personnalisées pourraient être effectuées en modifiant le code, en remplaçant les modèles d'IA à l'intérieur par des modèles plus précis, etc.

Jeux de données populaires pour les modèles pré-entraînés

Les solutions qui utilisent des heuristiques ont leurs propres limites. L'augmentation de la complexité des questions n'est pas facile à gérer avec une programmation explicite.

Par exemple, nous devons être capables de répondre à des questions qui nécessitent plusieurs étapes et qui ne sont pas triviales, comme : « Qui a terminé premier dans le championnat de F1 de cette année ? » ou « Quel est le moyen de transport le moins cher qui part demain matin ? »

Un modèle pré-entraîné avec un ensemble de données contenant de telles questions peut être utilisé dans des cas où une inférence de type humain est requise.

Le WikiTableQuestions (WTQ) est un ensemble de données qui consiste en des questions complexes accompagnées d'une table provenant de Wikipedia. L'ensemble de données contient 2108 tables provenant d'une grande variété de sujets (pour couvrir davantage de connaissances dans différents domaines) et 22033 questions de complexité différente.

Microsoft a mis à disposition un ensemble de données de questions séquentielles, également connu sous le nom de [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253). La tâche de répondre à des séquences de questions se fait sur des tableaux HTML. SQA a été créé en décomposant 2 022 questions provenant de WikiTableQuestions (WTQ). Chaque question WTQ a été décomposée en trois, ce qui a donné un ensemble de données de 6 066 séquences contenant au total 17 553 questions. Chacune de ces questions était également associée à des réponses sous forme d'emplacements de cellules dans les tableaux.

Un autre jeu de données populaire pour cette tâche est WikiSQL, un jeu de données de 80 654 paires question-requête SQL annotées par des humains, distribuées sur 24 241 tables tirées de Wikipédia. Contrairement aux autres jeux de données mentionnés ci-dessus, WikiSQL contient des requêtes SQL mappées à partir de questions avec des composants annotés.

TAPAS : Analyse de tableaux faiblement supervisée via la pré-formation

En 2020, Google Research a rendu open source un modèle d'apprentissage profond populaire pour interroger des données tabulaires sans générer de formes logiques appelé TAPAS. Il étend l'approche de Modélisation du Langage Masqué (MLM) aux données structurées.

Comme BERT, TAPAS utilise des fonctionnalités qui doivent encoder l'entrée tabulaire. Il initialise ensuite un pré-entraînement conjoint des séquences de texte et des tableaux entraînés de bout en bout et est capable de restaurer avec succès les mots et cellules de tableau masqués. Il peut inférer à partir d'une requête en sélectionnant un sous-ensemble de cellules du tableau. Si disponible, des opérations d'agrégation sont également effectuées au-dessus de celles-ci. Divers ensembles de données ont été évalués en utilisant TAPAS, y compris WTQ, SQA et WIKISQL.

Regardons un exemple.

Tout d'abord, installez les exigences :

!pip install tapas-table-parsing

Copiez les fichiers du modèle du cloud vers notre machine :

!gsutil cp gs://tapas_models/2020_04_21/tapas_sqa_base.zip . && unzip tapas_sqa_base.zip

Nous allons créer une fonction predict() pour entrer le tableau en tant que dataframe :

import tensorflow.compat.v1 as tf
import os 
import shutil
import csv
import pandas as pd
import IPython

tf.get_logger().setLevel('ERROR')
from tapas.utils import tf_example_utils
from tapas.protos import interaction_pb2
from tapas.utils import number_annotation_utils
from tapas.scripts import prediction_utils

os.makedirs('results/sqa/tf_examples', exist_ok=True)
os.makedirs('results/sqa/model', exist_ok=True)
with open('results/sqa/model/checkpoint', 'w') as f:
  f.write('model_checkpoint_path: "model.ckpt-0"')
for suffix in ['.data-00000-of-00001', '.index', '.meta']:
  shutil.copyfile(f'tapas_sqa_base/model.ckpt{suffix}', f'results/sqa/model/model.ckpt-0{suffix}')
  
  
max_seq_length = 512
vocab_file = "tapas_sqa_base/vocab.txt"
config = tf_example_utils.ClassifierConversionConfig(
    vocab_file=vocab_file,
    max_seq_length=max_seq_length,
    max_column_id=max_seq_length,
    max_row_id=max_seq_length,
    strip_column_names=False,
    add_aggregation_candidates=False,
)
converter = tf_example_utils.ToClassifierTensorflowExample(config)

def convert_interactions_to_examples(tables_and_queries):
  """Calls Tapas converter to convert interaction to example."""
  for idx, (table, queries) in enumerate(tables_and_queries):
    interaction = interaction_pb2.Interaction()
    for position, query in enumerate(queries):
      question = interaction.questions.add()
      question.original_text = query
      question.id = f"{idx}-0_{position}"
    for header in table[0]:
      interaction.table.columns.add().text = header
    for line in table[1:]:
      row = interaction.table.rows.add()
      for cell in line:
        row.cells.add().text = cell
    number_annotation_utils.add_numeric_values(interaction)
    for i in range(len(interaction.questions)):
      try:
        yield converter.convert(interaction, i)
      except ValueError as e:
        print(f"Can't convert interaction: {interaction.id} error: {e}")
        
def write_tf_example(filename, examples):
  with tf.io.TFRecordWriter(filename) as writer:
    for example in examples:
      writer.write(example.SerializeToString())

def predict(table_data, queries):
  table=[list(table_data.columns)]+table_data.values.tolist()
  examples = convert_interactions_to_examples([(table, queries)])
  write_tf_example("results/sqa/tf_examples/test.tfrecord", examples)
  write_tf_example("results/sqa/tf_examples/random-split-1-dev.tfrecord", [])
  
  ! python -m tapas.run_task_main \
    --task="SQA" \
    --output_dir="results" \
    --noloop_predict \
    --test_batch_size={len(queries)} \
    --tapas_verbosity="ERROR" \
    --compression_type= \
    --init_checkpoint="tapas_sqa_base/model.ckpt" \
    --bert_config_file="tapas_sqa_base/bert_config.json" \
    --mode="predict" 2> error


  results_path = "results/sqa/model/test_sequence.tsv"
  all_coordinates = []
  df = pd.DataFrame(table[1:], columns=table[0])
  display(IPython.display.HTML(df.to_html(index=False)))
  print()
  with open(results_path) as csvfile:
    reader = csv.DictReader(csvfile, delimiter='\t')
    for row in reader:
      coordinates = prediction_utils.parse_coordinates(row["answer_coordinates"])
      all_coordinates.append(coordinates)
      answers = ', '.join([table[row + 1][col] for row, col in coordinates])
      position = int(row['position'])
      print(">", queries[position])
      print(answers)
  return all_coordinates

Maintenant, utilisons un tableau d'exemple et chargeons-le en tant que dataframe. Il se compose de colonnes contenant les noms des acteurs et le nombre de films dans lesquels ils ont joué.

data = {'Actors': ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], 'Number of movies': ["87", "53", "69"]}
queries = ["Who played less than 60 movies", "How many movies has George Clooney played in?"]
table = pd.DataFrame.from_dict(data)
result = predict(table, queries)

L'inférence du modèle à partir du tableau peut être vue ci-dessous :

> Who played less than 60 movies
Leonardo Di Caprio
> How many movies has George Clooney played in?
69

Cependant, il existe certaines limites lors de l'utilisation de TAPAS. Il gère des tables uniques comme contexte, pouvant tenir en mémoire. Cela le rend inadapté pour les grands ensembles de données ou plusieurs bases de données. De plus, les questions nécessitant plusieurs opérations d'agrégation ne sont pas possibles, telles que : « combien d'acteurs ont des films moyens supérieurs à 10 ? »

Choisir la meilleure solution

Une bonne solution à cette tâche dépend de divers facteurs et des préférences de l'utilisateur.

Les solutions non basées sur l'apprentissage profond qui utilisent des heuristiques sont les plus rapides, mais elles ont un coût en termes de mauvaise compréhension sémantique.

Un modèle d'apprentissage profond comme TAPAS peut aider à une compréhension sémantique complexe d'une question en langage naturel et de la structure du tableau, cependant il comporte des préoccupations concernant les problèmes de mémoire et les exigences informatiques coûteuses.

Une solution assistée par IA comme TableQA a un avantage dans l'utilisation des heuristiques, puisqu'elles peuvent être modifiées afin d'améliorer les performances de la solution dans la plupart des cas sans avoir à réentraîner le modèle d'apprentissage profond. Mais à mesure que le langage naturel devient plus complexe, davantage d'erreurs se produisent lors de la récupération des informations depuis le tableau.

Conclusion

Dans cet article, nous avons examiné diverses solutions pour la question-réponse sur les données tabulaires. Nous avons également vu différentes solutions utilisant des heuristiques et l'apprentissage profond pour analyser sémantiquement les informations combinées provenant des données tabulaires et de la question en langage naturel. Le choix de la meilleure solution se fait en considérant divers facteurs : la vitesse, la performance dans la compréhension du langage naturel et la mémoire.