Cálculo

Por que o cálculo aparece em todo lugar no aprendizado de máquina

O aprendizado de máquina (machine learning) moderno transforma “aprender” em minimizar (ou maximizar) uma função objetivo (objective function). Você escolhe um modelo com parâmetros (\theta) (pesos (weights), vieses (biases) etc.), define uma perda (loss) (L(\theta)) que mede o quão errado o modelo está e então ajusta (\theta) para reduzir (L).

O cálculo fornece as ferramentas centrais para esse processo:

Derivadas (derivatives) dizem como uma função muda quando você altera sua entrada.
Gradientes (gradients) generalizam derivadas para muitos parâmetros e apontam na direção de maior aumento.
A regra da cadeia (chain rule) permite calcular derivadas através de composições de funções — esta é a base matemática da Retropropagação.
Derivadas de segunda ordem (second derivatives) e curvatura (curvature) (Hessianas (Hessians)) explicam velocidade e estabilidade da otimização e por que alguns problemas são “difíceis” de treinar. (Veja Gradientes, Jacobianas, Hessianas e Otimização.)
Integrais (integrals) aparecem quando você trabalha com probabilidades e expectativas (expectations) (por exemplo, perda esperada), conectando-se a Probabilidade e Estatística e a métodos de amostragem como Métodos de Monte Carlo.

Este artigo foca nas partes do cálculo que são mais diretamente usadas para otimizar modelos.

Funções, parâmetros e o que “derivada” significa

Uma derivada mede sensibilidade local. Para uma função escalar (f:\mathbb{R}\to\mathbb{R}), a derivada em (x) é

[ f'(x) = \lim_{\epsilon \to 0} \frac{f(x+\epsilon)-f(x)}{\epsilon}. ]

Em aprendizado de máquina, sua função costuma ser uma perda sobre parâmetros:

(L(\theta)): perda escalar
(\theta): parâmetros (frequentemente milhões de números)

A derivada responde: “Se eu deslocar (\theta) levemente, como (L) muda?”

Intuição geométrica

Se você visualizar (L(\theta)) como uma superfície:

A inclinação indica quão rapidamente a perda muda.
Seguir a inclinação negativa reduz a perda.

Essa “inclinação” se torna o gradiente em cenários com múltiplos parâmetros.

Derivadas parciais e o gradiente

A maioria dos objetivos em aprendizado de máquina depende de muitos parâmetros (\theta = (\theta_1,\dots,\theta_d)). A derivada parcial (partial derivative) em relação a (\theta_i) é:

[ \frac{\partial L}{\partial \theta_i}. ]

Empilhando-as, obtemos o vetor gradiente (gradient vector):

[ \nabla_\theta L(\theta) = \begin{bmatrix} \frac{\partial L}{\partial \theta_1}\ \vdots\ \frac{\partial L}{\partial \theta_d} \end{bmatrix}. ]

Fatos-chave usados o tempo todo no treinamento:

(\nabla L) aponta na direção de maior aumento.
(-\nabla L) aponta na direção de maior diminuição.
Uma atualização de primeira ordem como a descida do gradiente (gradient descent) é: [ \theta \leftarrow \theta - \eta \nabla_\theta L(\theta), ] em que (\eta) é a taxa de aprendizado (learning rate). Veja Descida do Gradiente.

Derivadas direcionais (por que “gradiente” é o objeto certo)

Para um pequeno passo (v) (uma direção no espaço de parâmetros), a aproximação de primeira ordem é:

[ L(\theta + \epsilon v) \approx L(\theta) + \epsilon \nabla L(\theta)^\top v. ]

Isso diz que a mudança na perda é aproximadamente o produto interno (dot product) do gradiente com a direção do seu passo — uma das razões pelas quais Álgebra Linear e cálculo são tão fortemente acoplados no aprendizado de máquina.

A regra da cadeia: o motor da retropropagação

Redes neurais (neural networks) são composições de funções. Se

[ y = f(g(x)), ]

então

[ \frac{dy}{dx} = f'(g(x))\cdot g'(x). ]

Em múltiplas dimensões, o mesmo princípio se aplica, usando Jacobianas (Jacobian) (matrizes de derivadas parciais). A retropropagação é, essencialmente, a aplicação repetida da regra da cadeia através das camadas.

Um pequeno exemplo: rede com 1 unidade oculta

Considere:

(z = wx + b)
(a = \sigma(z)) onde (\sigma) é a sigmoide (sigmoid)
Perda (L = \frac{1}{2}(a - t)^2) para alvo (t)

Queremos (\frac{\partial L}{\partial w}). Pela regra da cadeia:

\[ \frac{\partial L}{\partial w}

\frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w}. ]

