SIENA, NIPS-CERN, UFJF

Limiar

Redes neurais, do neurônio ao fractal

Aula 7: PyTorch, o que a biblioteca automatiza

27/11/2026. C∴ Chrysthofer A. A. Afonso

O diagrama de bifurcação da equação logística: uma linha que se divide em duas, depois em quatro, e se desfaz numa nuvem escura de pontos, com faixas claras no meio

O diagrama de bifurcação da equação logística: um só número decide se a conta repetida converge, oscila ou vira caos. Jordan Pierce, 2011, Wikimedia Commons, CC0, recortado.

Limiar, aula 7: PyTorch

A aula 7 troca o NumPy pelo PyTorch, a biblioteca de redes neurais que a pesquisa usa. A rede é a mesma da aula 6; a diferença é que a retropropagação, escrita à mão nas aulas 5 e 6, passa a ser feita pela biblioteca. Com o tempo que sobra, a aula olha para a taxa de aprendizado de perto: o erro final contra a taxa, que perto do limiar fica quebrado.

A imagem da capa é o diagrama de bifurcação da equação logística, x ← r·x·(1 − x), uma conta simples repetida muitas vezes. Para cada valor de r, no eixo horizontal, de 2,4 a 4, o diagrama marca os valores para onde a conta vai depois de muitas repetições. Até r = 3, ela vai para um número só; entre 3 e 3,44949, oscila entre dois; depois entre quatro, oito, e, a partir de r ≈ 3,56995, vira caos, com ilhas de ordem no meio. A ligação com a aula é uma analogia, e não uma conta: o gradiente descendente também é uma conta repetida, e a taxa de aprendizado faz o papel do r, decidindo se o treino converge, oscila ou se perde.

Diagrama de Jordan Pierce, de 2011, no Wikimedia Commons, com a licença CC0, de domínio público; recortado para tirar os eixos, que tinham ponto decimal.

1 · Revisão

O que ficou das aulas 5 e 6, de memória

O que a softmax faz com as dez saídas?

Para que servem a validação e o teste?

O que é sobreajuste?

Por que treinar em lotes?

Limiar, aula 7: PyTorch

1 · Revisão

O fio do curso, da aula 1 à 10

O neurônio e o perceptron

um neurônio desenha uma reta, e nenhuma reta separa o XOR

25/09, presencial

Derivada e gradiente

o passo contra a derivada; a taxa grande demais faz o treino divergir

02/10, presencial

Matrizes e camadas

duas camadas separam o XOR, com pesos escolhidos à mão

13/11, on-line

O Jacobiano

a regra da cadeia com vetores, uma camada de cada vez

13/11, on-line

Retropropagação

a regra da cadeia, de trás para a frente, acha os pesos do XOR

13/11, on-line

O MNIST em NumPy

um MLP em 70 mil dígitos escritos à mão, com treino, validação e teste

27/11, on-line

PyTorch

a biblioteca faz a retropropagação; o erro final contra a taxa

27/11, on-line

Os dados do CERN

um MLP estima a massa dos dois múons, conferida pela fórmula

04/12, on-line

O fractal e o projeto

a fronteira entre a taxa que converge e a que diverge

04/12, on-line

A apresentação

a apresentação do projeto e a revisão do curso inteiro

11/12, on-line

Limiar, aula 7: PyTorch

2 · O que o PyTorch automatiza

E se a biblioteca fizesse a retropropagação?

Nas aulas 5 e 6, ela foi escrita à mão. O PyTorch guarda as contas da passada para a frente e faz a de trás para a frente sozinho.

Limiar, aula 7: PyTorch

2 · O que o PyTorch automatiza

O tensor, a tabela de números do PyTorch

o que é

forma

um número

()

um vetor

(784,)

uma matriz

(50000, 784)

um lote de imagens

(64, 28, 28)

forma, shape: quantos números o tensor tem em cada eixo

As contas são as do NumPy

X = torch.from_numpy(X)

X.shape

