LangChain est un outil de pointe et robuste développé pour exploiter la puissance des grands modèles de langage (LLM).
Ces LLM possèdent des capacités remarquables et peuvent s'attaquer efficacement à un large éventail de tâches. Cependant, il est important de noter que leur force réside dans leur nature générale plutôt que dans une expertise approfondie du domaine. Sa popularité a augmenté rapidement depuis l'introduction de GPT-4.
Bien que les LLM excellent dans la gestion de diverses tâches, ils peuvent être confrontés à des limites lorsqu'il s'agit de fournir des réponses spécifiques ou de s'attaquer à des tâches qui nécessitent une connaissance approfondie du domaine. Envisagez, par exemple, d'utiliser un LLM pour répondre à des questions ou effectuer des tâches dans des domaines spécialisés comme la médecine ou le droit.
Alors que le LLM peut certainement répondre aux demandes générales sur ces domaines, il peut avoir du mal à offrir des réponses plus détaillées ou nuancées qui nécessitent des connaissances ou une expertise spécialisées.
En effet, les LLM sont formés sur de grandes quantités de données textuelles provenant de diverses sources, ce qui leur permet d'apprendre des modèles, de comprendre le contexte et de générer des réponses cohérentes. Cependant, leur formation n'implique généralement pas l'acquisition de connaissances spécifiques à un domaine ou spécialisées dans la même mesure que les experts humains dans ces domaines.
Par conséquent, bien que LangChain, en conjonction avec les LLM, puisse être un outil précieux pour un large éventail de tâches, il est important de reconnaître qu'une expertise approfondie du domaine peut encore être nécessaire dans certaines situations. Des experts humains possédant des connaissances spécialisées peuvent fournir la profondeur nécessaire, une compréhension nuancée et des informations spécifiques au contexte qui pourraient dépasser les capacités des seuls LLM.
Nous vous conseillons de consulter la documentation de LangChain ou GitHub référentiel pour une compréhension plus approfondie de ses cas d'utilisation typiques. Il est fortement conseillé d'obtenir une image plus grande de ce bundle.
Comment ça marche?
Pour comprendre le but et le travail de LangChain, considérons un exemple pratique. Nous sommes conscients que GPT-4 possède des connaissances générales impressionnantes et peut fournir des réponses fiables à un large éventail de questions.
Cependant, que se passe-t-il si nous voulons des informations spécifiques à partir de nos propres données, telles qu'un document personnel, un livre, un fichier PDF ou une base de données propriétaire ?
LangChain nous permet de connecter un grand modèle de langage comme GPT-4 à nos propres sources de données. Cela va au-delà du simple collage d'un extrait de texte dans une interface de chat. Au lieu de cela, nous pouvons référencer une base de données entière remplie de nos propres données.
Une fois que nous obtenons les informations souhaitées, LangChain peut nous aider à prendre des mesures spécifiques. Par exemple, nous pouvons lui demander d'envoyer un e-mail contenant certains détails.
Pour y parvenir, nous suivons une approche de pipeline utilisant LangChain. Tout d'abord, nous prenons le document que nous voulons le modèle de langage pour le référencer et le diviser en plus petits morceaux. Ces morceaux sont ensuite stockés sous forme d'intégrations, qui sont représentations vectorielles du texte, dans une base de données vectorielle.
Avec cette configuration, nous pouvons créer des applications de modèle de langage qui suivent un pipeline standard : un utilisateur pose une question initiale, qui est ensuite envoyée au modèle de langage. La représentation vectorielle de la question est utilisée pour effectuer une recherche de similarité dans la base de données vectorielle, en récupérant les informations pertinentes.
Ces morceaux sont ensuite renvoyés au modèle de langage, lui permettant de fournir une réponse ou de prendre l'action souhaitée.
LangChain facilite le développement d'applications sensibles aux données, car nous pouvons référencer nos propres données dans un magasin de vecteurs, et authentiques, car elles peuvent prendre des mesures au-delà de la réponse aux questions. J
Cela ouvre une multitude de cas d'utilisation pratiques, en particulier dans l'assistance personnelle, où un grand modèle de langage peut gérer des tâches telles que la réservation de vols, le transfert d'argent ou l'assistance en matière fiscale.
De plus, les implications pour l'étude et l'apprentissage de nouvelles matières sont importantes, car un modèle linguistique peut référencer un programme complet et accélérer le processus d'apprentissage. Le codage, l'analyse des données et la science des données devraient également être fortement influencés par ces avancées.
L'une des perspectives les plus intéressantes consiste à connecter de grands modèles de langage aux données existantes de l'entreprise, telles que les informations sur les clients ou les données marketing. Cette intégration avec des API avancées comme l'API de Meta ou l'API de Google promet des progrès exponentiels dans l'analyse de données et la science des données.
Comment créer une page Web (démo)
Actuellement, Langchain est disponible sous forme de packages Python et JavaScript.
Nous pouvons créer une application Web de démonstration utilisant Streamlit, LangChain et le modèle OpenAI GPT-3 pour mettre en œuvre le concept LangChain.
Mais d'abord, nous devons installer quelques dépendances, notamment Streamlit, LangChain et OpenAI.
Conditions préalables
Streamlit : Un package Python populaire pour créer des applications Web liées à la science des données
OpenAI : L'accès au modèle de langage GPT-3 d'OpenAI est nécessaire.
Pour installer ces dépendances, utilisez les commandes suivantes dans cmd :
pip install streamlit
pip install langchain
pip install openai
Importer des packages
Nous commençons par importer les packages requis, tels que OpenAI, LangChain et Streamlit. Nos chaînes de modèles de langage sont définies et exécutées à l'aide de trois classes de LangChain : LLMChain, SimpleSequentialChain et PromptTemplate.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Configuration de base
La base structurelle de notre projet a ensuite été mise en place en utilisant la syntaxe Streamlit. Nous avons donné à l'application le titre « What's TRUE : Using Simple Sequential Chain » et avons inclus un lien Markdown vers le référentiel GitHub qui a servi d'inspiration à l'application.
import streamlit as st
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
Widgets frontaux
Nous avons configuré l'application avec peu d'informations pertinentes, en utilisant une syntaxe Streamlit simple :
# If an API key has been provided, create an OpenAI language model instance
if API:
llm = OpenAI(temperature=0.7, openai_api_key=API)
else:
# If an API key hasn't been provided, display a warning message
st.warning("Enter your OPENAI API-KEY. Get your OpenAI API key from [here](https://platform.openai.com/account/api-keys).\n")
Pour ajouter des widgets frontaux
De plus, nous devons fournir un widget de saisie pour permettre à nos utilisateurs de saisir des questions.
# Add a text input box for the user's question
user_question = st.text_input(
"Enter Your Question : ",
placeholder = "Cyanobacteria can perform photosynthetsis , are they considered as plants?",
)
Terminé! Les chaînes sont en place et fonctionnent!
Nous employons diverses chaînes d'opérations avec SimpleSequentialChain
pour répondre à la requête de l'utilisateur. Les chaînes sont exécutées dans l'ordre suivant lorsque l'utilisateur sélectionne le "Tell me about it"
bouton:
if st.button("Tell me about it", type="primary"):
# Chain 1: Generating a rephrased version of the user's question
template = """{question}\n\n"""
prompt_template = PromptTemplate(input_variables=["question"], template=template)
question_chain = LLMChain(llm=llm, prompt=prompt_template)
# Chain 2: Generating assumptions made in the statement
template = """Here is a statement:
{statement}
Make a bullet point list of the assumptions you made when producing the above statement.\n\n"""
prompt_template = PromptTemplate(input_variables=["statement"], template=template)
assumptions_chain = LLMChain(llm=llm, prompt=prompt_template)
assumptions_chain_seq = SimpleSequentialChain(
chains=[question_chain, assumptions_chain], verbose=True
)
# Chain 3: Fact checking the assumptions
template = """Here is a bullet point list of assertions:
{assertions}
For each assertion, determine whether it is true or false. If it is false, explain why.\n\n"""
prompt_template = PromptTemplate(input_variables=["assertions"], template=template)
fact_checker_chain = LLMChain(llm=llm, prompt=prompt_template)
fact_checker_chain_seq = SimpleSequentialChain(
chains=[question_chain, assumptions_chain, fact_checker_chain], verbose=True
)
# Final Chain: Generating the final answer to the user's question based on the facts and assumptions
template = """In light of the above facts, how would you answer the question '{}'""".format(
user_question
)
template = """{facts}\n""" + template
prompt_template = PromptTemplate(input_variables=["facts"], template=template)
answer_chain = LLMChain(llm=llm, prompt=prompt_template)
overall_chain = SimpleSequentialChain(
chains=[question_chain, assumptions_chain, fact_checker_chain, answer_chain],
verbose=True,
)
# Running all the chains on the user's question and displaying the final answer
st.success(overall_chain.run(user_question))
question_chain
: qui est la première étape de notre pipeline, reçoit la question de l'utilisateur en entrée et en sortie. La requête de l'utilisateur sert de modèle à la chaîne.- Sur la base d'une déclaration liée à la question, le
assumptions_chain
génère une liste à puces d'hypothèses en utilisant la sortie duquestion_chain
comme entrée. LeLLMChain
ainsi que leOpenAI
Le modèle de LangChain a été utilisé pour construire la déclaration. L'utilisateur est chargé de créer une liste des hypothèses qui ont été faites afin de produire la déclaration en utilisant le modèle pour cette chaîne. - Sur la base des sorties du
question_chain
ainsi que leassumptions_chain
,fact_checker_chain
génère une liste d'assertions sous forme de puces. Les revendications sont produites à l'aide de laOpenAI
modèle etLLMChain
de LangChain. L'utilisateur est chargé de déterminer si chaque affirmation est exacte ou incorrecte et de fournir une justification pour celles qui le sont. - La
answer_chain
utilise les sorties duquestion_chain
,assumptions_chain
et unefact_checker_chain
comme entrées pour créer une réponse à la question de l'utilisateur en utilisant les données produites par les chaînes précédentes. Le modèle de cette chaîne demande à l'utilisateur de répondre à la première requête en utilisant les faits qui ont été créés. - Afin de fournir la réponse ultime à la demande de l'utilisateur sur la base des informations produites par les chaînes précédentes, nous intégrons ces chaînes dans la chaîne globale. Une fois les chaînes terminées, nous utilisons
st.success()
pour montrer à l'utilisateur la solution.
Conclusion
Nous pouvons simplement enchaîner différentes actions de modèle de langage pour créer des pipelines plus compliqués en utilisant le SimpleSequentialChain
module de LangChain. Pour une grande variété d'applications NLP, y compris les chatbots, les systèmes de questions-réponses et les outils de traduction linguistique, cela peut être très utile.
L'éclat de LangChain se trouve dans sa capacité d'abstraction, qui permet à l'utilisateur de se concentrer sur le problème actuel plutôt que sur les spécificités de la modélisation du langage.
LangChain rend le processus de création de modèles de langage sophistiqués plus convivial en proposant des modèles pré-formés et une sélection de modèles.
Il vous donne la possibilité d'affiner les modèles de langage à l'aide de leurs propres données, ce qui simplifie la personnalisation des modèles de langage. Cela permet le développement de modèles plus précis et spécifiques à un domaine qui, pour un travail donné, surpassent les modèles entraînés.
La SimpleSequentialChain
module et d'autres fonctionnalités de LangChain en font un outil efficace pour développer et déployer rapidement des systèmes NLP sophistiqués.
Soyez sympa! Laissez un commentaire