🐣✨Explorando o conceito de LLM criando uma Bebê IA no Google Colab
A Inteligência Artificial muitas vezes parece uma “caixa preta” mágica, mas, na verdade, ela é construída com blocos de lógica, matemática e muita repetição. Hoje, ouvimos falar constantemente de LLMs (do inglês, Large Language Models ou Grandes Modelos de Linguagem). Mas o que eles são na prática?
De forma simples, um LLM é um algoritmo de aprendizado profundo treinado em quantidades massivas de texto para entender, gerar e prever a próxima palavra de uma frase. Modelos como o ChatGPT são chamados de “Large” (Grandes) por possuírem bilhões de parâmetros, mas a lógica fundamental que os move é a mesma desta nossa pequena IA.”
Neste artigo, vou mostrar como criei a MinhaIABebe, uma versão minimalista de um modelo de linguagem baseada na arquitetura Transformer — “”O grande segredo por trás dos Transformers é o chamado Mecanismo de Atenção. Diferente de modelos antigos que liam o texto de forma linear, a atenção permite que a IA olhe para a frase inteira de uma vez e entenda quais palavras são mais importantes para o contexto. É por isso que ela consegue saber que, em ‘O céu é azul’, a palavra ‘céu’ é a chave para prever ‘azul’.
Vamos acompanhar como ensinei essa IA a responder do absoluto zero.
Para esse exemplo vamos usar o Google Colab usando códigos em python.
Passo 1. Configurando o Ambiente no Google Colab
O Google Colab ( https://colab.research.google.com/ ) é uma ferramenta gratuita que permite rodar código Python diretamente no navegador. A grande vantagem é que o Google nos empresta uma GPU (um processador potente), o que acelera drasticamente o treinamento da nossa IA.
Adicione um novo “New notebook”, caso feche a tela de entrada você pode usar o menu “File” -> “New notebook in Drive”, conforme abaixo:
Altere o nome do arquivo, no meu caso usei o nome “Minha_IA_Bebe”
Agora vamos alterar as configurações para o runtime, através do menu “Runtime” -> “Change runtime type”.
Por default a opção selecionada é “CPU”, vamos alterar para “T4 GPU”
Com isso temos o Colab pronto para receber o código em python.
Passo 2. Construindo o “Cérebro” (A Arquitetura)
O primeiro passo é definir a estrutura neural. Usamos a biblioteca PyTorch, uma das mais populares para Deep Learning.
import torch
import torch.nn as nn
class BebeIA(nn.Module):
def __init__(self, vocab_size):
super().__init__()
# Transforma letras em representações numéricas de 128 dimensões
self.embedding = nn.Embedding(vocab_size, 128)
# O TransformerEncoder é o coração: ele entende o contexto das letras
self.transformer = nn.TransformerEncoder(
nn.TransformerEncoderLayer(d_model=128, nhead=8, batch_first=True),
num_layers=2
)
# Transforma os números de volta para o tamanho do nosso vocabulário
self.saida = nn.Linear(128, vocab_size)
def forward(self, x):
x = self.embedding(x)
x = self.transformer(x)
return self.saida(x)Explicação:
nn.Embedding: IAs não leem letras, leem números. Essa camada traduz caracteres para vetores numéricos.nn.TransformerEncoder: É onde a "atenção" acontece, permitindo que a IA entenda que o "i" depois do "O" forma um "Oi".
Adicionamos ao primeiro bloco de código no Colab:
E na sequencia adicionamos mais um bloco de código para receber as próximas etapas, separamos os blocos para que possamos executar separadamente conforme a nossa necessidade. Ex: As etapas de construção e aprendizado serão executadas uma ínica vez.
Adicionando uma nova instância
# Criando a instância da sua IA (vamos supor um vocabulário de 256 caracteres)
modelo = BebeIA(vocab_size=256)
print("IA Bebê criada e pronta para aprender!")Nesse momento podemos temos a nossa IA criada e podemos executar todos os blocos de código na opção “Executar tudo”.
O resultado deve ser a mensagem “IA Bebê criada e pronta para aprender!” no resultado do segundo bloco.
Passo 3. Atribuindo novos sentidos para conversar
Antes de treinar, a IA é como um bebê que acabou de nascer: ela tem o cérebro, mas não sabe o que as letras significam, nesse momento vamos ensina-la a receber uma pergunta e responder, mesmo não entendo.
Get Andrey Angelini’s stories in your inbox
Join Medium for free to get updates from this writer.
Dessa forma alteramos o segundo bloco de código para receber a função conversar.
# Criando a instância da sua IA (vamos supor um vocabulário de 256 caracteres)
modelo = BebeIA(vocab_size=256)
print("IA Bebê criada e pronta para receber perguntas!")
# Ensinando a Conversar
# Função para converter texto em números e pedir uma resposta
def conversar(pergunta, tamanho_resposta=15):
palavra_gerada = ""
entrada_texto = pergunta
for _ in range(tamanho_resposta):
# Transforma o texto atual em números
entrada = torch.tensor([ord(c) for c in entrada_texto]).unsqueeze(0)
with torch.no_grad():
saida = modelo(entrada)
# Pega a letra com maior probabilidade
_, proximo_id = torch.max(saida[:, -1, :], dim=-1)
letra = chr(proximo_id.item())
palavra_gerada += letra
# Adiciona a letra na entrada para ela pensar na próxima
entrada_texto += letra
return palavra_gerada
print("IA Bebê pronta para aprender!")Após as alterações o resultado da execução, temos a seguinte resposta:
Passo 4. A Alfabetização (O Treinamento)
Para a IA aprender, precisamos de um “livro” (Dataset) e de um “professor” (Otimizador).
# Treinamento
import torch.optim as optim
# 1. O livro de tarefas
perguntas = ["Ola", "Qual seu nome?", "O ceu e", "Voce e uma IA?"]
respostas = ["Oi!", "Sou a BebeIA", "azul", "Sim, sou."]
otimizador = optim.Adam(modelo.parameters(), lr=0.001)
criterio = nn.CrossEntropyLoss()
print("Iniciando treinamento completo...")
for epoca in range(2000):
total_perda = 0
for p, r in zip(perguntas, respostas):
# Vamos ensinar a IA que: Pergunta -> Resposta
# Entrada: Pergunta + parte da resposta
# Alvo: Próxima letra da resposta
texto_completo = p + r
for i in range(len(p), len(texto_completo)):
# O que ela lê (pergunta + letras que já saíram)
x = torch.tensor([ord(c) for c in texto_completo[:i]]).unsqueeze(0)
# O que ela deve dizer em seguida
y = torch.tensor([ord(texto_completo[i])])
previsao = modelo(x)
perda = criterio(previsao[:, -1, :], y)
otimizador.zero_grad()
perda.backward()
otimizador.step()
total_perda += perda.item()
if epoca % 500 == 0:
print(f"Epoca {epoca} - Erro: {total_perda:.4f}")
print("Agora ela aprendeu a sequência! Converse com ela.")O treinamento é o processo que demanda maior tempo de processamento e recursos, pois nessa etapa a IA recebe as informações para responder as perguntas.
Durante o processo no Google Colab, você verá o contador de Épocas e o valor do Erro. Pense na Época como cada vez que a IA lê o livro de estudos, e no Erro como a quantidade de ‘notas baixas’ que ela tira. O nosso objetivo é que, ao final das épocas, o erro seja o menor possível, mostrando que ela não está mais chutando, mas sim compreendendo o padrão do texto.
*Nota: O tempo total da etapa de treinamento no meu caso foi de 19 minutos.
Passo 5. Resultados e Lições Aprendidas
Após o treinamento, na primeira tentativa de obter uma resposta ela não conseguiu responder corretamente, temos que ter paciência pois é a primeira interação.
Nesse caso para a pergunta “Qual seu nome?” ela respondeu “Sou a a a a B”, gagejou um pouco
Na segunda tentativa, sem qualquer alteração no código, ela começa a ter mais confiança e para a mesma pergunta ela respondeu “Sou BeIA Bebe”.
Nessa etapa, é necessário insistência e paciência, pois como respostas podemos ter repetições infinitas, respostas cortadas e etc, no meu caso precisei alternar as perguntas algumas vezes até que a IA respondesse corretamente!
Repetições infinitas:
O Sucesso Final:
Esse foi o resultado final com a IA respondendo corretamente e pergunta “Qual seu nome?”.
Conclusão
Construir essa “IA Bebê” demonstra que, por trás das interfaces complexas como o ChatGPT, existe uma base de previsão de texto (Next Token Prediction). Treinar uma IA exige paciência, ajuste de parâmetros e, acima de tudo, entender que o erro faz parte do aprendizado — tanto para a máquina quanto para o programador.
