LangChain: automatizando análise de dados com agentes

Respondendo perguntas sobre dados em arquivos CSV - Apresentação

Apresentando o curso e a instrutora

Olá! Já consideramos a ideia de desenvolver um agente autônomo para auxiliar na análise de dados? Neste curso, é exatamente isso que faremos. Meu nome é Valquíria, sou instrutora na Escola de Dados e na Escola de Inteligência Artificial.

Audiodescrição: Valquíria é uma mulher branca, de olhos castanhos, com cabelos loiros e ondulados na altura abaixo dos ombros. Ela possui um piercing no lábio e está vestindo uma blusa preta.

Introduzindo a aplicação de análise de dados

Neste curso, desenvolveremos uma aplicação para análise de dados. Ao final, faremos o deploy (implantação) dessa aplicação. Vou apresentar a aplicação agora. Esta é a página inicial, a partir da qual podemos gerar relatórios automáticos, fazer perguntas sobre os dados e também criar gráficos.

Vamos testar juntos? Podemos fazer o upload de um arquivo CSV. Vou clicar para realizar o upload. Este é o arquivo que utilizaremos no curso, contendo dados de uma empresa de logística, com várias informações sobre entregas realizadas.

Explorando funcionalidades de relatórios e estatísticas

O que podemos fazer com esses dados? Temos opções de ações rápidas. Podemos clicar em relatórios de informações gerais. Ao clicar, ele começará a gerar um relatório, que nos mostrará a dimensão do arquivo, a descrição de cada coluna, além de informar se há dados nulos ou duplicados. O relatório também sugere possíveis análises e tratamentos a serem realizados. É incrível! Podemos, inclusive, baixar esse relatório.

Além disso, podemos nos aprofundar e criar um relatório de estatísticas descritivas. Vamos clicar para testar essa funcionalidade. Cliquei, e ele está gerando o nosso relatório.

Ao ampliarmos aqui, temos uma visão geral sobre os dados, incluindo uma análise por cada coluna, identificação de outliers (valores atípicos) e recomendações de próximos passos. Também é possível fazer o download. Esse resultado é bastante interessante.

Interagindo com os dados e gerando gráficos

Além disso, podemos fazer perguntas sobre os dados. Por exemplo, se quisermos saber a média do tempo de entrega, podemos clicar em "responder pergunta" para ver o que acontece. O sistema analisa e já responde, informando que a média do tempo de entrega é de 124,91 minutos.

Se desejarmos gerar um gráfico, podemos testar essa funcionalidade também. Na seção de gráficos, podemos solicitar a criação de um gráfico da média do tempo de entrega por clima, ordenado do maior para o menor valor. Ao clicar em "gerar gráfico", o gráfico é gerado, bem formatado, e podemos ampliá-lo ou fazer o download.

Essa ferramenta permite analisar os dados de forma abrangente, oferecendo um panorama geral, mostrando estatísticas, respondendo perguntas simples e criando gráficos.

Utilizando o LangChain para desenvolvimento

Para construir tudo isso, utilizaremos um framework muito popular na área de inteligência artificial, o LangChain. Com essa ferramenta, desenvolveremos um agente orquestrador que, a partir de várias ferramentas que criaremos ao longo do curso, escolherá a ferramenta adequada de acordo com a pergunta feita pelo usuário e a utilizará para fornecer a resposta. Teremos um LLM (Modelo de Linguagem Grande) por trás para responder a essas perguntas e utilizar essas ferramentas.

Preparando-se para o curso

Esse processo será incrível e auxiliará bastante no dia a dia, na análise de dados, reduzindo tarefas repetitivas e aumentando a produtividade. Para acompanhar bem este curso, recomendamos que já se tenha conhecimento na linguagem de programação Python e na biblioteca Pandas.

Vamos começar?

Respondendo perguntas sobre dados em arquivos CSV - Gerando códigos com LLMs para analisar dados

