Un guide complet de Langchain à Python

Langchain: une puissante bibliothèque Python pour la construction, l'expérimentation et l'analyse des modèles de langage et des agents

Points de base:

• Langchain est une bibliothèque Python qui simplifie la création, l'expérimentation et l'analyse des modèles de langage et des agents, offrant un large éventail de fonctions pour le traitement du langage naturel.
• Il permet la création d'agents multifonctionnels qui sont capables de comprendre et de générer du texte et peuvent configurer des comportements et des sources de données spécifiques pour effectuer diverses tâches liées à la langue.
• Langchain fournit trois types de modèles: modèle grand langage (LLM), modèle de chat et modèle d'intégration de texte, chacun offrant une fonctionnalité unique pour les tâches de traitement du langage.
• Il fournit également des fonctionnalités telles que la segmentation du grand texte en blocs faciles à gérer, liant plusieurs fonctions LLM via des chaînes pour effectuer des tâches complexes et s'intégrer à divers services LLM et AI en dehors de l'OpenAI.

Langchain est une puissante bibliothèque Python qui permet aux développeurs et aux chercheurs de créer, expérimenter et analyser les modèles et les agents de langage. Il offre aux amateurs de traitement du langage naturel (NLP) avec un riche ensemble de fonctionnalités, de la construction de modèles personnalisés à une manipulation efficace de données texte. Dans ce guide complet, nous creuserons dans les composants de base de Langchain et montrerons comment profiter de son pouvoir à Python.

Paramètres d'environnement:

Pour apprendre cet article, créez un nouveau dossier et installez Langchain et Openai à l'aide de PIP:

pip3 install langchain openai

AGENTS:

Dans Langchain, un agent est une entité qui peut comprendre et générer du texte. Ces agents peuvent configurer des comportements et des sources de données spécifiques et sont formés pour effectuer diverses tâches liées à la langue, ce qui en fait un outil multifonctionnel pour une variété d'applications.

Créer Langchain Agent:

Les agences peuvent être configurées pour utiliser des "outils" pour collecter les données requises et développer une bonne réponse. Veuillez consulter l'exemple ci-dessous. Il utilise l'API SERP (une API de recherche Internet) pour rechercher des informations liées à une question ou une entrée et à répondre. Il utilise également l'outil LLM-Math pour effectuer des opérations mathématiques - par exemple, la conversion des unités ou la recherche d'un pourcentage de variation entre deux valeurs:

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.llms import OpenAI
import os

os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
os.environ["SERPAPI_API_KEY"] = "YOUR_SERP_API_KEY" # 获取你的Serp API密钥：https://serpapi.com/

OpenAI.api_key = "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"
llm = OpenAI(model="gpt-3.5-turbo", temperature=0)
tools = load_tools(["serpapi", "llm-math"], llm=llm)
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
agent.run("How much energy did wind turbines produce worldwide in 2022?")

Comme vous pouvez le voir, après avoir terminé toutes les importations de base et l'initialisation de LLM (llm = openai (Model = "GPT-3.5-Turbo", température = 0)), le code utilise des outils = load_tools (["serpapi" , "LLM-Math"], llm = llm) Chargez les outils requis pour que l'agent fonctionne. Il utilise ensuite la fonction initialize_agent pour créer un agent, lui fournir l'outil spécifié et lui fournit une description zéro_shot_react_description, ce qui signifie qu'il ne se souviendra pas du problème précédent.

Exemple de test d'agence 1:

Testons cet agent avec l'entrée suivante:

<code>"How much energy did wind turbines produce worldwide in 2022?"</code>

Comme vous pouvez le voir, il utilise la logique suivante:

• Rechercher "Production d'énergie d'éoliennes dans le monde entier 2022" en utilisant l'API de recherche Internet SERP
• les meilleurs résultats pour l'analyse
• Obtenez des numéros pertinents
• Utilisez l'outil LLM-Math pour convertir 906 GW en Joule parce que nous demandons l'énergie, pas la puissance

