Marcus Andrey Estudo
Read in English Biblioteca

IA para UX · Passo 1 · 15 min de leitura

Como um modelo aprende: treine um no seu laptop

Explicação passo a passo, para designers que estão começando em IA, do que é um modelo de linguagem, como ele é treinado em três etapas, o que fine-tuning e LoRA mudam, e como ler um treino real feito num laptop, com os erros que ele cometeu.

Você não precisa programar para acompanhar esta nota. Ela explica, em palavras simples, o que acontece dentro de um modelo de linguagem quando ele "aprende", usando um experimento pequeno feito num laptop: ensinar um modelo a escrever mensagens de erro num padrão fixo de UX. Os comandos estão aqui para quem quiser repetir, mas cada passo é explicado em palavras antes.

O que você vai conseguir fazer depois de ler:

  • Explicar a diferença entre pré-treino, ajuste por instruções e ajuste por preferência
  • Dizer o que fine-tuning e LoRA mudam num modelo, e o que não mudam
  • Ler um relatório de treino (loss, validação, overfitting) sem ser engenheiro
  • Decidir, com o seu time, se um problema precisa de fine-tuning ou só de prompts e contexto melhores

O experimento foi feito num MacBook Pro (M3 Max, 36 GB) em novembro de 2026. Ferramentas e modelos mudam rápido; confira as versões antes de repetir.


1. Primeiro: o que é um modelo?

Um modelo de linguagem é, no fundo, um conjunto enorme de números (os parâmetros) e uma receita fixa para combiná-los. Um modelo "4B" tem cerca de 4 bilhões desses números. Nada ali dentro é uma frase, uma regra ou um fato guardado num banco de dados: tudo o que ele "sabe" está espalhado por esses números.

O modelo faz uma única coisa: dado um texto, ele prevê o que vem a seguir. O texto é cortado em pedaços pequenos chamados tokens (palavras inteiras, partes de palavras, pontuação). Para cada posição, o modelo dá uma probabilidade a cada token que conhece. Um exemplo ilustrativo:

"Seu pagamento foi recusado porque o cartão …"

  1. expirou62%
  2. não21%
  3. está9%
  4. outros tokens8%

O app escolhe um token, acrescenta ao texto e pergunta de novo. Uma resposta inteira é esse ciclo, centenas de vezes.

O que um modelo de linguagem faz a cada passo: dá uma probabilidade a cada próximo token possível. Os números são ilustrativos. Diagrama: Marcus Andrey, CC BY 4.0.

O app escolhe um token (normalmente um dos mais prováveis; a temperatura controla o quanto essa escolha é ousada), acrescenta ao texto e pergunta de novo. Uma resposta inteira é esse ciclo repetido centenas de vezes. Por isso um modelo pode soar fluente e ainda assim estar errado: ele produz texto provável, não verifica fatos.


2. As três etapas do treino

Os modelos que você usa no dia a dia passaram por três etapas. Cada uma ajusta os mesmos controles, com material diferente e um objetivo diferente.

Etapa 1: Pré-treino (aprender a língua e o mundo)

  • Material: trilhões de tokens de páginas da web, livros, artigos e código.
  • Objetivo: prever o próximo token, de novo e de novo, em todo esse texto.
  • Resultado: um modelo base. Ele escreve texto fluente e absorveu muito conhecimento geral, mas não "responde" de verdade: ele continua o que você entrega. Pergunte a um modelo base clássico "Qual é uma boa mensagem de erro para cartão recusado?" e ele pode continuar com mais três perguntas, como se estivesse completando uma página de fórum.
  • Custo: meses de trabalho em grandes data centers. É a etapa que só poucas empresas conseguem pagar, e a que torna o modelo grande.
Fileiras de computadores servidores em prateleiras de metal num data center, com luzes azuis.
O pré-treino acontece em salas como esta, numa escala muito maior: milhares de máquinas rodando por meses. Foto: BalticServers.com, Wikimedia Commons, CC BY-SA 3.0.