Calcule cada parte:

(\frac{\partial L}{\partial a} = (a - t))
(\frac{\partial a}{\partial z} = \sigma(z)(1-\sigma(z)) = a(1-a))
(\frac{\partial z}{\partial w} = x)

Então:

[ \frac{\partial L}{\partial w} = (a-t),a(1-a),x. ]

Esse é o padrão “gradiente local vezes gradiente a montante (upstream gradient)” usado em todo lugar na Retropropagação.

Exemplo prático 1: regressão linear e erro quadrático médio (mean squared error, MSE)

A regressão linear (linear regression) prediz:

[ \hat{y} = w^\top x + b. ]

Uma perda comum em um conjunto de dados ({(x_i, y_i)}_{i=1}^n) é o erro quadrático médio:

[ L(w,b) = \frac{1}{n}\sum_{i=1}^n (\hat{y}_i - y_i)^2. ]

Calcule os gradientes:

(\frac{\partial L}{\partial w} = \frac{2}{n}\sum_{i=1}^n (\hat{y}_i - y_i) x_i)
(\frac{\partial L}{\partial b} = \frac{2}{n}\sum_{i=1}^n (\hat{y}_i - y_i))

Essas fórmulas são a base do treinamento baseado em gradientes para muitos modelos, não apenas para regressão linear.

Um loop mínimo de descida do gradiente (pseudocódigo no estilo NumPy):

w = zeros(d)
b = 0.0
for step in range(T):
    yhat = X @ w + b             # shape: (n,)
    err = yhat - y               # shape: (n,)
    grad_w = (2/n) * (X.T @ err) # shape: (d,)
    grad_b = (2/n) * err.sum()

    w -= lr * grad_w
    b -= lr * grad_b

Em frameworks de aprendizado profundo (deep learning frameworks), você normalmente escreve a computação direta (forward computation) e deixa a diferenciação automática (automatic differentiation, autodiff) calcular esses gradientes.

Exemplo prático 2: regressão logística e entropia cruzada

Para classificação binária, a regressão logística (logistic regression) usa:

[ p(y=1\mid x) = \sigma(w^\top x + b). ]

A perda de log-verossimilhança negativa (negative log-likelihood) (entropia cruzada binária) é:

[ L(w,b) = -\frac{1}{n}\sum_{i=1}^n \left[y_i \log p_i + (1-y_i)\log(1-p_i)\right]. ]

Um resultado-chave:

[ \nabla_w L = \frac{1}{n}\sum_{i=1}^n (p_i - y_i)x_i, \quad \frac{\partial L}{\partial b} = \frac{1}{n}\sum_{i=1}^n (p_i - y_i). ]

Isso parece notavelmente similar à regressão linear, mas com (p_i) (uma função não linear de (w)) substituindo (\hat{y}_i). Esse gradiente de “predição menos rótulo” também aparece em classificadores softmax (softmax) e redes neurais treinadas com entropia cruzada, conectando cálculo à Teoria da Informação (a entropia cruzada vem de noções informacionais de codificação e surpresa).

Não diferenciabilidade e subgradientes (ReLU, L1, max)

Nem toda função útil é diferenciável em todo lugar:

ReLU: (\text{ReLU}(x) = \max(0,x)) não é diferenciável em (0).
Regularização L1 (L1 regularization): (|w|) não é diferenciável em (0).
Operações de máximo (max) aparecem em pooling (pooling), margens e perdas hinge (hinge losses).

Na prática:

Usamos subgradientes (subgradients) (gradientes generalizados) ou definimos um valor conveniente no ponto de quina (por exemplo, derivada da ReLU em 0 definida como 0).
A otimização ainda funciona bem com métodos de gradiente estocástico (stochastic gradient methods).

Esta é uma das razões pelas quais a otimização em aprendizado de máquina é frequentemente descrita como não suave (nonsmooth) e por que o desempenho prático depende de mais do que suposições de diferenciabilidade de livro-texto (veja Otimização).