Exemple de test d'agence 2:

Langchain L'agent ne se limite pas à la recherche sur Internet. Nous pouvons connecter presque toutes les sources de données (y compris la nôtre) à l'agent de Langchain et poser des questions sur les données. Essayons de créer un agent formé sur un ensemble de données CSV.

Téléchargez cet ensemble de données de films et d'émissions de télévision Netflix à partir de Shivam Bansal sur Kaggle et de le déplacer vers votre répertoire. Ajoutez maintenant ce code à un nouveau fichier python:

pip3 install langchain openai

Ce code appelle la fonction create_csv_agent et utilise l'ensemble de données Netflix_titles.csv. La figure suivante montre notre test.

Comme indiqué ci-dessus, sa logique consiste à rechercher toutes les occurrences de "chrétienne" dans la colonne des acteurs.

Nous pouvons également créer un agent Pandas DataFrame comme ceci:

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.llms import OpenAI
import os

os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
os.environ["SERPAPI_API_KEY"] = "YOUR_SERP_API_KEY" # 获取你的Serp API密钥：https://serpapi.com/

OpenAI.api_key = "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"
llm = OpenAI(model="gpt-3.5-turbo", temperature=0)
tools = load_tools(["serpapi", "llm-math"], llm=llm)
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
agent.run("How much energy did wind turbines produce worldwide in 2022?")

Si nous l'exécutons, nous verrons le résultat comme indiqué ci-dessous.

Ce ne sont que quelques exemples. Nous pouvons utiliser presque toutes les API ou ensembles de données avec Langchain.

Modèles:

Il existe trois types de modèles dans Langchain: modèle grand langage (LLM), modèle de chat et modèle d'intégration de texte. Explorons chaque type de modèle avec quelques exemples.

Modèle de grande langue:

Langchain fournit un moyen d'utiliser de grands modèles de langage dans Python pour générer une sortie de texte en fonction de l'entrée de texte. Il n'est pas aussi complexe que le modèle de chat et est le mieux adapté aux tâches de langage de sortie d'entrée. Voici un exemple utilisant Openai:

<code>"How much energy did wind turbines produce worldwide in 2022?"</code>

Comme indiqué ci-dessus, il utilise le modèle GPT-3.5-turbo pour générer une sortie pour l'entrée fournie ("trouver un nom de rap pour Matt Nikonorov"). Dans cet exemple, j'ai réglé la température à 0,9 pour rendre le LLM plus créatif. Il est venu avec «Mc Megamatt». Je lui ai donné une marque 9/10.

Modèle de chat:

C'est amusant d'amener le modèle LLM à proposer des noms de rap, mais si nous voulons des réponses et des conversations plus complexes, nous devons utiliser le modèle de chat pour améliorer nos compétences. Techniquement, en quoi le modèle de chat est-il différent d'un modèle grand langage? Dans les mots du document Langchain:

Le modèle de chat est une variante du modèle de grande langue. Bien que les modèles de chat utilisent de grands modèles de langue en arrière-plan, ils utilisent des interfaces légèrement différentes. Ils n'utilisent pas l'API "Entrée de texte, sortie de texte", mais utilisent "Messages de chat" comme interface pour l'entrée et la sortie.

Il s'agit d'un simple script de modèle de chat Python:

pip3 install langchain openai

Comme indiqué ci-dessus, le code envoie d'abord un SystemMessage et dit au chatbot d'être amical et informel, puis il envoie un HumanMessage et dit au chatbot de nous convaincre que Djokovich est meilleur que Federer.

Si vous exécutez ce modèle de chatbot, vous verrez les résultats indiqués ci-dessous.

Embeddings:

Emballage fournit un moyen de convertir les mots et les nombres en blocs de texte en vecteurs qui peuvent ensuite être associés à d'autres mots ou nombres. Cela peut sembler abstrait, alors regardons un exemple:

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.llms import OpenAI
import os