Etapa 2: Ajuste por instruções, ou SFT (aprender a ser um assistente)

  • Material: de milhares a milhões de conversas de exemplo: um pedido e uma boa resposta, escritos ou revisados por pessoas. SFT quer dizer supervised fine-tuning (ajuste fino supervisionado).
  • Objetivo: a mesma previsão do próximo token, mas agora só nas respostas, para o modelo aprender como é a resposta de um assistente.
  • Resultado: um modelo instruct ou chat. Ele segue pedidos, usa formatos (listas, tabelas, passos) e tem um tom consistente.
  • Analogia: um estágio. "Aqui está uma pergunta; é assim que um bom profissional responde."

Etapa 3: Ajuste por preferência (aprender qual resposta as pessoas preferem)

  • Material: pares de respostas para o mesmo pedido, em que pessoas (ou outro modelo) escolheram a melhor. Os métodos têm nomes como RLHF (aprendizado por reforço com feedback humano) e DPO.
  • Objetivo: deixar as respostas preferidas mais prováveis e as rejeitadas menos prováveis.
  • Resultado: um modelo mais útil, mais cuidadoso, que recusa pedidos perigosos e se aproxima do que as pessoas acham útil.
  • Analogia: uma crítica de design. Não é "certo ou errado", é "esta versão funciona melhor, e o motivo é este".
  1. 1Pré-treino

    Prever o próximo token em trilhões de tokens de texto. Aprende a língua e conhecimento geral.

    Meses, data centers enormes. Resultado: um modelo base
  2. 2Ajuste por instruções (SFT)

    Aprender com conversas de exemplo como é uma boa resposta de assistente.

    Um estágio. Resultado: um modelo instruct
  3. 3Ajuste por preferência

    Aprender qual de duas respostas as pessoas preferem (RLHF, DPO).

    Uma crítica de design. Resultado: um modelo útil e cuidadoso

O conhecimento vem principalmente da etapa 1 · o comportamento (tom, formato, recusas) das etapas 2 e 3

As três etapas que formam os modelos que você usa no dia a dia. O fine-tuning de um time de produto é uma versão mínima da etapa 2. Diagrama: Marcus Andrey, CC BY 4.0.

3. Fine-tuning e LoRA

Fine-tuning (ajuste fino) (ajuste fino) é continuar treinando um modelo que já existe com os seus próprios exemplos, para ele adotar um comportamento, um estilo ou uma tarefa específica. A etapa 2 acima é um fine-tuning enorme; o fine-tuning de um time de produto é a mesma ideia em escala mínima.

Existem dois jeitos de fazer:

  • Fine-tuning completo ajusta todos os parâmetros. Num modelo de 4B, são 4 bilhões de números para atualizar e guardar: precisa de muita memória e gera uma cópia inteira nova do modelo.
  • LoRA (low-rank adaptation, adaptação de baixo posto) deixa o modelo original congelado e treina um conjunto pequeno de números extras que ficam por cima dele. No fim, você tem um arquivo pequeno, o adaptador, que é carregado junto com o modelo original.

Pequeno quanto? No nosso experimento, o LoRA treinou 0,2–0,5% dos parâmetros, e os adaptadores tinham 14 MB e 32 MB, ao lado de modelos de cerca de 1,6 e 3 GB.

CongeladoO modelo original

Bilhões de parâmetros. Nada muda aqui durante o treino LoRA.

Qwen3.5 4B, cerca de 3 GB em disco
TreinadoO adaptador LoRA

Uma camada fina por cima que direciona o modelo: 0,2–0,5% dos parâmetros.

O nosso adaptador: 32 MB, treinado em cerca de 2 minutos

Modelo + adaptador = comportamento novo · tirou o adaptador = o modelo original de volta

O LoRA funciona como um tema sobre um design system: os componentes continuam os mesmos; uma camada fina muda como eles se comportam. Números do nosso experimento, nov 2026. Diagrama: Marcus Andrey, CC BY 4.0.

Por que uma camada tão pequena funciona? A maior parte do que a tarefa precisa já está no modelo; o adaptador só precisa direcionar. Tecnicamente, o LoRA descreve a mudança em cada tabela grande de números como o produto de duas tabelas bem finas, o que é muito mais barato de treinar ("baixo posto" se refere a essa finura).

