Por trás de quase todos os avanços recentes de inteligência artificial está a mesma ideia: muitas unidades simples, conectadas em camadas, aprendendo a partir de exemplos.

A ideia tem mais de 80 anos. O que mudou recentemente foi a combinação de muitos dados, computadores rápidos (GPUs) e melhores técnicas de treino.
| Neurônio biológico | Neurônio artificial |
|---|---|
| Dendritos recebem sinais | Entradas \(x_1, x_2, \dots\) |
| Sinapses mais fortes ou mais fracas | Pesos \(w_1, w_2, \dots\) |
| Corpo celular acumula os sinais | Soma ponderada |
| Dispara se passar de um limiar | Função de ativação |
| Axônio envia o sinal adiante | Saída |
O que a rede aprende são os pesos e o viés: quanto cada entrada deve importar para a decisão.
Duas etapas:
\[z = w_1 x_1 + w_2 x_2 + \cdots + w_n x_n + b\]
| Entrada | Valor hoje | Peso |
|---|---|---|
| Está sol? | 1 (sim) | +0,6 |
| Está frio? | 0 (não) | −0,4 |
| Tenho companhia? | 1 (sim) | +0,3 |
| Viés | −0,5 |
\[\begin{aligned} z &= 0{,}6 \times 1 + (-0{,}4) \times 0 + 0{,}3 \times 1 - 0{,}5 \\ &= 0{,}4 \end{aligned}\]
Como \(z = 0{,}4 > 0\) → saída = 1: vou à praia!

Um neurônio sozinho = uma reta.
Vários neurônios em camadas = várias retas combinadas, capazes de formar regiões de qualquer formato.
| x₁ | x₂ | h₁ (OU) | h₂ (NÃO-E) | saída (E) |
|---|---|---|---|---|
| 0 | 0 | 0 | 1 | 0 |
| 0 | 1 | 1 | 1 | 1 |
| 1 | 0 | 1 | 1 | 1 |
| 1 | 1 | 1 | 0 | 0 |
Cada neurônio escondido resolve um pedaço fácil do problema (uma reta). O neurônio de saída combina os pedaços. A camada escondida criou novas variáveis (\(h_1\), \(h_2\)) em que o problema ficou simples!

Os pontos \((0,1)\) e \((1,0)\) viram o mesmo ponto \((1,1)\) no novo espaço. Essa é a grande ideia das redes neurais: transformar os dados até que o problema fique fácil.


Ativação: sigmoide (transforma qualquer número em um valor entre 0 e 1).
Neurônio \(h_1\) (pesos 0,4 e 0,3):
\(z = 0{,}4 \times 0{,}5 + 0{,}3 \times 1 = 0{,}50\) → \(h_1 = \sigma(0{,}50) = 0{,}62\)
Neurônio \(h_2\) (pesos −0,2 e 0,6; viés 0,1):
\(z = -0{,}2 \times 0{,}5 + 0{,}6 \times 1 + 0{,}1 = 0{,}60\) → \(h_2 = 0{,}65\)
Saída (pesos 0,7 e −0,5; viés 0,1):
\(z = 0{,}7 \times 0{,}62 - 0{,}5 \times 0{,}65 + 0{,}1 = 0{,}21\)
\(\hat{y} = \sigma(0{,}21) = 0{,}55\)
É só isso, repetido: somar, ativar, passar adiante.
Exemplo: dobrar e depois triplicar um número é o mesmo que multiplicá-lo por 6.
Duas transformações lineares em sequência equivalem a uma só.
A função de ativação é a “dobra” não linear que permite às camadas criarem coisas novas.

| Função | Ideia | Onde usar |
|---|---|---|
| Sigmoide | “espreme” qualquer número entre 0 e 1 | saída de classificação binária (probabilidade) |
| Tanh | parecida, mas entre −1 e 1 | camadas escondidas (redes mais antigas, sequências) |
| ReLU | negativo vira 0; positivo passa como está | camadas escondidas: o padrão atual |
Softmax: transforma os “escores” de cada classe em probabilidades que somam 1. Exemplo — a foto é de quê?
| Classe | Escore | Probabilidade |
|---|---|---|
| Gato | 2,0 | 66% |
| Cachorro | 1,0 | 24% |
| Pássaro | 0,1 | 10% |
Regressão — erro quadrático médio:
\[\text{perda} = \text{média de } (y - \hat{y})^2\]
Erros grandes pesam muito mais que erros pequenos.
Classificação — entropia cruzada: olha a probabilidade que a rede deu para a classe certa:
\[\text{perda} = -\log(\text{prob. da classe certa})\]

