Ir para o conteúdo

Playground: NetLab

Carregando o NetLab… (ele precisa de JavaScript)

Como usar
Para Faça
pôr um nó dê um duplo clique na tela e digite o nome dele ou arraste da lista Nós (no celular: + Nó)
ligar dois nós arraste de uma porta de saída (à direita) até uma de entrada (à esquerda); a cor diz o que a porta leva: azul um tensor, laranja o alvo, roxo uma perda
mudar um fio arraste a ponta de entrada dele e solte em outro lugar; solto no vazio, ele abre a busca com os nós que o recebem
apagar escolha um nó ou um fio e aperte Del (ou o × do nó)
navegar roda ou pinça para o zoom, arraste o fundo para mover, F para enquadrar tudo
treinar ▶ Treinar (ou Espaço), ⏭ Passo para um mini-batch, ↺ Reiniciar para pesos aleatórios novos
ler o código { } PyTorch; clique num nó para destacar as linhas dele ou numa linha para achar o nó

Nada é enviado para lugar nenhum: o grafo fica salvo neste navegador e Exportar e Importar o levam num arquivo JSON. Cada nó tem um ↗ que abre a aula onde ele é ensinado.

Um nó com a borda vermelha tem um problema e a mensagem diz o que fazer: uma entropia cruzada cuja última camada não tem uma unidade por classe, uma soma de dois tensores de larguras diferentes, uma porta sem fio. Os rótulos dos fios (N×16) são os formatos que a aula de MLP calcula à mão: N linhas (uma por exemplo do batch) e 16 colunas (uma por unidade). Uma imagem viaja como N×C×H×W (canais, altura, largura), como na aula de CNN: Conv2d e MaxPool2d a recebem, a Linear não; um Flatten entre elas transforma N×16×2×2 em N×64.

Os modelos

Cada modelo é um experimento curto. Treine, olhe os visualizadores e depois mude uma coisa.

O menu agrupa os modelos por aula, na ordem do curso; montar um abre uma nota do que experimentar, com um link de volta para a aula. Cada página de aula tem um quadro que abre o seu cenário direto (playground/?t=<nome>); o grafo que você tinha fica a um Ctrl+Z.

