Machine Learning · Insper

Redes Neurais

Neurônios em camadas: a camada oculta aprende os próprios atributos

Do perceptron à retropropagação, número a número

O caminho desta aula

  1. Um neurônioa regressão logística como neurônio; o perceptron
  2. Camadas ocultasXOR, uma camada oculta, ativações não lineares
  3. Passagem diretaum produto de matrizes por camada; contar parâmetros
  4. Retropropagaçãoregra da cadeia, seis passos, uma perda não convexa
  5. Na práticaescala, largura, weight decay; dados tabulares
Cada etapa responde a uma pergunta: o que um único neurônio aprende? → por que uma reta não basta e o que as camadas acrescentam? → o que uma rede calcula? → como ela aprende todos os pesos de uma vez? → como treinar bem e quando vale a pena?
Etapa 1 · o que um único neurônio aprende?

Um neurônio é uma regressão logística

\[ z = w^\top x + b, \qquad a = \varphi(z) \]

Com \(\varphi = \sigma\) isso é a regressão logística: \(a\) é a probabilidade da classe positiva.

à mão

\(w = (2, -1)\), \(b = 0{,}5\), \(x = (1, 2)\): \(z = 2 \cdot 1 - 1 \cdot 2 + 0{,}5 = 0{,}5\) e \(a = \sigma(0{,}5) = 0{,}622\).

Tudo nesta aula muda uma de duas coisas: a ativação \(\varphi\) (um degrau, uma sigmoide, uma ReLU) ou a ligação (um neurônio ou camadas deles).

O perceptron (Rosenblatt, 1958)

Ativação: um degrau, \(+1\) se \(z > 0\), \(-1\) caso contrário. Rótulos \(y \in \{-1, +1\}\).

Visite os pontos um a um. Se o ponto \(i\) está errado ou sobre a reta (\(y_i z_i \le 0\)):

\[ w \leftarrow w + \eta \, y_i \, x_i, \qquad b \leftarrow b + \eta \, y_i \]

Depois da atualização, o escore com sinal do ponto cresce \(\eta(\lVert x_i \rVert^2 + 1) > 0\): a reta se inclina para classificá-lo.

Repita em épocas (passadas completas) até uma época sem erro. Não precisa de cálculo.

Três atualizações à mão

ponto\(x_1\)\(x_2\)\(y\)
A42+1
B02−1
C13−1
D24−1
E30+1
F31+1

Início \(w = (0, 0)\), \(b = 0\), \(\eta = 1\).

  • A: \(z = 0\), erro → \(w = (4, 2)\), \(b = 1\)
  • B: \(z = 5\), \(y = -1\), erro → \(w = (4, 0)\), \(b = 0\)
  • C: \(z = 4\), \(y = -1\), erro → \(w = (3, -3)\), \(b = -1\)
  • D, E, F: \(z = -7, 8, 5\), todos corretos
A época 2 não tem erro: a reta \(3x_1 - 3x_2 - 1 = 0\).

A fronteira depois de cada atualização

Perceptron em seis pontos: depois de A a reta é 4x1 + 2x2 + 1 = 0, depois de B é x1 = 0, depois de C é x2 = x1 − 1/3, que separa as classes
\(w\) é perpendicular à reta e aponta para o lado \(+1\). Um erro num ponto \(-1\) o subtrai de \(w\); num ponto \(+1\), o soma. Se existe uma margem \(\gamma\), no máximo \((R/\gamma)^2\) erros (Novikoff, 1962), mas numa reta qualquer, não na melhor.

Simulador: o perceptron

Passo visita um ponto e mostra as contas. Preveja. No terceiro preset (XOR), os erros por época vão chegar a zero?

Etapa 2 · por que uma reta não basta e o que as camadas acrescentam?

XOR: por que uma reta não basta

\((0, 1)\) e \((1, 0)\) são \(+1\); \((0, 0)\) e \((1, 1)\) são \(-1\). Uma reta separadora precisaria de:

  • \((0,0)\) negativo: \(b < 0\)
  • \((0,1)\), \((1,0)\) positivos: \(w_2 + b > 0\), \(w_1 + b > 0\)
  • \((1,1)\) negativo: \(w_1 + w_2 + b < 0\)

