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.
- 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:
- uma soma ponderada de suas entradas mais uma viés:
- uma função de ativação aplicada a essa soma:
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.
Funções de ativação
| Ativação | Fórmula | Alcance | Notas |
|---|---|---|---|
| Sigmóide | (0, 1) | esmaga até uma probabilidade; caudas planas | |
| Tanh | (−1, 1) | sigmóide centrado em zero; caudas ainda planas | |
| ReLU | [0, ∞) | o padrão para camadas ocultas: barato, gradiente 1 quando ativo | |
| ReLU com vazamento | (−∞, ∞) | mantém um pequeno gradiente para entradas negativas | |
| GELU | 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 XPExplorador 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
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))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:
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))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:
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.
Tabela de ativação
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
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.
Um softmax que nunca transborda
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
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…