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, apporte commodité et flexibilité à la conception, à la mise en œuvre et au réglage des invites. Au fur et à mesure que nous déballons les principes et les pratiques de l'ingénierie rapide, vous apprendrez à utiliser les puissantes fonctionnalités de Langchain pour tirer parti des atouts des modèles SOTA Generative AI tels que 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 'rapide' 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 rapide est l'art et la science de la conception d'invites efficaces. L'objectif est d'obtenir la sortie souhaitée d'un modèle de langage. En sélectionnant et en structurant soigneusement les invites, on peut guider le modèle vers la génération de réponses plus précises et pertinentes. En pratique, cela implique d'affiner les phrases d'entrée pour répondre à la formation et aux biais 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 modèles d'E/S, 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 de l'utilisateur, l'état de l'environnement et les objectifs de l'agent. Les stratégies ConversationBufferMemory et ConversationBufferWindowMemory permettent de garder une trace des parties complètes ou récentes d'une conversation, respectivement. Pour une approche plus sophistiquée, la stratégie ConversationKGMemory permet d'encoder la conversation sous la forme d'un graphe de connaissances qui peut être réinjecté dans des invites ou utilisé pour prédire les 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 Zero-shot ReAct, où la décision est basée 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'inviter à répondre dans une boucle pensée/acte/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 Combiner des documents. Nous plongerons dans les chaînes utilitaires et génériques pour notre discussion.

• Chaînes utilitaires sont spécifiquement conçus pour extraire des réponses précises à partir de modèles de langage pour des tâches étroitement définies. Par exemple, examinons le LLMMathChain. Cette chaîne utilitaire permet aux modèles de langage d'effectuer des calculs mathématiques. Il 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 notre article, nous utiliserons Pip, le gestionnaire de packages standard pour Python, pour faciliter l'installation et la gestion de bibliothèques tierces. S'il n'est pas inclus dans votre distribution Python, vous pouvez installer Pip en suivant les instructions sur 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 tout seul. 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 client OpenAI Python. Notamment, OpenAI fournit une classe Embedding pour les modèles d'incorporation de texte. Deux modèles LLM clés sont GPT-3.5 et GPT-4, différant principalement par la longueur du jeton. Les prix de chaque modèle sont disponibles sur le site Web d'OpenAI. Alors qu'il y a plus 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. Cela peut être fait en créant un compte sur la plate-forme OpenAI, en configurant les informations de facturation et en générant 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 en tant que fournisseur de vos modèles, vous aurez besoin d'un compte et de clés API, qui peuvent être obtenues sur leur site Web. Le jeton peut être mis à disposition dans votre environnement en tant que 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 rapide. Améliorons-le en introduisant des structures d'invite 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 à l'aide de LangChain, capable de répondre aux questions sur les articles universitaires 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 NLP les plus récents d'arXiv et les convertit en objets LangChain Document. Nous utilisons le résumé de l'article et son identifiant d'entrée unique (URL de l'article) comme contenu et source, respectivement.

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 modifier le système selon vos besoins. Par exemple, nous passons ici au GPT-4 qui finit par nous donner une réponse bien meilleure et 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

Un jeton dans GPT-4 peut être aussi court qu'un caractère ou aussi 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ée ou de sortie.

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 morceaux de texte les plus pertinents liés à la requête de l'utilisateur. Il crée une représentation vectorielle de chaque bloc de texte et utilise ces vecteurs pour identifier et récupérer les blocs les plus similaires à la représentation vectorielle d'une question donnée.

Il est important de se rappeler que même avec l'utilisation d'outils comme FAISS, la nécessité de diviser le texte en plus petits morceaux en raison de limitations symboliques peut parfois entraîner une perte de contexte, affectant la qualité des réponses. Par conséquent, une gestion et une optimisation minutieuses de l'utilisation des jetons sont cruciales lorsque vous travaillez avec ces grands modèles de langage.

 
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 des grands modèles de langage (LLM) dans les applications a accéléré l'adoption de plusieurs domaines, notamment la traduction linguistique, l'analyse des sentiments et la recherche d'informations. L'ingénierie rapide est un outil puissant pour maximiser le potentiel de ces modèles, et Langchain ouvre la voie en simplifiant cette tâche complexe. Son interface standardisée, ses modèles d'invites flexibles, son intégration de modèles robuste 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, il y a quelques conseils à garder à l'esprit. Lorsque vous utilisez Langchain, il est essentiel de comprendre que la qualité de la sortie dépend fortement de la formulation de l'invite. L'expérimentation de différents styles et structures d'invite peut donner de meilleurs résultats. N'oubliez pas non plus que même si Langchain prend en charge une variété de modèles de langage, chacun a ses forces et ses faiblesses. Choisir le bon pour votre tâche spécifique est crucial. Enfin, il est important de se rappeler que l'utilisation de ces modèles s'accompagne de considérations de coût, 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.