Modelo O que mostra Onde é ensinado
MLP na espiral Duas camadas ocultas de 32 unidades ReLU separam três espirais entrelaçadas, o que nenhuma reta faz. A fronteira se curva enquanto a perda cai. Experimente 4 unidades por camada ou tanh. MLP
Perceptron no XOR Uma camada Linear é uma reta, então ela fica perto de 50% no XOR seja qual for o otimizador. Mude as Features do dataset para + quadrados, produto e o mesmo perceptron resolve: o produto \(x_1 x_2\) é a feature de que o XOR precisa. Perceptron
Funda demais, com sigmoide Seis camadas sigmoides com a inicialização padrão: o Fluxo do gradiente mostra o gradiente encolhendo camada após camada, a perda fica parada perto de \(\ln 2\) e os fios apagam na direção da entrada. Redes Profundas
Mesma profundidade: ReLU + residual As mesmas seis camadas com ReLU, inicialização de He e um atalho em volta de cada bloco: as barras do fluxo do gradiente ficam niveladas e a perda cai. Redes Profundas
Mesma profundidade: sigmoide + BatchNorm As seis camadas sigmoides de Funda demais, com uma BatchNorm entre cada Linear e a sua sigmoide: cada camada volta a receber entradas de média 0 e variância 1, as sigmoides saem das caudas planas e a perda cai. No treino a BatchNorm usa a média e a variância de cada batch; na avaliação, as médias móveis que ela guardou (o model.train() e o model.eval() do código). Redes Profundas
Overfitting × dropout e weight decay Duas cópias de uma rede grande treinadas em 50 pontos com ruído. A simples leva a perda de treino a zero enquanto a de validação sobe (a melhor época é uma das primeiras); na com dropout e weight decay as duas curvas ficam próximas, a perda de validação continua caindo e a fronteira é mais suave. Regularização
Regressão num seno Uma rede tanh ajusta um seno com ruído usando MSE. A segunda fronteira, na primeira camada oculta, mostra as 32 curvas que a camada de saída soma. Métricas: regressão
CNN nos dígitos Dois blocos de Conv2d, ReLU e MaxPool2d, depois um Flatten e uma camada Linear, nos dígitos manuscritos 8×8 (1.797 imagens, 10 classes): cerca de 98% na validação em poucos segundos, com 1.898 parâmetros. O primeiro Mapas de ativação mostra um dígito de validação e os 8 canais do primeiro bloco; o segundo, na saída, uma página de dígitos de validação com o dígito que a rede escolhe (verde quando acerta, vermelho quando erra). A Matriz de confusão mostra quais dígitos ela troca; a Saliência mostra, sob cada dígito de validação, os pixels onde mais tinta aumentaria a nota daquele dígito (azul) ou a diminuiria (laranja). Adversarial (FGSM) move cada pixel \(\epsilon\) na direção que aumenta a perda: dígitos que parecem iguais são lidos errado e \(\epsilon = 0{,}1\) da faixa dos pixels leva a acurácia de cerca de 98% a cerca de 56%. Experimente um bloco só ou uma única camada Linear nos pixels achatados. CNN
VAE nos dígitos Um encoder leva cada dígito à média \(\mu\) e à log-variância \(\log \sigma^2\) de uma gaussiana 2D. Amostrar z sorteia \(z = \mu + \sigma \epsilon\) (o truque da reparametrização, para o gradiente chegar a \(\mu\) e \(\sigma\)) e um decoder transforma \(z\) de volta em 64 pixels. A Perda do VAE soma o erro de reconstrução a \(\beta\) vezes a KL até \(\mathcal{N}(0, I)\); a reconstrução é o erro quadrático ou a entropia cruzada binária. O primeiro Espaço latente põe cada dígito de validação no seu \(\mu\), colorido pela classe (os grupos se formam sem os rótulos); o segundo roda o decoder numa grade de \(z\), que é o que o VAE gera. Mapas de ativação na saída mostra cada dígito sobre a sua reconstrução. Experimente \(\beta = 0\): a KL sobe e os códigos se espalham muito além dos círculos tracejados da priori. VAE
Autoencoder nos dígitos A rede do VAE sem o Amostrar z e sem o KL: a Perda de reconstrução só compara a saída com \(x\), então o código é um ponto, não uma gaussiana. Compare o Espaço latente dele com o do VAE: os códigos se espalham muito além dos círculos da \(\mathcal{N}(0, I)\) e a grade decodificada em volta da origem cobre só parte deles; é por isso que um autoencoder simples não gera. O decoder também pode ser convolucional: Unflatten lê um vetor plano como \(C \times H \times W\) e Upsample ×2 seguido de uma Conv2d o devolve a 8×8. VAE
Flow matching nas luas Um Par do fluxo pega cada ponto \(x_1\) dos dados, sorteia um ruído \(x_0 \sim \mathcal{N}(0, I)\) e um tempo \(t\) e dá à rede o ponto \(x_t = t\,x_1 + (1 - t)\,x_0\) na reta entre eles, com o alvo \(v = x_1 - x_0\). Uma MLP pequena faz a regressão de \(v\) com MSE; a perda fica bem acima de 0, porque muitas retas cruzam o mesmo \((x_t, t)\) e a rede só consegue aprender a média delas. O Amostrador integra a velocidade aprendida do ruído em \(t = 0\) aos dados em \(t = 1\) com passos de Euler: a primeira visão desenha as trajetórias; a segunda, o campo de velocidade num instante. Mude o par para o caminho cosseno e para prever \(\epsilon\) e ele vira um modelo de difusão, amostrado com DDIM. Experimente 1, 2 ou 5 passos. Flow Matching
Mini ViT nos dígitos Um nó Patches corta cada dígito 8×8 em 16 quadrados de 2×2; uma camada Linear transforma cada um num token de 16 números (a mesma camada para todo token) e Posição soma um vetor aprendido por lugar. Vem um bloco Transformer: LayerNorm, Atenção com 2 cabeças e uma Soma residual, depois LayerNorm, uma MLP e outra Soma. Média dos tokens alimenta uma Linear com 10 saídas: cerca de 93% na validação depois de 15 épocas, com 2.730 parâmetros. O Mapa de atenção mostra, num dígito de validação, para onde cada cabeça olha: a partir de um patch, ou quanta atenção cada patch recebe. Compare com o modelo de CNN nos mesmos dígitos. Vision Transformers
RNN × LSTM: o problema da soma Sequências de 40 passos de dois números: um valor entre 0 e 1 e uma marca, que vale 1 em dois passos (um em cada metade) e 0 nos outros. O alvo é a soma dos dois valores marcados, então a rede precisa guardar o primeiro por 20 a 40 passos enquanto ignora todos os outros. A mesma cabeça é treinada sobre uma RNN simples (tanh) e sobre um LSTM, de 16 unidades cada. A RNN fica com R² perto de 0 ou abaixo: no máximo ela aprende a responder a média, 1. O LSTM chega a R² ≈ 0,99 dentro das 40 épocas. O visualizador Ao longo do tempo mostra por quê, numa sequência de validação: a entrada, o estado \(h_t\) de cada unidade e \(\lVert \partial L / \partial h_t \rVert\) em cada passo. Na RNN o gradiente cai de três a treze ordens de grandeza do último passo de volta ao primeiro, com os estados presos em ±1; no LSTM ele cai menos de duas ordens de grandeza. Nele uma unidade acende na primeira marca e guarda o valor até o fim (em Mostrar, o portão da memória exibe o portão de esquecimento \(f_t\)). No começo o gradiente do LSTM também some, porque os portões de esquecimento começam perto de 0,5: veja as barras dele se nivelarem quando a perda cai. Com o Comprimento T em 10 a RNN também aprende (R² ≈ 0,93); em 20 ela já falha. A célula GRU aprende em 40 e em 80. A taxa de aprendizado é 0,03 com o gradiente cortado na norma 1: com 0,01 sem corte, o LSTM às vezes fica no primeiro platô durante as 40 épocas (6 execuções em 20). Se a curva dele ficar plana, use ↺ Reiniciar e treine de novo. Atenção: a recorrência
LSTM lê dígitos linha a linha O Patches em linhas (1×W) transforma cada dígito 8×8 numa sequência de 8 passos de 8 pixels, lida de cima para baixo. Um LSTM de 32 unidades lê a sequência e uma camada Linear sobre o último estado dá as 10 classes: cerca de 98% na validação em 20 épocas, com 5.706 parâmetros, perto do modelo da CNN. Oito passos formam uma sequência curta, então uma RNN simples também aprende (troque a Célula: 93% a 96%, alguns pontos abaixo); a vantagem clara do LSTM precisa de distância, como no modelo acima. Atenção: a recorrência
Transfer learning na espiral Um MLP aprende os três braços da espiral com todos os rótulos (1.050): treine umas 30 épocas, até cerca de 99%. Depois dê a ele uma tarefa mais fina sobre os mesmos pontos: ponha a Tarefa do Dataset em braço, dentro ou fora (6 classes: cada braço partido no meio do seu comprimento, o que a tarefa dos três braços nunca pediu) e os Rótulos em 12, dois por classe. A cabeça antiga não responde a isso, porque as suas três saídas dizem qual é o braço, não qual é a metade. Aperte o botão da Perda que muda fc3 para 6 unidades (uma cabeça nova; o resto guarda os pesos), deixe fc1 e fc2 congeladas e treine: cerca de 87% nos 450 pontos de validação. Agora aperte Reiniciar, volte as duas para treinável e treine do zero com os mesmos 12 rótulos: cerca de 70%; a fronteira mostra o porquê (12 pontos não desenham uma espiral). Ajustar tudo sem Reiniciar fica no meio (cerca de 84%): 12 rótulos bastam para estragar parte das features. As camadas congeladas só foram treinadas para separar os braços, mas ainda guardam em que altura do braço o ponto está; a cabeça nova lê as duas coisas. Só com dentro ou fora os braços não servem para nada e nenhum regime fica sempre à frente (67% congelada, 59% ajustando tudo, 60% do zero). Transferir compensa quando a tarefa de origem aprendeu o que a nova precisa (no PyTorch, em 5 sementes: 0,91 congelada, 0,86 ajustando tudo, 0,80 do zero; com dentro ou fora, 0,75, 0,79 e 0,81). Transfer Learning
World model: RSSM (Dreamer) Um passo do modelo de espaço de estados recorrente do PlaNet e do Dreamer, nos dados da Sala: um ponto numa sala com paredes, visto como uma imagem 8×8, um passo \(a\) e o próximo quadro. A Transição separa cada linha em \(o\), \(a\) e \(o'\); Empilhar passa \(o\) e \(o'\) pelo mesmo encoder num lote só e Separar em dois afasta os embeddings \(e\) e \(e'\). O estado determinístico é \(h = f(e, a)\) (uma GRU no Dreamer; aqui uma camada, porque um passo não precisa de memória). De \(h\) sozinho saem \(\mu\) e \(\log\sigma^2\) do prior (fc4, fc5); de \(h\) com \(e'\), os do posterior (fc6, fc7), de onde Amostrar z tira \(s'\); o decoder desenha \(o'\) a partir de \((h, s')\). A Perda do RSSM soma à reconstrução os termos de KL do DreamerV3: \(0{,}5\,\mathrm{KL}(\mathrm{sg}(q)\,\|\,p)\) treina o prior, \(0{,}1\,\mathrm{KL}(q\,\|\,\mathrm{sg}(p))\) o posterior (sg: stop-gradient), nenhum abaixo de 1 nat (free bits). Próximo quadro mostra quatro passos de validação: \(o\) com o seu passo, o \(o'\) verdadeiro, o quadro decodificado do posterior e o sonho, o decoder alimentado com a média do prior, que é tudo o que o modelo tem quando imagina. Depois de 35 épocas: 0,40 por quadro pelo posterior, 0,43 sonhando (no PyTorch, 0,41 e 0,44). Ponha o termo de KL em nenhum e aperte Reiniciar: o posterior melhora para 0,32, porque vê \(o'\); o sonho piora para 1,61. Modelos de Mundo
LeWorldModel: latente + SIGReg A mesma Sala sem decoder: um encoder para \(o\) e \(o'\) (8 números cada), um preditor de \((z, a)\) para \(\hat z'\) e a Perda latente \(\|\hat z' - z'\|^2 + \lambda\,\mathrm{SIGReg}(Z)\) com \(\lambda = 0{,}1\), sem stop-gradient e sem EMA. O SIGReg projeta o lote de embeddings em 64 direções aleatórias e mede em cada uma quão longe ele está de \(\mathcal{N}(0, 1)\) (a estatística de Epps–Pulley). A Sonda do latente desenha \(z\) nas suas duas direções principais na cor de onde o ponto realmente está (as cores da sala do Dataset), o espalhamento σ de cada dimensão, o posto efetivo e uma sonda linear da posição: \(R^2 \approx 0{,}86\) depois de 30 épocas (de 0,83 a 0,91 no PyTorch, em 3 sementes). Ponha \(\lambda = 0\) e aperte Reiniciar: o erro de previsão vai a 0 porque todo quadro recebe o mesmo \(z\) (σ 0,006, \(R^2\) 0,07), um colapso. Com \(\lambda = 0{,}03\) a sonda chega a 0,94. O preditor do LeWM lê os três últimos latentes; o ponto precisa de um, porque a posição é todo o seu estado. Planejar no latente, na saída do preditor, usa o modelo como o LeWM, o DINO-WM e o PLDM fazem: para 100 pares de um quadro inicial e um quadro-objetivo ele codifica os dois, busca os 5 passos cujo latente imaginado termina mais perto do latente do objetivo (o método da entropia cruzada: 64 planos candidatos, os 8 melhores definem os 64 seguintes, 4 rodadas) e depois faz o plano na sala de verdade. Depois de 30 épocas ele leva cerca de metade dos objetivos a menos de 0,2 (de 47% a 57% em 3 execuções; de 30% a 39% no PyTorch, onde só o sorteio dos planos já move o número em uns 8 pontos), contra 3% com ações aleatórias; com o latente colapsado de \(\lambda = 0\), 4%. O Alvo z′ da perda dá a outra saída do colapso, a assimetria do BYOL e do JEPA: com \(\lambda = 0\) e um stop-gradient em \(z'\), ou \(z'\) vindo de um encoder EMA (uma média dos pesos passados, momento 0,99), nada colapsa (\(R^2\) de 0,91 a 0,95) e os planos alcançam de 33% a 40% (stop-gradient) e de 44% a 53% (EMA) dos objetivos. Modelos de Mundo Discriminativos Temporais
GAN nas luas Um Ruído z alimenta um gerador (64, 64, 2 unidades); o Par da GAN empilha um lote de pontos reais sobre os falsos do gerador (rótulos 1 e 0) e o discriminador (64, 64, 1) lê todos. A Perda da GAN tem duas portas: a perda D (real → 1, falso → 0) para o otimizador do discriminador e a perda G (não saturante: falso → 1) para o do gerador, que atravessa o discriminador mas muda só o gerador. A Visão da GAN desenha, como o GAN Lab, os dados, as amostras e o veredito do discriminador no plano; a segunda distância (dados → amostras) cresce quando o gerador colapsa sobre parte dos dados. As curvas oscilam: isso é o jogo, não um defeito. GANs
Uma reta num seno Uma unidade Linear, o erro quadrático e o SGD: as três peças de que todo modelo é feito. Uma reta não acompanha um seno (\(R^2 \approx 0{,}72\), por mais que treine); ponha uma Linear oculta com uma tanh no meio e ela acompanha. Conceitos
Treino, validação e ruído 120 pontos das luas com ruído (metade deles para validação) e uma rede grande o bastante para decorar a outra metade: a perda de treino vai a 0 enquanto a de validação sobe acima de 2. Mude o número de pontos, o ruído, a fração de validação ou a semente da divisão e veja o quanto o número da validação se mexe. Dados
Três neurônios nas luas Uma camada oculta de 3 unidades tanh: cada uma é uma reta no plano e a saída combina as três (cerca de 91% na validação). Experimente 1 unidade (uma reta só) e 8. Redes Neurais
SGD × Adam A MLP da espiral duas vezes, treinada com SGD (taxa 0,1) e com Adam (0,01). Nos mesmos 14 segundos, o SGD estava em 75% e o Adam em 94%. Mude as taxas ou experimente momentum e RMSProp. Otimização
Dígitos: a matriz de confusão Uma MLP nos dígitos 8×8 (cerca de 98% na validação) lida pela Matriz de confusão: as células de uma linha fora da diagonal são os erros daquele dígito (o seu recall); as de uma coluna, os alarmes falsos (a sua precisão). Métricas: classificação
Atenção: o problema da soma O problema da soma do modelo de RNN, por atenção: uma Linear transforma cada passo num token de 16, a Atenção (2 cabeças) deixa cada token alcançar os dois passos marcados num salto e a Média dos tokens alimenta a resposta. \(R^2 \approx 0{,}94\) em 10 épocas com \(T = 40\), onde a RNN simples fica perto de 0. Não é preciso posição: a soma não depende da ordem. O Mapa de atenção mostra para onde as cabeças olham. Atenção
Um bloco Transformer As mesmas sequências por um bloco pré-LN inteiro: LayerNorm, atenção e um Add residual, depois LayerNorm, uma MLP com GELU e outro Add: \(R^2 \approx 0{,}99\) em 7 épocas. Tire um fio residual e treine de novo. Transformers: o bloco
Um GPT minúsculo: o próximo caractere O dataset Texto: frases de um sujeito, um verbo e um objeto ("o gato pulou no chão."), cortadas em janelas de 20 caracteres; a entrada é cada janela em one-hot e o alvo é a mesma janela deslocada de um. Uma Linear faz o embedding de cada caractere, Posição soma onde ele está e vem um bloco pré-LN, com a Atenção na máscara causal (cada token só vê o passado); uma última Linear dá um escore por caractere em cada posição e a Perda toma a entropia cruzada de todas elas. Cerca de 89% dos próximos caracteres certos depois de 5 épocas. O visualizador Próximo caractere mostra a previsão em cada posição de uma janela de validação e depois escreve texto a partir dela, um caractere de cada vez, com uma temperatura. Ponha a máscara em nenhuma: a perda cai perto de 0 porque toda posição menos a última lê a sua resposta; o número deixa de medir previsão. Geração Autorregressiva
Dois blocos: um modelo de linguagem maior A mesma receita com dois blocos e um fluxo de 48: cerca de três vezes os parâmetros, cada passo mais caro. Compare com o modelo de um bloco na mesma época; depois corte o número de janelas para ver treino e validação se separarem. LLMs
CLIP nos dígitos Dois encoders: um para a imagem (64 pixels → 64 → 16) e um para a sua legenda, que aqui é a classe do dígito escrita como um vetor one-hot (Legenda one-hot → Linear de 16). A Perda contrastiva (CLIP) normaliza os dois embeddings, divide a matriz N×N de cossenos pela temperatura \(\tau\) e toma a entropia cruzada de cada linha (imagem → a sua legenda) e de cada coluna (legenda → a sua imagem). A acurácia dela é a fração das imagens cuja legenda mais parecida é a própria; na validação, onde todas as classes aparecem, isso é a classificação zero-shot: cerca de 98% depois de 20 épocas. A perda fica perto de 4 e isso é esperado: um lote tem muitas imagens da mesma classe, que dividem a mesma legenda, então o par certo nunca fica com toda a probabilidade. CLIP
Difusão nas luas O grafo de Flow matching nas luas com o Par do fluxo no caminho cosseno prevendo o ruído \(\epsilon\): um modelo de difusão, que o Amostrador roda com o DDIM. Compare as trajetórias com as do flow matching e experimente poucos passos de amostragem. Stable Diffusion
I-JEPA nos dígitos O I-JEPA com os nós do NetLab. Patches corta cada dígito em 16 tokens, uma Linear e Posição fazem o embedding deles e a Máscara JEPA sorteia dois blocos-alvo de 2×2 patches por imagem e manda o lote duas vezes, [vista do contexto; imagem inteira], para que um único encoder calcule as duas. A Atenção dele, em contexto JEPA, impede a metade do contexto de olhar os alvos (o mesmo que deixá-los de fora). Separar em dois divide as metades: o contexto vai para os Mask tokens (um token aprendido mais uma posição aprendida em cada alvo) e um bloco preditor; a imagem inteira, por uma LayerNorm, é o alvo. A Perda JEPA compara os dois só nos alvos, com stop-gradient no alvo. A Sonda da representação lê a imagem inteira: espalhamento, posto efetivo e uma sonda linear contra os pixels brutos. Medido: a sonda do encoder sem treino (média dos tokens) dá cerca de 56%, uma dúzia de épocas cerca de 65% com o espalhamento dobrando, os pixels brutos 92%. Nesta escala, como no laboratório do capítulo de JEPA, prever representações não vence os pixels. Com a sonda em todos os tokens lado a lado, até o encoder sem treino chega a cerca de 97%: mais números, não features melhores; é por isso que uma sonda se lê contra o encoder sem treino. Com o gradiente nos dois lados a perda vai a 0,000 e o espalhamento a 0,01 (colapso), enquanto o posto efetivo fica perto de 9, cego a uma representação que só encolheu. JEPA
JEPA: colapso e stop-gradient O grafo do LeWorldModel com \(\lambda = 0\) e o alvo atrás de um stop-gradient: uma JEPA sustentada só pela assimetria. Troque o Alvo z′ para o gradiente nos dois lados e o latente colapsa; o encoder EMA, ou o SIGReg com \(\lambda = 0{,}1\), volta a impedir. JEPA

Os otimizadores são os da aula de Otimização: SGD, SGD com momentum, RMSProp e Adam, com a taxa de aprendizado e o weight decay no nó. O nó Otimizador também mostra a razão entre o tamanho da última atualização e o tamanho dos pesos: perto de \(10^{-3}\) é um passo saudável; muito maior, o treino pula; muito menor, ele se arrasta. Ele também pode mudar a taxa ao longo das épocas (degraus de ×0,1, um cosseno ou um aquecimento seguido do cosseno, como os lr_scheduler do PyTorch; a curva no nó marca a época atual) e cortar a norma do gradiente (clip_grad_norm_), dizendo com que frequência cortou.

Seus dados (CSV)

No nó Dataset, escolha Seus dados · CSV e aperte Escolher arquivo… ou solte o arquivo sobre o nó. O arquivo precisa vir pronto: o nó treina com o que recebe e mexe muito pouco nele. Passo a passo, ele faz só isto (o próprio nó lista os mesmos passos em O que este nó faz com o arquivo, com os números do seu arquivo):

  1. Lê o arquivo neste navegador; nada é enviado para lugar nenhum. A primeira linha dá os nomes das colunas; o separador (,, ; ou tab) é detectado, assim como a vírgula decimal (3,14) quando o separador não é a vírgula.
  2. Alvo: a coluna escolhida em Alvo (a última, se nenhuma). Com a Tarefa em automática, é uma classificação quando o alvo é texto ou tem até 10 valores inteiros (numerados 0, 1, … em ordem); senão é uma regressão. No máximo 10 classes.
  3. Entradas: todas as colunas numéricas menos o alvo. As colunas de texto ficam de fora, assim como uma coluna chamada id, index ou Unnamed: 0.
  4. Valores faltantes: uma linha com uma célula vazia (ou NA, NaN, null, ? e as outras marcas que o pandas lê como faltante) no alvo ou numa entrada é descartada, não preenchida.
  5. Linhas e divisão: no máximo Pontos linhas (2.000 no máximo, sorteadas com a semente quando o arquivo tem mais), separadas em treino e validação (estratificadas por classe).
  6. Padronização: cada entrada recebe a média e o desvio padrão do treino, como um StandardScaler ajustado só nele. Numa regressão o alvo também é padronizado, então a perda fica em unidades do desvio dele; o R² não muda.

Ele não imputa valores, não codifica categorias (one-hot), não transforma colunas (log, potências), não remove outliers nem escolhe colunas. Faça isso antes no simulador de ML, que tem um bloco de Preparação para cada uma dessas etapas, ou numa planilha; depois salve o resultado em CSV. O arquivo pode ter até 10 MB. Ele fica guardado neste navegador para a próxima visita e Exportar o leva dentro do JSON do grafo. O código PyTorch repete os mesmos passos com pd.read_csv, dropna e StandardScaler e roda com o arquivo ao lado.

Duas conferências, com o modelo MLP e as flores íris (150 linhas, 8 delas com um valor faltante): sobram 142 linhas e a rede chega a cerca de 95% na validação (98% no PyTorch). Nos dados de diabetes do scikit-learn (442 linhas, 10 entradas, uma regressão), uma única camada Linear chega a \(R^2 \approx 0{,}46\) (a regressão linear do scikit-learn tem de 0,44 a 0,50, conforme a divisão); o MLP de 32 + 32 sobreajusta em uma centena de épocas, um bom momento para testar dropout ou weight decay. A fronteira de decisão só desenha um arquivo com 2 entradas (1 numa regressão).

O que roda por baixo

Tudo é calculado na página, em JavaScript: o forward de cada nó, o backward que manda o gradiente de volta pelos fios (um fio que alimenta dois nós soma os dois gradientes que voltam) e a atualização do otimizador. Os datasets são pequenos (até 2.000 pontos) e as camadas têm até 256 unidades, então um passo leva uma fração de milissegundo. Uma convolução custa mais: nos dígitos um passo da CNN leva alguns milissegundos e a curva da perda ganha pontos com menos frequência. Os dígitos são o load_digits do scikit-learn (UCI, CC BY 4.0), carregado com a página.

O código PyTorch descreve a mesma rede, perda, otimizador e dados e roda como está. Os números que ele imprime não serão os mesmos daqui: os pesos iniciais aleatórios e a ordem dos batches são sorteados de outro jeito.