os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
os.environ["SERPAPI_API_KEY"] = "YOUR_SERP_API_KEY" # 获取你的Serp API密钥：https://serpapi.com/

OpenAI.api_key = "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"
llm = OpenAI(model="gpt-3.5-turbo", temperature=0)
tools = load_tools(["serpapi", "llm-math"], llm=llm)
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
agent.run("How much energy did wind turbines produce worldwide in 2022?")

Cela renverra une liste de numéros de points flottants: [0,022762885317206383, -0.01276398915797472, 0,00481598172368168, -0.0094353929068]. Voilà à quoi ressemble l'intégration.

Cas d'utilisation des modèles intégrés:

Si nous voulons former un chatbot ou un LLM pour répondre aux questions liées à nos données ou à des échantillons de texte spécifiques, nous devons utiliser l'intégration. Créons un fichier CSV simple (EMBS.CSV) avec une colonne "texte" contenant trois informations:

<code>"How much energy did wind turbines produce worldwide in 2022?"</code>

Maintenant, c'est un script qui utilisera des intégres pour obtenir la question "qui était l'humain le plus grand de tous les temps?"

from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.agents.agent_types import AgentType
from langchain.agents import create_csv_agent
import os

os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"

agent = create_csv_agent(
    OpenAI(temperature=0),
    "netflix_titles.csv",
    verbose=True,
    agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
)

agent.run("In how many movies was Christian Bale casted")

Si nous exécutons ce code, nous verrons qu'il sortira "Robert Wadlow était le plus haut humain de tous les temps". Le code trouve la bonne réponse en obtenant l'incorporation de chaque élément d'information et en trouvant l'intégration qui est la plus pertinente pour la question "qui était l'homme le plus grand de tous les temps?". Puissance intégrée!

morceaux:

Les modèles Langchain ne peuvent pas traiter de grands textes en même temps et les utiliser pour générer des réponses. C'est là que la segmentation des blocs et du texte entrera en jeu. Examinons deux façons simples de diviser les données de texte en blocs avant de les nourrir à Langchain.

Blocs de segment par caractère:

Pour éviter les interruptions soudaines dans les blocs, nous pouvons diviser le texte par paragraphe en divisant le texte à chaque occurrence d'une nouvelle ligne ou d'une double nouvelle ligne:

from langchain.agents import create_pandas_dataframe_agent
from langchain.chat_models import ChatOpenAI
from langchain.agents.agent_types import AgentType
from langchain.llms import OpenAI
import pandas as pd
import os

os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_KEY"
df = pd.read_csv("netflix_titles.csv")

agent = create_pandas_dataframe_agent(OpenAI(temperature=0), df, verbose=True)

agent.run("In what year were the most comedy movies released?")

Bloc de segmentation récursive:

Si nous voulons strictement diviser le texte par des caractères d'une certaine longueur, nous pouvons utiliser RecursiVECHarAtteTtexTsPlitter:

from langchain.llms import OpenAI
import os
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"

llm = OpenAI(model="gpt-3.5-turbo", temperature=0.9)
print(llm("Come up with a rap name for Matt Nikonorov"))

Taille et chevauchement des blocs:

Lorsque vous regardez l'exemple ci-dessus, vous voudrez peut-être savoir exactement ce que signifient la taille du bloc et les paramètres de chevauchement et comment ils affectent les performances. Cela peut être expliqué de deux manières:

• La taille du bloc détermine le nombre de caractères dans chaque bloc. Plus la taille du bloc est grande, plus il y a de données dans le bloc, plus il faut Langchain pour le traiter et générer la sortie, et vice versa.
• Le chevauchement des blocs est le contenu qui partage des informations entre les blocs afin qu'ils partagent un certain contexte. Plus le chevauchement du bloc est élevé, plus nos blocs sont redondants, plus le chevauchement du bloc est bas, moins le contexte est partagé entre les blocs. En règle générale, un bon chevauchement de blocs est de 10% à 20% de la taille du bloc, bien que le chevauchement de bloc souhaité varie selon différents types de texte et cas d'utilisation.