h = torch.tanh(W @ x + b)

com requires_grad, cada conta feita com o tensor fica registrada, para a derivada vir depois

Tensor, no curso: uma tabela de números com qualquer número de eixos. Na física, a palavra quer dizer outra coisa.

Limiar, aula 7: PyTorch

O tensor é a estrutura de dados do PyTorch. Tensor, no curso, é uma tabela de números com qualquer número de eixos: um número sozinho tem zero eixos; um vetor, um; uma matriz, dois; um lote de imagens de 28 por 28, três. A forma, shape, diz quantos números há em cada eixo: os 50 mil dígitos de treino formam um tensor de forma (50000, 784). Na física, tensor quer dizer outra coisa, um objeto que muda de um jeito determinado quando se trocam as coordenadas; o curso não usa esse sentido.

As contas são as do NumPy: W @ x multiplica matriz por vetor, torch.tanh vale para cada posição, e torch.from_numpy(X) transforma um array do NumPy num tensor sem copiar os números. A diferença está no que o tensor guarda a mais: se ele pede requires_grad, cada conta feita com ele fica registrada, para a derivada vir depois.

2 · O que o PyTorch automatiza

O autograd refaz a conta da aula 4

A rede do exemplo da aula 4

x = torch.tensor(X0, requires_grad=True)

h1 = torch.tanh(W1 @ x + b1)

h2 = torch.tanh(W2 @ h1 + b2)

L = (v @ h2 + c - t) ** 2

L.backward()

x.grad

pelo autograd e pela regra da cadeia da aula 4: a diferença é zero

Autograd: a biblioteca guarda cada conta da passada para a frente e aplica a regra da cadeia de trás para a frente.

Limiar, aula 7: PyTorch

Autograd, no PyTorch, é a diferenciação automática: a biblioteca registra cada conta da passada para a frente e, quando se chama backward(), aplica a regra da cadeia de trás para a frente, o modo reverso da aula 4, e deixa em cada tensor a derivada da perda em relação a ele, no campo .grad.

O teste é a rede do exemplo da aula 4, com os mesmos números: duas camadas com a tanh, a saída linear e a perda L = (y − t)². Na aula 4, o gradiente da perda em relação à entrada saiu como produto de Jacobianos, linha vezes matriz, de trás para a frente: (1,0940; −4,6074). Com o autograd, x.requires_grad_(True) pede o registro, a passada para a frente se escreve como antes, e L.backward() faz o resto. O resultado é (1,0940; −4,6074), com diferença zero para a conta da aula 4: as duas fazem as mesmas multiplicações, na mesma ordem, em float64, a precisão de 16 algarismos do NumPy.

2 · O que o PyTorch automatiza

O grafo das contas, para a frente e para trás

Para a frente: cada conta vira um nó do grafo

Para trás, com backward(): uma linha vezes uma matriz por camada

Grafo, no curso: o desenho das contas, cada conta um nó, ligado por setas às contas de que depende.

Limiar, aula 7: PyTorch

Como o autograd faz isso: na passada para a frente, cada conta vira um nó de um grafo, com setas para as contas de que ela depende. Grafo, no curso, é esse desenho das contas, nós ligados por setas; na matemática, grafo é o nome de qualquer conjunto de pontos ligados por linhas.

Na rede do exemplo, $\vec{x}$ entra na primeira camada, sai $\vec{h}$ ₁, entra na segunda, sai $\vec{h}$ ₂, vira y e vira L. Quando se chama backward(), o PyTorch percorre o grafo de L para trás: em cada nó, multiplica a derivada que chegou pela derivada da própria conta, o Jacobiano da aula 4, e passa adiante. É a conta de trás para a frente, uma linha vezes uma matriz por camada, que a aula 4 mostrou ser a mais barata quando a saída é um número só, a perda.

O grafo se monta de novo a cada passada para a frente; por isso a rede pode ser escrita como um programa comum, com laços e condições, e o autograd segue o caminho que as contas fizeram.