QLoRA é o LoRA sobre um modelo quantizado: um modelo cujos números são guardados com menos precisão (por exemplo, 4 bits em vez de 16). É como salvar uma imagem em JPEG de boa qualidade em vez do arquivo bruto: perde um pouco de detalhe, o arquivo fica cerca de quatro vezes menor e passa a caber num laptop.


4. O vocabulário de um treino

Você vai encontrar estas palavras em qualquer conversa sobre fine-tuning. Cada uma tem um paralelo em UX.

Termo O que significa Paralelo em UX
Dataset Os exemplos com que o modelo aprende: entradas e as respostas desejadas A biblioteca de padrões com exemplos de faça/não faça
Conjunto de treino Os exemplos que o modelo de fato estuda Os casos com que você desenha
Conjunto de validação Exemplos guardados para checar o progresso durante o treino Um teste piloto com pessoas que não ajudaram a desenhar
Conjunto de teste Exemplos guardados até o fim, para a checagem final O teste de usabilidade de verdade
Passo (iteração) Um pequeno ajuste dos controles, depois de olhar alguns exemplos Uma iteração de design
Batch (lote) Quantos exemplos o modelo olha por passo (4 nos nossos treinos) Quantas telas você revisa antes de ajustar
Época Uma passada completa por todo o conjunto de treino Percorrer todos os casos uma vez
Taxa de aprendizado O tamanho de cada ajuste. Grande demais: ele oscila; pequena demais: quase não aprende O quanto você muda entre uma iteração e outra
Loss (perda) O quanto o modelo se surpreende com a resposta certa. Quanto menor, melhor; 0 é nunca se surpreender A taxa de erro num teste
Checkpoint Uma cópia salva do adaptador num certo passo Uma versão salva no histórico do arquivo
Overfitting (sobreajuste) Ajustar-se tanto aos exemplos de treino que os casos novos pioram Desenhar para as cinco pessoas do último teste, e não para todo mundo que elas representam

5. O experimento: ensinar ao modelo o seu padrão de mensagem de erro

A tarefa

Muitos guias de content design têm uma regra para mensagens de erro. A nossa: todo erro vira três linhas, um título que diz o que aconteceu, uma mensagem que diz o porquê ou o que continua seguro, e uma ação.

Entrada: HTTP 413 Payload Too Large: max 10MB
Saída:   Title: File too large
         Message: Files can be up to 10 MB.
         Action: Choose a smaller file

É um bom caso para fine-tuning: é um comportamento (um formato e um tom), não conhecimento, e é fácil de avaliar a olho. (Os exemplos estão em inglês porque o curso é em inglês.)

Os dados

36 exemplos escritos à mão, cobrindo problemas de conexão, permissões, pagamentos, uploads, validação e logística. Eles foram divididos assim:

  • 28 para treino, os exemplos que o modelo estuda
  • 4 para validação, para acompanhar o progresso durante o treino
  • 4 para teste, para checar no fim

Cada exemplo é uma linha num arquivo, escrita como uma conversa curtinha: uma instrução ("You rewrite technical error messages into user-facing microcopy"), o erro técnico e a resposta que queremos.

As ferramentas

  • mlx-lm, a biblioteca open source da Apple para rodar e treinar modelos em chips Apple (licença MIT).
  • Dois modelos abertos da família Qwen3.5 (Apache 2.0, livres para usar e modificar): 0.8B (800 milhões de parâmetros) e 4B, este comprimido para 4 bits.

Os passos

# 1. Instalar a biblioteca
pip install mlx-lm

# 2. Perguntar ao modelo antes do treino (a foto do "antes")
mlx_lm.generate --model mlx-community/Qwen3.5-4B-MLX-4bit \
  --system-prompt "You rewrite technical error messages into user-facing microcopy." \
  --prompt "NotAllowedError: Permission denied (camera)"

# 3. Treinar um adaptador LoRA com os exemplos da pasta data/
mlx_lm.lora --model mlx-community/Qwen3.5-4B-MLX-4bit --train --data data \
  --iters 30 --batch-size 4 --learning-rate 5e-5 --mask-prompt --adapter-path adapters/microcopy