Introduzindo o projeto de automação de análise de dados

Vamos iniciar nosso projeto imaginando uma empresa de logística que possui uma grande quantidade de dados relacionados às suas entregas. Eles têm informações sobre o clima no dia da entrega, o tráfego, o tipo de produto entregue, o tempo da entrega, entre outras. Esses dados são utilizados para tomar decisões, criar modelos preditivos, otimizar tarefas e melhorar o atendimento ao cliente. A equipe responsável por analisar esses dados e criar modelos preditivos pode enfrentar tarefas repetitivas devido à grande quantidade de informações. Por exemplo, sempre que um arquivo é recebido, é necessário verificar dados nulos, duplicados e analisar quais colunas usar para os modelos preditivos.

A ideia é criar uma ferramenta que automatize a análise de dados, permitindo que a equipe se concentre em tarefas mais complexas, como a criação de modelos, sem sobrecarregar os processos da empresa. Vamos desenvolver uma solução utilizando agentes de inteligência artificial. Imagine um agente autônomo que, a partir de uma pergunta do usuário, consiga executar um código e fornecer um relatório, uma resposta ou até mesmo um gráfico. Isso será de grande ajuda para a equipe no dia a dia.

Carregando e visualizando dados no Google Colab

Vamos começar entendendo como um LLM (grande modelo de linguagem) pode nos auxiliar, por exemplo, gerando um código para analisar um arquivo. Iniciaremos no Google Colab carregando os dados da empresa. Para isso, importaremos a biblioteca Pandas, voltada para análise de dados, com o comando:

import pandas as pd

Em seguida, criaremos uma variável para armazenar os dados, chamada df (dataframe). Inicialmente, definimos a variável df sem atribuir um valor específico:

df = 

Agora, utilizaremos o comando pd.read_csv para carregar o arquivo no formato CSV, que é separado por vírgulas. O arquivo está localizado no GitHub, em um repositório do curso, com o nome dados_entregas.csv. Vamos completar a linha de código para carregar o arquivo:

df = pd.read_csv("https://raw.githubusercontent.com/vqrrca/agentes_langchain/refs/heads/main/Dados/dados_entregas.csv")

Para visualizar os dados, clicaremos na opção "View Raw" no GitHub, copiaremos o endereço do arquivo e colaremos no Google Colab. Executaremos a célula para visualizar as informações. As colunas incluem o ID do pedido, anos de experiência do agente, classificação do agente, informações geográficas (latitude e longitude da loja e do local de entrega), data e hora do pedido, hora de retirada, clima, tráfego, veículo usado, área da entrega, categoria do produto e tempo da entrega. Para visualizar as primeiras linhas do dataframe, utilizamos:

df.head()

Automatizando a análise de dados com LLMs

O objetivo é que a equipe de dados, ao receber esse arquivo, possa construir um modelo preditivo para prever o tempo de entrega com base nas características disponíveis. Para isso, é necessário analisar os dados, verificar os tipos de cada coluna, tratar dados nulos e duplicados, e explorar relações, como a influência dos anos de experiência no tempo de entrega.

Queremos automatizar esse processo, evitando a necessidade de escrever código manualmente para calcular correlações, por exemplo. Desejamos que um LLM gere o código necessário para automatizar essas tarefas. Vamos aprender a obter esse código utilizando a ferramenta LangChain, que está em alta no campo da inteligência artificial e é útil para criar soluções e aplicações.

Configurando o LangChain e o Grok no Google Colab

Dentro do LangChain, podemos usar diferentes modelos de linguagem, como o da OpenAI (ChatGPT) ou o Gemini do Google, mas com custos associados. Optaremos por uma alternativa gratuita, utilizando a ferramenta Grok, que fornece uma chave de API para acessar modelos gratuitos, como o Lama. Vamos conectar o LangChain ao Grok para começar a usar o modelo, fazer perguntas e realizar o processo.

