Crie um pequeno mecanismo de autograd
Escreva uma classe Value que registre operações e calcule gradientes automaticamente, como faz o PyTorch.
- Represente um cálculo como um gráfico de objetos Value que lembram suas entradas
- Dê a cada operação uma regra local inversa e execute-as em ordem topológica reversa
- Use seu mecanismo para treinar um neurônio com descida gradiente
Trabalhar gradientes manualmente envelhece rapidamente. Frameworks como PyTorch fazem isso automaticamente: cada operação que você executa é registrada em um gráfico, e chamar .backward() executa a regra da cadeia sobre ela. Isso é diferenciação automática (autograd), e você pode construir uma versão funcional em cerca de 50 linhas. (Esta lição segue o espírito da micrograduação de Andrej Karpathy.)
O plano:
- Um
Valueagrupa um número, lembra de quais valores ele foi calculado (_children) e possui umgradque começa em 0. - Cada operação (
+,*,tanh, ...) cria um novo valor e anexa uma pequena função_backwardque conhece a regra local - por exemplo. paraout = a * b:a.grad += b.data * out.grad. backward()classifica o gráfico para que cada nó venha depois de suas entradas (uma classificação topológica), define a graduação da saída como 1 e chama cada_backwardao contrário.
Os gradientes usam +=, não =, porque um valor usado em vários lugares deve soma os gradientes de cada uso.
1import math
2
3class Value:
4 """A number that remembers how it was computed, so it can backpropagate."""
5
6 def __init__(self, data, children=(), op=""):
7 self.data = data
8 self.grad = 0.0
9 self._backward = lambda: None
10 self._children = children
11 self.op = op
12
13 def __add__(self, other):
14 other = other if isinstance(other, Value) else Value(other)
15 out = Value(self.data + other.data, (self, other), "+")
16 def backward():
17 self.grad += out.grad
18 other.grad += out.grad
19 out._backward = backward
20 return out
21
22 def __mul__(self, other):
23 other = other if isinstance(other, Value) else Value(other)
24 out = Value(self.data * other.data, (self, other), "*")
25 def backward():
26 self.grad += other.data * out.grad
27 other.grad += self.data * out.grad
28 out._backward = backward
29 return out
30
31 def tanh(self):
32 t = math.tanh(self.data)
33 out = Value(t, (self,), "tanh")
34 def backward():
35 self.grad += (1 - t * t) * out.grad
36 out._backward = backward
37 return out
38
39 def __neg__(self):
40 return self * -1
41
42 def __sub__(self, other):
43 return self + (-other)
44
45 __radd__ = __add__
46 __rmul__ = __mul__
47
48 def backward(self):
49 order, seen = [], set()
50 def visit(node):
51 if node not in seen:
52 seen.add(node)
53 for child in node._children:
54 visit(child)
55 order.append(node)
56 visit(self)
57 self.grad = 1.0
58 for node in reversed(order):
59 node._backward()
60
61# L = tanh(w*x + b) - y; depois, eleve ao quadrado por multiplicação
62w, x, b, y = Value(0.5), Value(2.0), Value(-0.3), Value(1.0)
63p = (w * x + b).tanh()
64d = p - y
65L = d * d
66L.backward()
67print(f"p={p.data:.4f} L={L.data:.4f}")
68print(f"dL/dw={w.grad:.4f} dL/db={b.grad:.4f} dL/dx={x.grad:.4f}")p=0.6044 L=0.1565 dL/dw=-1.0045 dL/db=-0.5022 dL/dx=-0.2511
Leia backward() lentamente - é o coração de toda estrutura de aprendizado profundo:
visitcaminha da saída até as entradas e anexa cada nó após seus filhos, dando uma ordem onde as entradas vêm primeiro.- Invertido, a saída é a primeira: o gradiente de cada nó está completo (todos os seus usuários já adicionaram suas contribuições) no momento em que seu próprio
_backwardpassa o gradiente mais abaixo.
Treinando com seu motor
Com gradientes sob demanda, o treinamento é um loop: passagem direta, backward(), desloque cada parâmetro contra seu gradiente e redefina os graduados para zero para a próxima etapa (eles se acumulam de outra forma - PyTorch faz você chamar zero_grad() exatamente por esse motivo).
1import math
2
3class Value:
4 """A number that remembers how it was computed, so it can backpropagate."""
5
6 def __init__(self, data, children=(), op=""):
7 self.data = data
8 self.grad = 0.0
9 self._backward = lambda: None
10 self._children = children
11 self.op = op
12
13 def __add__(self, other):
14 other = other if isinstance(other, Value) else Value(other)
15 out = Value(self.data + other.data, (self, other), "+")
16 def backward():
17 self.grad += out.grad
18 other.grad += out.grad
19 out._backward = backward
20 return out
21
22 def __mul__(self, other):
23 other = other if isinstance(other, Value) else Value(other)
24 out = Value(self.data * other.data, (self, other), "*")
25 def backward():
26 self.grad += other.data * out.grad
27 other.grad += self.data * out.grad
28 out._backward = backward
29 return out
30
31 def tanh(self):
32 t = math.tanh(self.data)
33 out = Value(t, (self,), "tanh")
34 def backward():
35 self.grad += (1 - t * t) * out.grad
36 out._backward = backward
37 return out
38
39 def __neg__(self):
40 return self * -1
41
42 def __sub__(self, other):
43 return self + (-other)
44
45 __radd__ = __add__
46 __rmul__ = __mul__
47
48 def backward(self):
49 order, seen = [], set()
50 def visit(node):
51 if node not in seen:
52 seen.add(node)
53 for child in node._children:
54 visit(child)
55 order.append(node)
56 visit(self)
57 self.grad = 1.0
58 for node in reversed(order):
59 node._backward()
60
61# Aprenda y = tanh(2x - 1) com quatro exemplos
62data = [(-1.0, math.tanh(-3)), (0.0, math.tanh(-1)), (0.5, math.tanh(0)), (1.0, math.tanh(1))]
63w, b = Value(0.1), Value(0.0)
64for step in range(301):
65 loss = Value(0.0)
66 for x, y in data:
67 d = (w * x + b).tanh() - y
68 loss = loss + d * d
69 w.grad = b.grad = 0.0
70 loss.backward()
71 w.data -= 0.2 * w.grad
72 b.data -= 0.2 * b.grad
73 if step % 100 == 0:
74 print(f"step {step}: loss {loss.data:.4f}")
75print(f"w = {w.data:.2f}, b = {b.data:.2f}")step 0: loss 1.8224 step 100: loss 0.0001 step 200: loss 0.0000 step 300: loss 0.0000 w = 2.00, b = -1.00
Principais conclusões
O Autograd registra cada operação e suas entradas, construindo um gráfico à medida que você calcula.
Cada operação carrega uma regra local de retrocesso; gradientes se acumulam com +=.
Backward() executa essas regras em ordem topológica reversa, começando em grad = 1.
Treinamento: avançar, zerar os graduados, retroceder, passo - o mesmo loop que o PyTorch usa.
Quiz da aula
7 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.
Ensine novos truques ao motor
Adicione duas operações a Value:
__pow__(self, exponent)para um expoente numérico constante: o resultado édata ** exponente a derivada local éexponent * data ** (exponent - 1).relu(self):max(0, data), com derivada local 1 se dados > 0 caso contrário 0.
O código de teste na parte inferior calcula duas expressões e imprime valores e gradientes.
- Duas expressões
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.
Ajuste uma linha com seu motor
Cada linha de entrada é um ponto x y. Usando a classe Value, ajuste minimizando o erro quadrático ** médio ** com descida de gradiente: comece em w = b = 0, taxa de aprendizagem 0,05, 500 passos (lembre-se de redefinir os gradientes a cada passo). Imprima w= e b= com 2 casas decimais.
- y = 3x + 2
- Pontos barulhentos
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…