Acertar com confiança → perda perto de zero. Errar com confiança → perda enorme.
É a mesma montanha da aula de gradient boosting:
peso novo = peso atual − taxa de aprendizado × inclinação
A diferença: aqui a montanha tem milhares (ou bilhões) de direções — uma para cada peso.

Analogia: um time perde o jogo. O técnico revê o vídeo do fim para o começo e descobre quanto cada jogada (e cada jogador) contribuiu para o gol sofrido — e treina mais quem mais precisa.
Pergunta: se eu mexer um pouquinho em um peso lá do começo da rede, quanto muda o erro lá no final?

Como engrenagens: se a 1ª gira a 2ª 2 vezes mais, a 2ª gira a 3ª 3 vezes mais e a 3ª gira a 4ª 2 vezes mais, então a 1ª gira a 4ª 2 × 3 × 2 = 12 vezes mais. Essa é a regra da cadeia: o efeito total é o produto dos efeitos de cada elo.



Começamos pelo fim: quanto o erro muda se ŷ mudar um pouquinho?
Como \(L = \tfrac{1}{2}(\hat{y} - y)^2\):
\[\frac{\partial L}{\partial \hat{y}} = \hat{y} - y = 3 - 1 = \mathbf{2}\]
Lê-se: “cada unidade a mais em ŷ aumenta o erro em cerca de 2 unidades”.
Conferindo: ŷ de 3 para 3,01
\(L = \tfrac{1}{2}(3{,}01 - 1)^2 = 2{,}0200\)
O erro subiu 0,020 ≈ 2 × 0,01 ✔

\(\hat{y} = 3h\): h mexe em ŷ 3 vezes mais. A regra da cadeia multiplica os efeitos:
\[\frac{\partial L}{\partial h} = \underbrace{\frac{\partial L}{\partial \hat{y}}}_{2\ \text{(elo 1)}} \times \underbrace{\frac{\partial \hat{y}}{\partial h}}_{w_2\ =\ 3} = 2 \times 3 = \mathbf{6}\]
Idem para w₂: culpa \(= 2 \times h = 2 \times 1 = \mathbf{2}\).
Conferindo: h de 1 para 1,01
ŷ = 3 × 1,01 = 3,03 → erro sobe 0,060 ≈ 6 × 0,01 ✔
w₂ de 3 para 3,01 → erro sobe 0,020 ≈ 2 × 0,01 ✔

Com a ReLU ativa, \(h = w_1 \cdot x = 2 w_1\): w₁ mexe em h 2 vezes mais.
\[\frac{\partial L}{\partial w_1} = \underbrace{\frac{\partial L}{\partial h}}_{6\ \text{(elo 2)}} \times \underbrace{\frac{\partial h}{\partial w_1}}_{x\ =\ 2} = \mathbf{12}\]
Reaproveitamos o 6 do elo anterior: nada de refazer contas desde o erro.
Conferindo: w₁ de 0,5 para 0,51
h = 1,02 → ŷ = 3,06 → erro sobe 0,122 ≈ 12 × 0,01 ✔

\[\frac{\partial L}{\partial w_1} \;=\; \underbrace{\frac{\partial L}{\partial \hat{y}}}_{\large 2} \;\times\; \underbrace{\frac{\partial \hat{y}}{\partial h}}_{\large 3} \;\times\; \underbrace{\frac{\partial h}{\partial w_1}}_{\large 2} \;=\; \mathbf{12}\]
Regra da cadeia = multiplicar os efeitos de cada elo, como nas engrenagens. O backpropagation faz isso de trás para frente, guardando os resultados parciais (2 → 6 → 12): por isso é eficiente mesmo com milhões de pesos.

peso novo = peso − taxa × culpa (taxa = 0,02)
| Peso | Antes | Culpa | Depois |
|---|---|---|---|
| \(w_1\) | 0,5 | 12 | 0,5 − 0,02 × 12 = 0,26 |
| \(w_2\) | 3 | 2 | 3 − 0,02 × 2 = 2,96 |
Nova previsão: \(\hat{y} = 1{,}54\) (antes: 3). A perda caiu de 2 para 0,15 em um único passo!

