Déclencher la révolution de l'IA - Un voyage avec RAG et LangChain

Cet article entraîne les lecteurs dans une exploration instructive du chemin parcouru par la révolution de l'IA transformative, en se plongeant dans l...

À l'ère de l'intelligence artificielle (IA), il est devenu essentiel pour les entreprises comme pour les particuliers de pouvoir extraire des connaissances utiles à partir de vastes ensembles de données. C'est là qu'intervient la génération augmentée de récupération (RAG), une percée qui a décuplé les capacités de l'IA, en permettant aux systèmes non seulement de générer du texte semblable au langage humain, mais également d'extraire des informations pertinentes en temps réel. Cette fusion produit des réponses au contexte riche et aux détails précis.

Alors que nous embarquons pour ce voyage passionnant à travers le vaste océan de l'intelligence artificielle (IA), il est essentiel de comprendre les trois piliers qui seront les étoiles pour nous guider : l'IA générative, les grands modèles de langage (LLM, Large Language Models), LangChain, Hugging Face et l'application utile sur cette RAG (génération augmentée de récupération).

Grands modèles de langage et IA générative: les moteurs de l'innovation

Au cœur de notre voyage se trouvent les grands modèles de langage (LLM) et l'IA générative, deux puissants moteurs faisant avancer le navire de l'innovation.

Grands modèles de langage (LLM)

Les LLM, tels que Qwen et GPT, entre autres, sont les titans en matière de texte, grâce à leur capacité à comprendre et à générer un langage semblable au langage humain à grande échelle. Ces modèles ont été entraînés à partir de vastes corpus de données textuelles, leur permettant de prédire et de produire des chaînes de texte cohérentes et contextuellement pertinentes. Ils sont la clé de voûte de nombreuses tâches de traitement du langage naturel, de la traduction à la création de contenu.

IA générative (GenAI)

L'IA générative est en quelque sorte l'assistant futé de la création dans le domaine de l'IA. Elle englobe des technologies qui génèrent de nouvelles instances de données ressemblant aux données d'entraînement, telles que des images, de la musique et, le plus important pour notre voyage, du texte. Dans notre contexte, l'IA générative fait référence à la capacité de l'IA à créer des réponses, des histoires ou des idées innovantes et informatives n'ayant jamais été vues auparavant. Elle permet à l'IA non seulement d'imiter le passé, mais aussi d'inventer, d'innover et d'inspirer.

LangChain : le chef d'orchestre de votre symphonie IA

LangChain joue le rôle d'architecte de notre flux de travail IA, concevant méticuleusement la structure qui permet une intégration et une interaction fluides entre divers composants de l'IA. Ce cadre simplifie le processus complexe de chaînage des flux de données à partir de sous-systèmes intelligents, y compris les LLM et les systèmes de récupération, rendant des tâches telles que l'extraction d'informations et la compréhension du langage naturel plus accessibles que jamais.

Hugging Face : la métropole du modèle d'IA

Hugging Face est une métropole animée où prospèrent les modèles d'IA. Ce hub central propose une vaste gamme de modèles préformés, offrant un terrain fertile pour l'exploration et l'application de l'apprentissage automatique. Pour accéder à ce hub et à ses ressources, vous devez créer un compte Hugging Face. Une fois que vous avez franchi cette étape, les portes d'un vaste monde d''IA s'ouvrent à vous. Il vous suffit de vous rendre sur Hugging Face pour vous inscrire et démarrer votre aventure.

RAG : l'exploitation des bases de données vectorielles pour une intelligence accélérée

La génération augmentée de récupération (RAG) est une technique d'IA sophistiquée qui allie la puissance inventive de l'IA générative à la précision de la récupération des connaissances, créant un système non seulement articulé mais aussi riche en informations. Pour libérer le plein potentiel et l'efficacité de la RAG, ce système intègre des bases de données vectorielles, qui sont un outil puissant pour passer rapidement au crible de vastes référentiels d'informations. Voici une explication détaillée du fonctionnement de la RAG avec les bases de données vectorielles:

Récupération avec Bases de données vectorielles : La RAG commence son processus en interrogeant une base de données vectorielle, qui abrite des représentations enchâssées d'un grand corpus d'informations. Ces enchâssements sont des vecteurs de grande dimension qui renferment l'essence sémantique des documents ou des extraits de données. Les bases de données vectorielles permettent à la RAG d'effectuer des recherches ultra-rapides dans ces enchâssements pour identifier le contenu le plus pertinent pour une requête donnée, un peu comme une IA naviguant rapidement dans une bibliothèque numérique pour trouver le bon livre.
Enrichissement avec contexte : Les informations pertinentes extraites de la base de données vectorielle sont ensuite fournies à un modèle génératif sous forme d'enrichissement contextuel. Cette étape dote l'IA d'une dose concentrée de connaissances, améliorant sa capacité à créer des réponses non seulement créatives mais aussi contextuellement riches et précises.
Génération de réponses éclairées : Armé de ce contexte, le modèle génératif procède à la production de texte. Contrairement aux modèles génératifs standard qui reposent uniquement sur des modèles appris, la RAG intègre les spécificités des données récupérées, ce qui donne des résultats à la fois imaginatifs et étayés par les connaissances récupérées. La génération est donc améliorée, donnant des réponses plus précises, informatives et reflétant le vrai contexte.

L'intégration de bases de données vectorielles est la clé de l'efficacité de la RAG. Les méthodes traditionnelles de recherche de métadonnées peuvent être plus lentes et moins précises, mais les bases de données vectorielles facilitent la récupération quasi instantanée d'informations contextuellement pertinentes, même à partir d'ensembles de données extrêmement volumineux. Cette approche permet non seulement de gagner un temps précieux, mais garantit également que les réponses de l'IA sont fondées sur les informations les plus appropriées et les plus récentes disponibles.

Les prouesses de la RAG sont particulièrement avantageuses dans des applications telles que les chatbots, les assistants numériques et les outils de recherche sophistiqués, et partout où la production d'informations précises, fiables et fondées sur un contexte est cruciale. Il ne s'agit pas simplement d'élaborer des réponses convaincantes ; il s'agit de générer du contenu fermement basé sur des données vérifiables et des connaissances du monde réel.

Forts d'une compréhension enrichie de LangChain, de Hugging Face, des LLM, de GenAI et de la RAG améliorée par les bases de données vectorielles, nous sommes sur le point d'embarquer pour une aventure de programmation qui donnera vie à ces technologies. Le script Python dans lequel nous allons plonger représente la synergie de ces éléments, en montrant un système d'IA capable de répondre non seulement avec créativité et contexte, mais aussi avec une profondeur de compréhension autrefois considérée comme appartenant au domaine de la science-fiction. Préparez-vous à programmer et à découvrir le pouvoir transformatif de la RAG avec des bases de données vectorielles.

Commencez votre aventure de programmation

Avant de commencer : les éléments essentiels

Avant de nous lancer dans cette odyssée technologique, assurons-nous que vous soyez bien préparé :

Un serveur Linux performera mieux avec une carte GPU, car avouons-le, la vitesse est essentielle.
Python 3.6 ou supérieur, la baguette magique de tout programmeur.
pip ou Anaconda, vos gestionnaires de paquets pratiques et performants.
Si c'est avec une carte GPU, alors les pilotes NVIDIA, CUDA Toolkit et cuDNN, la sainte trinité de l'accélération GPU.

Vous avez tout ? Formidable ! Mettons la main à la pâte (au sens figuré, bien sûr).

Exécution du code

En gérant soigneusement vos dépendances Python, vous vous assurez que votre projet d'IA repose sur une base stable et fiable. Une fois les dépendances en place et l'environnement configuré correctement, vous êtes prêt à exécuter le script et à observer la puissance de la RAG et de LangChain à l'œuvre.

Maintenant, vous pouvez exécuter le script Python pour voir la RAG en action.

Plantage du décor : importation des bibliothèques et chargement des variables

Avant de pouvoir nous lancer dans notre exploration de l'IA avec le cadre LangChain et la bibliothèque Transformers de Hugging Face, il est essentiel d'établir un environnement sécurisé et bien configuré. Cette préparation implique l'importation des bibliothèques nécessaires et la gestion des informations sensibles, telles que les clés API, via des variables d'environnement.

from torch import cuda
from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_community.embeddings.huggingface import HuggingFaceEmbeddings
from transformers import AutoModelForCausalLM, AutoTokenizer
from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
from transformers import pipeline
from dotenv import load_dotenv

load_dotenv()

Lorsque vous travaillez avec des modèles d'IA de Hugging Face, vous avez souvent besoin d'accéder à l'API de Hugging Face, qui nécessite une clé API. Cette clé est votre identifiant unique lorsque vous envoyez des demandes aux services Hugging Face et elle vous permet de charger des modèles à utiliser dans vos applications.

Voici ce que vous devez faire pour configurer votre environnement en toute sécurité:

Obtenez votre clé API Hugging Face: Une fois que vous avez créé votre compte Hugging Face, vous pouvez trouver votre clé API dans les paramètres de votre compte, sous la section « Accès aux jetons » (Access Tokens).
Sécurisez votre clé API : Votre clé API est une information sensible qui doit rester privée. Plutôt que de la coder en dur dans vos scripts, vous devez utiliser des variables d'environnement.
Créez un fichier .env : Créez un fichier nommé .env. Ce fichier stockera vos variables d'environnement.
Ajoutez votre clé API au fichier .env : Ouvrez le fichier .env dans un éditeur de texte et ajoutez votre clé API de Hugging Face au format suivant:

HUGGINGFACE_API_KEY=votre_clé_api_ici

Remplacez votre_clé_api_ici par la clé API réelle que vous avez reçue de Hugging Face.

Définition du chemin et de la configuration du modèle

modelPath = "sentence-transformers/all-mpnet-base-v2"
device = 'cuda' if cuda.is_available() else 'cpu'
model_kwargs = {'device': device}

Ici, nous avons défini le chemin vers le modèle préformé qui sera utilisé pour les enchâssements. Nous configurons également le réglage du périphérique, en utilisant une carte GPU si disponible pour un calcul plus rapide, ou en utilisant le CPU par défaut.

Initialisation des enchâssements de Hugging Face et du magasin de vecteurs FAISS

embeddings = HuggingFaceEmbeddings(
    model_name=modelPath,
    model_kwargs=model_kwargs,
)

# Made up data, just for fun, but who knows in a future
vectorstore = FAISS.from_texts(
    ["Harrison worked at Alibaba Cloud"], embedding=embeddings
)

retriever = vectorstore.as_retriever()

Nous initialisons une instance d'enchâssements Hugging Face (HuggingFaceEmbeddings) avec le modèle et la configuration de notre choix. Ensuite, nous créons un magasin de vecteurs en utilisant FAISS, ce qui nous permet d'effectuer des recherches de similitude efficaces dans des espaces de grande dimension. Nous instancions également un récupérateur, qui récupérera des informations basées sur les enchâssements.

Configuration du modèle d'invite de chat

template = """Answer the question based only on the following context:
{context}
Question: {question}
"""

prompt = ChatPromptTemplate.from_template(template)

Ici, nous définissons un modèle d'invite de chat qui sera utilisé pour structurer l'interaction avec l'IA. Il comprend des espaces réservés pour le contexte et une question, qui seront remplis dynamiquement lors de l'exécution de la chaîne.

Préparation du tokenizer et du modèle de langage

Dans le monde de l'IA et du traitement du langage naturel, le tokenizer et le modèle de langage sont le duo dynamique qui transforme le texte en action concrète. Le tokenizer décompose le langage en éléments que le modèle peut comprendre, tandis que le modèle de langage prédit et génère un langage basé sur ces entrées. Au cours de notre voyage, nous allons utiliser les classes AutoTokenizer et AutoModelForCausalLM de Hugging Face pour tirer parti de ces capacités. Il est toutefois important de se rappeler qu'il n'y a pas de modèle universel lorsqu'il s'agit de choisir un modèle de langage.

Taille du modèle et ressources informatiques

La taille du modèle est un facteur primordial qu'il faut prendre en compte. Les modèles plus grands, comme Qwen-72B, disposent de plus de paramètres, ce qui signifie généralement qu'ils peuvent comprendre et générer un texte plus nuancé. Cependant, ils nécessitent également plus de puissance informatique. Si vous disposez de cartes GPU haut de gamme et d'une mémoire suffisante, vous pouvez opter pour ces modèles plus grands pour tirer le meilleur parti de leurs capacités.

D'un autre côté, les modèles plus petits, comme Qwen-1.8B, sont beaucoup plus gérables pour les environnements informatiques standard. Même ce petit modèle devrait pouvoir fonctionner sur l'IdO et les appareils mobiles. Bien qu'ils ne capturent peut-être pas les subtilités du langage aussi bien que leurs homologues plus grands, les petits modèles offrent tout de même d'excellentes performances et sont plus accessibles pour ceux qui n'ont pas de matériel spécialisé.

Modèles spécifiques à des tâches

La nature de votre tâche est un autre point à prendre en compte. Si vous construisez une IA conversationnelle, l'utilisation d'un modèle spécifique au chat, tel que Qwen-7B-Chat, peut donner de meilleurs résultats, car ces modèles sont affinés pour les dialogues et peuvent mieux gérer les nuances de la conversation que les modèles de base.

Coût de l'inférence

Les modèles plus grands exigent non seulement plus de votre matériel, mais peuvent également entraîner des coûts plus élevés si vous utilisez des services basés sur le cloud pour exécuter vos modèles. Chaque inférence nécessite du temps de traitement et des ressources, qui peuvent s'additionner si vous travaillez avec un modèle massif.

