NLP: explorando LLM para aplicações de chatbot

Utilizando modelos de LLM - Apresentação

Boas-vindas a mais este curso na Alura! Meu nome é Allan Spadini.

Audiodescrição: Allan é um homem de pele branca, com cabelos e olhos castanhos. Veste uma camisa cinza com o texto "Alura" e está no estúdio da Alura.

O que vamos aprender?

Neste curso, aprenderemos a construir um chatbot inteligente que utilizará um Modelo de Linguagem Grande (LLM, do inglês "Large Language Model").

Nosso objetivo é criar um chatbot avançado, não apenas capaz de interagir de forma geral, mas especializado em auxiliar profissionais de uma área técnica específica. Focaremos no desenvolvimento de um chatbot voltado para geociências, que será utilizado em contextos práticos, como em campo, por especialistas da área. Esse chatbot precisará, simultaneamente, esclarecer dúvidas sobre geologia, prever fenômenos como tempestades solares e tempestades comuns, além de fornecer informações sobre a previsão do tempo.

Para atingir esse objetivo, o chatbot precisará ser capaz de consultar uma série de ferramentas e integrar funcionalidades diversas. Ele será projetado para acessar funções Python que vamos desenvolver, além de interagir com bases de dados específicas. Por exemplo, poderemos fornecer uma base de dados proprietária em formato de texto, e o chatbot será capaz de consultar essa base de forma eficiente, extraindo as informações necessárias.

Pré-requisitos

Para acompanhar este curso, é fundamental possuir um bom domínio da linguagem Python, além de conhecimentos básicos em Processamento de Linguagem Natural (NLP, do inglês "Natural Language Processing"). Isso se deve ao fato de que utilizaremos conceitos como embeddings para processar e estruturar o texto, garantindo que as informações sejam transmitidas de maneira adequada para as LLMs, permitindo respostas precisas e contextualizadas.

Conclusão

Espero vê-los nos próximos vídeos deste curso. Até lá!

Utilizando modelos de LLM - Obtendo uma resposta da LLM

Trabalhamos em uma consultoria de IA e fomos contratados para desenvolver um chatbot, porém, um chatbot mais específico. Este chatbot precisará interagir com algumas ferramentas, com o objetivo de auxiliar geocientistas que realizam trabalho de campo e precisam tirar dúvidas específicas.

Por exemplo, ele deverá informar se no local onde será realizado o trabalho de campo haverá chuva ou se ocorrerá uma tempestade geomagnética, já que os equipamentos utilizados pelos geocientistas na busca por ouro, baseados em ondas eletromagnéticas, são afetados por essas tempestades.

Além disso, os geocientistas precisarão consultar informações técnicas relevantes e precisas sobre o local que irão estudar. Portanto, nosso primeiro passo será entender como elaborar perguntas eficazes para uma LLM (Large Language Model, ou Modelo de Linguagem Grande), de modo a permitir esse tipo de interação.

A proposta é desenvolver um chatbot, mas neste vídeo, nosso foco estará em como formular as perguntas adequadas para a LLM.

Elaborando perguntas

Para isso, utilizaremos a biblioteca Litellm. Já realizamos a instalação dessa ferramenta no Google Colab, que é o ambiente que estamos utilizando:

!pip install litellm

Analisaremos o site dessa biblioteca. A Litellm permite trabalhar com diversos modelos de LLM, incluindo modelos pagos, como os da OpenAI (por exemplo, os GPTs) ou o Gemini do Google.

Além disso, ela também oferece suporte a modelos abertos, como o Llama da Meta e o Gemma do Google. Agora, o próximo passo será escolher um fornecedor de LLM para integrar ao nosso chatbot.

Além da Litellm, precisaremos de um fornecedor dessa LLM que permita sua utilização. Neste curso, utilizaremos o Grog, que permite o uso do llama de forma gratuita, tanto em diferentes tamanhos, como o modelo de 8 bilhões de parâmetros, quanto o de 70 bilhões de parâmetros. Também há a possibilidade de utilizar o Gemma, do Google. Assim, podemos escolher e testar diferentes modelos com essa biblioteca.

Inserindo a chave do Groq

Voltando ao nosso código, precisamos acessar o Google Colab e inserir a chave do Groq. No canto esquerdo da página, há um ícone de chave chamado "Secrets". Dentro dessa seção de "Secrets", há uma opção para adicionar um novo Secret. É necessário clicar em "Adicionar novo Secret" e inserir a chave do Groq.

Essa chave permitirá o acesso aos modelos llama ou Gemma através do Groq. Após inserir a chave, precisamos garantir que o notebook tenha acesso a ela para utilizá-la nas interações com os modelos de LLM.

Já copiamos a chave, mas dentro da plataforma do Groq, na seção de desenvolvimento, deixaremos o link disponível em uma atividade para facilitar o acesso. Será necessário seguir os seguintes passos:

• Vá para o lado esquerdo da plataforma e clique em "API Keys".
• Clique em "Create API Key" para gerar uma nova chave de API.
• Após criar a chave, cole-a na área apropriada do secrets, e ela ficará disponível para o notebook.

