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 …"
- expirou62%
- não21%
- está9%
- outros tokens8%
O app escolhe um token, acrescenta ao texto e pergunta de novo. Uma resposta inteira é esse ciclo, centenas de vezes.
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.
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".
- 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 - 2Ajuste por instruções (SFT)
Aprender com conversas de exemplo como é uma boa resposta de assistente.
Um estágio. Resultado: um modelo instruct - 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
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.
Bilhões de parâmetros. Nada muda aqui durante o treino LoRA.
Qwen3.5 4B, cerca de 3 GB em discoUma 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 minutosModelo + adaptador = comportamento novo · tirou o adaptador = o modelo original de volta
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ó:
- 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.
- 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
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)
- 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.
- 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.
- 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.
- 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
- Artigos: LoRA (Hu et al., 2021) · QLoRA (Dettmers et al., 2023) · Training language models to follow instructions with human feedback (Ouyang et al., 2022)
- Prática: guia de LoRA do mlx-lm · MiniMind, um modelo de 64M de parâmetros treinado do zero em PyTorch puro, para ver o tokenizer e o loop de pré-treino (horas por etapa num laptop)
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