Insight

Structuration des données à l'aide de l'intelligence artificielle

Publié le 24 août 2023

Titouan Launay

Co-founder

Paris, France

Les données non structurées telles que les chats ou les e-mails contiennent des informations précieuses qui peuvent être utilisées pour améliorer les processus commerciaux. Nous expliquons comment structurer ces données en utilisant les dernières technologies d'IA.

Introduction

Les données non structurées sont courantes dans le monde des affaires. On peut les trouver dans les e-mails, les chats, les documents et de nombreuses autres sources. Elles peuvent également être trouvées dans les médias d'information ou d'autres sources textuelles. Ces données ne sont souvent pas utilisées à leur plein potentiel, car il est difficile d'en extraire des informations. Certaines entreprises peuvent avoir recours à la main-d'œuvre humaine pour extraire des informations de ces données, mais cela est à la fois chronophage et sujet à des erreurs. Dans cet article, nous expliquerons comment vous pouvez exploiter les capacités de l'IA pour structurer ces données et en extraire des informations précieuses.

Convertir des données non structurées en un format facilement utilisable est une tâche complexe, mais elle peut être décomposée en trois étapes principales :

Préparation à la structuration : comprendre les données et définir la structure
Structuration : utiliser l'IA pour structurer les données
Travailler vers la production : comprendre si la solution est viable et, le cas échéant, comment aller plus loin

Préparation à la structuration

Pour le reste de cet article, nous supposerons que nous travaillons avec une simple conversation commerciale, où deux parties discutent d'accords conclus. L'objectif est d'extraire les informations de la conversation et de les stocker dans un format structuré.

Collecte de données

La première étape consiste à collecter des données. Cela peut généralement être fait en compilant une liste d'e-mails ou en exportant un historique de chat. Dans notre cas, nous utiliserons un historique de chat, qui contient des messages comme ceux-ci :

Hi John,
We confirm that we will buy 1000 shares of Apple at 100$ per share.
Have a good day,
Jane

Ou cela pourrait aussi être

Dear John,
The transaction is confirmed for 1000 shares of AAPL@100$.
Best regards

Faire des hypothèses

L'étape suivante consiste à faire des hypothèses sur les données. C'est une étape cruciale, car elle déterminera la structure des données. Dans notre cas, nous savons ce qui suit :