Série Qwen

Qwen-1.8B : Un modèle plus petit adapté aux tâches nécessitant moins de puissance informatique. Convient au prototypage et à l'exécution sur des machines sans GPU puissants.
Qwen-7B : Un modèle de taille moyenne qui offre un équilibre entre la performance et l'exigence informatique. Convient pour toute une gamme de tâches, y compris la génération de texte et la réponse à des questions.
Qwen-14B : Un modèle plus grand qui peut gérer des tâches plus complexes avec une plus grande nuance en matière de compréhension et de génération du langage.
Qwen-72B : Le plus grand modèle de la série, offrant des performances de pointe pour les applications d'IA avancées qui nécessitent une compréhension approfondie du langage.
Qwen-1.8B-Chat : Un modèle conversationnel conçu spécifiquement pour la création de chatbots et d'autres systèmes de dialogue.
Qwen-7B-Chat: Semblable à Qwen-1.8B-Chat, mais avec une capacité accrue pour gérer des dialogues plus complexes.
Qwen-14B-Chat : Un modèle conversationnel haut de gamme capable d'interactions de dialogue sophistiquées.
Qwen-72B-Chat: Le modèle de conversation le plus avancé de la série Qwen, offrant des performances exceptionnelles pour les applications de chat exigeantes.

Choix du modèle

Lorsque vous décidez du modèle à utiliser, évaluez les avantages d'un modèle plus grand par rapport aux ressources disponibles et aux exigences spécifiques de votre projet. Si vous débutez tout juste ou développez à plus petite échelle, un modèle plus petit pourrait être le meilleur choix. À mesure que vos besoins augmentent, ou si vous avez besoin de capacités plus grandes, envisagez de passer à un modèle plus grand.

N'oubliez pas que la série Qwen est en accès libre ; vous pouvez donc expérimenter différents modèles pour voir lequel correspond le mieux à votre projet. Voici à quoi pourrait ressembler la partie de sélection de modèle du script si vous décidiez d'utiliser un modèle différent:

# This can be changed to any of the Qwen models based on your needs and resources
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen-7B", trust_remote_code=True)
model_name_or_path = "Qwen/Qwen-7B"
model = AutoModelForCausalLM.from_pretrained(model_name_or_path,
                                             device_map="auto",
                                             trust_remote_code=True)

Nous chargeons un tokenizer et un modèle de langage causal à partir de Hugging Face avec les classes AutoTokenizer et AutoModelForCausalLM, respectivement. Ces composants sont essentiels pour traiter les entrées en langage naturel et générer des résultats.

Création du pipeline de génération de texte

Ce pipeline est conçu pour générer du texte à l'aide d'un modèle de langage et d'un tokenizer qui ont été précédemment chargés. Examinons les paramètres en détails pour comprendre leurs rôles dans le contrôle du comportement de la génération de texte :

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_new_tokens=8192,
    do_sample=True,
    temperature=0.7,
    top_p=0.95,
    top_k=40,
    repetition_penalty=1.1
)

hf = HuggingFacePipeline(pipeline=pipe)

Explication des paramètres dans le pipeline de génération de texte :

max_new_tokens (8192) : Ce paramètre spécifie le nombre maximum de jetons pouvant être générés en sortie. Les jetons peuvent être des mots, des caractères ou des sous-mots, selon le tokenizer.
do_sample (True) : Lorsqu'il est réglé sur True, ce paramètre permet un échantillonnage probabiliste à partir de la distribution des prochains jetons possibles générés par le modèle. Cela introduit du hasard et de la variété dans le texte généré. S'il est réglé sur False, le modèle choisira alors toujours le prochain jeton le plus probable, conduisant à des résultats déterministes et moins variés.
temperature (0.7) : Le paramètre de température contrôle le degré de hasard introduit dans le processus d'échantillonnage. Une valeur de température plus basse (plus proche de 0) rend le modèle plus confiant dans ses choix, ce qui se traduit par moins de résultats aléatoires, tandis qu'une valeur de température plus élevée (plus proche de 1) encourage des résultats plus aléatoires et plus variés.
top_p (0.95) : Ce paramètre contrôle l'échantillonnage par noyau, une technique qui ne considère que les jetons les plus probables avec une probabilité cumulative au-dessus du seuil top_p. Il aide à générer un texte à la fois diversifié et cohérent, évitant l'inclusion de jetons à très faible probabilité qui pourraient rendre le texte absurde.
top_k (40) : L'échantillonnage Top-k limite le pool d'échantillonnage aux k prochains jetons les plus probables. Cela affine encore davantage l'ensemble des jetons que le modèle prendra en compte pour générer le prochain morceau de texte, en veillant à ce que les résultats restent pertinents et cohérents.
repetition_penalty (1.1) : Ce paramètre dissuade le modèle de répéter les mêmes jetons ou phrases, en encourageant la génération d'un texte plus intéressant et diversifié. Une valeur supérieure à 1 pénalise, et donc réduit, la probabilité de jetons déjà apparus.

