Carregando
0x60Lição 7 de 17

Crie um pequeno mecanismo de autograd

Escreva uma classe Value que registre operações e calcule gradientes automaticamente, como faz o PyTorch.

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

  1. Um Value agrupa um número, lembra de quais valores ele foi calculado (_children) e possui um grad que começa em 0.
  2. Cada operação (+, *, tanh, ...) cria um novo valor e anexa uma pequena função _backward que conhece a regra local - por exemplo. para out = a * b: a.grad += b.data * out.grad.
  3. 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 _backward ao contrário.

Os gradientes usam +=, não =, porque um valor usado em vários lugares deve soma os gradientes de cada uso.

value.py
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}")
Saída
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:

  • visit caminha 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 _backward passa 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).

train_neuron.py
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}")
Saída
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.

Exercício 1

Ensine novos truques ao motor

+25 XP

Adicione duas operações a Value:

  • __pow__(self, exponent) para um expoente numérico constante: o resultado é data ** exponent e 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
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

Ajuste uma linha com seu motor

+25 XP

Cada linha de entrada é um ponto x y. Usando a classe Value, ajuste y^=wx+b\hat{y} = w x + b 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
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…