Ingénierie rapide de zéro à avancée avec Langchain en Python

Un aspect important des grands modèles de langage (LLM) est le nombre de paramètres que ces modèles utilisent pour l'apprentissage. Plus un modèle a de paramètres, mieux il peut comprendre la relation entre les mots et les phrases. Cela signifie que les modèles avec des milliards de paramètres ont la capacité de générer divers formats de texte créatifs et de répondre à des questions ouvertes et stimulantes de manière informative.

Les LLM tels que ChatGPT, qui utilisent le modèle Transformer, sont compétents pour comprendre et générer le langage humain, ce qui les rend utiles pour les applications qui nécessitent une compréhension du langage naturel. Cependant, ils ne sont pas sans limites, notamment des connaissances obsolètes, une incapacité à interagir avec des systèmes externes, un manque de compréhension du contexte et parfois la génération de réponses plausibles mais incorrectes ou absurdes, entre autres.

Pour remédier à ces limitations, il faut intégrer les LLM à des sources et des capacités de données externes, ce qui peut présenter des complexités et exiger des compétences étendues en matière de codage et de traitement des données. Ceci, associé aux défis de la compréhension des concepts d'IA et des algorithmes complexes, contribue à la courbe d'apprentissage associée au développement d'applications utilisant des LLM.

Néanmoins, l'intégration des LLM avec d'autres outils pour former des applications alimentées par le LLM pourrait redéfinir notre paysage numérique. Le potentiel de ces applications est vaste, notamment l'amélioration de l'efficacité et de la productivité, la simplification des tâches, l'amélioration de la prise de décision et la fourniture d'expériences personnalisées.

Dans cet article, nous approfondirons ces questions, en explorant les techniques avancées d'ingénierie rapide avec Langchain, en offrant des explications claires, des exemples pratiques et des instructions étape par étape sur la façon de les mettre en œuvre.

Langchain, une bibliothèque de pointe, offre confort et flexibilité pour la conception, la mise en œuvre et le réglage des invites. En explorant les principes et les pratiques de l'ingénierie des invites, vous apprendrez à exploiter les puissantes fonctionnalités de Langchain pour exploiter les atouts des modèles d'IA générative SOTA comme GPT-4.

Comprendre les invites

Avant de plonger dans les détails techniques de l'ingénierie des invites, il est essentiel de comprendre le concept d'invites et leur signification.

UNE 'prompt ' est une séquence de jetons qui sont utilisés comme entrée dans un modèle de langage, lui demandant de générer un type particulier de réponse. Les invites jouent un rôle crucial dans le pilotage du comportement d'un modèle. Ils peuvent avoir un impact sur la qualité du texte généré et, lorsqu'ils sont correctement rédigés, ils peuvent aider le modèle à fournir des résultats pertinents, précis et spécifiques au contexte.

L'ingénierie des invites est l'art et la science de concevoir des invites efficaces. L'objectif est d'obtenir le résultat souhaité d'un modèle linguistique. En sélectionnant et en structurant soigneusement les invites, on peut guider le modèle vers des réponses plus précises et pertinentes. En pratique, cela implique d'affiner les phrases d'entrée pour tenir compte des biais d'apprentissage et structurels du modèle.

La sophistication de l'ingénierie des invites va de techniques simples, telles que l'alimentation du modèle avec des mots-clés pertinents, à des méthodes plus avancées impliquant la conception d'invites complexes et structurées qui utilisent la mécanique interne du modèle à son avantage.

Langchain : l'outil d'invite à la croissance la plus rapide

LangChain, lancé en octobre 2022 par Harrison Chase, est devenu l'un des frameworks open source les mieux notés sur GitHub en 2023. Il offre une interface simplifiée et standardisée pour l'intégration de Large Language Models (LLM) dans les applications. Il fournit également une interface riche en fonctionnalités pour une ingénierie rapide, permettant aux développeurs d'expérimenter différentes stratégies et d'évaluer leurs résultats. En utilisant Langchain, vous pouvez effectuer des tâches d'ingénierie rapides de manière plus efficace et intuitive.

LangFlow sert d'interface utilisateur pour orchestrer les composants LangChain dans un organigramme exécutable, permettant un prototypage et une expérimentation rapides.

LangChain comble une lacune cruciale dans le développement de l'IA pour les masses. Il permet à un éventail d'applications NLP telles que des assistants virtuels, des générateurs de contenu, des systèmes de questions-réponses, etc., de résoudre une gamme de problèmes du monde réel.

Plutôt que d'être un modèle ou un fournisseur autonome, LangChain simplifie l'interaction avec divers modèles, étendant les capacités des applications LLM au-delà des contraintes d'un simple appel API.

