Olá, pessoal. Vamos começar a implementar nosso projeto e, para isso, utilizaremos um framework chamado LangChain, bastante utilizado quando buscamos independência na escolha de modelos e queremos garantir robustez na abordagem determinística, ou seja, trazendo previsibilidade na geração de resultados com IA generativa.
Para isso, temos alguns arquivos de base que serão utilizados para implementar um assistente que auxiliará nos estudos. Basicamente, utilizaremos o LangChain para trabalhar com diferentes LLMs que nos ajudarão a interpretar imagens para facilitar anotações de estudos e simplificar a compreensão de determinados assuntos.
Conhecendo o projeto
Para a implementação, utilizaremos três arquivos que já estão no projeto base. O primeiro deles gerencia nossas chaves de acesso da API:
my_keys.py:
import os
from dotenv import load_dotenv
load_dotenv()
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
MARITACA_API_KEY = os.getenv("MARITACA_API_KEY")
Neste curso, usaremos a API do Gemini e a API da Maritaca, uma LLM brasileira. No curso, há uma atividade "Para Saber Mais" explicando como gerar essa chave de acesso e utilizar os créditos disponíveis.
Além disso, utilizaremos outros dois arquivos de script. Um deles contém os principais modelos que usaremos:
my_models.py:
GEMINI_PRO = "gemini-1.5-pro"
GEMINI_FLASH = "gemini-1.5-flash"
MARITACA_SABIA = "sabia-3"
Na linha 1 e 2, temos os dois modelos do Gemini, Gemini Pro e Gemini Flash; enquanto na linha 3, acrescentamos o Maritaca Sabiá-3, o modelo mais moderno disponível nesta LLM brasileira.
O terceiro script, chamado my_helper.py, contém um código curto que permite abrir uma imagem, dado um caminho passado como parâmetro para a função encode_image().
my_helper.py:
import base64
def encode_image(image):
with open(image, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
return encoded_string
Abrimos a imagem e a convertemos para uma base chamada base64. Com a imagem convertida para base64 e no formato de string, conseguimos enviá-la para uma LLM para análise e retorno.
Importando biblioteca e modelo do Gemini
Vamos criar nosso primeiro script. No diretório raiz do projeto, criaremos um novo arquivo chamado lang_chain.py. Nele, faremos as implementações necessárias para conectar com a API da LLM escolhida, tornando-a o mais independente possível e garantindo que os recursos do LangChain nos ajudem a trabalhar com aplicações mais complexas. Ressaltamos que esse framework é amplamente utilizado no mercado.
A primeira ação será importar a biblioteca do LangChain. Para isso, utilizaremos o módulo langchain_google_genai. Dentro deste módulo, encontraremos os recursos necessários para instanciar uma LLM, que inicialmente será a LLM do Gemini. Para isso, importaremos o construtor ChatGoogleGenerativeAI.
lang_chain.py:
from langchain_google_genai import ChatGoogleGenerativeAI
O próximo passo é garantir que possamos tornar genérica a relação de envio de mensagens para a LLM, dissociando o processo de escolha. Para isso, faremos outra importação dentro da biblioteca langchain_core, que oferece diversos recursos. Como queremos trocar mensagens, vamos usar o recurso de messages e importar HumanMessage para assumir o papel de um ser humano que faz perguntas para a LLM.
from langchain_core.messages import HumanMessage
Além disso, precisamos importar nossa chave de acesso e o modelo que utilizaremos. Acessaremos os modelos no my_models e importaremos o modelo mais econômico do Gemini, o GEMINI_FLASH, além da chave de acesso no my_keys, importando a chave GEMINI_API_KEY. Lembre-se de configurá-la no espaço de variáveis de ambiente.
from my_models import GEMINI_FLASH
from my_keys import GEMINI_API_KEY
Por fim, a última importação envolverá nosso encoder. No my_helper, importaremos o encode_image.
from my_helper import encode_image
Criando LLM via LangChain
Com todas as bibliotecas necessárias, podemos interagir com a LLM. Vamos trocar uma mensagem "Olá Mundo", para mostrar que já conseguimos enviar uma imagem e obter uma resposta da LLM.
Vamos começar a criar a LLM. Escolheremos uma variável com nome genérico, pois migraremos de LLM do Gemini para outras LLMs durante o curso. Por isso, chamaremos essa variável de llm.
Em vez de criar uma LLM do zero, traremos a LLM do Gemini para cá. Para isso, usaremos o construtor ChatGoogleGenerativeAI(), que espera dois parâmetros: a chave de acesso, importada na linha 4 como GEMINI_API_KEY; e o tipo de modelo, que será o GEMINI_FLASH importado na linha 3.
llm = ChatGoogleGenerativeAI(
api_key=GEMINI_API_KEY,
model=GEMINI_FLASH
)
Note como esse construtor é mais genérico. Como o LangChain é o orquestrador, ele tira essas diferenças existentes quando criamos um código que utiliza IA generativa.
Codificando imagem
Agora, temos uma LLM que podemos usar na aplicação. O próximo passo é importar a imagem de teste. Para isso, criaremos uma variável chamada imagem e usaremos o método encode_image(), passando o caminho da imagem como parâmetro.
No diretório raiz do projeto, há uma pasta "dados" com um exemplo de gráfico. Este gráfico, criado com dados fictícios, mostra a relação de crescimento do percentual da população brasileira com smartphones ao longo dos anos.
Clicando com o botão direito em exemplo_grafico.jpg, escolhemos a opção para copiar o caminho relativo da imagem (atalho "Ctrl + K, Ctrl + Shift + C") e o inserimos no método encode_image(), entre aspas duplas, no script lang_chain.py .
imagem = encode_image("dados\exemplo_grafico.jpg")
Assim, transformamos a imagem em base64 para enviá-la à LLM para análise. A abordagem varia conforme a LLM escolhida, mas adotamos este orquestrador para reduzir diferenças de interface.
Criando mensagem
Na próxima linha, começamos a criar nossa mensagem. Primeiro, vamos criar a pergunta que faremos a LLM. A variável pergunta vai receber uma string qualquer, como "Descreva a imagem". Desse modo, a LLM deve interpretar e descrever a imagem.
pergunta = "Descreva a imagem: "
Por padrão, entregamos aos modelos multimodais, como o Gemini, um texto com a pergunta e a imagem a ser analisada.
Para compor a mensagem, utilizamos o construtor HumanMessage() para passar uma mensagem humana composta por uma estrutura básica, que é o content.
Esse conteúdo é uma lista com dois objetos dicionários. O primeiro dicionário envolve a mensagem de texto com a pergunta. O par chave-valor inicial, "type": "text", envolve o tipo de mensagem utilizada que, nesse caso, será um texto.
Usamos o termo "multimodal", porque enviamos tanto texto quanto imagem, ou seja, diferentes modais de informação.
Depois do tipo, também precisamos informar o conteúdo textual que a IA vai interpretar, que é a pergunta. Por isso, passamos a chave text com o valor armazenado na variável pergunta.
mensagem = HumanMessage(
content = [
{
"type" : "text",
"text" : pergunta
}
]
)
O segundo dicionário indica o conteúdo da imagem. Para especificar o tipo, usamos a chave type com valor image_url.
O conteúdo da image_url será uma imagem no formato de base64. Por isso, em vez de uma string literal, usamos uma f-string. Assim parte dela é composta pela variável imagem.
Basta começar com a letra f e abrir e fechar aspas, para indicar a composição com variável. Definimos o protocolo data, indicando um dado composto, do tipo imagem no formato JPEG em base 64. E aí, sim, passamos a imagem inteira para a LLM.
mensagem = HumanMessage(
content = [
{
"type" : "text",
"text" : pergunta
},
{
"type" : "image_url",
"image_url" : f"data:image/jpeg;base64,{imagem}"
}
]
)
Embora diferente do que aprendemso em outros cursos, essa abordagem garante robustez ao trocar de LLMs, pois esse formato se manterá igual.
Recebendo a resposta
Agora, vamos enviar a pergunta à LLM. Criamos uma variável resposta e usamos a llm com o método invoke(), que espera um único parâmetro: a mensagem que será enviada.
Passamos o parâmetro como lista de conteúdos, entre colchetes, informando a variável mensagem.
resposta = llm.invoke([mensagem])
Por fim, imprimimos a resposta através do método print(). Lembrando que será devolvido um objeto composto. Podemos extrair apenas a resposta textual, se desejado.
Salvamos o arquivo com "Ctrl + S" e clicamos no botão "Run Python File" no canto superior direito para executar e conferir a resposta da LLM.
Retorno no terminal:
imagem = encode_image("dados\exemplo_grafico.jpg")
content="Claro, aqui está uma descrição da imagem:\n\nA imagem é um gráfico de linha que mostra o percentual da população com smartphones de 2010 a 2020. O eixo x representa o ano, e o eixo y representa o percentual da população. A linha mostra um aumento constante no percentual da população com smartphones durante esse período. Em 2010, o percentual era de cerca de 15%, enquanto em 2020, o percentual era de cerca de 90%. O título do gráfico é 'Percentual da População com Smartphones (2010-2020)'. O gráfico é claro e fácil de entender, e mostra uma tendência clara de aumento no uso de smartphones ao longo do tempo."
additional_kwargs={} response_metadata={'prompt_feedback': {'block_reason': 0, 'safety_ratings': []}, 'finish_reason': 'STOP', 'safety_ratings': []} id='run-08244224-cc24-409c-9ffd-7e774014c39b-0' usage_metadata={'input_tokens': 265, 'output_tokens': 160, 'total_tokens': 425, 'input_token_details': {'cache_read': 0}}
A LLM retorna a resposta, dentro de content, com o texto: "Claro, aqui está uma descrição da imagem. A imagem é um gráfico de linhas, que mostra o percentual da população com smartphones de 2010 até 2020. O eixo X representa o ano, e o eixo Y representa o percentual da população." Isso demonstra que a LLM conseguiu interpretar a imagem.
Próximos passos
Com isso, já conseguimos interagir, desacoplando a dependência de um modelo de LLM específico, como o Gemini, e tornando o processo de troca de modelos mais flexível.
No próximo vídeo, discutiremos como trocar rapidamente de LLM. Até lá.