¿Cómo implementar la autopregunta con la cadena de búsqueda?

Self-Ask es el proceso para mejorar el proceso de encadenamiento, ya que comprende los comandos a fondo. Las cadenas comprenden la pregunta extrayendo los datos sobre todos los términos importantes del conjunto de datos. Una vez que el modelo está entrenado y comprende la consulta, genera la respuesta a la consulta realizada por el usuario.

Para conocer el proceso de implementación de la autopregunta con las cadenas de búsqueda en LangChain, simplemente consulta la siguiente guía:

Paso 1: instalar marcos

En primer lugar, inicie el proceso instalando el proceso LangChain usando el siguiente código y obtenga todas las dependencias para el proceso:

pip instalar cadena larga

Después de instalar LangChain, instale el ' resultados-de-búsqueda-de-google ”para obtener los resultados de búsqueda de Google utilizando el entorno OpenAI:

pip instalar openai resultados de búsqueda de google

Paso 2: entorno de construcción

Una vez instalados los módulos y marcos, configure el entorno para el Abierto AI y SerpAPi usando sus API usando el siguiente código. Importe las bibliotecas os y getpass que se pueden usar para ingresar las claves API desde sus respectivas cuentas:

importar tú
importar conseguir pase

tú . alrededor de [ 'OPENAI_API_KEY' ] = conseguir pase . conseguir pase ( 'Clave API de OpenAI:' )
tú . alrededor de [ 'SERPAPI_API_KEY' ] = conseguir pase . conseguir pase ( 'Clave API de Serpapi:' )

Paso 3: Importar bibliotecas

Después de configurar el entorno, simplemente importe las bibliotecas necesarias de las dependencias de LangChain, como utilidades, agentes, llm y otras:

de cadena larga. llms importar Abierto AI

de cadena larga. utilidades importar SerpAPIWrapper

de cadena larga. agentes . analizadores_de_salida importar SelfAskOutputParser

de cadena larga. agentes . formato_scratchpad importar formato_log_to_str

de cadena larga importar centro

de cadena larga. agentes importar agente_inicializar , Herramienta

de cadena larga. agentes importar Tipo de agente

Paso 4: construir modelos de lenguaje

Es necesario obtener las bibliotecas anteriores durante todo el proceso, ya que OpenAI() se utiliza para configurar el modelo de lenguaje. Utilice el método SerpAPIWrapper() para configurar la variable de búsqueda y establecer las herramientas necesarias para que el agente realice todas las tareas:

llm = Abierto AI ( temperatura = 0 )
buscar = SerpAPIWrapper ( )
herramientas = [
Herramienta (
nombre = 'Respuesta intermedia' ,
función = buscar. correr ,
descripción = 'útil para cuando necesitas preguntar con la búsqueda' ,
)
]

Paso 5: usar el lenguaje de expresión LangChain

Comenzando con la configuración del agente usando LangChain Expression Language (LCEL) cargando el modelo en la variable de solicitud:

inmediato = centro. jalar ( 'hwchase17/autopregunta-con-búsqueda' )

Defina otra variable que se pueda ejecutar para dejar de generar texto y controlar la longitud de las respuestas:

llm_con_parada = llm. unir ( detener = [ ' \norte Respuesta intermedia:' ] )

Ahora, configure los agentes utilizando Lambda, que es una plataforma sin servidor basada en eventos para generar las respuestas a las preguntas. Además, configure los pasos necesarios para entrenar y probar el modelo para obtener resultados optimizados utilizando los componentes configurados anteriormente:

agente = {
'aporte' : lambda x:x [ 'aporte' ] ,
'agente_scratchpad' : lambda x: formato_log_to_str (
X [ 'pasos_intermedios' ] ,
prefijo_observación = ' \norte Respuesta intermedia: ' ,
prefijo_llm = '' ,
) ,
} | rápido | llm_with_stop | SelfAskOutputParser ( )

Paso 6: Configurar Agent Executor

Antes de probar el método, simplemente importe la biblioteca AgentExecutor desde LangChain para que el agente responda:

de cadena larga. agentes importar AgentExecutor

Defina la variable agent_executor llamando al método AgentExecutor() y utilizando los componentes como argumentos:

agente_ejecutor = AgentExecutor ( agente = agente , herramientas = herramientas , verboso = Verdadero )

Paso 7: ejecutar el agente

Una vez que el agente ejecutor esté configurado, simplemente pruébelo proporcionando la pregunta/mensaje en la variable de entrada:

agente_ejecutor. invocar ( { 'aporte' : '¿Quién es el campeón del US Open masculino?' } )

Al ejecutar el código anterior se respondió con el nombre del campeón del US Open en el resultado, es decir, Dominic Thiem:

Paso 8: uso del agente de autopregunta

Después de obtener la respuesta del agente, utilice el SELF_ASK_WITH_SEARCH agente con la consulta en el método run():

self_ask_with_search = agente_inicializar (
herramientas , llm , agente = Tipo de agente. SELF_ASK_WITH_SEARCH , verboso = Verdadero
)
self_ask_with_search. correr (
'¿Cuál es la ciudad natal de Dominic Thiem, el campeón del mundo abierto de Estados Unidos?'
)

La siguiente captura de pantalla muestra que el agente de autopregunta extrae la información sobre cada término importante del conjunto de datos. Una vez que reúne toda la información sobre la consulta y comprende las preguntas, simplemente genera la respuesta. Las preguntas que se hace el agente son:

¿Quién es Dominic Thiem?
¿Cuál es la ciudad natal de Dominic Thiem?

Después de obtener las respuestas a estas preguntas, el agente generó la respuesta a la pregunta original que es ' Viena, Austria ”:

Se trata del proceso de implementación de la autopregunta con una cadena de búsqueda utilizando el marco LangChain.

Conclusión

Para implementar la autopregunta con búsqueda en LangChain, simplemente instale los módulos necesarios como google-search-results para obtener los resultados del agente. Después de eso, configure el entorno utilizando las claves API de las cuentas OpenAI y SerpAPi para comenzar con el proceso. Configure el agente y cree el modelo con el modelo de autopregunta para probarlo utilizando el método AgentExecutor().

¿Cómo implementar la autopregunta con la cadena de búsqueda?