# 4. Perguntar de novo, agora com o adaptador por cima (a foto do "depois")
mlx_lm.generate --model mlx-community/Qwen3.5-4B-MLX-4bit --adapter-path adapters/microcopy \
  --system-prompt "You rewrite technical error messages into user-facing microcopy." \
  --prompt "NotAllowedError: Permission denied (camera)"

Em palavras: --iters 30 é o número de passos, --batch-size 4 os exemplos por passo, --learning-rate o tamanho de cada ajuste, e --mask-prompt diz ao modelo para aprender só com as respostas, não com as perguntas. Cada treino levou cerca de 2 minutos.


6. Lendo os resultados

Antes do treino

Os dois modelos ignoraram o padrão. Diante de NotAllowedError: Permission denied (camera), começaram um longo monólogo de raciocínio ("Thinking Process: 1. Analyze the request…") e nunca chegaram a uma resposta de três linhas. Eles sabiam o que é microcopy; só não se comportavam do jeito que queríamos.

Depois do treino: o modelo pequeno decorou

O modelo 0.8B foi treinado por 120 passos, então viu cada exemplo umas 17 vezes. Aprendeu o formato perfeitamente e parou de "pensar em voz alta". Mas veja o conteúdo, para erros que ele nunca tinha visto:

Entrada (nunca vista) Resposta
NotAllowedError: Permission denied (camera) Message: "Allow location access to see nearby depots. Archive them instead." (permissão de localização e "arquivar", de outros exemplos)
HTTP 402 Payment Required: subscription lapsed Title: "Sign-in cancelled", copiado palavra por palavra de um exemplo do treino

Ele costurou pedaços de respostas do treino. Aprendeu como uma resposta parece, não como escrever uma.

Depois do treino: o modelo maior generalizou

O modelo 4B foi treinado por só 30 passos (cada exemplo visto umas 4 vezes). Manteve o formato e escreveu textos novos e coerentes:

Entrada (nunca vista) Title Message Action
NotAllowedError: Permission denied (camera) Camera is off Allow camera to take photos. Open settings
HTTP 402 Payment Required: subscription lapsed Check subscription status Subscription ended. Renew subscription
MemoryError: worksheet exceeds 1,048,576 rows Sheet too big Too many rows in worksheet. Reduce rows or use pivot table
SSL_ERROR_BAD_CERT_DOMAIN Check the domain name It doesn't match the one in the certificate. Edit email address ✗

Duas lições numa tabela só:

  1. Um modelo maior traz mais conhecimento do pré-treino. Ele já "sabia" o que é permissão de câmera ou limite de planilha; o adaptador só precisou ensinar o padrão.
  2. A última linha é um erro confiante. Nenhum dos 28 exemplos era sobre certificados, então o modelo preencheu a lacuna com uma ação que parece certa e não é ("Editar endereço de e-mail" para um erro de certificado). É uma alucinação em miniatura, e o motivo pelo qual todo modelo ajustado ainda precisa de pessoas revisando o que ele produz.

7. Overfitting que dá para ver

Durante o treino, a ferramenta mostra a loss de treino (o quanto o modelo se ajusta aos exemplos que está estudando) e, a cada alguns passos, a loss de validação (como ele se sai nos exemplos guardados). Este é o treino do 4B:

Loss de validaçãoLoss de treino

Gráfico de linhas. A loss de treino cai de 1,57 no passo 5 para 0,04 no passo 30. A loss de validação cai de 2,48 no passo 1 para 0,92 no passo 10 e depois sobe para 1,04 nos passos 20 e 30.00,511,522,50102030Passoa partir daqui, decoramelhor: passo 10
A curva real do nosso treino LoRA (Qwen3.5 4B, 28 exemplos, nov 2026). O treino quase zera, mas a validação piora depois do passo 10: é ali que o modelo começa a decorar. Dados e gráfico: Marcus Andrey, CC BY 4.0.

