Carregando
0x100Lição 17 de 17

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.

50 min Questionário com 6 perguntas 3 exercícios de código
Ao final desta lição, você saberá
  • 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ê.

look_at_the_data.py
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))
Saída
(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 ln⁡4≈1.386\ln 4 \approx 1.386 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.

one_hot_gradient.py
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)
Saída
[[-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.

Exercício 1

Verifique a integridade da rede não treinada

+25 XP

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
main.py
Carregando editor…

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.

Exercício 2

Treine a rede da Neuro

+25 XP

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
main.py
Carregando editor…

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.

Exercício 3

Leia novos rabiscos

+25 XP

O código inicial treina a rede finalizada (20 épocas, taxa de aprendizado 0,5). Conclua o trabalho:

  1. Imprima a matriz de confusão no conjunto de validação: 4 linhas (classe verdadeira) de 4 contagens (classe prevista), separadas por espaços.
  2. 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
main.py
Carregando editor…

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…