Some as duas do meio: \(w_1 + w_2 + 2b > 0\), então \(w_1 + w_2 + b > -b > 0\). Contradição.

O perceptron erra 4 vezes por época, para sempre: as quatro atualizações de uma época somam exatamente zero. Minsky e Papert, Perceptrons (1969).

O mesmo muro para a regressão logística

Um XOR com ruído: 400 pontos em volta dos quatro cantos (205 e 195 por classe), validação cruzada em 5 folds.

regressão logística

0,485
acurácia na validação cruzada: nível do acaso

suas probabilidades

0,37–0,61
P(classe 1) em todo lugar: ela fica em cima do muro
Preveja. XOR é "\(x_1\) OU \(x_2\), mas NÃO os dois". Cada pedaço é linearmente separável. Como vários neurônios poderiam resolvê-lo?

Uma camada oculta resolve o XOR

  • \(h_1\): \(x_1 + x_2 - 0{,}5 > 0\), OU
  • \(h_2\): \(x_1 + x_2 - 1{,}5 > 0\), E
  • saída: \(h_1 - h_2 - 0{,}5 > 0\), XOR
\(x_1\)\(x_2\)\(h_1\)\(h_2\)\(z_{\text{saída}}\)saída
0000−0,50
01100,51
10100,51
1111−0,50

Linha \((1, 1)\): \(z_1 = 1{,}5 \Rightarrow h_1 = 1\); \(z_2 = 0{,}5 \Rightarrow h_2 = 1\); \(z_{\text{saída}} = 1 - 1 - 0{,}5 = -0{,}5 \Rightarrow 0\). Todos os pesos escolhidos à mão.

A camada oculta constrói atributos novos

À esquerda, o XOR com ruído e as retas OU e E; a classe 1 fica entre elas. À direita, no espaço oculto os pontos caem em três cantos e uma reta separa as classes
A camada oculta calcula atributos em que o problema fica linearmente separável; a saída é um classificador linear sobre eles. Atributos polinomiais faziam isso à mão, o kernel da SVM (support vector machine) implicitamente: uma rede os aprende.

Do degrau à sigmoide: algo para derivar

O degrau tem derivada 0 em todo lugar: o gradiente não diz nada. Troque-o por uma sigmoide e multiplique cada peso por 10:

\(x_1\)\(x_2\)\(h_1\)\(h_2\)P(XOR = 1)
000,0070,0000,007
010,9930,0070,992
100,9930,0070,992
111,0000,9930,007
A mesma rede, agora derivável: o tipo de rede que um treino por gradiente consegue encontrar sozinho.

Funções de ativação

Sigmoide, tanh e ReLU com suas derivadas: a inclinação da sigmoide nunca passa de 0,25; a tanh chega a 1; a ReLU tem inclinação 1 para toda entrada positiva
maior derivada
sigmoide0,25, em \(z = 0\)
tanh1, em \(z = 0\)
ReLU1, para todo \(z > 0\)
A retropropagação multiplica uma derivada por camada: em 10 camadas de sigmoide, no máximo \(0{,}25^{10} \approx 10^{-6}\). O gradiente que desaparece é o motivo de a ReLU (rectified linear unit) ser o padrão nas camadas ocultas.

Sem não linearidade, as camadas colapsam

\(W_2 (W_1 x + b_1) + b_2\) é uma camada com pesos \(W_2 W_1\): função linear de função linear é linear.

duas camadas lineares

−5,4084

uma camada fundida

−5,4084

ReLU no meio

−5,3273

No XOR com ruído, 8 unidades ocultas:

ativaçãoacurácia na validação cruzada
identity0,510
relu0,983
Etapa 3 · o que uma rede calcula?

A passagem direta: um produto de matrizes por camada

\[ z = W x + b^{h}, \quad h = \sigma(z), \quad u = v^\top h + b^{y}, \quad \hat{y} = \sigma(u) \]

Para um lote: \(H = \sigma(X W^\top + b^h)\). Por isso as redes rodam tão bem em GPUs (graphics processing units), máquinas de multiplicar matrizes.

uma rede 2-2-1, um exemplo \(x = (0{,}5;\ 0{,}8)\), alvo \(y = 0\)