chaînes:

Les chapitres

sont essentiellement des fonctions LLM multiples liées ensemble pour effectuer des tâches plus complexes qui ne peuvent pas être accomplies via la sortie LLM simple. Regardons un exemple sympa:

pip3 install langchain openai

Ce code entre deux variables dans ses invites et développe une réponse créative (température = 0,9). Dans cet exemple, nous lui demandons de proposer un bon titre pour un film d'horreur sur les mathématiques. La sortie après l'exécution de ce code est "la malédiction calculatrice", mais cela ne montre pas vraiment la pleine fonctionnalité de la chaîne.

Regardons un exemple plus pratique:

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.llms import OpenAI
import os

os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
os.environ["SERPAPI_API_KEY"] = "YOUR_SERP_API_KEY" # 获取你的Serp API密钥：https://serpapi.com/

OpenAI.api_key = "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"
llm = OpenAI(model="gpt-3.5-turbo", temperature=0)
tools = load_tools(["serpapi", "llm-math"], llm=llm)
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
agent.run("How much energy did wind turbines produce worldwide in 2022?")

Ce code peut sembler déroutant, alors expliquons-le pas à pas.

Ce code lit une courte biographie de NAS (artiste hip hop) et extrait les valeurs suivantes du texte et les formats comme des objets JSON:

• Nom de l'artiste
• Genre de musique de l'artiste
• Le premier album de l'artiste
• L'année de sortie du premier album de l'artiste

Dans l'invite, nous avons également spécifié "Assurez-vous de répondre au format correct" afin que nous obtenions toujours la sortie au format JSON. Voici la sortie de ce code:

<code>"How much energy did wind turbines produce worldwide in 2022?"</code>

En fournissant le motif JSON à la fonction create_structed_output_chain, nous faisons la chaîne de mettre sa sortie dans le format JSON.

au-delà de l'Openai:

Bien que j'aie utilisé le modèle OpenAI comme exemple de différentes fonctions de Langchain, il n'est pas limité au modèle OpenAI. Nous pouvons utiliser Langchain avec de nombreux autres services LLM et AI. (Il s'agit de la liste complète des LLM intégrés de Langchain.)

Par exemple, nous pouvons utiliser Cohere avec Langchain. Il s'agit de la documentation de l'intégration de Langchain Cohere, mais pour fournir un exemple pratique, après avoir installé Cohere à l'aide de PIP3 Installer Cohere, nous pouvons écrire un simple code de questions-réponses à l'aide de Langchain et Cohere comme suit:

from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.agents.agent_types import AgentType
from langchain.agents import create_csv_agent
import os

os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"

agent = create_csv_agent(
    OpenAI(temperature=0),
    "netflix_titles.csv",
    verbose=True,
    agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
)

agent.run("In how many movies was Christian Bale casted")

Le code ci-dessus produit la sortie suivante:

from langchain.agents import create_pandas_dataframe_agent
from langchain.chat_models import ChatOpenAI
from langchain.agents.agent_types import AgentType
from langchain.llms import OpenAI
import pandas as pd
import os

os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_KEY"
df = pd.read_csv("netflix_titles.csv")

agent = create_pandas_dataframe_agent(OpenAI(temperature=0), df, verbose=True)

agent.run("In what year were the most comedy movies released?")

Conclusion:

Dans ce guide, vous avez vu différents aspects et fonctions de Langchain. Une fois que vous avez maîtrisé ces connaissances, vous pouvez utiliser les capacités de Langchain pour effectuer un travail de PNL, que vous soyez chercheur, développeur ou passionné.

Vous pouvez trouver un référentiel sur GitHub qui contient toutes les images et les fichiers nas.txt dans cet article.

Je vous souhaite un codage heureux et expérimentant avec Langchain dans Python!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!