L'architecture de LangChain

Les principaux composants de LangChain incluent les E/S de modèle, les modèles d'invite, la mémoire, les agents et les chaînes.

Modèle E/S

LangChain facilite une connexion transparente avec divers modèles de langage en les enveloppant d'une interface standardisée appelée Model I/O. Cela facilite un changement de modèle sans effort pour une optimisation ou de meilleures performances. LangChain prend en charge divers fournisseurs de modèles de langage, notamment OpenAI, Étreindre, Azure, Feu d'artificeet plus encore.

Modèles d'invite

Ceux-ci sont utilisés pour gérer et optimiser les interactions avec les LLM en fournissant des instructions concises ou des exemples. L'optimisation des invites améliore les performances du modèle et leur flexibilité contribue de manière significative au processus de saisie.

Un exemple simple de modèle d'invite :

from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subject"],
template="What are the recent advancements in the field of {subject}?")
print(prompt.format(subject="Natural Language Processing"))

Au fur et à mesure que nous avançons dans la complexité, nous rencontrons des modèles plus sophistiqués dans LangChain, tels que le modèle Reason and Act (ReAct). ReAct est un modèle vital pour l'exécution d'une action où l'agent attribue une tâche à un outil approprié, personnalise l'entrée pour celle-ci et analyse sa sortie pour accomplir la tâche. L'exemple Python ci-dessous présente un modèle ReAct. Il montre comment une invite est structurée dans LangChain, en utilisant une série de pensées et d'actions pour raisonner sur un problème et produire une réponse finale :

PREFIX = """Answer the following question using the given tools:"""
FORMAT_INSTRUCTIONS = """Follow this format:
Question: {input_question}
Thought: your initial thought on the question
Action: your chosen action from [{tool_names}]
Action Input: your input for the action
Observation: the action's outcome"""
SUFFIX = """Start!
Question: {input}
Thought:{agent_scratchpad}"""

Mémoire

La mémoire est un concept essentiel dans LangChain, permettant aux LLM et aux outils de conserver les informations au fil du temps. Ce comportement avec état améliore les performances des applications LangChain en stockant les réponses précédentes, les interactions utilisateur, l'état de l'environnement et les objectifs de l'agent. Les stratégies ConversationBufferMemory et ConversationBufferWindowMemory permettent de suivre respectivement l'intégralité ou la partie récente d'une conversation. Pour une approche plus sophistiquée, la stratégie ConversationKGMemory permet d'encoder la conversation sous forme de graphe de connaissances pouvant être intégré dans des invites ou utilisé pour prédire des réponses sans appeler le LLM.

Agents

Un agent interagit avec le monde en effectuant des actions et des tâches. Dans LangChain, les agents combinent des outils et des chaînes pour l'exécution des tâches. Il peut établir une connexion avec le monde extérieur pour la récupération d'informations afin d'augmenter les connaissances LLM, surmontant ainsi leurs limites inhérentes. Ils peuvent décider de transmettre les calculs à une calculatrice ou à un interpréteur Python selon la situation.

Les agents sont équipés de sous-composants :

• Outils: Ce sont des composants fonctionnels.
• Toolkits: Collections d'outils.
• Agents exécutants: C'est le mécanisme d'exécution qui permet de choisir entre les outils.

Les agents de LangChain suivent également le modèle ReAct Zero-shot, où la décision repose uniquement sur la description de l'outil. Ce mécanisme peut être étendu avec de la mémoire afin de prendre en compte l'historique complet des conversations. Avec ReAct, au lieu de demander à un LLM de compléter automatiquement votre texte, vous pouvez l'inciter à répondre dans une boucle pensée/action/observation.

Chaînes

Les chaînes, comme le terme l'indique, sont des séquences d'opérations qui permettent à la bibliothèque LangChain de traiter les entrées et les sorties du modèle de langage de manière transparente. Ces composants intégrés de LangChain sont fondamentalement constitués de liens, qui peuvent être d'autres chaînes ou des primitives telles que des invites, des modèles de langage ou des utilitaires.

Imaginez une chaîne comme un tapis roulant dans une usine. Chaque étape de cette ceinture représente une certaine opération, qui peut être l'appel d'un modèle de langage, l'application d'une fonction Python à un texte ou même l'incitation du modèle d'une manière particulière.

LangChain classe ses chaînes en trois types : les chaînes utilitaires, les chaînes génériques et les chaînes de combinaison de documents. Nous aborderons les chaînes utilitaires et génériques dans notre discussion.