\(W = \begin{pmatrix} 0{,}2 & 0{,}4 \\ 0{,}6 & 0{,}8 \end{pmatrix}\), \(b^h = (0{,}1;\ 0{,}2)\), \(v = (0{,}3;\ 0{,}5)\), \(b^y = 0{,}4\)

Preveja. O alvo é 0. A saída da rede vai ficar perto de 0?

A rede 2-2-1, à mão

\(z_1 = 0{,}2 \cdot 0{,}5 + 0{,}4 \cdot 0{,}8 + 0{,}1 = 0{,}52\)

\(z_2 = 0{,}6 \cdot 0{,}5 + 0{,}8 \cdot 0{,}8 + 0{,}2 = 1{,}14\)

\(h = \sigma(z) = (0{,}627;\ 0{,}758)\)

\(u = 0{,}3 \cdot 0{,}627 + 0{,}5 \cdot 0{,}758 + 0{,}4 = 0{,}967\)

\(\hat y = \sigma(0{,}967) = 0{,}725\)

perda quadrática

0,5249
\(L = (0{,}725 - 0)^2\): bem errada

scikit-learn, com os mesmos pesos carregados: 0,7245

Contando parâmetros

Uma camada: \((n_\text{ent} + 1) \cdot n_\text{sai}\) parâmetros.

arquiteturaparâmetros
2 → 2 → 19
64 → 10650
64 → 32 → 102.410
64 → 256 → 1019.210
64 → 64 → 64 → 108.970
256 unidades: mais parâmetros que imagens no conjunto de dígitos inteiro (1.797). A contagem cresce com o produto das larguras vizinhas; regularizar não é opcional.
Etapa 4 · como ela aprende todos os pesos de uma vez?

Retropropagação: a regra da cadeia, organizada

\[ w_{11} \;\to\; z_1 \;\to\; h_1 \;\to\; u \;\to\; \hat y \;\to\; L \]
  1. gradiente da perda: \(\partial L / \partial \hat y = 2(\hat y - y)\)
  2. delta da saída: \(\delta_y = 2(\hat y - y) \cdot \hat y (1 - \hat y)\)
  3. pesos da saída: \(\partial L / \partial v_{1j} = \delta_y \, h_j\)
  4. deltas ocultos: \(\delta_{h_j} = \delta_y \, v_{1j} \cdot h_j (1 - h_j)\)
  5. pesos ocultos: \(\partial L / \partial w_{jk} = \delta_{h_j} \, x_k\)
  6. atualização: \(p \leftarrow p - \eta \, \partial L / \partial p\)
O gradiente de cada peso = o delta da unidade que ele alimenta × o valor que entrou nele. Rumelhart, Hinton & Williams (1986).

Os seis passos, com números

passovalorleitura
1. \(\partial L/\partial \hat y\)1,449empurrar \(\hat y\) para baixo, rumo a 0
2. \(\delta_y\)0,2892\(1{,}449 \times 0{,}199\), a inclinação da sigmoide de saída
3. \(\partial L/\partial v\)0,1814; 0,2191maior para \(h_2 = 0{,}758\), que contribuiu mais
4. \(\delta_h\)0,0203; 0,0266dez vezes menores: pesos < 1 e inclinações < 0,25
5. \(\partial L/\partial W\)0,0101 a 0,0212os menores: o gradiente que desaparece, em miniatura
As diferenças finitas concordam até \(1{,}3 \times 10^{-10}\): a retropropagação é a derivada exata. Um passo com \(\eta = 0{,}5\): perda 0,5249 → 0,4405.

Simulador: retropropagação, passo a passo

O passo 1 é a passagem direta; os passos 2 a 6 mandam o gradiente de volta; o passo 7 atualiza com \(\eta = 0{,}5\). Use Avançar e Voltar (clique no simulador para usar as setas dentro dele).

Por que a retropropagação importa: o custo

diferenças finitas

2 passagens diretas extras por parâmetro: 18 para os 9 parâmetros; 4.820 numa rede 64-32-10 de dígitos

retropropagação

uma passagem de volta para todos os gradientes, mais ou menos o custo da passagem direta

Com a entropia cruzada, os passos 1 e 2 viram um só, \(\delta_y = \hat y - y\): o mesmo "previsão menos alvo" da regressão logística.

