L’une des compétences fascinantes des LLM (Large Language Models) est leur capacité à extraire des données. Un exemple simple d’extraction de données par ChatGPT pourrait être une demande de conversion d’unités de mesure. Voici un scénario simple :
- Utilisateur : “Peux-tu convertir 5 miles en kilomètres ?”
- ChatGPT : “Bien sûr ! 5 miles équivaut à environ 8,05 kilomètres.”
Dans cet exemple, ChatGPT a extrait l’information pertinente (la conversion de miles en kilomètres) à partir de la question de l’utilisateur et a fourni une réponse précise. L’extraction de données peut être utilisée pour répondre à une variété de questions et de demandes d’informations de manière précise et contextuelle.
Aujourd’hui, nous allons explorer un scénario bien plus complexe : l’analyse d’un Curriculum Vitae en vue d’en extraire les informations les plus pertinentes pour une utilisation ultérieure. Dans cet article, je vais vous montrer comment nous pouvons obtenir rapidement des résultats exploitables, tout en abordant les limitations de cette méthode.
Comment extraire la liste des expériences d’un curiculum vitae grâce à un LLM?
Pour effectuer cette tâche d’extraction, nous allons utiliser Langchain, une boîte à outils open source qui nous permettra de communiquer avec le LLM en lui donnant des instructions claires.
Comment fonctionne Langchain ?
Développé en Python, Langchain offre un niveau d’abstraction profond des interactions possible avec un LLM ce qui nous dispense de nous préoccuper des détails techniques qui compliqueraient généralement ce type de travail. Dans Langchain, nous avons ce que l’on appelle une “chaîne”(chain), qui, dans le contexte de ce framework, représente une séquence d’appels au LLM.
Pour simplifier, un modèle de langage est comme un robot en attente d’instructions, et nous lui fournissons ces instructions à travers des “chaînes” (chains). Nous pouvons également permettre au LLM de se souvenir des conversations précédentes grâce à la “mémoire” (memory). De plus, nous pouvons lui fournir des “outils” (tools) et lui laisser le choix d’utiliser les plus pertinents en fonction des instructions données. Les “chaînes”, les “agents”, la “mémoire” et les “outils” sont des interfaces fournies par Langchain qui nous aideront à accomplir notre tâche.
Maintenant que vous avez un aperçu de ce qu’est Langchain, nous allons l’utiliser pour extraire les informations nécessaires. Notre architecture sera simple. Nous enverrons successivement une liste d’instructions à un “agent”. Dans notre contexte, un “agent” est une interface composée d’un LLM et d’un modèle de prompt. Il produira en sortie un résultat conforme aux instructions que nous lui fournirons, en spécifiant également le format attendu pour les résultats. Voici à quoi ressemblera notre “agent” :
# /career_coach.py
# les imports
from langchain.chains.llm import LLMChain
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI
class CareerCoach:
def __init__(self, instructions: str, output_parser=None) -> None:
self.instructions = instructions
self.output_parser = output_parser
format_instructions = (
self.output_parser.get_format_instructions() if output_parser else ""
)
prompt = PromptTemplate.from_template(
instructions, partial_variables={"format_instructions": format_instructions}
)
self.chain = LLMChain(
llm=ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo-16k"), prompt=prompt
)
def proceed(self, docs):
return self.chain.run(docs)
Il convient de noter que :
- La classe d’agent CareerCoach prend en entrée un texte d’instructions ainsi qu’une éventuelle spécification du format de sortie souhaité.
- Si un format de sortie est spécifié, nous veillerons à l’ajouter à la liste d’instructions.
- Nous créerons un modèle de prompt auquel nous intégrerons les instructions.
- Nous instancierons une chaîne en utilisant le modèle de LLM “gpt-3.5-turbo-16k” dans notre cas, que nous passerons ensuite au prompt.
- Enfin, nous attribuerons une action “proceed” à notre “agent”.
Comment produire un format de sortie exploitable immédiatement par le code?
Nous sommes donc prêts à automatiser l’extraction de données à partir de notre curiculum vitae. Un aspect crucial que nous n’avons fait qu’effleurer jusqu’à présent est le format de sortie.
En effet, ce qui est essentiel pour nous ici, c’est non seulement d’extraire les informations souhaitées du CV, mais aussi de les produire dans un format directement exploitable par notre code. C’est seulement de cette manière que nous pouvons réellement parler d’automatisation. Idéalement, nous souhaitons être en mesure de fournir une liste d’expériences, chaque expérience étant définie par son titre, ses dates de début et de fin, ses références, son industrie, etc.
Langchain simplifie considérablement la structuration des données en tirant parti de Pydantic, une bibliothèque largement adoptée pour la validation des données dans l’écosystème Python. Voici la classe Pydantic qui définit une “expérience”:
from typing import List, Optional
from datetime import date
from pydantic import BaseModel, Field, validator
class Experience(BaseModel):
job_title: Optional[str] = Field(description="the job title or name")
company_name: Optional[str] = Field(description="the company name")
location: Optional[str] = Field(description="the company location")
start_date: Optional[str] = Field(description="Start date of the job")
end_date: Optional[str] = Field(
description="End date of the job (nullable for ongoing jobs)"
)
description: Optional[str] = Field(description="Job description")
skills: Optional[str] = Field(description="Skills used or gained in the role")
references: Optional[str] = Field(description="references or contact information")
order_or_priority: Optional[str] = Field(description="Order or priority of the job")
is_current_job: bool = Field(description="Indicates if it's the current job")
type_of_employment: Optional[str] = Field(
description="Type of employment (e.g., full-time)"
)
salary_or_compensation: Optional[str] = Field(description="Salary or compensation")
supervisor_manager: Optional[str] = Field(
description="Supervisor or manager's name"
)
company_website: Optional[str] = Field(description="Company's website")
industry: Optional[str] = Field(description="Industry or sector")
achievements: Optional[str] = Field(description="Notable achievements")
responsibilities: Optional[str] = Field(description="Detailed responsibilities")
@validator("*", pre=True, always=True)
def set_to_none_if_na(cls, value):
# If the value is 'NA', set it to None
if value == "N/A":
return None
return value
@validator("end_date", pre=True, always=True)
def parse_end_date(cls, value):
if isinstance(value, Optional[str]):
# Attempt to parse the Optional[str] ing into a date format
try:
return date.fromisoformat(value)
except ValueError:
# Handle parsing error by returning None (or raising an error)
return None
return value
@validator("start_date", pre=True, always=True)
def parse_start_date(cls, value):
if isinstance(value, Optional[str]):
# Attempt to parse the Optional[str] ing into a date format
try:
return date.fromisoformat(value)
except ValueError:
# Handle parsing error by returning None (or raising an error)
return None
return value
class Experiences(BaseModel):
experiences: List[Experience]
Dans cette section, nous allons accomplir plusieurs tâches :
- Nous allons définir chaque champ attendu et son type. Nous préciserons également s’il est requis ou facultatif.
- Dans la description, nous expliquerons la signification de chaque champ pour les données extraites.
- Nous aurons la possibilité d’appliquer des validations à chaque champ. Par exemple, le premier validateur stipule que si nous recevons la valeur “N/A” pour un champ, nous la remplacerons par “None”.
Ce modèle Experience servira donc de modèle de sortie pour les expériences extraites du CV.
La prochaine étape consiste donc à créer une fonction qui va définir les intructions et les passer à l’agent.
from langchain.output_parsers import PydanticOutputParser
from app.agents.schemas.Experience import Experiences
from app.agents.career_coach import CareerCoach
def extract_experiences(resume):
instructions = """ You are a Resume specialist. Your area of expertise revolves around analyzing a resume in order to extract any relevant informations about all job experience it contains.
You excel in extracting experience information from a resume.
Here are the informations you want to extract :
Job Title: [Extracted Job Title]
Company Name: [Extracted Company Name]
Location: [Extracted Location]
Start Date: [Extracted Start Date]
End Date: [Extracted End Date]
Description: [Extracted Job Description]
Skills: [Extracted Skills]
References: [Extracted References]
Order or Priority: [Extracted Order or Priority]
Current Job: [Extracted Current Job Status]
Type of Employment: [Extracted Employment Type]
Salary or Compensation: [Extracted Salary/Compensation]
Supervisor or Manager: [Extracted Supervisor/Manager]
Company Website: [Extracted Company Website]
Industry: [Extracted Industry/Sector]
Achievements: [Extracted Achievements]
Responsibilities: [Extracted Responsibilities]
If you can't find a specific informations to extract just dont do it.
Return a list of Experience when finish.
n{format_instructions}
{resume}
"""
output_parser = PydanticOutputParser(pydantic_object=Experiences)
coach = CareerCoach(instructions=instructions, output_parser=output_parser)
response = coach.proceed(docs=resume)
return output_parser.parse(response)
Dans cette étape, nous allons :
- Importer le modèle Experiences que nous avons créé précédemment à l’aide de pydantic.
- Créer une fonction qui prendra en entrée un CV et renverra en sortie une liste d’expériences.
Dans cette fonction, nous allons : - Écrire les instructions qui indiqueront au LLM ce qu’il doit faire et comment le faire.
- Préparer le format de sortie souhaité.
- Instancier un agent en lui fournissant les instructions et le format de sortie.
- Ordonner à l’agent de procéder à l’extraction et de nous renvoyer le résultat.
Comment exploiter le résultat obtenu grâce à notre code?
Maintenant que nous avons créé notre fonction python extract_experiences(cv) et que nous lui fournissons le contenu d’un CV en entrée, nous pouvons nous attendre à un résultat similaire :
[
Experience(
job_title="Lead Developer",
company_name="Tech Innovators",
location="San Francisco, CA",
start_date=None,
end_date=None,
description="En tant que Lead Developer chez Tech Innovators, j'ai dirigé une équipe de développeurs dans la création de solutions logicielles innovantes. J'ai géré l'ensemble du cycle de développement, de la conception au déploiement. J'ai collaboré avec des équipes pluridisciplinaires pour atteindre les objectifs du projet. J'ai mis en œuvre des méthodologies agiles pour une gestion de projet efficace. J'ai développé et maintenu des applications web complexes en utilisant des technologies de pointe.",
skills="Gestion de Projet Agile, Développement Full-Stack, Leadership d'Équipe, Méthodologies Agiles, Développement d'Applications Web",
references="John Smith (CTO), jsmith@email.com",
order_or_priority="",
is_current_job=False,
type_of_employment="Temps Plein",
salary_or_compensation="USD 120,000 par an",
supervisor_manager="",
company_website="",
industry="",
achievements="Mise en place réussie de méthodologies agiles, entraînant une augmentation de 20% de l'efficacité des projets. Livraison ponctuelle et dans les limites du budget de 15 applications web.",
responsibilities="Direction d'une équipe de 8 développeurs. Gestion des calendriers de projet. Collaboration avec les chefs de produit. Conception et mise en œuvre d'applications web.",
),
Experience(
job_title="Marketing Coordinator",
company_name="Global Marketing Solutions",
location="New York, NY",
start_date=None,
end_date=None,
description="En tant que Coordinateur Marketing chez Global Marketing Solutions, j'ai coordonné des campagnes marketing pour des clients de diverses industries. J'ai participé à la recherche et à l'analyse de marché. J'ai créé des supports marketing et réalisé des présentations clients. J'ai géré les comptes de médias sociaux et analysé les performances. J'ai collaboré avec une équipe diversifiée pour élaborer des stratégies marketing réussies.",
skills="Stratégie Marketing, Recherche de Marché, Relations Client, Gestion des Médias Sociaux, Analyse de Données",
references="Sarah Johnson (Marketing Manager), sjohnson@email.com",
order_or_priority="",
is_current_job=False,
type_of_employment="Temps Plein",
salary_or_compensation="USD 50,000 par an",
supervisor_manager="",
company_website="",
industry="",
achievements="Développement et exécution de campagnes marketing réussies pour 10 clients, entraînant une augmentation de 15% de l'engagement client. Analyse des tendances du marché et fourniture d'informations précieuses aux clients.",
responsibilities="Assistance à la recherche de marché. Création de supports marketing. Gestion des comptes de médias sociaux. Réalisation de présentations clients. Collaboration avec des équipes pluridisciplinaires.",
),
]
Vous pouvez observer que le résultat est clair et compréhensible. Il est possible de souhaiter enregistrer chaque expérience dans une base de données, par exemple, ou d’extraire le nombre total d’années de travail de cette personne. Vous l’aurez compris, les possibilités sont infinies. Vous pouvez dans la même logique extraire les formations contenues dans le CV.
Le véritable avantage ici réside dans l’utilisation d’un LLM. Il nous permet de traiter des CV dans n’importe quelle langue, et le LLM sera en mesure d’extraire les données requises si elles se trouvent dans le document. En affinant les instructions, nous pouvons obtenir d’excellents résultats.
Néamoins, il faut rester prudent sur l’utilisation de ce genre de méthode en production.
Quelles sont les limites des LLMs actuellement en ce qui concerne l’extraction de données?
Pour notre test, nous avons utilisé un CV bien structuré et détaillé. Le LLM n’a rencontré que peu de difficultés pour extraire les données. Cependant, dans un environnement de production, il est actuellement difficile de se fier entièrement aux LLMs pour ce type de tâche. Ils ont parfois tendance à fournir des informations incorrectes pour combler les lacunes, ce qui peut rendre les résultats peu fiables. Heureusement, il existe déjà des outils pour résoudre ce genre de problème, notamment les rappels (callbacks) de Langchain. Ces rappels permettent de définir des points d’accroche à différentes étapes de l’exécution des tâches par les LLMs. Ils peuvent être utilisés pour évaluer les résultats obtenus et les corriger si nécessaire.
Comme vous avez pu le constater, il est relativement simple d’utiliser les LLMs pour extraire les données d’un document et les formater selon nos besoins. Cependant, il est essentiel de noter que, pour l’instant, les LLMs ne sont pas des outils à utiliser sans précaution. Il est crucial de prendre en compte la fiabilité des données extraites avant de les envisager pour une utilisation en production.
Que pensez-vous des LLMs ? Nous vous encourageons à partager vos opinions et commentaires ci-dessous.