Diferenciação automática (autodiff): cálculo em escala

O aprendizado profundo seria muito mais difícil sem autodiff. Em vez de derivar e implementar gradientes manualmente, você constrói um grafo de computação (computation graph) e deixa o framework aplicar a regra da cadeia.

Dois modos principais:

Diferenciação automática em modo reverso (reverse-mode autodiff) (retropropagação): eficiente quando você tem muitos parâmetros e uma perda escalar (típico em aprendizado de máquina).
Diferenciação automática em modo direto (forward-mode autodiff): eficiente quando você tem poucos parâmetros e muitas saídas.

Conceitualmente, autodiff é diferenciação exata do programa, não uma aproximação numérica.

Diferenciação numérica geralmente é uma má ideia no treinamento

Diferenças finitas (finite differences) aproximam:

[ \frac{\partial L}{\partial \theta_i} \approx \frac{L(\theta+\epsilon e_i) - L(\theta)}{\epsilon}. ]

Problemas:

Computacionalmente caro: uma passagem direta por dimensão de parâmetro.
Sensível a (\epsilon): pequeno demais causa problemas de ponto flutuante (floating point); grande demais causa viés (bias).
Ruidoso com minilotes (minibatches).

Diferenças finitas continuam úteis como uma verificação de gradiente (gradient check) para depurar modelos pequenos.

Derivadas de segunda ordem: curvatura, Hessianas e por que elas importam

O gradiente diz em que direção se mover; curvatura diz como o gradiente muda conforme você se move.

Para uma perda escalar (L(\theta)), a Hessiana (Hessian) é:

[ H(\theta) = \nabla^2_\theta L(\theta), ]

uma matriz (d\times d) de segundas derivadas parciais. Em 1D, (f''(x)) indica convexidade e quão rapidamente a inclinação muda.

Por que informação de segunda ordem importa no aprendizado de máquina:

Ajuda a explicar por que algumas direções são “rígidas” (alta curvatura) e exigem taxas de aprendizado pequenas.
Motiva otimizadores adaptativos e pré-condicionamento (preconditioning) (mesmo quando eles não computam Hessianas explicitamente).
Sustenta métodos do tipo Newton (Newton-type methods) (menos comuns em redes profundas gigantes, mas importantes em problemas menores e na teoria).

Na prática, computar a Hessiana completa costuma ser inviável para redes profundas. Em vez disso, usamos:

Produtos Hessiana-vetor (Hessian-vector products) (podem ser computados com diferenciação automática de forma eficiente)
Métodos quase-Newton (quasi-Newton methods) (por exemplo, L-BFGS) para problemas de escala moderada
Aproximações de curvatura (por exemplo, diagonal, bloco-diagonal)

Para mais sobre esses objetos e seus formatos em cenários multivariados, veja Gradientes, Jacobianas, Hessianas.

Aproximações de Taylor: o modelo local por trás de métodos de gradiente

Uma ideia central por trás da otimização baseada em gradientes é aproximar (L(\theta+\Delta)) localmente.

Aproximação de primeira ordem (linear):

[ L(\theta+\Delta) \approx L(\theta) + \nabla L(\theta)^\top \Delta. ]

Aproximação de segunda ordem (quadrática):

[ L(\theta+\Delta) \approx L(\theta) + \nabla L(\theta)^\top \Delta + \frac{1}{2}\Delta^\top H(\theta)\Delta. ]

A descida do gradiente usa a visão de primeira ordem.
O método de Newton (Newton’s method) vem de minimizar a aproximação de segunda ordem: [ \Delta = -H^{-1}\nabla L. ]

Mesmo que você nunca execute o método de Newton, essa perspectiva de Taylor explica:

por que taxas de aprendizado importam,
por que a curvatura afeta a estabilidade do treinamento,
por que normalização (normalization) e inicialização (initialization) podem ajudar.

Integrais e expectativas: cálculo no aprendizado de máquina probabilístico (probabilistic ML)

Embora a otimização enfatize derivadas, integrais aparecem quando você trabalha com expectativas:

[ \mathbb{E}_{x\sim p}[f(x)] = \int f(x)p(x),dx. ]

Em aprendizado de máquina, padrões comuns incluem:

Minimização do risco esperado (expected risk minimization): minimizar (\mathbb{E}[\ell(\hat{y}, y)])
Máxima verossimilhança (maximum likelihood): maximizar (\sum_i \log p_\theta(x_i))
Regularização como priores (priors) em visões bayesianas (veja Teoria da Decisão Bayesiana)
Evidência / verossimilhança marginal (evidence / marginal likelihood) envolve integrais sobre variáveis latentes (latent variables): [ p(x)=\int p(x,z),dz ] o que frequentemente é intratável, motivando aproximações via Métodos de Monte Carlo ou Monte Carlo via Cadeias de Markov (Markov Chain Monte Carlo, MCMC).

Diferenciando através de expectativas

Muitos objetivos têm a forma:

[ L(\theta)=\mathbb{E}_{\xi\sim p(\xi)}[f(\theta,\xi)]. ]

Sob condições regulares comuns, você pode trocar derivada e expectativa:

[ \nabla_\theta L(\theta) = \mathbb{E}[\nabla_\theta f(\theta,\xi)]. ]

Isso justifica a descida do gradiente estocástica (stochastic gradient descent): estimar a expectativa com amostras (minilotes), calcular gradientes nessa amostra e atualizar os parâmetros.

Cálculo no kit de ferramentas do dia a dia em aprendizado de máquina

Cálculo não é um tópico isolado em aprendizado de máquina; ele está embutido em fluxos de trabalho padrão:

Treinar redes profundas: gradientes via diferenciação automática + regra da cadeia (Retropropagação)
Escolher otimizadores e escalonamentos (schedules): intuição de primeira ordem vs segunda ordem (Descida do Gradiente, Otimização)
Projetar perdas: entropia cruzada, perdas de margem (margin losses), regularizadores (regularizers) (frequentemente dependendo de propriedades de suavidade (smoothness))
Depurar: verificação de gradiente, diagnosticar gradientes que desaparecem/explodem (vanishing/exploding gradients)
Modelagem probabilística: expectativas, gradientes da verossimilhança, aproximações baseadas em amostragem (Probabilidade e Estatística, Métodos de Monte Carlo)

Armadilhas comuns e intuições úteis

Gradientes que desaparecem e que explodem

Multiplicações repetidas pela regra da cadeia podem encolher ou explodir gradientes, especialmente em redes profundas ou sequências longas. Isso motivou:

inicialização cuidadosa,
camadas de normalização,
RNNs com portas (gated RNNs) e conexões residuais (residual connections),
arquiteturas como Arquitetura Transformer (que também ajuda no fluxo de gradientes (gradient flow) via caminhos residuais (residual paths)).

A taxa de aprendizado é “sensível a unidades (units-aware)”

Um gradiente tem a mesma “forma” que os parâmetros, mas a escala pode variar enormemente entre camadas. Isso explica:

a necessidade de ajustar (\eta),
por que escalonamento de atributos (feature scaling) e normalização importam,
por que métodos adaptativos (adaptive methods) (Adam, RMSProp) podem ajudar (embora não substituam boa modelagem e ajuste (tuning)).

Gradientes são locais

Derivadas descrevem mudança local. Perdas não convexas (non-convex) (típicas no aprendizado profundo) podem ter:

planaltos (plateaus),
pontos de sela (saddle points),
muitos mínimos locais (local minima) com desempenho similar.

Por isso, o comportamento da otimização pode ser sensível à inicialização e à estocasticidade.

Resumo

O cálculo fornece a linguagem e a maquinaria para o aprendizado na IA (AI) moderna:

Derivadas e gradientes quantificam como os parâmetros do modelo afetam a perda.
A regra da cadeia torna modelos profundos treináveis e sustenta a retropropagação.
Métodos de primeira ordem (descida do gradiente e variantes) escalam para modelos grandes.
Ideias de segunda ordem (curvatura, Hessianas) explicam dinâmicas de treinamento e inspiram otimizadores mais avançados.
Integrais/expectativas conectam otimização à modelagem probabilística e à estimação estocástica.

Para o próximo passo — como gradientes se generalizam para funções com valores vetoriais (vector-valued functions) e como Jacobianas/Hessianas são usadas na prática — veja Gradientes, Jacobianas, Hessianas.