• Chaînes utilitaires Ces chaînes sont spécifiquement conçues pour extraire des réponses précises des modèles de langage pour des tâches étroitement définies. Prenons l'exemple de LLMMathChain. Cette chaîne utilitaire permet aux modèles de langage d'effectuer des calculs mathématiques. Elle accepte une question en langage naturel, et le modèle de langage génère à son tour un extrait de code Python, qui est ensuite exécuté pour produire la réponse.
• Chaînes génériques, d'autre part, servent de blocs de construction pour d'autres chaînes mais ne peuvent pas être directement utilisés de manière autonome. Ces chaînes, telles que LLMChain, sont fondamentales et sont souvent combinées avec d'autres chaînes pour accomplir des tâches complexes. Par exemple, LLMChain est fréquemment utilisé pour interroger un objet de modèle de langage en formatant l'entrée en fonction d'un modèle d'invite fourni, puis en le transmettant au modèle de langage.

Mise en œuvre étape par étape de Prompt Engineering avec Langchain

Nous vous guiderons tout au long du processus de mise en œuvre de l'ingénierie rapide à l'aide de Langchain. Avant de continuer, assurez-vous d'avoir installé les logiciels et packages nécessaires.

Vous pouvez tirer parti d'outils populaires tels que Docker, Conda, Pip et Poetry pour configurer LangChain. Les fichiers d'installation pertinents pour chacune de ces méthodes se trouvent dans le référentiel LangChain à l'adresse https://github.com/benman1/generative_ai_with_langchain. Cela comprend un Dockerfile pour Docker, un conditions.txt pour Pip, un pyproject.toml pour la poésie, et un langchain_ai.yml dossier pour Conda.

Dans cet article, nous utiliserons Pip, le gestionnaire de paquets standard de Python, pour faciliter l'installation et la gestion des bibliothèques tierces. S'il n'est pas inclus dans votre distribution Python, vous pouvez l'installer en suivant les instructions disponibles sur le site. https://pip.pypa.io/.

Pour installer une bibliothèque avec Pip, utilisez la commande pip install library_name.

Cependant, Pip ne gère pas les environnements de manière autonome. Pour gérer différents environnements, nous utilisons l'outil virtualenv.

Dans la section suivante, nous discuterons des intégrations de modèles.

Étape 1 : Configurer Langchain

Tout d'abord, vous devez installer le package Langchain. Nous utilisons le système d'exploitation Windows. Exécutez la commande suivante dans votre terminal pour l'installer :

pip install langchain

Étape 2 : Importation de Langchain et des autres modules nécessaires

Ensuite, importez Langchain avec les autres modules nécessaires. Ici, nous importons également la bibliothèque de transformateurs, qui est largement utilisée dans les tâches NLP.

import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Étape 3 : charger le modèle pré-entraîné

Ouvrir AI

OpenAI Les modèles peuvent être facilement interfacés avec la bibliothèque LangChain ou la bibliothèque cliente Python d'OpenAI. OpenAI fournit notamment une classe Embedding pour les modèles d'incorporation de texte. Deux modèles LLM clés sont GPT-3.5 et GPT-4, qui diffèrent principalement par la longueur des jetons. Les tarifs de chaque modèle sont disponibles sur le site web d'OpenAI. Il existe d'autres modèles. modèles sophistiqués comme GPT-4-32K qui ont une acceptation de jeton plus élevée, leur disponibilité via l'API est pas toujours garanti.

L'accès à ces modèles nécessite une clé API OpenAI. Pour cela, créez un compte sur la plateforme OpenAI, configurez vos informations de facturation et générez une nouvelle clé secrète.

import os
os.environ["OPENAI_API_KEY"] = 'your-openai-token'

Après avoir créé la clé avec succès, vous pouvez la définir en tant que variable d'environnement (OPENAI_API_KEY) ou la transmettre en tant que paramètre lors de l'instanciation de classe pour les appels OpenAI.

Envisagez un script LangChain pour mettre en valeur l'interaction avec les modèles OpenAI :

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# The LLM takes a prompt as an input and outputs a completion
prompt = "who is the president of the United States of America?"
completion = llm(prompt)

The current President of the United States of America is Joe Biden.

Dans cet exemple, un agent est initialisé pour effectuer des calculs. L'agent prend une entrée, une simple tâche d'addition, la traite à l'aide du modèle OpenAI fourni et renvoie le résultat.

Étreindre le visage

Étreindre le visage est une GRATUIT Bibliothèque Transformers Python, compatible avec PyTorch, TensorFlow et JAX, et inclut des implémentations de modèles tels que BERT, T5, etc.