Na parte inferior da tela na seção "Secrets", a plataforma exibirá o código necessário para acessar essa chave dentro do notebook:

import google.colab import userdata
userdata.get('SecretName')

Copiamos esse código e colamos em uma célula no nosso notebook para integrar corretamente a chave de API e permitir a interação com os modelos disponíveis. Alteramos o nome da chave e inserimos GROQ_API_KEY = antes de userdata e executamos a célula com "Shift + Enter":

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

Fazendo isso, com a biblioteca Litellm instalada, faremos o import dela:

from litellm import completion

Se já utilizamos a API do ChatGPT, por exemplo, do GPT da OpenAI, lembramos que dentro das opções API, há a função chat_completion. Aqui, trouxeram a mesma estrutura com o nome completion. Não é necessário conhecer a API do ChatGPT para este curso. Começaremos trabalhando com essa função.

Com essa função, precisamos passar uma mensagem para a LLM, de forma que ela complete o texto com algo que faça sentido, por exemplo, para responder uma pergunta. Definiremos essa mensagem dentro de uma lista utilizando messages = []. Dentro dos colchetes passamos papéis que estão passando essa mensagem para o modelo. Ao teclarmos "Tab" o autocomplete já insere algumas informações.

É necessário enviar uma mensagem com o parâmetro system, que serve para definir o papel do modelo (LLM). Essa mensagem orienta o modelo sobre sua função. No nosso caso, o chatbot terá um papel específico, que será o de responder perguntas direcionadas aos geocientistas.

Temos um código pronto com uma mensagem que indica para a LLM qual o seu papel:

Você é o chat da Terra e do Universo, que responde perguntas em português brasileiro sobre previsão do tempo na Terra e no espaço próximo à Terra, além de informações sobre terremotos.

Inserimos a mensagem acima após o content. Na sequência, passamos a pergunta que desejamos que a LLM responda. Assim, ficamos com:

messages = [
    {"role": "system", "content": "Você é o chat da Terra e do Universo, que responde perguntas em português brasileiro sobre previsão do tempo na Terra e no espaço próximo à Terra, além de informações sobre terremotos."},
    {"role": "user", "content": "Qual é a frequência dos máximos solares?"}
]

Rodamos com "Shift + Enter".

Agora, precisamos chamar o modelo. Em uma nova célula, utilizaremos a função completion e armazenaremos a saída na variável response. Ao teclarmos "Tab" ele completa o model com algumas informações, mas iremos alteramos para groq/gema-2-9b-it e inserimos a chave de API com api_key=GROQ_API_KEY:

response = completion(
        model="groq/gema-2-9b-it",
        messages=messages,
        api_key=GROQ_API_KEY,
)

Teclamos "Shift + Enter". Para capturar a resposta, utilizaremos o seguinte código:

print(response.choices[0].message.content)

Teclamos "Shift + Enter" e obtemos a resposta:

Olá! Sou o Chat Terra e do Universo, pronto para te ajudar com suas perguntas sobre o tempo, terremotos e espaço…

Quanto à sua pergunta sobre a frequência dos máximos solares, eles ocorrem aproximadamente a cada 11 anos…

É importante lembrar que a duração e intensidade de cada ciclo solar podem variar.

Espero ter ajudado! Tem mais alguma pergunta? Estou à disposição!

Se a resposta não for a esperada, podemos testar outro modelo. Alteraremos o modelo para llama3 utilizando a mesma estrutura da célula anterior:

response = completion(
        model="groq/llama3-groq-70b-8192-tool-use-preview",
        messages=messages,
        api_key=GROQ_API_KEY,
)

Teclamos novamente "Shift + Enter". Logo após, rodamos o print para exibir a resposta:

print(response.choices[0].message.content)

A frequência dos máximos solares, ou ciclos solares, é de aproximadamente 11 anos. Isso significa que, em média…

Agora, o modelo forneceu uma resposta mais concisa, o que pode ser mais interessante para o nosso projeto. No entanto, se fizermos uma pergunta relacionada à que acabamos de fazer, ele não saberá responder, pois está apenas completando as respostas individualmente.

Próximo passo

No próximo vídeo, vamos trabalhar em uma estrutura de chat que permita ao modelo "lembrar" do contexto da conversa. Até lá!

Utilizando modelos de LLM - Construindo um chatbot

Já conseguimos fazer perguntas para a nossa LLM e estamos no processo de construção do chatbot. Até o momento, ele só sabe responder perguntas diretas e não consegue manter um contexto.

Se fizermos outra pergunta para esse modelo, ele não lembrará da pergunta anterior. Nosso objetivo para este vídeo é adicionar uma estrutura de chat, de forma que possamos adicionar essa recursão às perguntas do modelo.

Criando uma estrutura de chat para o chatbot

Para isso, guardaremos o código que fizemos em uma função, e faremos isso em uma nova célula. A chamada do modelo será feita pela função call_groq_api.

