Carregando
0x20Lição 3 de 17

Neurônios e funções de ativação

Construa um neurônio artificial, explore funções de ativação e veja por que a não linearidade é essencial.

26 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • Calcule a saída de um neurônio como uma ativação de uma soma ponderada mais polarização
  • Compare sigmóide, tanh, ReLU, ReLU com vazamento e GELU, incluindo suas inclinações
  • Explique por que as camadas empilhadas precisam de ativações não lineares e calcule um softmax estável

Um neurônio artificial faz duas coisas:

  1. uma soma ponderada de suas entradas mais uma viés: z=w1x1+w2x2+⋯+wnxn+b=w⋅x+bz = w_1 x_1 + w_2 x_2 + \dots + w_n x_n + b = \mathbf{w} \cdot \mathbf{x} + b
  2. uma função de ativação aplicada a essa soma: a=f(z)a = f(z)

Os pesos dizem o quanto cada input é importante (e em que direção); o viés muda o limite. Uma camada consiste em muitos neurônios compartilhando as mesmas entradas, então seus pesos formam uma matriz e toda a camada é um x @ W + b.

x₁w₁x₂w₂x₃w₃Σ + bativaçãoy
Um neurônio artificial: multiplique cada entrada por um peso, some um viés e aplique uma função de ativação.

Funções de ativação

AtivaçãoFórmulaAlcanceNotas
Sigmóideσ(z)=11+e−z\sigma(z) = \frac{1}{1 + e^{-z}}(0, 1)esmaga até uma probabilidade; caudas planas
Tanhtanh⁡(z)\tanh(z)(−1, 1)sigmóide centrado em zero; caudas ainda planas
ReLUmax⁡(0,z)\max(0, z)[0, ∞)o padrão para camadas ocultas: barato, gradiente 1 quando ativo
ReLU com vazamentomax⁡(0.1z,z)\max(0.1z, z)(−∞, ∞)mantém um pequeno gradiente para entradas negativas
GELUz⋅Φ(z)z \cdot \Phi(z)cerca de [−0,17, ∞)um ReLU suave usado em transformadores

O que mais importa para o aprendizado é a inclinação (derivada): durante o treinamento, os gradientes são multiplicados por ela em cada camada. Onde a inclinação é próxima de zero, o aprendizado é interrompido.

Experimente

Até 15 XP

Explorador de ativação

Escolha uma ativação e deslize a entrada. A curva tracejada é a sua inclinação.

  • Deslize o sigmóide para x = 5: a saída é quase 1, mas a inclinação é quase 0. Empilhe dez dessas camadas e o gradiente praticamente desaparece.
  • Compare ReLU: sua inclinação é exatamente 1 para qualquer entrada positiva - e é por isso que tornou treináveis ​​redes profundas. Mas para entradas negativas a sua inclinação é 0 (um neurônio “morto”); ReLU com vazamento corrige isso.

σ(x) = 1 / (1 + e^-x)

Linha contínua: a função. Tracejada: sua derivada (a inclinação pela qual o backprop multiplica).

saída
0.731
inclinação
0.197
activations.py
1import numpy as np
2
3z = np.array([-3.0, -0.5, 0.0, 0.5, 3.0])
4sigmoid = 1 / (1 + np.exp(-z))
5relu = np.maximum(0, z)
6print("sigmoid:", np.round(sigmoid, 3))
7print("slope:  ", np.round(sigmoid * (1 - sigmoid), 3))
8print("tanh:   ", np.round(np.tanh(z), 3))
9print("relu:   ", relu)
10print("leaky:  ", np.where(z > 0, z, 0.1 * z))
Saída
sigmoid: [0.047 0.378 0.5   0.622 0.953]
slope:   [0.045 0.235 0.25  0.235 0.045]
tanh:    [-0.995 -0.462  0.     0.462  0.995]
relu:    [0.  0.  0.  0.5 3. ]
leaky:   [-0.3  -0.05  0.    0.5   3.  ]

Por que a não linearidade é essencial

Sem ativações, uma pilha de camadas é inútil: duas camadas lineares, (x @ W1) @ W2, equivalem a uma camada linear com pesos W1 @ W2. Cem camadas lineares ainda desenham apenas linhas retas. A não linearidade entre as camadas é o que permite que a profundidade adicione poder:

collapse.py
1import numpy as np
2
3rng = np.random.default_rng(0)
4x = rng.normal(size=(4, 3))
5W1, W2 = rng.normal(size=(3, 5)), rng.normal(size=(5, 2))
6two_layers = (x @ W1) @ W2
7one_layer = x @ (W1 @ W2)
8print(np.allclose(two_layers, one_layer))
9with_relu = np.maximum(0, x @ W1) @ W2
10print(np.allclose(with_relu, one_layer))
Saída
True
False

Softmax: pontuações em probabilidades

Para classificação, a última camada gera uma pontuação bruta por classe - os logits. Softmax os transforma em probabilidades positivas que somam 1:

softmax(z)i=ezi∑jezj\text{softmax}(z)_i = \frac{e^{z_i}}{\sum_j e^{z_j}}

Calculado ingenuamente, np.exp(1000) transborda para o infinito. Como o softmax não muda quando você subtrai o mesmo número de cada logit, subtraia o máximo primeiro - o softmax estável padrão.

Principais conclusões

  • Um neurônio calcula f(w·x + b); uma camada faz isso para muitos neurônios ao mesmo tempo com x @ W + b.

  • ReLU é a ativação oculta padrão; sigmóide e tanh têm caudas planas que diminuem os gradientes.

  • Sem ativações não lineares, qualquer pilha de camadas colapsa em uma única camada linear.

  • Softmax transforma logits em probabilidades; subtraia o máximo primeiro para estabilidade numérica.

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

Tabela de ativação

+25 XP

Cada linha de entrada é um número z. Imprima uma linha com z e seus valores sigmóide, tanh, ReLU e ReLU com vazamento (inclinação 0,1), todos com 3 casas decimais, separados por espaços. Escreva cada ativação como uma função que funciona em matrizes numpy.

  • Cinco entradas
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

Um softmax que nunca transborda

+25 XP

Cada linha de entrada contém os logits de um exemplo. Imprima as probabilidades softmax com 3 casas decimais e depois sum=1.000. Os logits podem ser enormes (como 1000) - seu softmax deve subtrair o máximo de cada linha para que nada transborde.

  • Enormes logits
  • logitos comuns
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…