2 · O que o PyTorch automatiza

O grafo com números

Cinco nós em fila, x, h1, h2, y e L, com as contas em cima das setas. Para a frente, em azul, os valores, até a perda 0,9766. Para trás, em laranja, a derivada da perda por cada nó, da direita para a esquerda, até a entrada: (1,0940; −4,6074), o gradiente da aula 4

Limiar, aula 7: PyTorch

O vídeo mostra o grafo do slide anterior com os números da rede da aula 4, no ponto $\vec{x}$ = (1; 0,25). Grafo, no curso, é o desenho das contas: cada conta um nó, ligado por setas às contas de que depende.

Para a frente, em azul, o PyTorch faz as contas e guarda cada valor: $\vec{h}$ ₁ = (0,6351; 0), $\vec{h}$ ₂ = (0,8539; −0,1343), y = 0,9882 e a perda L = 0,9766, a mesma da aula 4. Em cima de cada seta, a conta que leva de um nó ao outro.

Para trás, em laranja, L.backward() começa pela derivada da perda por ela mesma, 1, e volta de nó em nó: por y, 2(y − t) = 1,9764; por $\vec{h}$ ₂, a linha (1,9764; −1,9764), que é 1,9764 vezes $\vec{v}$ = (1; −1); por $\vec{h}$ ₁, (3,0115; −1,4054); e pela entrada, (1,0940; −4,6074), o gradiente que a aula 4 calculou à mão, de trás para a frente. Em cada passo, a linha que chega vezes o Jacobiano da conta, como no slide do grafo.

No código, a derivada fica em x.grad depois do backward(). O PyTorch guarda a derivada só dos tensores criados com requires_grad; para mostrar a dos nós do meio, o programa pede retain_grad() a cada um.

3 · A rede da aula 6 em PyTorch

A rede e o laço do treino

A rede, a perda e o passo

rede = nn.Sequential(

nn.Linear(784, 256), nn.Tanh(),

nn.Linear(256, 10))

perda_fn = nn.CrossEntropyLoss()

opt = torch.optim.SGD(rede.parameters(), lr=0.1)

Para cada lote

opt.zero_grad()

perda = perda_fn(rede(X[i]), t[i])

perda.backward()

opt.step()

As sete linhas da retropropagação da aula 6 viram uma: perda.backward(). A softmax vai dentro de CrossEntropyLoss.

Limiar, aula 7: PyTorch

A rede da aula 6 em PyTorch. nn.Linear(784, 256) é a camada W $\vec{x}$ + $\vec{b}$ , com os pesos e os vieses dentro dela; nn.Tanh() é a ativação; a segunda nn.Linear dá as dez saídas. nn.Sequential encadeia as três. A softmax não aparece: ela vai junto com a entropia cruzada em nn.CrossEntropyLoss, que recebe as dez saídas e o rótulo.

O laço do treino tem quatro linhas por lote: zero_grad() apaga os gradientes do lote anterior, que o PyTorch somaria aos novos; a passada para a frente calcula a perda; backward() calcula o gradiente de todos os pesos; e step() dá o passo, w ← w − η ∂L/∂w, para cada peso. O otimizador, torch.optim.SGD, é o gradiente descendente da aula 2, com a taxa 0,1 da aula 6.

As sete linhas da retropropagação da aula 6 viram uma: perda.backward().

3 · A rede da aula 6 em PyTorch

A mesma conta, mais depressa

NumPy

PyTorch

teste

97,59%

segundos por época

5,1

0,5

retropropagação

7 linhas

1 linha

Mesmos pesos iniciais, mesma ordem dos lotes, float64: a diferença é zero em todas as épocas. O tempo é o do laptop do professor.

Limiar, aula 7: PyTorch

O teste da troca: a rede em PyTorch começa com os pesos que o código da aula 6 sorteia, percorre os lotes na mesma ordem, com a mesma taxa, por 20 épocas, e em float64. As duas curvas da acurácia na validação caem uma em cima da outra: a diferença é zero em todas as épocas, e o teste dá os mesmos 97,59%. O PyTorch não aprende diferente; ele faz a mesma conta.