Começando de um ponto ruim (\(w_1 = 0{,}05\), \(w_2 = 0{,}3\): a rede prevê \(\hat{y} \approx 0\)), com taxa 0,1. Cada ponto vermelho é uma rodada completa: ① para frente → ② para trás (regra da cadeia) → ③ ajuste. A rede desce até o vale, onde \(\hat{y} \approx 1\).
| Gradiente descendente | Regra da cadeia (backpropagation) | |
|---|---|---|
| Papel | decide para onde e quanto andar | calcula a inclinação de cada peso |
| Pergunta | “como desço a montanha?” | “quanto cada peso influencia o erro?” |
| Na rede mínima | \(w_1\): 0,5 → 0,26 | culpa de \(w_1\) = 2 × 3 × 2 = 12 |
Backpropagation não é um jeito novo de aprender: é um jeito eficiente de calcular todas as inclinações de uma vez, reaproveitando as contas feitas na ida.
Um neurônio com sigmoide, peso \(w = 0{,}1\), recebe \(x = 2\) e a resposta certa é \(y = 1\).
① Prever: \(\hat{y} = \sigma(0{,}1 \times 2) = 0{,}55\)
② Erro: \(\hat{y} - y = 0{,}55 - 1 = -0{,}45\) — previu baixo demais.
③ Culpa do peso: \(\text{erro} \times x = -0{,}45 \times 2 = -0{,}90\)
④ Ajuste (taxa 0,5):
\(w = 0{,}1 - 0{,}5 \times (-0{,}90) = 0{,}55\)
Com o peso novo: \(\hat{y} = \sigma(0{,}55 \times 2) = 0{,}75\)
A previsão subiu de 0,55 para 0,75, mais perto da resposta certa (1)!
Numa rede, o backpropagation faz essa mesma conta para todos os pesos ao mesmo tempo.

| Termo | Significado | No exemplo |
|---|---|---|
| Lote (batch) | pedaço dos dados usado para um ajuste dos pesos | 100 observações |
| Iteração | um ajuste dos pesos (um lote processado) | 10 por época |
| Época | uma passada completa por todos os dados | 1.000 observações vistas |
Usar lotes pequenos é o gradiente descendente estocástico (SGD): cada passo é mais “ruidoso”, porém muito mais rápido — e o ruído ajuda a escapar de mínimos locais.


Solução: a ReLU tem inclinação 1 para valores positivos — o sinal atravessa as camadas sem encolher. Foi um dos segredos para treinar redes profundas.
Padronizar as variáveis numéricas
Codificar as variáveis categóricas
| Cor | azul | verde | vermelho |
|---|---|---|---|
| azul | 1 | 0 | 0 |
| verde | 0 | 1 | 0 |
| vermelho | 0 | 0 | 1 |
Os parâmetros da padronização (média e desvio) são calculados só no treino e depois aplicados ao teste — senão vazamos informação do teste para o modelo.


Dropout

A cada passo do treino, desliga aleatoriamente alguns neurônios. A rede não pode depender de nenhum neurônio específico — como um time que treina sem saber quem vai faltar.
Early stopping

Acompanhar o erro de validação a cada época e parar quando ele começa a subir.
| Hiperparâmetro | O que controla | Dica |
|---|---|---|
| Nº de camadas escondidas | profundidade da rede | para dados tabulares, 1 a 3 costumam bastar |
| Nº de neurônios por camada | “largura” da rede | comece pequeno e aumente se houver underfitting |
| Função de ativação | não linearidade | ReLU nas escondidas; a saída depende do problema |
| Taxa de aprendizado | tamanho do passo | o hiperparâmetro mais importante; teste 0,1, 0,01, 0,001… |
| Tamanho do lote | quantas obs. por ajuste | 32 a 256 são valores comuns |
| Nº de épocas | quanto tempo treinar | use early stopping |
| Regularização | weight decay, dropout | aumente se houver overfitting |
Como em todas as aulas: os hiperparâmetros são escolhidos por validação cruzada (ou um conjunto de validação), nunca olhando o teste.
Vantagens
Limitações
Planilhas pequenas ou médias: random forest e boosting costumam ganhar. Imagens, texto, áudio: redes neurais dominam.