Après avoir mis en place le pipeline avec les paramètres souhaités, la prochaine ligne de code est comme suit :

hf = HuggingFacePipeline(pipeline=pipe)

Encapsule l'objet pipe dans un HuggingFacePipeline. Cette classe fait partie du cadre LangChain et permet au pipeline d'être intégré de manière fluide dans le flux de travail de LangChain pour la création d'applications d'IA. En encapsulant le pipeline, nous pouvons maintenant l'utiliser en conjonction avec d'autres composants de LangChain, tels que les récupérateurs et les analyseurs, pour créer des systèmes d'IA plus complexes.

La sélection minutieuse de ces paramètres vous permet d'affiner le comportement de la génération de texte en fonction des besoins spécifiques de votre application, que vous recherchiez des résultats plus créatifs et variés ou que vous visiez un texte toujours cohérent et ciblé.

Construction et exécution de la chaîne RAG

L'extrait de code ci-dessous représente un système RAG complet de bout en bout où la question initiale déclenche une recherche des informations pertinentes, qui sont ensuite utilisées pour améliorer le processus de génération, résultant en une réponse éclairée et contextuellement pertinente à la question d'entrée.

1. Construction de la chaîne:

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | hf
    | StrOutputParser()
)

Voici ce qui se passe dans cette partie du code :

Un récupérateur est utilisé pour récupérer les informations pertinentes en fonction de la requête. Le rôle du récupérateur est de parcourir un ensemble de données ou une collection de documents pour trouver les informations les plus pertinentes pour la question posée. Une base de données vectorielle est probablement utilisée, pour plus d'efficacité.
RunnablePassthrough() est un composant qui transmet simplement la question sans aucune modification. Cela suggère que la chaîne est conçue pour traiter directement la question, probablement telle qu'elle a été saisie par un utilisateur.
L'_invite_ (prompt) n'est pas montrée en détail ici, mais elle sert probablement de modèle ou d'ensemble d'instructions qui formate la question d'entrée et le contexte récupéré d'une manière adaptée à l'étape suivante du pipeline, qui est le modèle Hugging Face.
La hf variable représente le pipeline Hugging Face, qui est vraisemblablement un modèle de langage préformé capable de générer des réponses. Ce pipeline prendra l'entrée formatée de l'étape précédente et utilisera ses capacités génératives pour produire une réponse.
Ce StrOutputParser() est un analyseur de sortie dont la tâche consiste à prendre la sortie brute du pipeline Hugging Face et à la décomposer en un format plus facile d'utilisation, probablement une chaîne.

L'utilisation de l'opérateur | (pipe) suggère que ce code utilise un style de programmation fonctionnel, spécifiquement le concept de composition en fonction ou un modèle de pipeline où la sortie d'une fonction devient l'entrée de la suivante.

2. Invocation de la chaîne:

results = chain.invoke("Where did Harrison work?")

Dans cette ligne, la chaîne est invoquée avec une question spécifique :_"Where did Harrison work?"_ Cette invocation déclenche toute la séquence d'opérations définie dans la chaîne. Le récupérateur recherche les informations pertinentes, qui sont ensuite transmises avec la question via l'invite et dans le modèle Hugging Face. Le modèle génère une réponse basée sur les entrées qu'il reçoit.

3. Affichage des résultats :

print(results)

La réponse générée est ensuite analysée par le StrOutputParser() et renvoyée comme résultat final, qui est ensuite copié sur la console ou une autre sortie.

Enfin, nous construisons la chaîne RAG en reliant le récupérateur, le modèle d'invite, le pipeline Hugging Face et l'analyseur de sortie. Nous invoquons la chaîne avec notre question, et les résultats sont affichés.

Conclusion : votre portail vers la maîtrise de l'IA

Vous venez de faire un pas de géant dans le monde de l'IA avec la RAG et LangChain. En comprenant et en exécutant ce code, vous débloquez le potentiel de créer des systèmes intelligents capables de raisonner et d'interagir avec les informations d'une manière sans précédent.

Cet article a été initialement rédigé en anglais. Consultez l'article original ici.

Community