Hugging Face propose également Hugging Face Hub, une plate-forme d'hébergement de référentiels de code, de modèles d'apprentissage automatique, d'ensembles de données et d'applications Web.

Pour utiliser Hugging Face comme fournisseur pour vos modèles, vous aurez besoin d'un compte et de clés API, disponibles sur leur site web. Le jeton est disponible dans votre environnement sous le nom HUGGINGFACEHUB_API_TOKEN.

Considérez l'extrait de code Python suivant qui utilise un modèle open source développé par Google, le modèle Flan-T5-XXL :

from langchain.llms import HuggingFaceHub

llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64},repo_id="google/flan-t5-xxl")
prompt = "In which country is Tokyo?"
completion = llm(prompt)
print(completion)

Ce script prend une question en entrée et renvoie une réponse, mettant en valeur les connaissances et les capacités de prédiction du modèle.

Étape 4 : Ingénierie rapide de base

Pour commencer, nous allons générer une simple invite et voir comment le modèle répond.

prompt = 'Translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

Dans l'extrait de code ci-dessus, nous fournissons une invite pour traduire le texte anglais en français. Le modèle de langage essaie ensuite de traduire le texte donné en fonction de l'invite.

Étape 5 : Ingénierie avancée des invites

Bien que l'approche ci-dessus fonctionne bien, elle ne tire pas pleinement parti de la puissance de l'ingénierie des invites. Améliorez-la en introduisant des structures d'invites plus complexes.

prompt = 'As a highly proficient French translator, translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

Dans cet extrait de code, nous modifions l'invite pour suggérer que la traduction est effectuée par un "traducteur français très compétent". La modification de l'invite peut conduire à des traductions améliorées, car le modèle assume désormais la personnalité d'un expert.

Construire un système de questions-réponses sur la littérature académique avec Langchain

Nous allons créer un système de questions et réponses sur la littérature académique en utilisant LangChain qui peut répondre à des questions sur des articles académiques récemment publiés.

Premièrement, pour mettre en place notre environnement, nous installons les dépendances nécessaires.

pip install langchain arxiv openai transformers faiss-cpu

Après l'installation, nous créons un nouveau notebook Python et importons les bibliothèques nécessaires :

from langchain.llms import OpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.docstore.document import Document
import arxiv

Le cœur de notre système de questions-réponses est la capacité de récupérer des articles académiques pertinents liés à un certain domaine, ici nous considérons le traitement du langage naturel (TALN), en utilisant la base de données académique arXiv. Pour cela, on définit une fonction get_arxiv_data(max_results=10). Cette fonction collecte les résumés d'articles NLP les plus récents à partir d'arXiv et les encapsule dans des objets LangChain Document, en utilisant le résumé comme contenu et l'identifiant d'entrée unique comme source.

Nous utiliserons l'API arXiv pour récupérer des articles récents liés à la PNL :

def get_arxiv_data(max_results=10):
    search = arxiv.Search(
        query="NLP",
        max_results=max_results,
        sort_by=arxiv.SortCriterion.SubmittedDate,
    )
   
    documents = []
   
    for result in search.results():
        documents.append(Document(
            page_content=result.summary,
            metadata={"source": result.entry_id},
        ))

    return documents

Cette fonction récupère les résumés des articles de TAL les plus récents sur arXiv et les convertit en objets Document LangChain. Nous utilisons respectivement le résumé de l'article et son identifiant d'entrée unique (URL de l'article) comme contenu et comme source.

def print_answer(question):
    print(
        chain(
            {
                "input_documents": sources,
                "question": question,
            },
            return_only_outputs=True,
        )["output_text"]
    )                 

Définissons notre corpus et configurons LangChain :

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(temperature=0))

Maintenant que notre système de questions-réponses académiques est prêt, nous pouvons le tester en posant une question :

print_answer("What are the recent advancements in NLP?")

La sortie sera la réponse à votre question, citant les sources à partir desquelles les informations ont été extraites. Par exemple:

Recent advancements in NLP include Retriever-augmented instruction-following models and a novel computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs).
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Vous pouvez facilement changer de modèle ou adapter le système à vos besoins. Par exemple, nous passons ici au GPT-4, qui offre une réponse bien meilleure et plus détaillée.

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(model_name="gpt-4",temperature=0))