O que muda é o tempo e o trabalho. No laptop do professor, cada época levou 0,5 s no PyTorch, contra 5,1 s no NumPy da aula 6, na última vez que o mlp.py rodou; o tempo do NumPy já foi 7,2 s, com o computador mais ocupado. A biblioteca usa rotinas de multiplicação de matrizes mais rápidas. Num laptop mais fraco os dois números crescem, mas a proporção deve se manter perto disso; isso é dedução, não medida.

Na figura, o NumPy em círculos azuis vazados, o PyTorch em xis laranja, por cima.

3 · A rede da aula 6 em PyTorch

O Adam, outro jeito de dar o passo

A acurácia na validação, época a época: o Adam, em laranja tracejado, começa mais alto e termina perto do gradiente descendente, em azul

Caixa-preta

entra o gradiente de cada peso; sai o passo de cada peso, com a taxa ajustada peso a peso

93,6% contra 90,0%

na validação, depois de uma época

97,42% contra 97,59%

no teste, depois de 20 épocas

Limiar, aula 7: PyTorch

3 · A rede da aula 6 em PyTorch

Dois jeitos de dar o passo

Uma tigela alongada, rasa na horizontal e íngreme na vertical, desenhada duas vezes. Em cima, o gradiente descendente ziguezagueia na direção íngreme e anda devagar na rasa; embaixo, o Adam vai na diagonal, com passos de tamanho parecido nas duas direções, e faz uma curva perto do fundo

Limiar, aula 7: PyTorch

O vídeo compara dois jeitos de dar o passo numa tigela alongada, L(a, b) = (a² + 25 b²)/2: rasa na direção a e 25 vezes mais íngreme na direção b. Os dois caminhos saem do mesmo ponto, (−4; 1,2), e dão 40 passos.

Em cima, o gradiente descendente, com η = 0,075, perto da maior taxa que a direção íngreme aguenta, 2/25 = 0,08. O passo é η vezes a inclinação: grande em b, onde a tigela é íngreme, e pequeno em a. Em b, ele passa do fundo e volta, e o caminho ziguezagueia: os primeiros pontos são (−3,70; −1,05), (−3,42; 0,92) e (−3,17; −0,80). Em a, anda devagar.

Embaixo, o Adam, com taxa 0,3 e os valores de fábrica do PyTorch para as duas médias, 0,9 e 0,999. O passo de cada peso é dividido por uma média do tamanho do gradiente daquele peso, e sai de tamanho parecido nas duas direções: (−3,70; 0,90), (−3,40; 0,61), (−3,10; 0,32), uma diagonal. Perto do fundo, ele passa e faz uma curva, porque a média do gradiente, o momento, carrega o passo anterior.

É isso que a caixa-preta do slide anterior quer dizer com a taxa ajustada peso a peso. O Adam não é sempre melhor: nesta tigela, depois de 40 passos, o gradiente descendente chega mais perto do fundo, perda 0,016 contra 0,064; no MNIST, o Adam começou na frente e terminou junto. Os números saem de caminhos(), em codigo/animacoes.py.

4 · O erro final contra a taxa

Qual a maior taxa que ainda funciona?

Na aula 2, o limiar era um ponto. Numa rede com camadas e a tanh, ele se quebra.

Limiar, aula 7: PyTorch

4 · O erro final contra a taxa

O erro final contra a taxa

O erro final de 161 redes, uma por taxa, de 0,01 a 100, nos dois eixos em escala logarítmica: cai até perto de 0,007 e depois sobe acima da perda de antes do treino

Menor erro final: 0,0070, com η = 2,37. A partir de η = 4,47, o treino deixa a rede pior do que estava.

Limiar, aula 7: PyTorch

