Projeto final: ensine Neuro a reconhecer rabiscos
Crie, treine, depure e avalie um classificador de rabiscos do zero em NumPy, reunindo toda a trilha em um projeto.
- Configure os dados, um modelo e uma perda e verifique-os antes do treinamento
- Implementar retropropagação e um loop de treinamento de minilote para um classificador real
- Avalie com precisão e uma matriz de confusão e classifique novas entradas
Este é o momento. A câmera do Neuro captura rabiscos 5×5, e há quatro tipos de linha para reconhecer: vertical, horizontal, diagonal () e anti-diagonal (/). Linhas verticais e horizontais podem aparecer em qualquer coluna ou linha, e a câmera introduz ruído – cerca de 8% dos pixels saem invertidos.
Você construirá tudo do zero: uma rede 25 → 16 → 4 (ReLU, softmax), perda de entropia cruzada, backprop, descida gradiente de minilote - então avalie honestamente e deixe-o ler rabiscos que nunca viu.
Etapa 1: observe os dados
Antes de qualquer modelagem, observe o que você está modelando. O gerador do conjunto de dados desenha cada tipo de linha e inverte pixels aleatórios. Existem 400 doodles de treinamento e um conjunto de validação separado de 100 que o treinamento nunca vê.
1import numpy as np
2
3CLASSES = ["vertical", "horizontal", "diagonal", "anti-diagonal"]
4
5def draw(label, position):
6 canvas = np.zeros((5, 5))
7 if label == 0:
8 canvas[:, position] = 1
9 elif label == 1:
10 canvas[position, :] = 1
11 elif label == 2:
12 canvas = np.eye(5)
13 else:
14 canvas = np.fliplr(np.eye(5))
15 return canvas.ravel()
16
17def make_doodles(per_class, noise, rng):
18 X, y = [], []
19 for label in range(4):
20 for _ in range(per_class):
21 pixels = draw(label, rng.integers(0, 5))
22 flips = rng.random(25) < noise
23 X.append(np.abs(pixels - flips))
24 y.append(label)
25 order = rng.permutation(len(y))
26 return np.array(X)[order], np.array(y)[order]
27
28rng = np.random.default_rng(7)
29X_train, y_train = make_doodles(100, 0.08, rng)
30X_val, y_val = make_doodles(25, 0.08, rng)
31
32print(X_train.shape, y_train.shape, X_val.shape)
33print("examples per class:", np.bincount(y_train))
34for index in range(3):
35 print(CLASSES[y_train[index]])
36 for row in X_train[index].reshape(5, 5):
37 print("".join("#" if pixel else "." for pixel in row))(400, 25) (400,) (100, 25) examples per class: [100 100 100 100] horizontal ##### ..... ..... ..... ..... horizontal ..... ..... .#... ##### .#... anti-diagonal ...## ...#. ..#.. .#..# #....
Já é uma lição: a segunda linha horizontal captou dois pixels perdidos, e a antidiagonal tem dois extras próprios – ruído que a rede deve aprender a ignorar. As classes são balanceadas (100 cada), então a precisão do nível de chance é de 25%: o número a ser vencido.
Etapa 2: verificar a sanidade do modelo não treinado
Com pesos inicializados por He, a rede não treinada deve ser aproximadamente uniforme em 4 classes: perda próxima de e precisão próxima de 25%. Se não estiver, algo está quebrado antes mesmo de o treinamento começar - a verificação da lição de depuração. Esse é o exercício 1.
Etapa 3: treinar
A passagem para trás é o coração do ciclo de treinamento. Para softmax com entropia cruzada, o gradiente logit é “probabilidades menos rótulos one-hot” - no código, copie as probabilidades e subtraia 1 em cada classe correta. A partir daí, são as regras que você conhece: dW = inputᵀ @ upstream, soma dos vieses no lote e ReLU passa o gradiente apenas onde sua entrada foi positiva. O Exercício 2 reúne tudo com minilotes embaralhados.
1import numpy as np
2
3probabilities = np.array([[0.7, 0.1, 0.1, 0.1],
4 [0.2, 0.2, 0.5, 0.1]])
5labels = np.array([0, 3])
6d_logits = probabilities.copy()
7d_logits[np.arange(2), labels] -= 1 # probabilities - one-hot labels
8print(d_logits)[[-0.3 0.1 0.1 0.1] [ 0.2 0.2 0.5 -0.9]]
Passo 4: avalie honestamente
A precisão é um número; uma matriz de confusão mostra quais classes se misturam. Linha = classe verdadeira, coluna = classe prevista, então a diagonal contém as respostas corretas. Então o verdadeiro teste: rabiscos totalmente novos, digitados como # e . - exercício 3.
Espere que a precisão da validação chegue em meados dos anos 90, em vez de 100%. Com 8% dos pixels invertidos, alguns rabiscos são genuinamente ambíguos - até mesmo para um ser humano.
Para onde ir a seguir
- Treine um modelo real: dígitos MNIST ou Fashion-MNIST com PyTorch, primeiro com um MLP e depois com uma CNN.
- Leia os clássicos: AlexNet, ResNet (“Deep Residual Learning”) e “Attention Is All You Need” estão todos legíveis agora.
- Construa um pequeno modelo de linguagem: um transformador de nível de personagem treinado em um livro - cada peça é desta trilha.
- Aprofunde-se nos cursos relacionados aqui: Visão Computacional, PNL e Grandes Modelos de Linguagem baseiam-se em tudo o que você aprendeu.
Principais conclusões
Observe primeiro os dados e conheça a linha de base do nível de chance.
Verifique a perda inicial (≈ ln K) antes do treino.
Treine com minilotes embaralhados enquanto monitora um conjunto de validação prolongado.
Avalie com uma matriz de confusão e entradas genuinamente novas, não apenas com um número de precisão.
Quiz da aula
6 perguntas · aprovação com 5 acertos · até 50 XP
Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.
Pratique: escreva código em Python
Escreva código Python no editor e execute os testes com exemplos. O Python roda localmente no navegador usando WebAssembly.
Verifique a integridade da rede não treinada
O código inicial gera os rabiscos e configura init_params. Escreva forward(params, X) retornando (z1, h, probabilities) para a rede 25 → 16 → 4 (camada oculta ReLU, saída softmax estável) e cross_entropy(probabilities, y).
A entrada é uma semente para os pesos. Imprima a perda de validação do modelo não treinado com 3 casas decimais, ln 4 para comparação e sua precisão de validação com 2 casas decimais.
- Semente 0
- Semente 1
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Treine a rede da Neuro
Agora faça aprender. Escreva backward(params, X, y, z1, h, probabilities) retornando os gradientes para W1, b1, W2 e b2 e train(...): cada época, embaralhe com rng.permutation, percorra minilotes e atualize cada parâmetro com params[name] -= lr * grads[name].
A entrada é epochs learning_rate. O código inicial relata perda de validação e precisão a cada 5 épocas.
- 20 épocas, lr 0,5
- Uma pequena taxa de aprendizado
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Leia novos rabiscos
O código inicial treina a rede finalizada (20 épocas, taxa de aprendizado 0,5). Conclua o trabalho:
- Imprima a matriz de confusão no conjunto de validação: 4 linhas (classe verdadeira) de 4 contagens (classe prevista), separadas por espaços.
- A entrada contém novos rabiscos: 5 linhas de
#e.cada, separadas por linhas em branco. Para cada um, imprima a classe prevista e sua probabilidade com 2 casas decimais:doodle 1: vertical (0.99).
- Quatro rabiscos limpos
- Doodles bagunçados
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Dúvidas sobre esta lição
Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.
Carregando publicações…