Conozca agentes y herramientas en LangChain

Ejemplo de código

Para seguir los ejemplos de código, deberá configurar un entorno de cuaderno. Creo que Google Colab es muy fácil para comenzar, pero también puedes trabajar en un cuaderno Jupyter.

Para comenzar, necesitaremos instalar las bibliotecas necesarias para crear agentes y herramientas en LangChain.

!pip install -qU langchain openai

# Imports
import os
import requests
import pandas as pd
from datetime import date
from langchain.llms.openai import OpenAI
from langchain.agents import (
initialize_agent,
load_tools,
tool,
Tool,
AgentType)

Ejemplo de código: definición de herramientas personalizadas

En la naturaleza, lo más probable es que desee crear herramientas personalizadas para sus agentes. Entonces, en lugar de usar una de las herramientas preconstruidas, crearemos herramientas personalizadas y haremos que nuestro agente las use.

# A tool is simply a function decorated with the @tool
@tool
def time(text: str) -> str:
"""Returns todays date, use this for any \
questions related to knowing todays date. \
The input should always be an empty string, \
and this function will always return todays \
date - any date mathmatics should occur \
outside this function."""
return str(date.today())

Poder preguntarle a nuestro agente cuál es la fecha es genial, pero es como un «Hola mundo» del desarrollo de software. Pienso que podemos hacerlo mejor. Démosle a nuestro agente la capacidad de decirnos las acciones con mejor desempeño en el mercado.

“El futuro de la inteligencia artificial: tendencias e innovaciones a tener en cuenta”

# A tool is simply a function decorated with the @tool
@tool
def get_top_gainers(text: str) -> str:
"""Returns stocks that are trending as the top gainers in the stock market. \
The input should always be an empty string, and this function will always \
the best performing stocks in the form of a json."""
base_url = 'https://financialmodelingprep.com/api/v3'
top_gainers_endpoint = '/gainers'
api_key = FMP_API_KEY # get your free key at https://site.financialmodelingprep.com/
if not api_key:
raise Exception("API key not found in environment variables")
request_url = f"{base_url}{top_gainers_endpoint}?apikey={api_key}"
response = requests.get(request_url)
if response.status_code == 200:
data = response.json()
df = pd.DataFrame(data)
# Sort by changesPercentage in descending order
df = df.sort_values(by='changesPercentage', ascending=False).head(5)
# Convert to json
json_data = df.to_json()
# Return the top 5
return str(json_data)
else:
return None

Ahora que hemos definido nuestras herramientas, avancemos e inicialicemos nuestro modelo de lenguaje grande, el agente conversacional que vamos a usar. Para hacer eso, primero necesitamos una clave API de OpenAI. Puedes obtener eso desde aquí.

Introducción al aprendizaje profundo

# initialise LLM
llm = OpenAI(
openai_api_key=OPENAI_API_KEY,  # platform.openai.com
temperature=0,
model_name="gpt-3.5-turbo"
)

Luego inicializamos el LLM usando ChatOpenAI porque estamos usando el modelo OpenAI gpt-3.5-turbo. El argumento de la temperatura determina la aleatoriedad del modelo.

Cuando estamos haciendo tareas como matemáticas, escribiendo código o una búsqueda en Google que requieren poca aleatoriedad en la respuesta, mantenemos la temperatura baja. Esto es para que podamos obtener el mismo resultado (más o menos) cada vez que ejecutamos el código. Cuando queremos ser más creativos, por ejemplo, escribir creativamente, estableceríamos la temperatura en un valor más alto (el más alto es 1).

Ahora estamos listos para inicializar el agente. Tenga en cuenta que definimos los nombres de las herramientas que deseamos usar dentro de una lista porque podemos agregar varias herramientas dentro del mismo agente. Esto es muy útil para situaciones en las que es posible que deba realizar múltiples tareas: consultar la web, hacer operaciones matemáticas, etc.

agent = initialize_agent(
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
tools=[time],
llm=llm,
verbose=True,
max_iterations=3
)

Entendamos lo que está pasando aquí, comenzando con el argumento de la película. Como mencioné anteriormente, en el mundo de los agentes, el LLM actúa como el motor central de razonamiento.

Ajuste fino y evaluación de modelos de lenguaje grande (LLM)

El LLM está conectado a todos los tools hemos proporcionado, en nuestro caso, un motor de búsqueda. Entonces, cuando surge la pregunta de un usuario, el LLM en sí mismo actúa como un agent y decide qué herramienta utilizar.

Pero LangChain ofrece opciones para muchos tipos de agentes. Es decir, al usar el LLM como motor de razonamiento, tenemos diferentes opciones para controlar el comportamiento de este motor de razonamiento.

En nuestro caso, queremos que nuestra película actúe como un tipo particular de agente, el zero-shot-react-description agente. El zero-shot parte de eso significa que el agente no tiene memoria y se enfoca solo en la acción actual. Entonces, si tiene un chatbot, no usaría este tipo de agente.

Ahora en el react parte. Esto significa que el agente utiliza el marco ReAct para razonar y tomar medidas. Entonces, con este marco, el modelo puede razonar sobre qué pasos tomar y también tomar acciones (como qué herramienta usar) en función de esos pensamientos.

Comprender los datos y realizar EDA

En cuanto a qué acción tomar (o qué herramienta usar), el agente decide esto en función de la description de cada una de las herramientas.

Establecimos verbose a verdadero para que el modelo genere su proceso de pensamiento para llegar a la respuesta final. Este es un trato cuando todavía estamos en desarrollo, por supuesto.

El max_iteration el argumento se refiere a cuántos pasos de razonamiento, acción y observación se le permite tomar antes de que digamos alto. Esto es importante porque el agente puede quedarse atascado en un bucle infinito probando una herramienta tras otra, tras otra. Queremos evitar esto porque va a costar dinero para empezar.

También tenemos el early_stopping _method configurado para generar. Esto significa que el modelo decidirá cuándo debe detenerse.