Recent advancements in Natural Language Processing (NLP) include the development of retriever-augmented instruction-following models for information-seeking tasks such as question answering (QA). These models can be adapted to various information domains and tasks without additional fine-tuning. However, they often struggle to stick to the provided knowledge and may hallucinate in their responses. Another advancement is the introduction of a computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs). This approach utilizes a single-instruction, multiple-data (SIMD) abstraction of nonlinear programs (NLP) and employs a condensed-space interior-point method (IPM) with an inequality relaxation strategy. This strategy allows for the factorization of the KKT matrix without numerical pivoting, which has previously hampered the parallelization of the IPM algorithm.
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Dans GPT-4, un jeton peut être aussi court qu'un caractère ou long qu'un mot. Par exemple, GPT-4-32K peut traiter jusqu'à 32,000 4 jetons en une seule exécution, tandis que GPT-8-3.5K et GPT-8,000-turbo prennent en charge respectivement 4,000 XNUMX et XNUMX XNUMX jetons. Cependant, il est important de noter que chaque interaction avec ces modèles a un coût directement proportionnel au nombre de jetons traités, qu'il s'agisse d'entrées ou de sorties.

Dans le contexte de notre système de questions-réponses, si un document académique dépasse la limite maximale de jetons, le système ne parviendra pas à le traiter dans son intégralité, ce qui affectera la qualité et l'exhaustivité des réponses. Pour contourner ce problème, le texte peut être décomposé en parties plus petites qui respectent la limite de jetons.

FAISS (Recherche de similarité IA sur Facebook) Aide à trouver rapidement les fragments de texte les plus pertinents pour la requête de l'utilisateur. Il crée une représentation vectorielle de chaque fragment de texte et utilise ces vecteurs pour identifier et récupérer les fragments les plus proches de la représentation vectorielle d'une question donnée.

Il est important de garder à l'esprit que même avec des outils comme FAISS, la nécessité de diviser le texte en plus petits morceaux en raison des limitations des jetons peut parfois entraîner une perte de contexte, affectant ainsi la qualité des réponses. Par conséquent, une gestion et une optimisation rigoureuses de l'utilisation des jetons sont cruciales lorsqu'on travaille avec ces modèles linguistiques volumineux.

 
pip install faiss-cpu langchain CharacterTextSplitter

Après vous être assuré que les bibliothèques ci-dessus sont installées, exécutez

 
from langchain.embeddings.openai import OpenAIEmbeddings 
from langchain.vectorstores.faiss import FAISS 
from langchain.text_splitter import CharacterTextSplitter 
documents = get_arxiv_data(max_results=10) # We can now use feed more data
document_chunks = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for document in documents:
    for chunk in splitter.split_text(document.page_content):
        document_chunks.append(Document(page_content=chunk, metadata=document.metadata))

search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())

chain = load_qa_with_sources_chain(OpenAI(temperature=0))

def print_answer(question):
    print(
        chain(
            {
                "input_documents": search_index.similarity_search(question, k=4),
                "question": question,
            },
            return_only_outputs=True,
        )["output_text"]
    )

Avec le code complet, nous avons maintenant un outil puissant pour interroger la dernière littérature académique dans le domaine de la PNL.

 
Recent advancements in NLP include the use of deep neural networks (DNNs) for automatic text analysis and natural language processing (NLP) tasks such as spell checking, language detection, entity extraction, author detection, question answering, and other tasks. 
SOURCES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1 

Conclusion

L'intégration de grands modèles linguistiques (LLM) dans les applications a accéléré l'adoption de plusieurs domaines, notamment la traduction, l'analyse des sentiments et la recherche d'informations. L'ingénierie des invites est un outil puissant pour maximiser le potentiel de ces modèles, et Langchain ouvre la voie à la simplification de cette tâche complexe. Son interface standardisée, ses modèles d'invites flexibles, sa robustesse d'intégration des modèles et l'utilisation innovante d'agents et de chaînes garantissent des résultats optimaux pour les performances des LLM.

Cependant, malgré ces avancées, quelques conseils sont à retenir. Lorsque vous utilisez Langchain, il est essentiel de comprendre que la qualité du résultat dépend fortement de la formulation de l'invite. Expérimenter différents styles et structures d'invite peut améliorer les résultats. De plus, n'oubliez pas que, même si Langchain prend en charge divers modèles de langage, chacun présente ses avantages et ses inconvénients. Choisir le modèle le plus adapté à votre tâche est crucial. Enfin, il est important de garder à l'esprit que l'utilisation de ces modèles implique des considérations financières, car le traitement des jetons influence directement le coût des interactions.

Comme démontré dans le guide étape par étape, Langchain peut alimenter des applications robustes, telles que le système de questions-réponses sur la littérature académique. Avec une communauté d'utilisateurs croissante et une importance croissante dans le paysage open source, Langchain promet d'être un outil essentiel pour exploiter tout le potentiel des LLM comme GPT-4.