Les données sont au format chat
Les données concernent le trading
Les données concernent des accords conclus (NB : c'est une hypothèse, et cela peut ne pas être vrai, le chat pourrait également concerner un accord toujours en cours ou des bavardages)

Nous faisons également quelques hypothèses sur les informations contenues lorsqu'on parle d'accords conclus :

Le nombre d'actions, la société et le prix doivent toujours être présents.
Il devrait généralement y avoir un symbole monétaire (par exemple $, €, £, ¥, etc.) ou une information.
Il peut y avoir des informations sur l'acheteur, mais ce n'est pas toujours le cas ou cela pourrait être déduit de l'expéditeur du message.

Définir la structure

Sur la base des hypothèses que nous avons faites, nous pouvons définir la structure des données. Dans notre cas, nous définirons la structure suivante au format YAML :

trade:
  buyer: Nom de l'acheteur (facultatif)
  stock: Nom de l'action achetée
  currency: Code à trois lettres de la monnaie
  price: Prix de l'action (par action)
  quantity: Nombre d'actions, est un entier

Ou en anglais :

trade:
  buyer: Name of the buyer (optional)
  stock: Name of the bought stock
  currency: Three letter code of the currency
  price: Price of the stock (per share)
  quantity: Number of shares, is an integer

Voici le même modèle au format Pydantic, où nous avons ajouté quelques règles de validation. Cela sera utile plus tard. Pour installer Pydantic, exécutez pip install pydantic dans votre terminal ou autre gestionnaire de paquets.

from typing import Optional
from pydantic import BaseModel, Field, field_validator

class Trade(BaseModel):
  buyer: Optional[str] = Field(description="Name of the buyer (optional)")
  stock: str = Field(description="Name of the bought stock")
  currency: str = Field(description="Three letter code of the currency")
  price: float = Field(description="Price of the stock (per share)")
  quantity: int = Field(description="Number of shares, is an integer")

  @field_validator("currency")
  def currency_length(cls, v):
    if len(v) != 3:
      raise ValueError("Currency must be a three letter code")
    return v

Cette structure est simplifiée pour les besoins de l'exemple, mais elle pourrait être étendue pour inclure plus d'informations, telles que la date de la transaction, le vendeur, etc.

Structuration

Nous allons maintenant essayer d'utiliser l'IA pour structurer les données. Il existe de nombreuses façons de le faire, mais nous nous concentrerons sur une approche basée sur LLM, car elle est la plus flexible et peut être utilisée pour de nombreuses tâches différentes. Elle est également la plus facilement disponible et la moins chère à mettre en œuvre pour de petits ensembles de données.

Configuration de l'API OpenAI

Pour utiliser les LLM, nous utiliserons l'API d'OpenAI. OpenAI est une entreprise spécialisée dans la recherche en IA et a développé un LLM très puissant. Elle est disponible via une API, que nous utiliserons dans cet exemple.

Pour commencer, rendez-vous sur https://platform.openai.com/ et créez un nouveau compte. Ensuite, créez une nouvelle clé API et copiez-la dans un endroit sûr. Nous l'utiliserons plus tard.

Important : vous devrez également installer le package Python OpenAI. Vous pouvez le faire en exécutant pip install openai dans votre terminal ou autre gestionnaire de paquets.

Utilisation de Langchain

Les grands modèles de langage fonctionnent de manière similaire à la saisie semi-automatique, où ils essaient de prédire le mot suivant en fonction des mots précédents. Cela peut être utilisé pour générer du texte, mais étant donné que les modèles ont également été formés sur des données structurées telles que JSON ou XML, ils peuvent également être utilisés pour générer des données - quelque peu - structurées.

La nature même des LLM les empêche de générer de manière fiable des données structurées, car ils peuvent manquer certaines informations ou générer une syntaxe manifestement incorrecte. Cependant, il existe des outils, tels que Langchain, qui visent à résoudre ce problème, en orientant le LLM dans la bonne direction.

Une caractéristique majeure de Langchain est qu'il exploite également la capacité des LLM à corriger une syntaxe incorrecte. Cela signifie essentiellement que si la première tentative de génération de données structurées échoue, il demandera au LLM de se corriger, ce qui donne de très bons résultats.

Pour installer Langchain, exécutez pip install langchain dans votre terminal ou autre gestionnaire de paquets.

Pour notre exemple, une configuration de base utilisant l'API d'OpenAI et Langchain ressemblerait à ceci, ajoutée au code que nous avons écrit précédemment :

from langchain.output_parsers import PydanticOutputParser # Import the Pydantic output parser
from langchain.llms import OpenAI # Import the OpenAI LLM
from langchain.prompts import PromptTemplate # Import the prompt template
import os # Import the os module to set the environment API key
# ...


messages = [
  "Hi John,\nWe confirm that we will buy 1000 shares of Apple at 100$ per share.\nHave a good day,\nJane",
  "Dear John,\nThe transaction is confirmed for 1000 shares of AAPL@100$.\nBest regards",
] # Define the messages

os.environ['OPENAI_API_KEY'] = 'xxxxxxx' # Set the API key, replacing xxxxxxx with your API key.

model_name = "text-davinci-003" # Set the model name
temperature = 0.0 # Set the temperature. A higher temperature will yield more diverse results, but is not recommended for structured data. It can be seen as "freedom" given to the model to generate whatever it wants.
model = OpenAI(model_name=model_name, temperature=temperature)

parser = PydanticOutputParser(pydantic_object=Trade) # Create the output parser

prompt = PromptTemplate(
    template="If this message is about a closed deal, please fillin the information in the given format.\n{format_instructions}\n{message}\n",
    input_variables=["message"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
) # Create a prompt template

_input = prompt.format_prompt(message=messages[0])
# Feed the first message to the model

output = model(_input.to_string())
# Generate the output

structured_data = parser.parse(output)
# Parse the output

print(structured_data.model_dump_json())
# Print the structured data

L'exécution du fichier complet devrait donner la sortie suivante :

{
  "buyer": "John",
  "stock": "Apple",
  "currency": "USD",
  "price": 100,
  "quantity": 1000
}

L'essayer sur le second message est aussi simple que :

_input = prompt.format_prompt(message=messages[0])
_input = prompt.format_prompt(message=messages[1])

Cela donne également la même entrée, ce qui est correct.

Félicitations, vous avez structuré avec succès vos premiers messages !

Vous pouvez obtenir le code complet sur Replit :

NB: essayer le Replit ci-dessus ne fonctionnera pas, car vous devez fournir votre propre clé API.

Le few-shot learning à la rescousse

Comme vous pouvez le voir ci-dessus, le modèle a pu analyser correctement le premier message, sans aucune compréhension préalable des données ni de formation. En quelques minutes seulement, nous avons pu structurer un message qui aurait pris à un humain quelques minutes à analyser, en remplissant les informations dans un format structuré.

Cependant, les choses ne sont pas toujours aussi faciles. Le modèle a identifié John comme l'acheteur, ce que nous - compte tenu du contexte - pouvons inférer comme étant faux. L'acheteur est probablement Jane, car elle est celle qui envoie le message. C'est un problème courant avec les LLM, car ils ne sont pas capables de comprendre le contexte du message dans une conversation de chat.

Pour la plupart des erreurs d'analyse, nous pouvons tirer parti de la technique du few-shot learning (apprentissage en quelques exemples). Pour le dire simplement, le few-shot learning est une technique qui nous permet de former un modèle sur un petit ensemble de données, puis de l'utiliser pour effectuer une tâche, en lui donnant quelques indications ou exemples supplémentaires pour effectuer la tâche. L'idée est que le LLM sera capable de généraliser les quelques exemples que nous lui donnons pour effectuer la tâche.

Dans notre cas, nous pouvons utiliser le few-shot learning pour dire au modèle que l'acheteur est probablement l'expéditeur du message. Cela peut être fait en ajoutant quelques exemples au modèle d'invite, en ajoutant du contexte, ou en étant plus verbeux dans les descripteurs de champ. Ici, nous choisirons d'ajouter du contexte à la question posée au modèle.

prompt = PromptTemplate(
    template="If this message is about a closed deal, please fillin the information in the given format.\n{format_instructions}\n{message}\n",
    template="""
If this message is about a closed deal, please fillin the information in the given format.
Note that we are passing you chats, where the buyer is most likely the person who wrote the chat, and not the recipient. If the sender did not tell his name in the message, we can't tell who the buyer is.

{format_instructions}

{message}
""",
    input_variables=["message"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
)

Nous avons maintenant la sortie suivante pour le message 1 :

{
  "buyer": "Jane",
  "stock": "Apple",
  "currency": "USD",
  "price": 100,
  "quantity": 1000
}

Et la sortie suivante pour le message 2 :

{
  "buyer": null,
  "stock": "AAPL",
  "currency": "USD",
  "price": 100,
  "quantity": 1000
}

Ces sorties sont correctes, car l'acheteur n'est pas spécifié dans le second message.

Travailler vers la production

Bien que la solution ci-dessus donne de bons résultats, elle n'est pas prête pour la production. Il reste à vérifier que le modèle est capable de généraliser à d'autres messages, et qu'il est capable d'analyser des messages qui ne sont pas dans l'ensemble d'entraînement.

Il y a aussi d'autres éléments à prendre en compte, par exemple le fait que le nom de l'action a été fourni de différentes manières (AAPL, Apple, etc.). Cela peut être résolu en ajoutant plus d'exemples à l'ensemble d'entraînement, ou en ajoutant d'autres correcteurs en aval.

Surveillance

La clé d'une solution prête pour la production est la surveillance. Il est important de surveiller les performances du modèle et de comprendre quand il échoue. Cela peut être fait en enregistrant la sortie du modèle, puis en vérifiant manuellement la sortie pour voir si elle est correcte. Si ce n'est pas le cas, alors le modèle devrait être re-formé sur les nouvelles données.

Ce processus doit être mis à jour, car les données d'entrée peuvent évoluer avec le temps.

Fournisseurs d'IA pour les entreprises

Enfin, bien que la solution ci-dessus soit un bon point de départ, son utilisation sur des fournisseurs d'IA tiers pourrait ne pas être la meilleure solution pour votre entreprise. Bien qu'il existe des fournisseurs d'IA spécifiques pour les entreprises, tels qu'Azure ou AWS, vous voudrez peut-être franchir une étape supplémentaire pour déployer votre propre solution d'IA.

Lleed & Partners peut vous aider à déployer votre propre solution d'IA et à l'intégrer à votre infrastructure existante. Nous pouvons également vous aider à créer une solution personnalisée, adaptée à vos besoins.

Services liés

Nous contacter

Les experts de Lleed & Partners sont là pour vous aider dans le processus de digitalisation, de la stratégie à la mise en œuvre. Discutons de vos besoins actuels et de la façon dont nous pouvons vous aider à atteindre vos objectifs.

Nous contacter