A rede pequena da aula: 784 entradas, 16 neurônios com a tanh e 10 saídas, treinada nos 256 primeiros exemplos do treino do MNIST, com todos os exemplos de uma vez, sem lotes, por 200 passos. Sem lotes, nada é sorteado durante o treino, e a mesma taxa dá sempre o mesmo resultado. Os pesos começam da semente 0.

Cada ponto é uma rede treinada com uma taxa, de 0,01 a 100, e a altura é o erro final, a perda depois do último passo, nos dois eixos em escala logarítmica. Com taxas pequenas, o treino anda pouco em 200 passos; o erro final cai com a taxa até o menor valor, 0,0070, com η = 2,37. Depois, sobe depressa, e a partir de η = 4,47 o treino deixa a rede pior do que estava antes, acima da linha tracejada, a perda de antes do treino, 2,3220. Com taxas perto de 100, a perda passa de 1.000, e o programa marca a rede como explodida.

A melhor taxa fica logo antes da região em que o treino piora: quem procura a taxa mais rápida anda perto da borda.

4 · O erro final contra a taxa

Perto do limiar, de perto

Os pontos da varredura aparecem da taxa menor para a maior; depois, de 2 a 10, 601 taxas com o erro final e uma faixa azul e laranja que troca de cor muitas vezes

Limiar, aula 7: PyTorch

4 · O erro final contra a taxa

A fronteira entre melhorar e piorar é quebrada

Em cima, o erro final de 601 taxas de 2 a 10; embaixo, uma faixa com uma listra por taxa, azul onde o treino melhora a rede e laranja onde piora, com muitas trocas entre 3,9 e 7,6

601 taxas de 2 a 10: 383 pioram a rede, e a resposta troca 77 vezes entre taxas vizinhas.

Limiar, aula 7: PyTorch

A figura do zoom, parada. Em cima, o erro final das 601 taxas de 2 a 10; embaixo, a faixa, uma listra por taxa. Das 601, 383 pioram a rede, e a resposta, melhora ou piora, troca 77 vezes entre taxas vizinhas. Abaixo de 3,86, tudo melhora; acima de 7,55, tudo piora; no meio, as duas cores se misturam.

Fronteira, aqui, é o conjunto de taxas em que a resposta troca. Na aula 2, a fronteira era um ponto, o limiar. Nesta rede, ela é quebrada, e a causa está no treino de cada taxa da faixa: a perda salta para dezenas nos primeiros passos e fica oscilando, sem se assentar, e o passo 200 pega umas taxas com a perda abaixo da de antes e as vizinhas acima. A aula 9 mostra essas curvas e põe esta rede no plano de duas taxas, uma por camada; o fractal do curso é a fronteira da rede do projeto, a do artigo, com os dados do CMS.

5 · De onde vem

Do modo reverso ao PyTorch

1970

Seppo Linnainmaa descreve o modo reverso da diferenciação automática, a conta que o autograd faz.

2002

Ronan Collobert, Samy Bengio e Johnny Mariéthoz publicam o Torch, em C e Lua, no Instituto Idiap.

2016

Em setembro, sai a primeira versão do PyTorch: o Torch levado para o Python.

2017

O desenvolvimento do Torch passa para o PyTorch.

Fontes: Wikipedia, verbetes “PyTorch”, “Torch (machine learning)” e “Backpropagation”.

Limiar, aula 7: PyTorch

Quatro datas.

1970: Seppo Linnainmaa descreve o modo reverso da diferenciação automática, a conta de trás para a frente que o autograd faz, como estava nas aulas 4 e 5.

2002: Ronan Collobert, Samy Bengio e Johnny Mariéthoz publicam o Torch, uma biblioteca de aprendizado de máquina do Instituto de Pesquisa Idiap, na Suíça, escrita em C, com a linguagem Lua por cima.

2016: sai a primeira versão do PyTorch, em setembro, o Torch levado para o Python. A página do PyTorch na Wikipedia dá como autores Gregory Chanan, Soumith Chintala, Sam Gross e Adam Paszke, e como desenvolvedora a Meta AI; hoje o desenvolvimento tem apoio da Linux Foundation.

