A Derivada na Computação
Como uma única ideia do cálculo diferencial sustenta inteligência artificial, visão computacional, computação gráfica, métodos numéricos, engenharia, sistemas de informação e criptografia.
Abrir se apresentando brevemente e citando o grupo. Deixar claro logo de início que o fio condutor do trabalho é uma única pergunta prática, não uma lista de fórmulas soltas.
O que a derivada responde, na prática
Fora do contexto puramente matemático, a derivada responde a uma única pergunta:
"Quando eu mexo um pouquinho aqui, quanto muda ali?"
É a medida da taxa de variação — a sensibilidade de uma saída em relação a uma entrada. No computador ela quase nunca é calculada "no papel": é obtida de forma discreta, comparando valores vizinhos, ou de forma automática, por bibliotecas que derivam em tempo de execução.
Este é o slide-tese do trabalho: tudo que vem depois é uma instância dessa mesma pergunta aplicada a um domínio diferente (IA, imagem, controle, etc.). Vale enfatizar a frase final — a matemática é a mesma, o método de obtenção é que muda conforme a máquina.
Três papéis recorrentes
- Otimização — em que direção devo ajustar para melhorar? (treinamento de IA, custos, dimensionamento)
- Detecção de variação — onde algo mudou bruscamente? (bordas em imagens, alertas de monitoramento)
- Previsão e controle — para onde isso está indo? (controladores, sistemas embarcados, projeções)
Esses três papéis funcionam como roteiro do restante da apresentação: cada bloco temático que vem a seguir (IA, visão, engenharia, ADS) pode ser anunciado dizendo qual desses três papéis ele ilustra.
Do limite à diferença finita
Como o computador não trabalha com limites, usa-se um passo h pequeno e finito:
| h | progressiva | erro | central | erro |
|---|---|---|---|---|
| 0,1 | 12,610000 | 6,10 × 10⁻¹ | 12,010000 | 1,00 × 10⁻² |
| 0,01 | 12,060100 | 6,01 × 10⁻² | 12,000100 | 1,00 × 10⁻⁴ |
| 0,0001 | 12,000600 | 6,00 × 10⁻⁴ | 12,000000 | 1,00 × 10⁻⁸ |
A coluna "erro" usa notação científica: 6,10 × 10⁻¹ significa 0,610. Cada expoente mais negativo move a vírgula mais uma casa para a esquerda — por isso 1,00 × 10⁻⁸ (0,00000001) é um erro bem menor que 6,10 × 10⁻¹.
Ponto-chave: reduzir h por 10x derruba o erro da progressiva por 10x (1ª ordem) e o da central por 100x (2ª ordem) — por isso bibliotecas de sinal preferem a central. Alerta bônus se sobrar tempo: reduzir h abaixo de ~1e-8 piora o resultado por cancelamento catastrófico em ponto flutuante; existe um h ótimo.
Treinar é descer uma montanha
O erro de um modelo é uma superfície: a altitude é o tamanho do erro. O algoritmo é "cego" — só sente a inclinação do terreno sob os pés. Essa inclinação é a derivada.
novo peso = peso atual − (taxa de aprendizado × derivada do erro)
A taxa de aprendizado (α) é o tamanho do passo dado a cada ajuste: um número pequeno, tipicamente entre 0,001 e 1. Passo grande demais faz o modelo pular o vale e oscilar (ou divergir); passo pequeno demais torna o treinamento lento.
| iter | w | L'(w) |
|---|---|---|
| 0 | 0,000 | −6,000 |
| 2 | 1,080 | −3,840 |
| 4 | 1,771 | −2,458 |
Observar que os passos encolhem sozinhos conforme a derivada diminui — perto do mínimo o ajuste é naturalmente mais fino, sem nenhuma lógica extra. Isso prepara o terreno para a demonstração ao vivo no próximo slide, onde o grupo pode variar a taxa de aprendizado e mostrar a divergência acima de α ≈ 1.
Ajuste a taxa de aprendizado
A curva verde é o erro L(w) = (w−3)² para cada valor do parâmetro w; o vale (tracejado) é a resposta certa, w = 3. A bolinha é o valor atual de w, e α é o tamanho de cada passo que a derivada manda dar.
Cada passo multiplica o erro por (1 − 2α): até 0,5 desce sempre pelo mesmo lado; entre 0,5 e 1 atravessa o vale e volta; em 1,0 fica pulando entre 0 e 6 para sempre; acima de 1,0 diverge.
Mexer no slider já reinicia a descida sozinho — não precisa clicar "Reiniciar" a cada mudança. Roteiro sugerido: α = 0,1 (desce suave pelo mesmo lado) → α = 0,5 (acerta o mínimo em um único passo) → α = 0,8 (converge, mas atravessando o vale de um lado para o outro) → α = 1,0 (pula eternamente entre 0 e 6, sem nunca convergir nem divergir) → α = 1,2 (diverge, a bolinha sai da tela).
Se alguém perguntar de onde vem esse limite: a atualização é w ← w − α·2(w−3). Chamando o erro de e = w − 3, ela vira e ← (1 − 2α)·e — o erro é multiplicado por (1 − 2α) a cada passo. Converge só quando |1 − 2α| < 1, ou seja 0 < α < 1. É o caso particular da regra geral α < 2/L'', com L'' = 2 aqui. O rótulo no topo do gráfico mostra esse fator em tempo real.
Backpropagation é a regra da cadeia
Para saber quanto um parâmetro da primeira camada contribuiu para o erro na última, propaga-se a responsabilidade de trás para frente.
dL_da = 2 * (a_saida - alvo)
da_dz = derivada_sigmoide(a_saida)
delta_saida = dL_da * da_dz # regra da cadeiaRede 2-2-1 aprendendo XOR (não linearmente separável), sem nenhuma biblioteca:
| entrada | saída | esperado |
|---|---|---|
| 0 XOR 0 | 0,0087 | 0 |
| 0 XOR 1 | 0,9925 | 1 |
| 1 XOR 1 | 0,0079 | 0 |
Retirar a linha da_dz faz a rede parar de aprender — não há "inteligência" além da regra da cadeia aplicada repetidamente.
Se der tempo, mencionar a observação experimental do material: trocando a semente aleatória de 1 para 42, a mesma rede fica presa em um mínimo local (erro estaciona ~0,53) — a derivada só enxerga a inclinação imediata, não o relevo inteiro. Isso justifica técnicas como momentum e reinicializações múltiplas.
Por que a ReLU substituiu a sigmoide
Sigmoide e ReLU são duas funções de ativação — decidem o quanto um neurônio "dispara" a partir da soma que ele recebe. Sigmoide: (comprime qualquer entrada para entre 0 e 1). ReLU: (zero se negativo, o próprio valor se positivo).
A sigmoide tem derivada sempre menor que 0,25. Multiplicando dezenas dessas derivadas entre camadas, o gradiente que chega às primeiras camadas vira praticamente zero.
g_sig = 0.25 ** n # derivada máx. da sigmoide
g_relu = 1.0 ** n # derivada da ReLU na região ativa| camadas | sigmoide | ReLU |
|---|---|---|
| 1 | 2,500 × 10⁻¹ | 1,0 |
| 10 | 9,537 × 10⁻⁷ | 1,0 |
| 50 | 7,889 × 10⁻³¹ | 1,0 |
Com 50 camadas e sigmoide o gradiente é ~1e-31 — indistinguível de zero em ponto flutuante, o parâmetro nunca é atualizado. Esse cálculo de três linhas explica sozinho por que o deep learning só decolou após a adoção da ReLU. É uma decisão de engenharia tomada inteiramente com base no comportamento de uma derivada.
Detectar bordas é detectar derivadas altas
Uma imagem é uma função I(x,y). Onde é uniforme, a derivada é próxima de zero; onde há uma borda, a intensidade muda bruscamente e a derivada dispara.
gx = convolucao(imagem, MASCARA_X, linha, coluna)
gy = convolucao(imagem, MASCARA_Y, linha, coluna)
magnitude = math.sqrt(gx**2 + gy**2) # |grad I|Mencionar rapidamente a família de técnicas derivadas dessa ideia: Sobel/Prewitt (1ª derivada direcional), Laplaciano (2ª derivada, localiza a borda no zero-crossing), Canny (padrão da indústria) e fluxo óptico (derivada no tempo). A demonstração ao vivo do Sobel vem no próximo slide.
Detectando bordas em uma imagem
Imagem sintética à esquerda (padrão escolhido), mapa de bordas à direita. Subir o limiar mostra só as bordas mais fortes; baixar demais introduz ruído nas regiões uniformes. Os botões "Círculo/Xadrez/Diagonal" trocam o exemplo sintético; "Carregar imagem" processa uma foto enviada pelo próprio computador, inteiramente no navegador.
Iluminação, trajetória e física em tempo real
Normal por gradiente — direção perpendicular à superfície, usada em iluminação:
Tangente de curva de Bézier — orienta câmeras e personagens:
| t | posição | ângulo |
|---|---|---|
| 0,00 | (0,00; 0,00) | 71,57° |
| 0,50 | (2,50; 2,25) | 0,00° |
| 1,00 | (5,00; 0,00) | −71,57° |
Motores de física (Unity, Unreal) integram numericamente posição ← velocidade ← aceleração a cada quadro (integração de Euler), o caminho inverso da derivada.
A coluna de ângulos vai de +71,57° a −71,57° passando por 0° no meio — se um carro percorresse essa trajetória em um jogo, essa seria exatamente a rotação aplicada ao modelo a cada quadro. O objeto "aponta para onde está indo" porque a derivada informa a direção instantânea.
A reta tangente que encontra raízes
A partir de um chute inicial, traça-se a tangente (inclinação = derivada) e usa-se onde ela cruza o eixo como novo chute.
double derivada = df(x);
x = x - fx / derivada; /* o método, em 1 linha */| iter | aproximação | erro |
|---|---|---|
| 1 | 1,500000 | 8,58 × 10⁻² |
| 2 | 1,416667 | 2,45 × 10⁻³ |
| 3 | 1,414216 | 2,12 × 10⁻⁶ |
| 5 | 1,414214 | 2,22 × 10⁻¹⁶ |
O expoente do erro aproximadamente dobra a cada iteração — convergência quadrática. Cinco passos esgotam a precisão de um double. Mencionar a verificação `fabs(derivada) < 1e-12` no código genérico: se a derivada se anula, a tangente fica horizontal e a divisão explode — o principal modo de falha, que vamos ver ao vivo na demo a seguir.
Encontrando uma raiz quadrada com a tangente
Digite um número: cada tentativa sobe de xi até fi na curva, traça a tangente ali e mostra onde ela cruza o eixo — esse cruzamento vira a próxima tentativa.
Digite qualquer número e clique em Calcular — o padrão é 2, o mesmo exemplo do slide anterior (√2 ≈ 1,414214), então dá pra comparar diretamente com a tabela já mostrada. Todas as tentativas são calculadas de uma vez; use "◀ Anterior" / "Próximo ▶" ou o controle deslizante para navegar tentativa por tentativa e mostrar quantas são necessárias até um valor satisfatório — o gráfico reenquadra sozinho a cada tentativa. Arraste para mover a visão livremente e role o mouse para dar zoom. Depois usar "ver caso de falha": x₀ = 0,01 fica perto de x = 0, onde f'(x) = 2x ≈ 0 — a tangente quase horizontal lança a próxima aproximação para longe. É a mesma falha que o código em C precisa checar com `fabs(derivada) < 1e-12`.
sin() não existe no processador — é construído
Funções trigonométricas são polinômios cujos coeficientes são derivadas de ordem superior avaliadas em um ponto:
| termos | aproximação | erro |
|---|---|---|
| 1 | 0,500000 | 2,06 × 10⁻² |
| 3 | 0,479427 | 1,54 × 10⁻⁶ |
| 5 | 0,479426 | 1,22 × 10⁻¹¹ |
Com cinco termos, a implementação artesanal de 15 linhas coincide com a sin() da biblioteca padrão até a 11ª casa decimal — usando apenas multiplicação, divisão e soma, tudo que o processador sabe fazer nativamente. Cada termo da série vem de uma derivada de ordem superior avaliada em zero.
PID: antecipar em vez de apenas reagir
P reage ao erro atual. I reage ao erro acumulado. D reage à velocidade com que o erro muda — o componente antecipatório.
double derivada = (erro - c->erro_anterior) / dt;
double termo_d = c->kd * derivada;Exemplo: um forno que mede 20°C abaixo do alvo agora. O termo D olha se esse erro está diminuindo depressa ou devagar — o valor abaixo é o que ele subtrai da potência só por causa disso, com o erro atual idêntico nos dois casos:
| cenário | termo D (potência descontada) |
|---|---|
| temperatura subindo devagar | −100 |
| temperatura subindo rápido | −1000 |
O erro é idêntico nos dois cenários da tabela, mas o termo derivativo reduz drasticamente a potência quando percebe que o sistema se aproxima rápido demais do alvo — o termo proporcional sozinho seria incapaz de distinguir as duas situações. A demonstração ao vivo no próximo slide compara as curvas completas com e sem esse termo.
O efeito do termo derivativo
Um forno idêntico é aquecido até 200°C por dois controladores idênticos — a única diferença é que um deles também usa o termo derivativo (D). Veja o quanto cada um ultrapassa o alvo antes de estabilizar.
Os dois controladores são idênticos exceto pelo ganho do termo derivativo. Sem ele, o forno ultrapassa o alvo em 36,7°C; com ele, cai para 11,7°C — redução de 3,1 vezes. Aos 10s o controlador sem D ainda entrega 100% de potência porque só olha o erro atual; o com D já reduziu para 63% por antecipar a inércia térmica acumulada.
Do slew rate ao throttling preditivo
Corrente em capacitor e tensão em indutor são proporcionais à taxa de variação. Quanto mais rápido um sinal muda de nível, maior a corrente parasita — um dos limites físicos por trás da migração para arquiteturas multinúcleo.
O throttling de CPUs observa não só a temperatura, mas a velocidade com que ela sobe:
| cenário | dT/dt | ação |
|---|---|---|
| aquecimento lento | +2,0 °C/s | normal (4,5 GHz) |
| aquecimento agressivo | +12,0 °C/s | reduzir (2,0 GHz) |
A temperatura absoluta é a mesma nos dois cenários da tabela; o que difere é a derivada. Um controlador que observasse só o valor absoluto trataria as duas situações de forma idêntica. A derivada transforma uma proteção reativa em preditiva.
Por que sistemas "quebram do nada"
Até ~70% de utilização, mais carga quase não afeta o tempo de resposta. Perto de 100%, a sensibilidade explode — cresce quadraticamente.
def sensibilidade(carga, capacidade):
return 1.0 / (capacidade - carga) ** 2| utilização | T | impacto |
|---|---|---|
| 50% | 20 ms | +0,4 ms (1x) |
| 90% | 100 ms | +10 ms (25x) |
| 99% | 1000 ms | +1000 ms (2500x) |
O mesmo acréscimo de carga custa 2500x mais a 99% de utilização do que a 50%. É a justificativa matemática da prática de arquitetura "nunca dimensionar acima de 70-80% de utilização" — a demo ao vivo no próximo slide deixa isso tátil, arrastando o marcador de carga.
Arraste a carga até perto de 100%
Arrastar lentamente de 50% até perto de 99% e observar a leitura de dT/dλ crescendo várias ordens de grandeza. Esse é o "sistema caiu do nada" que operações de infraestrutura relatam — na verdade é a derivada explodindo perto da saturação. O gráfico é como o do Newton-Raphson: arrastar perto do marcador o move, arrastar em qualquer outro ponto move a visão (pan), e a roda do mouse dá zoom — útil para dar zoom perto de 100% e mostrar a reta tangente quase vertical de perto.
Três decisões de negócio guiadas por derivada
Alerta preditivo de disco
76% de uso não dispara limiar fixo (85–90%). A derivada revela 46,5 h até lotar.
| capacidade | 500 GB |
| uso atual | 380 GB (76%) |
| crescimento | 2,575 GB/h |
| alerta | 46,5 h |
Dois dias de antecedência, invisíveis para um alarme por limiar.
Lote econômico (EOQ)
O lote ideal é onde a derivada do custo total se anula.
| demanda anual (D) | 10.000 |
| custo por pedido (S) | 50 |
| custo de estoque (H) | 4 |
| lote ótimo (Q*) | 500 un. |
Busca exaustiva: 5.000 avaliações. Fórmula fechada: 1.
Curva de adoção (S)
O pico de pressão sobre a infraestrutura ocorre em U = K/2, não no final.
| mercado total (K) | 1.000.000 |
| taxa (r) | 0,5/mês |
| pico ocorre em | 500.000 usuários |
| pico de captação | 125.000/mês |
É esse número que dimensiona a arquitetura — não a média.
Um só princípio nos três: o valor absoluto informa pouco; a taxa de variação informa muito.
Três casos, um só princípio: valor absoluto informa pouco, taxa de variação informa muito. Disco: alerta com 2 dias de antecedência, impossível vendo só 76%. EOQ: busca exaustiva precisa de 5000 avaliações, a fórmula fechada (derivada resolvida uma vez) precisa de 1. Adoção: no mês 16 a base quase dobrou, mas a captação de novos usuários já caiu pela metade — sinal que só a derivada revela.
A tangente que protege o HTTPS
Duplicar um ponto em uma curva elíptica — operação central do ECDSA — usa a reta tangente à curva. Seu coeficiente angular é uma derivada implícita:
numerador = (3*x*x + A) % P
denominador = pow(2*y, -1, P)
lam = (numerador * denominador) % P # a derivada, em aritmética modularCurva secp256k1 — mesma do Bitcoin e de implementações de TLS. Gerar uma chave pública:
| operação | quantidade | usa |
|---|---|---|
| duplicação (tangente) | 253 | derivada implícita |
| soma (secante) | 124 | reta entre 2 pontos |
253 avaliações de derivada implícita para uma única chave. Toda conexão HTTPS e toda transação em blockchain executa centenas dessas avaliações.
Tópico complementar, pouco explorado em trabalhos acadêmicos — bom diferencial de banca. O valor de 2G (duplicação do ponto gerador) é uma constante pública verificável em qualquer implementação de referência do Bitcoin; nosso código de ~30 linhas reproduz esse valor exatamente.
Infraestrutura conceitual, não tópico isolado
- Sem derivada não existe IA moderna — treinamento é otimização guiada por gradiente.
- Sem derivada não existe visão computacional — reconhecer formas começa por detectar variações.
- Sem derivada não existe controle confiável — o termo derivativo antecipa em vez de reagir.
- Sem derivada não existiriam bibliotecas matemáticas — funções elementares vêm de métodos derivativos.
- Sem derivada a gestão de sistemas seria reativa — capacidade e risco vêm de taxas de variação.
- Sem derivada não existiria ECC — a tangente sustenta o ECDSA.
"A derivada é o instrumento que permite a um sistema computacional perceber tendência, e não apenas estado."
Fechar amarrando com o slide 2: a pergunta central ("quanto muda ali quando mexo aqui") atravessou seis áreas diferentes da computação sem nunca mudar de forma — só de aplicação. Boa deixa para abrir perguntas da banca.
Referências recomendadas para consulta
- STEWART, James. Cálculo, Volume 1 — aplicações da derivada e taxas relacionadas.
- GOODFELLOW, I.; BENGIO, Y.; COURVILLE, A. Deep Learning. MIT Press — cap. 4 e 6.
- GONZALEZ, R.; WOODS, R. Digital Image Processing — segmentação e detecção de bordas.
- OGATA, Katsuhiko. Engenharia de Controle Moderno — controladores PID.
- BURDEN, R.; FAIRES, J. Análise Numérica — Newton-Raphson e séries de Taylor.
- TANENBAUM, A. Organização Estruturada de Computadores — limites físicos de hardware.
- KLEINROCK, Leonard. Queueing Systems, Vol. 1: Theory — filas M/M/1 e tempo de resposta.
- HILLIER, F.; LIEBERMAN, G. Introdução à Pesquisa Operacional — lote econômico e otimização.
- HANKERSON, D.; MENEZES, A.; VANSTONE, S. Guide to Elliptic Curve Cryptography.
- Documentação oficial do PyTorch, seção Autograd; OpenCV,
cv2.Sobel; Prometheus, funçõesrateederiv.
Todos os valores numéricos citados nesta apresentação (erros de diferença finita, iterações do Newton-Raphson, picos do PID, sensibilidade da fila M/M/1 e contagem de operações do ECC) foram obtidos por execução real dos códigos do material de pesquisa, não por estimativa.
Explicação detalhada de cada assunto desta apresentação: material-de-apoio.html · lista de 10 exercícios para praticar: exercicios.html (arquivos incluídos junto com esta apresentação — funcionam também a partir do PDF exportado).
Último slide — deixar aberto para perguntas da banca. Se pedirem a fonte de algum número específico (ex.: 253 duplicações no ECC, 3,1x de redução no PID), esses valores vêm de execução real dos códigos do material de apoio, não de estimativa — a linha logo abaixo da lista já registra isso por escrito.
Cada bloco temático da apresentação tem pelo menos uma referência na lista: Stewart (fundamentos), Goodfellow (IA), Gonzalez & Woods (visão), Ogata (PID), Burden & Faires (métodos numéricos), Tanenbaum (hardware), Kleinrock (filas M/M/1), Hillier & Lieberman (EOQ) e Hankerson (criptografia), além da documentação de PyTorch, OpenCV e Prometheus para as ferramentas citadas.
Mencionar que existem dois arquivos complementares: material-de-apoio.html (explicação detalhada de cada tópico) e exercicios.html (10 questões com gabarito, para praticar antes do ensaio).
O material de apoio e a lista de exercícios estão abertos — podem ser abertos na hora, sem senha, e os links do PDF funcionam para quem receber o arquivo.