Como ler:

  • A loss de treino cai até perto de zero. O modelo fica muito bom nos exemplos que está estudando.
  • A loss de validação cai até o passo 10 e depois sobe. A partir dali, cada passo a mais o deixa pior nos casos novos. Ele começou a decorar.
  • O melhor adaptador é o de por volta do passo 10, não o último.

8. O que o fine-tuning consegue e não consegue fazer

Você quer que o modelo… Use Por quê
Siga o tom, o formato ou o padrão do time Prompts melhores e arquivos de contexto primeiro; fine-tuning se isso falhar em escala Prompts são mais baratos de mudar, revisar e desfazer
Conheça seu produto, políticas ou dados recentes RAG ou ferramentas Fine-tuning não acrescenta fatos confiáveis, e fatos ficam desatualizados
Rode offline, num aparelho, ou muito barato Um modelo pequeno ajustado Um modelo 0.8B com adaptador roda num laptop
Pare um comportamento (enrolar, respostas inseguras) Um system prompt e guardrails Mudanças profundas de comportamento são o ajuste por preferência do fornecedor

Custos escondidos para lembrar quando alguém propõe fine-tuning: juntar e limpar exemplos, manter um conjunto de teste, treinar de novo quando o modelo base ou o produto mudam, e alguém ser dono do adaptador ao longo do tempo. Para a maioria dos times de UX, a resposta honesta ainda é "ainda não": bons prompts e arquivos de contexto chegam mais longe, mais rápido. O fine-tuning se justifica quando a mesma tarefa específica roda milhares de vezes, ou precisa rodar onde um modelo grande não cabe.


9. Onde o designer faz a diferença

Fine-tuning parece tarefa de engenharia, mas a maior parte das decisões que fazem ele funcionar são decisões de design:

  • Definir o que é "bom". O padrão de três linhas, o tom, como é um rótulo de ação: isso é content design. Uma definição vaga gera um modelo vago.
  • Escrever os exemplos. O modelo copia o que vê. Exemplos inconsistentes ensinam inconsistência; exemplos sem empatia ensinam frieza. O nosso modelo só aprendeu "Open settings" porque os exemplos usavam isso de forma consistente.
  • Cobrir os casos de borda. O erro de certificado falhou porque nenhum exemplo se parecia com ele. Designers são bons em listar os casos em que ninguém pensou.
  • Escrever os casos de teste e revisar a saída. Os números de validação pegam a decoreba; só pessoas pegam o "tecnicamente certo, mas errado para os nossos usuários".
  • Desenhar para quando o modelo errar. Mesmo um bom adaptador vai, às vezes, produzir um erro do tipo "Edit email address". A interface precisa de um jeito de ver, corrigir e reportar isso. Veja Design agêntico.

10. Experimente (sem código)

  1. Escolha um padrão que o seu time já tem (mensagens de erro, estados vazios, rótulos de botão) e escreva como uma regra em três linhas.
  2. Escreva 10 exemplos à mão, e depois mais 3 que a regra não cobre de forma óbvia. Esses 3 são o seu conjunto de teste.
  3. Dê a regra e os 10 exemplos a qualquer assistente de IA como prompt e peça para ele resolver os 3 casos de teste. Isso é few-shot prompting, e muitas vezes é tudo o que você precisa.
  4. Anote onde ele falha. Mais exemplos resolveriam, ou uma regra mais clara? Essa é exatamente a pergunta que um time deveria fazer antes de escolher fine-tuning.

Perguntas para refletir: quais padrões do seu time são comportamento (bons para fine-tuning) e quais são conhecimento (melhores como contexto)? Quem seria dono de um adaptador na sua organização?


11. Checklist do UX lead

Para saber mais

Livros, cursos e vídeos para ir mais fundo (em inglês)

Relacionadas

Módulo 12: A IA e o UX lead, guiando um time de design pela IA · Fine-tuning (ajuste fino) · Evals (avaliações) · Geração aumentada por recuperação (RAG) · Arquivos de contexto · Few-shot prompting (prompt com exemplos) · Alucinação (hallucination) · Design agêntico · Governança de IA e proteção de dados

Salvo só neste dispositivo.

↑ ↓ para mover · Enter para abrir · Esc para fechar