Não convexo: o ponto de partida importa

O XOR com ruído, 10 inícios aleatórios (random_state 0–9), acurácia de treino:

unidades ocultassementes 0–9
20,76 0,66 0,74 0,94 0,94 0,94 0,94 0,94 0,74 0,66
80,98 0,98 0,97 0,98 0,98 0,96 0,99 0,99 0,97 0,95
Com 2 unidades, metade dos inícios fica presa num mínimo local pior. Unidades extras dão ao gradiente mais caminhos, um dos motivos de as redes serem mais largas que o mínimo. Confira as conclusões em algumas sementes.

Otimizadores e regularização

adam

o padrão: mini-lotes de 200 com momento e um passo por parâmetro

sgd

gradiente descendente em mini-lotes, momento opcional

lbfgs

o treino inteiro e a curvatura; o melhor em conjuntos pequenos

  • alpha: weight decay (decaimento de pesos), a penalidade L2 do Ridge em todo peso.
  • early_stopping=True: separa 10% e para depois de 10 épocas sem melhora.
  • dropout nas bibliotecas de deep learning; não no scikit-learn.
Etapa 5 · como treinar bem e quando vale a pena?

Na prática: escalone as entradas

Spambase: 4.601 e-mails, 57 atributos, desvios-padrão de 0,076 a 606.

MLP (multi-layer perceptron)acurácia na validação cruzada
entradas cruas0,927
StandardScaler antes0,948
Dois pontos com uma linha de pré-processamento, dentro do pipeline. Atributos sem escala esticam a superfície de perda num vale estreito, como nos modelos lineares.

Largura e weight decay, nas luas com ruído

Preveja. 1, 3, 10 ou 100 unidades ocultas, quase sem penalidade: qual tem a melhor acurácia na validação cruzada?
unidades ocultastreinovalidação
regressão logística0,830
10,8420,843
30,8970,873
100,9380,893
1000,9970,857
100 unidades, alphatreinovalidação
0,00010,9970,857
0,010,9930,880
0,10,9390,903
10,9140,917
100,8370,830

As fronteiras

Fronteiras de decisão nas luas com ruído: 1 unidade traça uma reta, 3 e 10 unidades a dobram, 100 unidades contornam pontos isolados, 100 unidades com alpha = 1 dão uma curva suave
A receita de todo modelo do curso: uma arquitetura generosa, depois ajustar o alpha (e a largura) por validação cruzada.

Profundidade e quando usar uma rede

  • Uma camada oculta é um aproximador universal (Cybenko, 1989; Hornik, 1991): existência, não que o treino a encontre.
  • Redes profundas constroem sobre as camadas anteriores: bordas → texturas → objetos. Essa hierarquia tomou conta da percepção a partir de 2012.
spambase, mesmos foldsmédiadesvio
logística0,9240,008
MLP0,9480,005
MLP com parada antecipada0,9420,006
gradient boosting0,9560,011
Em tabelas, os ensembles de árvores continuam tão bons ou melhores, com os padrões e sem pré-processamento. Em imagens, áudio e texto, o equilíbrio se inverte.

Resumo

  1. Um neurônio = soma ponderada + ativação; com sigmoide, regressão logística.
  2. Um neurônio traça uma reta: o XOR pede uma camada oculta, que aprende atributos novos.
  3. Ativações não lineares: sem elas, as camadas colapsam; a ReLU combate o gradiente que desaparece.
  4. Retropropagação: deltas mandados de volta, o gradiente exato numa passagem.
  5. Não convexo: as sementes importam. Escalone e ajuste largura e alpha por validação cruzada.
Próximo passo: o curso de Deep Learning continua exatamente daqui.
Lab

Uma rede neural em dígitos manuscritos

  • 1.797 dígitos, 8 × 8 pixels: dizer o dígito. Baixe o notebook do lab e abra no Jupyter ou no Colab; roda em cerca de um minuto.
  • Tranque o conjunto de teste; compare uma baseline e três modelos nos mesmos folds.
  • Ajuste a largura e o alpha; leia a curva de perda e a parada antecipada.
  • O MLP é mesmo melhor, fold a fold? Depois toque o teste uma única vez.