Primeiro, instalaremos o módulo do LangChain que utiliza o Grok no Colab com o comando:

pip install langchain-groq -q

Após a instalação, definiremos nosso modelo utilizando a chave de API do Grok. Detalharemos esse processo na atividade de preparação do ambiente, mas, resumidamente, acessaremos a página do Grok em grok.com e navegaremos até a seção de desenvolvedores para obter a chave necessária.

Obtendo e configurando a chave de API do Grok

Nós vamos clicar na parte indicada e selecionar a primeira opção, que é o Free API Key. Caso ainda não tenhamos uma conta, será necessário criar uma, podendo utilizar o GitHub ou o Gmail para isso. Já acessamos a nossa conta e temos algumas chaves criadas. Para criar uma nova chave, vamos à parte superior direita e clicamos em Create API Key. Precisamos dar um nome para essa chave, como por exemplo, projeto-agentes-langchain. Em seguida, clicamos em Submeter. A chave será gerada e podemos copiá-la. É importante lembrar que, após copiar e clicar em Done para fechar a janela, não teremos mais acesso a essa chave. Portanto, devemos colá-la em um local seguro para acessá-la posteriormente.

Voltamos ao Google Colab. No menu lateral esquerdo, há um ícone de chave, que representa os Secrets. Para adicionar a chave, já a nomeamos como GROK_API, em caixa alta, e colamos a chave na parte do valor. Precisamos ativar o acesso ao notebook, clicando até que o ícone de verificação apareça.

Utilizando o Grok no LangChain para gerar código

Para usar essa chave no Google Colab, dentro do notebook, há um código que acessa as chaves de Secret em Python. Vamos copiá-lo, fechar a janela e colá-lo na próxima célula. Utilizamos:

from google.colab import userdata
GROQ_API = userdata.get('GROQ_API')

Agora, para utilizar o Grok no LangChain e criar um modelo para interação, importamos uma classe especial. Digitamos:

from langchain_groq import ChatGroq

Executamos a célula e definimos nosso modelo. Criamos uma variável chamada llm, que será igual a ChatGroq. Inicialmente, definimos a temperatura do modelo:

llm = ChatGroq(temperature=0)

Em seguida, adicionamos a chave de API e o nome do modelo:

llm = ChatGroq(temperature=0, groq_api_key=GROQ_API, model_name='llama3-70b-8192')

Gerando e testando código para análise de dados

Executamos a célula e fazemos uma pergunta para a LLM, verificando se ela consegue gerar um código para análise de dados. Criamos uma variável ai_msg e usamos o método invoke da llm para passar a mensagem. Abrimos parênteses e usamos aspas triplas para digitar o texto. Informamos que temos um DataFrame chamado df com colunas "anos de experiência agente" e "tempo de entrega". Pedimos um código em Python com a biblioteca Pandas para calcular a correlação entre essas colunas, retornando o código formatado em Markdown:

ai_msg = llm.invoke(
    """
    Eu tenho um dataframe chamado 'df' com as colunas 'anos_experiencia_agente' e 'tempo_entrega'.
    Escreva o código Python com a biblioteca Pandas para calcular a correlação entre as duas colunas.
    Retorne o Markdown para o trecho de código Python e nada mais.
    """
)

Executamos a célula e exibimos a resposta com:

print(ai_msg.content)

O código gerado calcula a correlação entre as colunas, utilizando:

correlacao = df['anos_experiencia_agente'].corr(df['tempo_entrega'])
print(f"A correlação entre 'anos_experiencia_agente' e 'tempo_entrega' é de {correlacao:.2f}")

Podemos copiar e executar o código para verificar o cálculo, que resulta em uma correlação de -0.25.

Concluindo a utilização de LLMs para automação

Conseguimos utilizar um LLM com LangChain e Grok para gerar código a partir de informações sobre nossos dados. Os LLMs, treinados com documentações de bibliotecas, geram código que testamos e verificamos estar correto. O próximo passo é automatizar o processo para que o LLM execute o código e traga tudo pronto. Nos vemos no próximo vídeo!