def call_groq_api(messages, model="groq/llama-3.3-70b-versatile"):
    response = completion(
        model=model,
        messages=messages,
        api_key=GROQ_API_KEY,
    )
    return response.choices[0].message.content

Nessa função, mudamos o campo model para receber o valor model, passado entre parâmetros, para quando quisermos usar diferentes modelos. No fim, retornamos apenas o texto da resposta. Executamos a célula com "Shift + Enter" e temos nossa função.

Isso ainda não resolveu totalmente nosso problema. Falta criarmos uma função de chat. Em uma nova célula, criaremos a def chat(), onde passamos as mensagens. Antes da mensagem, exibiremos uma saudação, com o print().

def chat():
    print("Iniciando chat com o modelo. Digite 'sair' para encerrar.")
    messages = [
        {"role": "system", "content": "Você é o Chat da Terra e do Universo e responde em português brasileiro perguntas sobre a previsão do tempo na Terra e do espaço próximo à Terra, além de informações sobre terremotos."}
    ]

Na estrutura de mensagem, temos a estrutura do sistema, ou seja, estamos passando as informações para o sistema. Porém, essa informação para o sistema fica fixa. Quando mandarmos informações para o modelo, faremos isso com outro parâmetro, o user, como usamos no vídeo anterior. Assim mandaremos mensagens como pessoas usuárias.

Passaremos, então um loop para a função chat(), que funcionará indefinidamente até enviarmos a mensagem "sair". Para isso, usamos o while e passaremos a estrutura de mensagem.

def chat():
    print("Iniciando chat com o modelo. Digite 'sair' para encerrar.")
    messages = [
        {"role": "system", "content": "Você é o Chat da Terra e do Universo e responde em português brasileiro perguntas sobre a previsão do tempo na Terra e do espaço próximo à Terra, além de informações sobre terremotos."}
    ]

    while True:
        user_message = input("Você: ")
        if user_message.lower() == "sair":
            print("Encerrando chat. Até a próxima!")
            break
        messages.append({"role": "user", "content": user_message})
        model_response = call_groq_api(messages)
        messages.append({"role": "assistant", "content": model_response})
        print(f"Assistente: {model_response}")

Indicamos a mensagem da pessoa usuária com o "Você" e usamos um if para verificar se a pessoa mandou a mensagem "sair". Quando enviar sair, o loop acaba e a conversa é encerrada. Depois, passamos a mensagem da pessoa usuária.

Notem que temos uma lista de mensagens (messages) no início do chat e, no while, fazemos o messages.append() para essa lista, com a próxima mensagem da pessoa usuária. Em seguida, temos a resposta do modelo, guardada na variável model_response, chamando a call_groq_api().

Agregamos a resposta do modelo à sequência de mensagens, utilizando mais um messages.append(), dessa vez usando assistant no lugar de system. Com o assistat, o modelo já terá feito as próprias tarefas, mas ainda reconhece que foi uma resposta dele à nossa pergunta.

O conteúdo da resposta foi passado como model_response, que guardou a resposta com o call_groq_api(). Por fim, temos a resposta do nosso assistente, com o model_response.

Testando o chat

Feito isso, temos a função de chat está pronta. Um dos pontos iniciais que esperávamos para o chat é que ele conseguisse responder questões sobre a previsão do tempo, já que as pessoas podem querer saber se vai chover no dia em que planejam ir ao campo. Vamos fazer uma pergunta para esse chat, então, em uma nova célula, chamamos o chat() e executamos com "Shift + Enter".

chat()

Inciciando chat com o modelo. Digite 'sair' para encerrar

Você:

Abrimos a estrutura de chat dentro do Colab e, na caixa de texto em frente o "Você", escreveremos a pergunta: Qual é a previsão do tempo para São Paulo?. Pressionamos "Enter" para enviarmos a pergunta e recebemos a resposta:

Você: Qual a previsão do tempo para São Paulo?

Assistente: A previsão do tempo para São Paulo é de céu nublado com possibilidade de chuvas isoladas ao longo do dia. A temperatura deve variar entre 18°C e 24°C.

Ele não chegou a responder à pergunta como esperávamos, porque esse modelo não está conectado a nenhuma agência de previsão do tempo. Ele é um modelo fechado, um arquivo no nosso computador. Precisamos encontrar uma forma de ele consultar a previsão do tempo para nos informar.

No próximo vídeo, pensaremos em como fazer esse processo para o chat poder chamar essa informação de previsão do tempo de alguma forma.

Sobre o curso NLP: explorando LLM para aplicações de chatbot

O curso NLP: explorando LLM para aplicações de chatbot possui 142 minutos de vídeos, em um total de 55 atividades. Gostou? Conheça nossos outros cursos de Machine Learning em Data Science, ou leia nossos artigos de Data Science.

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

• Utilizando modelos de LLM
• Usando ferramentas
• Adicionando uma base de conhecimento
• Utilizando o conhecimento no chat
• Entregando a aplicação