As Intricacias das Cadeias da LangChain: Desbloqueando o Potencial de Soluções de Aprendizagem Multimodelos de Idiomas
LangChain é uma ferramenta cativante que está tendo um impacto significativo na dinâmica esfera de modelos de aprendizagem de idiomas (LLMs). Neste post de blog, exploraremos a peça fundamental desta ferramenta inovadora - as Cadeias da LangChain. O que são elas? Como funcionam? E por que são tão cruciais para a LangChain?
O que é a LangChain? O que é a IA da LangChain?
Antes de aprofundarmos nas Cadeias da LangChain, vamos entender a LangChain em si. LangChain é uma biblioteca robusta projetada para simplificar a interação com vários fornecedores de grandes modelos de idiomas (LLMs) como OpenAI, Cohere, Bloom, Huggingface e muito mais. A proposição única da LangChain é sua capacidade de criar Cadeias, que são links lógicos entre um ou mais LLMs. Essa característica é o que proporciona à LangChain sua considerável utilidade.
Você pode ler mais sobre a LangChain com nosso Artigo de Introdução à LangChain.
O que são Cadeias da LangChain?
As Cadeias são o núcleo vital da LangChain. Essas conexões lógicas entre um ou mais LLMs são a espinha dorsal da funcionalidade da LangChain. As Cadeias podem variar de simples a complexas, dependendo das necessidades e dos LLMs envolvidos. Vamos nos aprofundar em ambos os tipos:
Cadeias Básicas
Uma Cadeia básica é a forma mais simples de uma Cadeia que pode ser criada. Ela envolve um único LLM recebendo uma solicitação de entrada e usando essa solicitação para a geração de texto.
Por exemplo, construímos uma Cadeia básica usando a Huggingface como nosso fornecedor de LLM com o seguinte código:
python
from langchain.prompts import PromptTemplate
from langchain.llms import HuggingFace
from langchain.chains import LLMChain
prompt = PromptTemplate(
input_variables=["city"],
template="Descreva um dia perfeito em {city}?",
)
llm = HuggingFace(
model_name="gpt-neo-2.7B",
temperature=0.9)
llmchain = LLMChain(llm=llm, prompt=prompt)
llmchain.run("Paris")A saída será um texto gerado por IA descrevendo um dia perfeito em Paris.
Cadeias Avançadas
Cadeias avançadas, também conhecidas como Cadeias de utilidade, são compostas por vários LLMs para abordar uma tarefa específica. Um exemplo adequado é a SummarizeAndTranslateChain, que tem como objetivo tarefas como resumir e traduzir.
Por exemplo, a LangChain apresenta uma cadeia de utilidade específica chamada TopicModellingChain, que lê artigos e gera uma lista de tópicos relevantes.
python
from langchain.chains import TopicModellingChaintopic_chain = TopicModellingChain(llm=llm, verbose=True) topic_chain.run("Texto de um artigo científico sobre mudanças climáticas.")
Aqui, a saída fornece uma lista de tópicos relevantes para o artigo científico fornecido sobre mudanças climáticas.
## A força das cadeias LangChain
O que torna as cadeias LangChain tão importantes?
As cadeias LangChain permitem aos usuários vincular sem esforço vários LLMs, amalgamando as forças de diferentes modelos e facilitando a execução de tarefas mais complexas e sofisticadas. Eles aumentam as habilidades dos arranjos tradicionais de modelos únicos, abrindo caminho para soluções inventivas para problemas intricados.
As cadeias LangChain representam um avanço substancial no mundo do LLM. Ao preencher as lacunas entre modelos de maneira acessível, eles podem se tornar uma ferramenta inestimável para desenvolvedores em todo o mundo, desde entusiastas até profissionais de nível empresarial. Com o poder das cadeias LangChain, não há limites para o que os modelos de aprendizado de idiomas podem realizar.
## Cadeias sem LLMs e prompts
Embora o PalChain discutido anteriormente exija um LLM (e um prompt correspondente) para analisar a pergunta do usuário escrita em linguagem natural, existem cadeias em LangChain que não precisam de um. Essas são principalmente cadeias de transformação que pré-processam o prompt, como remover espaços extras, antes de inseri-lo no LLM. Por exemplo:
```python
from langchain.chains import TrimSpacesChain
trim_chain = TrimSpacesChain()
prompt_limpo = trim_chain.run(" Como está o clima ? ")
print(prompt_limpo) # Outputs: "Como está o clima?"Nesse caso, TrimSpacesChain é utilizado para limpar o prompt, eliminando espaços desnecessários. Após o pré-processamento, você pode inserir o prompt limpo em qualquer LLM de sua escolha.
Criando Cadeias: O SimpleSequentialChain
Agora, vamos nos concentrar em um tipo específico de cadeia: o SimpleSequentialChain. Esse tipo de cadeia nos permite vincular logicamente LLMs de modo que a saída de um sirva como entrada para o próximo.
Considere um cenário em que precisamos primeiro limpar o prompt (remover espaços extras, encurtá-lo, etc.), e depois usar este prompt limpo para chamar um LLM. Vamos usar o TrimSpacesChain acima e combiná-lo com um LLM Chain.
from langchain.chains import SimpleSequentialChain
trim_chain = TrimSpacesChain()
llm_chain = LLMChain(llm=llm, prompt=prompt)
combined_chain = SimpleSequentialChain([trim_chain, llm_chain])
output = combined_chain.run(" Como está o clima ? ")
print(output) # Outputs AI-generated text based on the cleaned promptNessa configuração, a saída do TrimSpacesChain (prompt limpo) é passada como entrada para o LLMChain.
O papel dos agentes em LangChain
Os agentes em LangChain apresentam uma maneira inovadora de chamar dinamicamente o LLM com base na entrada do usuário. Eles não só têm acesso a um LLM, mas também a um conjunto de ferramentas (como Pesquisa do Google, REPL do Python, calculadora matemática, APIs do clima, etc.) que podem interagir com o mundo externo.
Considere um exemplo prático usando o agente ZERO_SHOT_REACT_DESCRIPTION da LangChain:
from langchain.agents import initialize_agent, AgentType, load_tools
from langchain.llms import OpenAI
llm = OpenAI(temperature=0)
tools = load_tools(["pal-math"], llm=llm)
agente = initialize_agent(ferramentas, llm, agente=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
resposta = agente.run("Se a minha idade é metade da idade do meu pai e ele fará 60 anos no próximo ano, qual é a minha idade atual?")
print(resposta) # Saída: "Minha idade atual é de 29,5 anos."
Neste caso, o agente usa a ferramenta pal-math e um LLM da OpenAI para resolver um problema matemático embutido em uma prompt em linguagem natural. Ele demonstra um caso prático em que o agente traz um valor adicional ao entender o prompt, escolher a ferramenta correta para resolver a tarefa e, eventualmente, retornar uma resposta significativa.
---
Com as capacidades dinâmicas de cadeias e agentes no LangChain, os usuários podem projetar fluxos de trabalho de processamento de linguagem multi-etapas de forma flexível. Se você deseja pré-processar prompts, criar cadeias multi-LLM ou usar agentes para escolher dinamicamente LLMs e ferramentas, o LangChain fornece os blocos de construção para torná-lo possível.
# Caso de uso avançado: Gerar recomendações de filmes com base nos gêneros favoritos do usuário
Para este caso de uso, vamos trabalhar com duas cadeias:
Cadeia #1 - Uma cadeia LLM que pergunta ao usuário sobre seus gêneros favoritos de filmes.
Cadeia #2 - Outra cadeia LLM que usa os gêneros da primeira cadeia para recomendar filmes dos gêneros selecionados.
Em primeiro lugar, vamos criar a cadeia_one.
```python
template = '''Você é uma pesquisa de gênero de filmes. Pergunte ao usuário sobre seus gêneros favoritos.
Pergunte:'''
prompt_template = PromptTemplate(input_variables=[], template=template)
chain_one = LLMChain(llm=llm, prompt=prompt_template)Em seguida, criamos a cadeia_two para recomendar filmes.
template = '''Você é um recomendador de filmes. Dados os gêneros favoritos do usuário: {genres}, sugira alguns filmes que se enquadram nesses gêneros.
Sugira filmes:'''
prompt_template = PromptTemplate(input_variables=["genres"], template=template)
chain_two = LLMChain(llm=llm, prompt=prompt_template)Em seguida, vamos combinar essas cadeias usando SimpleSequentialChain.
from langchain.chains import SimpleSequentialChain
overall_chain = SimpleSequentialChain(
chains=[chain_one, chain_two],
verbose=True)Você notará que não mencionamos explicitamente input_variables e output_variables para SimpleSequentialChain. Isso ocorre porque a suposição subjacente é que a saída da cadeia 1 é passada como entrada para a cadeia 2.
Agora, vamos executar esta cadeia:
overall_chain.run('Quais são seus gêneros favoritos de filmes?')
# SAÍDA
# > Entrando em uma nova cadeia SimpleSequentialChain...
# > Entrando no novo LLMChain...
# Gêneros favoritos: Ação, Drama, Comédia
# > Chain concluída.
# Dado seus gêneros favoritos: Ação, Drama, Comédia, algumas recomendações de filmes seriam:
# Ação: Duro de Matar, Mad Max: Estrada da Fúria, Batman - O Cavaleiro das Trevas
# Drama: Um Sonho de Liberdade, A Lista de Schindler, Forrest Gump
# Comédia: Superbad, Se Beber, Não Case!, Missão Madrinha de Casamento
# > Chain concluída.
O primeiro LLMChain pede pelos gêneros favoritos e o segundo usa essas informações para gerar recomendações de filmes. Isso é um ótimo exemplo de como é possível combinar vários LLMChains em uma SimpleSequentialChain para criar um sistema de recomendação de filmes personalizado.
Agora, imagine que você também queira obter algumas informações adicionais do usuário, como a duração de filmes preferida. Podemos atualizar a chain_dois para receber outra variável de entrada, movie_length.
```python
template = '''Você é um recomedador de filmes. Dados os gêneros favoritos do usuário: {genres} e a duração preferida de filmes: {movie_length}, sugira alguns filmes que se enquadrem nesses gêneros.
Sugestão de filmes:'''
prompt_template = PromptTemplate(input_variables=["genres", "movie_length"], template=template)
chain_two = LLMChain(llm=llm, prompt=prompt_template)Finalmente, combinamos as chains usando SequentialChain, que nos permite lidar com múltiplas entradas e saídas.
overall_chain = SequentialChain(
input_variables=["input"],
memory=SimpleMemory(memories={"movie_length": "2 horas"}),
chains=[chain_one, chain_two],
verbose=True)Nesse cenário, estamos usando SimpleMemory para armazenar o contexto adicional 'movie_length', que não deve mudar entre os prompts. Quando executarmos essa chain, ela sugerirá filmes com base não apenas nos gêneros favoritos, mas também considerará a duração preferida dos filmes.
Conclusão
Eu encorajo você a experimentar e brincar com o LangChain. As possibilidades são ilimitadas quando se trata de encadear diferentes agentes e modelos de IA para criar aplicativos ainda mais poderosos e úteis!"
FAQ
-
O que é LangChain? LangChain é uma biblioteca Python que permite criar e encadear diferentes modelos de AI, agentes e prompts de forma estruturada. É perfeito para criar aplicativos de IA complexos em que você precisa interagir com vários modelos em sequência.
-
O que é SimpleSequentialChain e SequentialChain no LangChain? Ambos são tipos de chains no LangChain, que permitem encadear diferentes entidades de IA (modelos, agentes, etc.). SimpleSequentialChain é usado quando há uma única entrada e uma única saída entre as chains, enquanto o SequentialChain é usado quando há múltiplas entradas e saídas.
-
Como posso adicionar contexto adicional usando LangChain? Você pode usar o SimpleMemory para adicionar contexto adicional no LangChain. É uma maneira fácil de armazenar contexto ou outras informações que nunca devem mudar entre prompts.
-
Posso criar agentes personalizados no LangChain? Sim, você pode criar agentes personalizados usando a classe Agent no LangChain. Agentes podem encapsular lógica complexa e fazer parte de uma chain.
-
Onde posso encontrar mais informações sobre o LangChain? Você pode encontrar mais informações sobre o LangChain em seu site de documentação oficial. É um projeto de código aberto, então você também pode conferir seu código-fonte no GitHub.