2017: o desenvolvimento do Torch passa para o PyTorch.

Os anos de 2002, 2016 e 2017 e os nomes saem da Wikipedia em inglês, verbetes "Torch (machine learning)" e "PyTorch"; o de 1970, do verbete "Backpropagation", conferido na aula 5.

6 · O código

O PyTorch, passo a passo

autograd_exemplo.py refaz o gradiente da aula 4

mlp_torch.py treina a rede da aula 6, com os mesmos pesos e lotes

O mesmo treino com o Adam, para comparar

taxa.py varre 161 taxas e, de perto, 601

As figuras e o vídeo leem os números gravados em resultados/

O PyTorch que resolve

torch.from_numpy(X)

nn.Sequential(...)

perda.backward()

torch.autograd.grad(L, pesos)

o último devolve o gradiente sem guardá-lo, para o passo feito à mão

Limiar, aula 7: PyTorch

O código da aula fica pronto e testado antes. codigo/autograd_exemplo.py refaz o gradiente da aula 4 com o autograd. codigo/mlp_torch.py é a solução de referência da entrega, que não vai para a turma antes do prazo: a rede da aula 6 em PyTorch, com os mesmos pesos iniciais e a mesma ordem dos lotes, e o Adam ao lado. codigo/taxa.py faz as duas varreduras da taxa e grava os números; a figura e o vídeo leem dali.

Quatro peças do PyTorch resolvem quase tudo. torch.from_numpy(X) transforma os dados da aula 6 em tensores. nn.Sequential(nn.Linear(784, 256), nn.Tanh(), nn.Linear(256, 10)) monta a rede. perda.backward() calcula o gradiente de todos os pesos. E torch.autograd.grad(L, pesos) devolve o gradiente sem guardá-lo nos pesos, como na varredura da taxa, em que cada passo é escrito à mão: w ← w − η ∂L/∂w.

Tempos no laptop do professor: mlp_torch.py, cerca de 30 segundos; taxa.py, cerca de 50.

6 · O código

O que a entrega pede

O MNIST em PyTorch

a rede da aula 6 com nn.Sequential
a perda com CrossEntropyLoss
o laço de quatro linhas

A curva da taxa

a rede pequena da aula, sem lotes
o erro final de várias taxas
a melhor taxa e onde o treino piora

Entrega

a acurácia no teste, com a semente e a versão
a figura da taxa
uma pergunta sobre o estudo

Extra, opcional: a mesma curva no MNIST inteiro, com lotes, para quem quiser.

Limiar, aula 7: PyTorch

A entrega tem duas partes. A primeira é o MNIST em PyTorch: a rede da entrega da aula 6 reescrita com nn.Sequential, CrossEntropyLoss e o laço de quatro linhas, com a acurácia no teste, a semente e a versão dos dados. Quem começar dos mesmos pesos e da mesma ordem dos lotes deve achar a mesma acurácia da aula 6; quem não, um número perto.

A segunda é a curva do erro final contra a taxa, na rede pequena da aula, sem lotes, a mesma que a aula 9 leva ao plano das duas taxas, com uma figura como a da aula. Ela roda em menos de um minuto em qualquer laptop. Cada um escolhe a faixa de taxas; o que se pede é apontar a melhor taxa e a partir de onde o treino piora a rede. A mesma curva no MNIST inteiro, com lotes, é um extra opcional, para quem quiser.

O que se exige é saber dizer o que entra na rede, o que ela aprende e o que significa o número que sai.

7 · Fechamento

Para estudar e entregar

Estudo

CMS, registro 303: dois múons, 2010
Aubert e colegas, 1974: o J
Augustin e colegas, 1974: o psi

Entrega

o MNIST em PyTorch, com a acurácia no teste
a curva do erro final contra a taxa
uma pergunta sobre o estudo

A seguir

aula 8: um MLP nos dados do CERN
aula 9: a fronteira da taxa em duas dimensões

Limiar, aula 7: PyTorch