Derivadas — A Base do Aprendizado de Máquina
A derivada mede a taxa de variação de uma função — o quanto y muda quando x muda um pouquinho. Em ML, é usada para encontrar o mínimo da função de perda.
f'(x) = lim(h→0) [f(x+h) − f(x)] / h
Interpretação geométrica: a derivada é a inclinação da reta tangente ao gráfico de f no ponto x.
Regras de Derivação
| Função | Derivada | Exemplo |
|---|
| Constante: c | 0 | f(x)=5 → f'(x)=0 |
| Potência: xⁿ | n·xⁿ⁻¹ | f(x)=x³ → f'(x)=3x² |
| Exponencial: eˣ | eˣ | f(x)=eˣ → f'(x)=eˣ |
| Logaritmo: ln(x) | 1/x | f(x)=ln(x) → f'(x)=1/x |
| Soma: f+g | f' + g' | (x²+x)' = 2x+1 |
| Produto: f·g | f'g + fg' | (x·eˣ)' = eˣ + x·eˣ |
| Regra da Cadeia: f(g(x)) | f'(g(x))·g'(x) | (x²+1)³ → 3(x²+1)²·2x |
⚠ Regra da Cadeia em Deep Learning
A
regra da cadeia é o coração do
backpropagation em redes neurais. Para calcular o gradiente de uma rede com muitas camadas, aplica-se a regra da cadeia repetidamente de trás para frente (daí o nome "backward propagation").
Derivadas de Funções de Ativação (AI)
| Função | Fórmula | Derivada | Uso |
|---|
| Sigmoid | σ(x) = 1/(1+e⁻ˣ) | σ(x)·(1−σ(x)) | Saída binária (0 a 1) |
| ReLU | max(0, x) | 0 se x<0; 1 se x≥0 | Camadas ocultas — mais comum |
| Tanh | (eˣ−e⁻ˣ)/(eˣ+e⁻ˣ) | 1 − tanh²(x) | Saída entre −1 e 1 |
Exercício 1: Derive f(x) = 3x⁴ − 2x² + 5x − 1
→ f'(x) = 12x³ − 4x + 5
Aplica regra da potência em cada termo: (3x⁴)'=12x³, (2x²)'=4x, (5x)'=5, (1)'=0.
Gradiente e Otimização — O Coração do ML
Gradiente
O gradiente é a generalização da derivada para funções de várias variáveis. É um vetor que aponta na direção de maior crescimento da função.
∇f = (∂f/∂x₁, ∂f/∂x₂, ..., ∂f/∂xₙ)
Exemplo — Gradiente de f(x,y) = x² + y²
∂f/∂x = 2x ∂f/∂y = 2y
∇f = (2x, 2y)
No ponto (3,4): ∇f = (6, 8) — aponta para onde f cresce mais rapidamente.
Gradient Descent (Descida do Gradiente)
Algoritmo de otimização que caminha na direção oposta ao gradiente para minimizar a função de perda. É como descer uma montanha no escuro dando passos na direção mais íngreme para baixo.
θ = θ − α · ∇L(θ)
Onde: θ = parâmetros do modelo, α = learning rate (taxa de aprendizado), L = função de perda (loss).
Learning Rate (α) pequeno
Passos pequenos → converge lentamente. Mais preciso mas pode travar em mínimos locais. Ex: α = 0,001
Learning Rate (α) grande
Passos grandes → pode divergir (ultrapassar o mínimo). Treina rápido mas instável. Ex: α = 1,0
import numpy as np
# Gradient Descent simples para regressão linear
# Minimizar: L(w) = Σ(y - wx)² (MSE)
def gradient_descent(X, y, lr=0.01, epochs=1000):
w = 0.0 # peso inicial
n = len(X)
for _ in range(epochs):
# Gradiente de MSE em relação a w
grad = -2/n * sum(X[i]*(y[i] - w*X[i]) for i in range(n))
w = w - lr * grad # atualiza w na direção oposta ao gradiente
return w
X = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10] # y = 2x
w_otimo = gradient_descent(X, y)
print(f"w encontrado: {w_otimo:.4f}") # deve ser ~2.0
| Variante | Como funciona | Vantagem |
|---|
| Batch GD | Usa todos os dados por época | Gradiente preciso |
| Stochastic GD (SGD) | 1 exemplo por vez | Rápido, pode escapar de mínimos locais |
| Mini-batch GD | Lotes de 32–256 exemplos | Equilíbrio — mais usado em prática |
| Adam | Adapta learning rate por parâmetro | Converge rápido — padrão em deep learning |
⚠ Mínimo Local vs Global
Gradient descent pode ficar preso em um
mínimo local — ponto onde o gradiente é zero mas não é o menor valor global. SGD e mini-batch ajudam a escapar por serem "ruidosos". Em deep learning, mínimos locais geralmente são bons o suficiente.
Exercício 2: Por que o gradiente aponta na direção de MAIOR crescimento e descemos na direção OPOSTA?
→ Queremos minimizar a perda — então vamos na direção contrária ao crescimento.
∇f aponta para onde f sobe mais rápido. Para descer (minimizar), subtraímos o gradiente dos parâmetros: θ = θ − α·∇f.
Integrais
A integral é o processo inverso da derivação. Geometricamente, representa a área sob a curva. Em probabilidade, a integral da função de densidade dá a probabilidade acumulada.
∫f(x)dx — integral indefinida (antiderivada)
∫ₐᵇ f(x)dx — integral definida (área entre a e b)
Regras de Integração
| Função | Integral | Exemplo |
|---|
| xⁿ (n≠−1) | xⁿ⁺¹/(n+1) + C | ∫x³dx = x⁴/4 + C |
| 1/x | ln|x| + C | ∫(1/x)dx = ln|x| + C |
| eˣ | eˣ + C | ∫eˣdx = eˣ + C |
| Constante k | kx + C | ∫5dx = 5x + C |
Integrais em Probabilidade e ML
Distribuição Normal — P(a ≤ X ≤ b)
A probabilidade de X estar entre a e b é a integral da função densidade:
P(a ≤ X ≤ b) = ∫ₐᵇ f(x)dx
Na prática, usa-se tabela z ou scipy.stats — não se integra manualmente.
from scipy import stats
import numpy as np
# P(-1 <= Z <= 1) na normal padrão (μ=0, σ=1)
p = stats.norm.cdf(1) - stats.norm.cdf(-1)
print(f"P(-1 <= Z <= 1) = {p:.4f}") # 0.6827 ≈ 68%
# Integração numérica com scipy
from scipy.integrate import quad
f = lambda x: x**2
area, erro = quad(f, 0, 3) # ∫₀³ x² dx = 9.0
print(f"∫₀³ x²dx = {area}")
Exercício 3: Calcule ∫(2x + 3)dx
→ x² + 3x + C
∫2x dx = 2·x²/2 = x². ∫3 dx = 3x. Soma: x² + 3x + C. Verificação: derivada de x² + 3x = 2x + 3 ✓
Exercício 4: Calcule ∫₀² x³ dx
→ 4
∫x³dx = x⁴/4. Avaliando de 0 a 2: [2⁴/4] − [0⁴/4] = 16/4 − 0 = 4.
Álgebra Linear para ML — Essencial
Álgebra linear é a linguagem do Machine Learning. Dados são matrizes, modelos são transformações lineares, e operações vetoriais são o coração de todo algoritmo de ML.
Vetores e Matrizes
import numpy as np
# Vetor — 1D
v = np.array([1, 2, 3])
# Matriz — 2D
A = np.array([[1, 2], [3, 4]])
# Operações básicas
A + A # soma elemento a elemento
A * 2 # escalar
A @ A # multiplicação de matrizes (PRODUTO MATRICIAL)
A * A # multiplicação elemento a elemento (diferente!)
A.T # transposta
np.linalg.inv(A) # inversa
np.linalg.det(A) # determinante
# Produto escalar (dot product)
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
np.dot(a, b) # 1*4 + 2*5 + 3*6 = 32
Conceitos Fundamentais
| Conceito | Definição | Uso em ML |
|---|
| Produto escalar | Σ aᵢ·bᵢ — mede similaridade | Cosine similarity, atenção em transformers |
| Norma (‖v‖) | √(Σvᵢ²) — tamanho do vetor | Regularização L2, distância euclidiana |
| Multiplicação matricial | C[i,j] = Σ A[i,k]·B[k,j] | Camadas de redes neurais |
| Transposta (Aᵀ) | Troca linhas e colunas | Operações em redes neurais |
| Autovalores/vetores | Av = λv | PCA — redução de dimensionalidade |
Dados como Matrizes em ML
Representação de dados em ML
Dataset com 1000 exemplos e 10 features:
X = matriz 1000×10 (1000 linhas, 10 colunas)
y = vetor 1000×1 (rótulos)
W = matriz de pesos da rede neural
Predição: ŷ = X @ W + b (multiplicação matricial!)
import numpy as np
# Regressão linear em forma matricial
# ŷ = X @ w (sem bias para simplificar)
X = np.array([[1,2],[3,4],[5,6]]) # 3 exemplos, 2 features
w = np.array([0.5, 0.3]) # pesos
y_pred = X @ w # predições
# Solução analítica (mínimos quadrados)
# w = (XᵀX)⁻¹ Xᵀy
y = np.array([1.6, 2.7, 3.8])
w_otimo = np.linalg.inv(X.T @ X) @ X.T @ y
print(w_otimo)
⚠ Por que álgebra linear importa em ML
Uma rede neural com 1 camada é literalmente: saída = ativação(X @ W + b). Treinar a rede = encontrar W e b ótimos usando gradient descent. Cada forward pass = multiplicações matriciais. Cada backward pass = transposta de matrizes na regra da cadeia.
Exercício 5: Por que o produto escalar mede similaridade entre vetores?
→ a·b = ‖a‖‖b‖cos(θ) — quando vetores apontam na mesma direção, θ=0°, cos(0)=1, produto máximo.
Vetores similares têm ângulo pequeno entre eles → cos(θ) próximo de 1 → produto escalar alto. Vetores opostos → cos(180°)=−1. Ortogonais → cos(90°)=0. Usado em sistemas de recomendação e NLP.
📝 Cola — Cálculo para AI/ML
Derivadas Essenciais
| f(x) | f'(x) |
|---|
| xⁿ | n·xⁿ⁻¹ |
| eˣ | eˣ |
| ln(x) | 1/x |
| f(g(x)) — cadeia | f'(g(x))·g'(x) |
| Sigmoid σ(x) | σ(x)·(1−σ(x)) |
| ReLU | 0 se x<0; 1 se x≥0 |
Gradient Descent
θ = θ − α·∇L(θ) (α = learning rate)
Álgebra Linear — Operações Chave
| Operação | NumPy | Uso em ML |
|---|
| Produto matricial | A @ B | Forward pass de redes neurais |
| Transposta | A.T | Backpropagation |
| Produto escalar | np.dot(a,b) | Similaridade, atenção |
| Norma | np.linalg.norm(v) | Regularização L2 |
| Inversa | np.linalg.inv(A) | Mínimos quadrados analítico |
⭐ Regras de Ouro
Regra
Derivada = inclinação = taxa de variação. Derivada zero =
mínimo ou máximoRegra
Gradient descent desce na direção
oposta ao gradiente para minimizar a perda
Regra
Learning rate muito alto → diverge. Muito baixo → lento.
Adam adapta automaticamente
RegraBackpropagation = regra da cadeia aplicada de trás para frente na rede
Regra
Dados em ML = matrizes. Rede neural =
multiplicações matriciais + funções de ativação
RegraProduto escalar alto = vetores similares (mesmo sentido) → base de cosine similarity