Respondendo perguntas sobre dados em arquivos CSV - Executando o código gerado com ferramentas Python

Instalando o pacote experimental do LangChain

Para automatizar o processo de execução de código gerado por um LLM, utilizamos o LangChain, especificamente a ferramenta python-est-repltool. Vamos começar instalando o pacote experimental do LangChain, onde essa ferramenta está localizada. Para isso, executamos o seguinte comando:

pip install langchain-experimental -q

Com a instalação concluída, o próximo passo é importar a classe necessária para executar o código. Vamos importar a classe PythonAstREPLTool do módulo langchain_experimental.tools:

from langchain_experimental.tools import PythonAstREPLTool

Configurando a ferramenta PythonAstREPLTool

Agora, vamos instanciar essa classe. Criamos uma variável chamada ferramenta_python e a atribuímos à classe PythonAstREPLTool, passando um dicionário que contém nosso DataFrame df:

ferramenta_python = PythonAstREPLTool(locals={"df": df})

Com a ferramenta configurada, podemos executar um código diretamente. Vamos usar o método invoke da nossa ferramenta para calcular a correlação entre duas colunas do DataFrame:

ferramenta_python.invoke("df['anos_experiencia_agente'].corr(df['tempo_entrega'])")

Ao executar, obtemos o resultado rapidamente, que é -0.25. Isso demonstra que a ferramenta funciona conforme esperado, executando o código e retornando o resultado.

Integrando a ferramenta com um LLM

Para integrar essa ferramenta com um LLM, criamos uma nova variável chamada llm_com_ferramenta. Atribuímos a ela nosso LLM e usamos o método bind_tools para unir a ferramenta ao modelo:

llm_com_ferramenta = llm.bind_tools([ferramenta_python], tool_choice=ferramenta_python.name)

Agora, podemos fazer perguntas ao LLM e obter respostas que incluem a execução de código. Criamos uma variável resposta e utilizamos o método invoke para enviar uma pergunta ao LLM:

resposta = llm_com_ferramenta.invoke(
    """Eu tenho um dataframe 'df' e quero saber a correlação entre as colunas 'anos_experiencia_agente' 
    e 'tempo_entrega'"""
)

Formatando a saída com um parser

Para formatar a saída e obter apenas o código necessário, utilizamos um parser. Importamos a classe JsonOutputKeyToolsParser e a configuramos:

from langchain_core.output_parsers.openai_tools import JsonOutputKeyToolsParser

parser = JsonOutputKeyToolsParser(key_name=ferramenta_python.name, first_tool_only=True)

Construindo e executando a cadeia de processos

Finalmente, construímos uma cadeia de processos usando o LangChain. Definimos que a primeira etapa é gerar o código com o LLM e a segunda etapa é converter a saída em um formato de dicionário:

cadeia = llm_com_ferramenta | parser

Para executar essa cadeia, utilizamos o método invoke novamente:

cadeia.invoke(
    """Eu tenho um dataframe 'df' e quero saber a correlação entre as colunas 'anos_experiencia_agente' 
    e 'tempo_entrega'"""
)

Com isso, conseguimos automatizar o processo de geração e execução de código, integrando o LLM com a ferramenta do LangChain, e formatando a saída para obter apenas o que é necessário. No próximo vídeo, continuaremos a explorar como finalizar esse processo.

Sobre o curso LangChain: automatizando análise de dados com agentes

O curso LangChain: automatizando análise de dados com agentes possui 230 minutos de vídeos, em um total de 49 atividades. Gostou? Conheça nossos outros cursos de IA para Dados em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Respondendo perguntas sobre dados em arquivos CSV
• Obtendo respostas explicativas
• Construindo ferramentas do zero
• Orquestrando agentes capazes de usar múltiplas ferramentas
• Criando uma interface interativa