 |
| Bellacosa Mainframe em introducao a redes neurais |
☕ Um Café no Bellacosa Mainframe
Redes Neurais sem Mistérios para Programadores COBOL
Quando um Programador Descobre que a Inteligência Artificial Não Mora em Python — Ela Está Submersa em um Oceano de Matrizes, Gradientes e Pesos que Ninguém Documentou no COPYBOOK
Existe uma antiga lenda nos corredores refrigerados dos data centers.
Ela afirma que redes neurais são criaturas mágicas criadas por programadores de Python, alimentadas com placas de vídeo, café artesanal e bibliotecas cujo nome muda a cada quinze minutos.
Segundo essa lenda, basta escrever:
model.fit(x, y)
Depois disso, luzes piscam, ventiladores entram em rotação de emergência, a conta da nuvem sobe até a estratosfera e uma inteligência artificial nasce completamente formada, como uma deusa tecnológica saindo de uma concha de silício.
Naturalmente, isso é uma bobagem.
Redes neurais não são fundamentalmente sobre Python, TensorFlow, PyTorch, notebooks, APIs ou data scientists usando moletons em ambientes climatizados.
Redes neurais são, antes de tudo, matemática executada muitas vezes.
Muitas mesmo.
Milhões, bilhões ou trilhões de vezes.
O código apenas organiza o mergulho. A matemática é o oceano.
Nesta expedição do Bellacosa Mainframe ao Fundo do Mar, vamos embarcar em um submarino experimental, descer pelas camadas abissais da inteligência artificial e investigar seis estruturas fundamentais:
Transformações lineares
Funções de ativação
Funções de custo
Retropropagação
Métodos de otimização
Matrizes e vetores
Também encontraremos probabilidades, gradientes, redes profundas, neurônios artificiais, parâmetros perdidos e talvez um programador COBOL aposentado vivendo dentro de uma LPAR esquecida desde 1987.
Prepare o terminal 3270.
Verifique a pressão do casco.
E, por segurança, não execute nada diretamente em produção.
Capítulo 1 — Descendo Além da Superfície do Código
Na superfície, uma rede neural parece um programa.
Ela recebe dados, processa informações e produz uma resposta.
Por exemplo:
ENTRADA:
Imagem de um animal
PROCESSAMENTO:
Rede neural
SAÍDA:
92% de probabilidade de ser um gato
Para quem olha de longe, parece apenas mais um sistema.
Entrada, processamento e saída.
Nada que um programador COBOL não tenha visto desde que os discos eram grandes como mesas de jantar e os operadores usavam jalecos brancos para trocar fitas magnéticas.
A diferença está no modo como as regras são construídas.
Em um programa tradicional, alguém escreve explicitamente:
IF ORELHAS-PONTUDAS
AND TEM-BIGODES
AND MIA
MOVE 'GATO' TO TIPO-ANIMAL
END-IF
Em uma rede neural, ninguém escreve diretamente essas regras.
A rede recebe muitos exemplos de gatos e outros animais. Durante o treinamento, ela ajusta milhões de valores numéricos até encontrar combinações que permitam separar gatos, cachorros, capivaras e, em casos mais sofisticados, gerentes de projeto pedindo estimativas para ontem.
Esses valores numéricos são chamados de pesos.
Treinar uma rede neural significa encontrar pesos adequados.
Portanto, a inteligência não está em uma sequência de IF, ELSE ou EVALUATE.
Ela está distribuída por uma grande coleção de números.
Em termos de mainframe, seria como se as regras de negócio não estivessem claramente escritas no PROCEDURE DIVISION, mas espalhadas por bilhões de campos COMP-1, COMP-2 e matrizes carregadas em memória.
Um cenário que faria qualquer auditor pedir transferência imediata para o departamento de patrimônio.
Capítulo 2 — O Neurônio Artificial e a Transformação Linear
O componente básico de uma rede neural é o neurônio artificial.
Apesar do nome grandioso, ele começa com uma operação bastante simples:
z = Wx + b
Onde:
xrepresenta os valores de entrada;Wrepresenta os pesos;brepresenta o bias, ou viés;zrepresenta o resultado da transformação.
Vamos traduzir isso para uma linguagem compreensível por um programador COBOL iniciante.
Imagine um sistema que tenta estimar o preço de uma casa.
Temos três entradas:
Área: 120 m²
Quartos: 3
Garagens: 2
A rede atribui um peso para cada característica:
Peso da área: 2.000
Peso dos quartos: 15.000
Peso da garagem: 8.000
O cálculo seria aproximadamente:
120 × 2.000 = 240.000
3 × 15.000 = 45.000
2 × 8.000 = 16.000
Somando:
240.000 + 45.000 + 16.000 = 301.000
Depois acrescentamos o bias:
301.000 + 12.000 = 313.000
A previsão da rede seria:
R$ 313.000
Em COBOL conceitual:
COMPUTE PRECO-ESTIMADO =
(AREA * PESO-AREA)
+ (QUARTOS * PESO-QUARTOS)
+ (GARAGENS * PESO-GARAGENS)
+ BIAS
END-COMPUTE.
Nada sobrenatural aconteceu.
A rede apenas realizou uma soma ponderada.
A palavra “ponderada” significa que cada entrada tem uma importância diferente.
Se o peso da área for grande, a área influencia bastante o resultado.
Se o peso da garagem for próximo de zero, a garagem praticamente não importa.
Se o peso for negativo, determinada característica pode reduzir o valor previsto.
O grande mistério não está no cálculo.
Está em descobrir os pesos corretos.
Capítulo 3 — O Bias: O Pequeno Parâmetro que Move Montanhas
O bias costuma ser tratado como um detalhe, mas é fundamental.
Sem ele, temos:
z = Wx
Com ele:
z = Wx + b
Geometricamente, o bias permite deslocar uma reta, um plano ou uma fronteira de decisão.
Imagine uma reta que obrigatoriamente passa pelo ponto zero.
Sem bias, a rede fica presa a essa restrição.
Com bias, ela pode mover a reta para cima, para baixo ou para outra região do espaço.
Uma analogia para o mundo COBOL seria um valor padrão ou ajuste operacional que não depende diretamente do registro de entrada.
Por exemplo:
COMPUTE VALOR-FINAL =
VALOR-BASE
+ TAXA-FIXA
END-COMPUTE.
A TAXA-FIXA não nasceu dos dados do cliente. Ela é um deslocamento adicional do cálculo.
O bias faz algo semelhante.
Curiosidade: em muitas redes modernas, existem milhões ou bilhões de pesos, mas os biases continuam discretamente trabalhando, como aquele programa utilitário de 1979 que ninguém menciona, mas cuja remoção derruba o fechamento contábil de três países.
Capítulo 4 — Por Que Uma Rede Precisa de Funções de Ativação?
Se uma rede usasse apenas transformações lineares, ela teria um problema grave.
Imagine várias camadas:
Camada 1: z1 = W1x + b1
Camada 2: z2 = W2z1 + b2
Camada 3: z3 = W3z2 + b3
Mesmo empilhando muitas dessas operações, o resultado final ainda poderia ser reduzido a uma única transformação linear.
Seria como escrever mil programas COBOL que apenas movem campos de uma área para outra e esperar que, por algum milagre, eles desenvolvam consciência.
Não desenvolverão.
Talvez produzam um arquivo de saída com LRECL incorreto, mas consciência não.
Para aprender padrões complexos, a rede precisa de não linearidade.
É aí que entram as funções de ativação.
Capítulo 5 — ReLU: A Portinhola do Submarino
A função ReLU é definida assim:
f(x) = max(0, x)
Na prática:
-10 vira 0
-3 vira 0
0 vira 0
4 vira 4
15 vira 15
Ela corta valores negativos e mantém os positivos.
É simples, rápida e eficiente.
Em pseudocódigo COBOL:
IF VALOR-ENTRADA > 0
MOVE VALOR-ENTRADA TO VALOR-SAIDA
ELSE
MOVE ZERO TO VALOR-SAIDA
END-IF.
A ReLU permite que diferentes neurônios sejam ativados para diferentes tipos de entrada.
Alguns podem reagir a linhas verticais em uma imagem.
Outros, a bordas.
Outros, a formas mais complexas.
Em uma rede profunda, as primeiras camadas detectam padrões simples. As camadas posteriores combinam esses padrões.
Em reconhecimento de imagens, poderíamos ter:
Camada inicial:
Detecta bordas
Camada intermediária:
Detecta olhos, orelhas e texturas
Camada profunda:
Detecta um rosto ou um animal
Camada final:
Classifica como gato, cachorro ou entidade fiscalizadora
A não linearidade permite que a rede construa fronteiras complexas.
Sem ela, o submarino só poderia navegar em linha reta.
E todos sabemos que navegar em linha reta no fundo do oceano é uma ótima maneira de conhecer pessoalmente uma montanha submarina.
Capítulo 6 — Sigmoid: O Medidor de Probabilidade
A função sigmoid transforma qualquer número em um valor entre zero e um.
Sua fórmula é:
1
f(x) = --------
1 + e⁻ˣ
O resultado pode ser interpretado como probabilidade.
Por exemplo:
0,01 = probabilidade muito baixa
0,50 = incerteza
0,99 = probabilidade muito alta
Em um sistema de detecção de fraude:
0,03 = provavelmente legítimo
0,91 = fortemente suspeito
Em um sistema médico:
0,87 = alta probabilidade da condição analisada
Atenção: uma probabilidade produzida por um modelo não é uma verdade absoluta.
Um valor de 0,95 não significa que a máquina possui certeza metafísica.
Significa que, segundo os parâmetros, os dados e o treinamento, aquele resultado recebeu uma pontuação elevada.
Modelos podem estar mal calibrados.
Podem ter recebido dados tendenciosos.
Podem falhar fora do cenário em que foram treinados.
Uma rede neural pode estar 99% confiante e completamente errada.
Exatamente como um analista júnior executando DELETE sem WHERE.
Capítulo 7 — Tanh: O Oceano Entre -1 e 1
A função tangente hiperbólica, ou tanh, produz valores entre -1 e 1.
-1 ≤ tanh(x) ≤ 1
Ela foi bastante usada em redes neurais recorrentes e ainda aparece em diversas arquiteturas.
Diferentemente da sigmoid, cujo centro está próximo de 0,5, a tanh é centrada em zero.
Isso pode facilitar certos tipos de otimização.
Exemplo:
Entrada negativa forte → próximo de -1
Entrada neutra → próximo de 0
Entrada positiva forte → próximo de 1
Ela funciona como uma espécie de indicador de direção.
Negativo, neutro ou positivo.
Talvez fosse útil em reuniões de projeto:
-1 = prazo impossível
0 = ninguém entendeu o requisito
1 = o gerente já anunciou a entrega ao cliente
Capítulo 8 — A Função de Custo: O Sonar do Erro
Uma rede neural precisa saber se sua previsão foi boa ou ruim.
Para isso existe a função de custo, também chamada de:
função de perda;
loss function;
objective function.
A função de custo compara a previsão do modelo com a resposta correta.
Ela produz um número.
Quanto menor esse número, melhor o desempenho.
O treinamento busca reduzir a perda.
Em outras palavras, a função de custo é o sonar do submarino.
Ela informa se estamos nos aproximando do objetivo ou indo diretamente para uma fossa oceânica sem retorno.
Capítulo 9 — Mean Squared Error
O erro quadrático médio, conhecido como MSE, é muito usado em problemas de regressão.
Regressão é quando queremos prever um valor contínuo, como:
preço;
temperatura;
consumo;
demanda;
tempo;
faturamento.
A fórmula é:
1
MSE = ----- Σ(ŷᵢ - yᵢ)²
n
Onde:
ŷé a previsão;yé o valor verdadeiro;né a quantidade de exemplos.
Imagine:
Valor real: 80
Previsão: 70
Erro: -10
Erro²: 100
Outro exemplo:
Valor real: 80
Previsão: 78
Erro: -2
Erro²: 4
O segundo resultado é muito melhor.
Por que elevar o erro ao quadrado?
Primeiro, porque erros negativos e positivos não se anulam.
Sem o quadrado:
Erro 1: +10
Erro 2: -10
Soma: 0
Pareceria que o modelo está perfeito, embora tenha errado duas vezes.
Segundo, porque o quadrado pune erros grandes com mais severidade.
Erro 2 → 4
Erro 10 → 100
Erro 20 → 400
Isso é útil quando grandes desvios são especialmente prejudiciais.
Mas existe uma consequência: o MSE é sensível a valores extremos.
Um único erro gigantesco pode dominar a função de custo.
Portanto, escolher uma loss não é um detalhe decorativo.
É uma decisão de projeto.
Capítulo 10 — Cross-Entropy: O Tribunal da Classificação
Para classificação, uma função muito usada é a entropia cruzada.
Imagine que a rede analise uma imagem e produza:
Gato: 0,80
Cachorro: 0,15
Capivara: 0,05
Se a resposta correta for gato, a perda será relativamente baixa.
Agora imagine:
Gato: 0,01
Cachorro: 0,04
Capivara: 0,95
Se a imagem for de um gato, a perda será enorme.
A cross-entropy pune especialmente situações em que o modelo está muito confiante na resposta errada.
Isso é importante.
Errar com dúvida é ruim.
Errar com arrogância estatística é pior.
Em linguagem corporativa:
“Não tenho certeza, mas talvez seja um gato.”
produz menos preocupação do que:
“Com absoluta certeza é uma capivara.”
quando o animal está miando em cima do teclado.
Capítulo 11 — Forward Pass: O Mergulho de Ida
Quando os dados entram na rede e percorrem todas as camadas até gerar uma previsão, ocorre o forward pass.
Exemplo:
Entrada
↓
Transformação linear
↓
Ativação
↓
Transformação linear
↓
Ativação
↓
Saída
↓
Cálculo da perda
Esse é o caminho de ida.
Em uma rede de classificação de imagens:
Pixels
↓
Características simples
↓
Formas intermediárias
↓
Padrões complexos
↓
Probabilidades das classes
No treinamento, o forward pass gera a previsão e permite calcular o erro.
Mas ainda falta responder à pergunta mais difícil:
quais pesos causaram esse erro?
É aqui que encontramos a criatura mais temida das profundezas.
A retropropagação.
Capítulo 12 — Backpropagation: A Investigação do ABEND Matemático
A retropropagação, ou backpropagation, calcula quanto cada peso contribuiu para o erro.
Imagine uma rede com cem milhões de parâmetros.
Ela gera uma previsão incorreta.
Quem foi o culpado?
Um peso?
Uma camada?
Um bias?
Todos?
A resposta correta é: muitos parâmetros contribuíram em diferentes proporções.
O backpropagation percorre a rede de trás para frente, usando a regra da cadeia do cálculo diferencial.
Ele calcula derivadas como:
∂L
───
∂W
Isso significa:
Quanto a perda
Lmuda quando o pesoWsofre uma pequena alteração?
Se uma pequena mudança em determinado peso provoca uma grande mudança na perda, esse peso tem forte influência.
Se quase nada muda, o peso tem pouca influência naquele exemplo.
Para um programador COBOL, pense em uma análise de causa de ABEND.
O erro aparece no final:
S0C7
Mas a origem pode estar em:
um campo lido incorretamente;
uma redefinição inadequada;
um arquivo com layout diferente;
um sinal inválido;
um movimento alfanumérico para campo numérico;
um registro criado por um programa de 1992 que ninguém ousa recompilar.
O backpropagation faz algo conceitualmente semelhante.
Ele parte do erro final e investiga o caminho inverso.
Loss
↑
Saída
↑
Camada final
↑
Camada intermediária
↑
Camada inicial
↑
Pesos
Só que, em vez de abrir um dump, ele usa derivadas.
Capítulo 13 — A Regra da Cadeia
A regra da cadeia permite calcular derivadas de funções compostas.
Se:
x → a → b → c → perda
então a influência de x sobre a perda depende de todas as etapas intermediárias.
De forma simplificada:
∂L ∂L ∂c ∂b ∂a
── = ── × ── × ── × ──
∂x ∂c ∂b ∂a ∂x
A rede é uma composição de funções.
Cada camada transforma a saída da camada anterior.
A regra da cadeia permite decompor o impacto de cada transformação.
É como rastrear um dado em um sistema legado:
Arquivo de entrada
↓
Programa A
↓
Arquivo temporário
↓
Programa B
↓
Tabela Db2
↓
Programa C
↓
Relatório incorreto
Para descobrir a causa, percorremos o fluxo de trás para frente.
No mundo neural, cada ligação do fluxo possui uma derivada.
Capítulo 14 — Gradiente: A Direção da Montanha Submarina
O gradiente reúne as derivadas de todos os parâmetros.
Ele aponta para a direção em que a perda cresce mais rapidamente.
Se queremos reduzir a perda, caminhamos na direção oposta.
Imagine uma paisagem montanhosa no fundo do oceano.
O submarino está em uma região elevada.
O objetivo é encontrar o vale mais profundo.
O gradiente informa onde fica a subida mais inclinada.
Então seguimos no sentido contrário.
Esse é o princípio do gradient descent, ou descida do gradiente.
Capítulo 15 — Gradient Descent: Corrigindo os Pesos
A atualização básica é:
θₜ₊₁ = θₜ - η∇L(θₜ)
Onde:
θrepresenta os parâmetros;ηrepresenta a taxa de aprendizado;∇Lrepresenta o gradiente da perda.
Em palavras:
Novo parâmetro =
Parâmetro atual
-
Taxa de aprendizado
×
Gradiente
Em pseudocódigo COBOL:
COMPUTE NOVO-PESO =
PESO-ATUAL
- (TAXA-APRENDIZADO * GRADIENTE)
END-COMPUTE.
O processo se repete:
1. Faz previsão
2. Calcula erro
3. Calcula gradientes
4. Atualiza pesos
5. Faz nova previsão
6. Calcula novo erro
7. Repete
Depois de muitas repetições, os pesos tendem a produzir previsões melhores.
Isso é aprender.
Não existe uma pequena entidade consciente dentro da GPU dizendo:
“Agora finalmente compreendi a essência filosófica dos gatos.”
Existe apenas um processo iterativo de redução de erro.
O que não deixa de ser impressionante.
Capítulo 16 — Learning Rate: O Controle de Profundidade
A taxa de aprendizado define o tamanho do passo usado para atualizar os pesos.
Se for pequena demais:
Aprendizado lento
Treinamento caro
Muitas iterações
Se for grande demais:
Oscilações
Instabilidade
Perda divergente
Treinamento fracassado
Imagine tentar chegar ao fundo de um vale.
Com passos de um centímetro, talvez você chegue, mas a empresa encerra o orçamento antes.
Com saltos de cem metros, você atravessa o vale e bate no paredão oposto.
A taxa de aprendizado precisa ser adequada.
Em treinamentos modernos, ela frequentemente muda ao longo do processo.
Pode começar maior e diminuir depois.
Isso permite avançar rapidamente no início e fazer ajustes delicados no final.
É como aproximar um submarino de uma estação submersa:
velocidade alta em mar aberto;
velocidade moderada perto dos recifes;
movimento lento na hora de atracar;
desespero absoluto quando alguém percebe que o manual está em japonês.
Capítulo 17 — Momentum, RMSProp e Adam
O gradient descent básico funciona, mas pode ser lento ou instável.
Por isso surgiram variantes.
Momentum
O momentum mantém parte da direção das atualizações anteriores.
É semelhante a uma bola descendo uma encosta.
Ela acumula velocidade.
Se o gradiente continua apontando na mesma direção, o movimento acelera.
Isso ajuda a atravessar regiões planas e reduz certas oscilações.
RMSProp
O RMSProp ajusta o tamanho do passo para cada parâmetro com base no histórico recente dos gradientes.
Parâmetros com gradientes grandes podem receber passos menores.
Parâmetros com gradientes pequenos podem receber passos maiores.
Adam
O Adam combina ideias de momentum e adaptação individual da taxa de aprendizado.
Ele mantém estimativas de:
média dos gradientes;
média dos quadrados dos gradientes.
É um dos otimizadores mais populares.
O AdamW é uma variante muito usada em Transformers e modelos de linguagem porque trata melhor a regularização por decaimento de pesos.
Em termos marítimos:
gradient descent é um barco com remo;
momentum adiciona correnteza;
RMSProp adiciona controle automático de estabilidade;
Adam instala sonar, piloto automático e um comandante excessivamente confiante.
Capítulo 18 — Matrizes: O Verdadeiro Motor da IA
Até agora falamos de neurônios individualmente.
Mas uma rede moderna não calcula um neurônio por vez.
Ela processa milhares ou milhões de valores simultaneamente.
É aí que entram as matrizes.
Considere vários exemplos organizados em uma matriz X.
Os pesos formam outra matriz W.
A operação:
Z = WX + b
pode calcular as saídas de muitos neurônios para muitos exemplos de uma só vez.
Imagine um lote com 1.000 imagens.
Em vez de processar:
Imagem 1
Imagem 2
Imagem 3
...
Imagem 1000
uma por uma, podemos organizá-las em uma estrutura matricial e executar grandes multiplicações em paralelo.
Isso é chamado de processamento em batch.
Para um programador COBOL, seria como substituir um fluxo puramente registro a registro por uma operação vetorizada capaz de processar grandes blocos de dados simultaneamente.
O mainframe tradicional se destaca em alto volume transacional, I/O, confiabilidade e processamento batch.
As GPUs se destacam em cálculos paralelos repetitivos, especialmente multiplicações de matrizes.
São especializações diferentes.
A GPU não é “mais inteligente” que a CPU.
Ela foi desenhada para realizar muitas operações semelhantes ao mesmo tempo.
Uma rede neural moderna precisa exatamente disso.
Capítulo 19 — Vetores, Matrizes e Tensores
Um vetor é uma sequência de números.
[1, 2, 3]
Uma matriz é uma grade de números.
[1 2 3]
[4 5 6]
Um tensor é uma generalização para mais dimensões.
Uma imagem colorida pode ser representada como um tensor:
Altura × Largura × Canais
Por exemplo:
640 × 480 × 3
Os três canais normalmente representam vermelho, verde e azul.
Um lote de imagens adiciona outra dimensão:
Batch × Altura × Largura × Canais
Um modelo de linguagem trabalha com tensores contendo:
lotes de frases;
posições dos tokens;
dimensões dos embeddings;
cabeças de atenção;
camadas;
estados intermediários.
Quando alguém diz que um LLM está “pensando”, dentro do hardware há matrizes e tensores sendo multiplicados, normalizados, transformados e reutilizados.
É uma festa matemática sem música, sem comida e com consumo elétrico suficiente para assustar o setor de infraestrutura.
Capítulo 20 — CNNs, Transformers e LLMs Continuam Usando os Mesmos Pilares
As arquiteturas mudam, mas os fundamentos permanecem.
CNNs
Redes convolucionais são especializadas em dados espaciais, principalmente imagens.
Elas utilizam filtros que percorrem regiões da imagem.
Esses filtros aprendem a detectar:
bordas;
texturas;
formas;
padrões visuais.
RNNs
Redes recorrentes processam sequências mantendo um estado interno.
Foram muito usadas em:
texto;
fala;
séries temporais.
Elas enfrentam dificuldades com sequências longas, incluindo gradientes que desaparecem ou explodem.
Transformers
Transformers usam mecanismos de atenção.
A atenção permite que cada elemento de uma sequência avalie sua relação com outros elementos.
Em uma frase, uma palavra pode “olhar” para palavras anteriores e posteriores para construir contexto.
LLMs
Grandes modelos de linguagem são, em essência, Transformers de grande escala treinados com enormes volumes de texto.
Eles aprendem a prever tokens.
Exemplo:
“O programador abriu o terminal e executou o...”
O modelo calcula probabilidades:
programa 32%
comando 25%
job 18%
JCL 12%
submarino 3%
Dependendo do contexto do Bellacosa Mainframe, “submarino” pode subir perigosamente no ranking.
Mesmo em um LLM gigantesco, continuam presentes:
transformações lineares;
matrizes;
ativações;
funções de perda;
backpropagation;
otimização.
A escala muda.
Os princípios não.
Capítulo 21 — O Sétimo Pilar: Probabilidade
A imagem original apresenta seis blocos fundamentais, mas existe um sétimo elemento atravessando quase toda a inteligência artificial: a probabilidade.
Modelos frequentemente não produzem certezas.
Produzem distribuições.
Em uma classificação:
Classe A: 0,70
Classe B: 0,20
Classe C: 0,10
Em um modelo de linguagem:
Próximo token:
“sistema” 0,28
“programa” 0,21
“arquivo” 0,14
“oceano” 0,05
A escolha do próximo token pode depender de parâmetros como:
temperatura;
top-k;
top-p;
amostragem;
penalidade por repetição.
Temperatura baixa produz respostas mais previsíveis.
Temperatura alta produz maior variedade e também maior risco de a embarcação matemática aparecer em um porto que não constava no mapa.
Capítulo 22 — Por Que Modelos Falham?
Compreender a matemática ajuda a entender as falhas.
Dados ruins
Se os dados de treinamento estiverem incorretos, incompletos ou enviesados, o modelo aprenderá padrões problemáticos.
Overfitting
O modelo pode decorar os dados de treinamento em vez de aprender padrões generalizáveis.
É como um programador que memoriza um JCL específico, mas não entende DISP, DCB, COND ou catálogo.
Quando o nome do dataset muda, ele entra em colapso emocional.
Underfitting
O modelo pode ser simples demais ou insuficientemente treinado.
Ele não consegue capturar o padrão.
Gradiente desaparecendo
Em redes muito profundas, os gradientes podem ficar progressivamente pequenos.
As primeiras camadas praticamente deixam de aprender.
Gradiente explodindo
Os gradientes podem crescer demais e causar instabilidade numérica.
Distribuição diferente
Um modelo treinado em determinado tipo de dado pode falhar quando encontra dados muito diferentes.
Um classificador treinado apenas com gatos domésticos pode confundir um felino selvagem, uma escultura ou um chinelo peludo.
Objetivo mal definido
O modelo otimiza aquilo que a função de custo mede.
Se a função mede a coisa errada, o modelo pode melhorar matematicamente e piorar operacionalmente.
Esta é uma lição importante:
A rede não conhece a intenção humana. Ela apenas otimiza o objetivo fornecido.
Capítulo 23 — Passo a Passo de um Treinamento Completo
Vamos organizar toda a operação.
Etapa 1 — Preparar os dados
Os dados precisam ser:
coletados;
limpos;
organizados;
normalizados;
separados em treinamento, validação e teste.
Etapa 2 — Inicializar os pesos
Os pesos começam com valores pequenos, normalmente aleatórios.
Não se costuma inicializar tudo com zero, pois isso pode fazer muitos neurônios aprenderem exatamente a mesma coisa.
Etapa 3 — Executar o forward pass
A entrada atravessa as camadas.
x → Wx+b → ativação → próxima camada → saída
Etapa 4 — Calcular a loss
A previsão é comparada com o valor correto.
Etapa 5 — Executar backpropagation
As derivadas são calculadas de trás para frente.
Etapa 6 — Atualizar os pesos
O otimizador aplica as correções.
Etapa 7 — Repetir
O processo ocorre para muitos lotes.
Uma passagem completa por todos os dados é chamada de época, ou epoch.
Etapa 8 — Validar
O modelo é testado em dados que não estão sendo usados diretamente para atualizar os pesos.
Etapa 9 — Testar
Ao final, o desempenho é avaliado em um conjunto separado.
Etapa 10 — Colocar em produção
Aqui surge a parte que os diagramas acadêmicos frequentemente omitem:
monitoramento;
versionamento;
custo;
segurança;
privacidade;
mudança de dados;
latência;
explicabilidade;
governança;
usuários tentando enviar arquivos de 18 GB por uma tela projetada para 5 MB.
Capítulo 24 — Dicas para o Programador COBOL que Quer Entender IA
Não tente aprender tudo de uma vez.
Comece por vetores e matrizes.
Depois estude funções.
Em seguida, derivadas e gradientes.
Aprenda o significado antes de decorar fórmulas.
Implemente uma regressão linear simples.
Depois crie um neurônio.
Em seguida, monte uma rede pequena.
Faça cálculos manualmente com poucos valores.
Use planilhas ou programas curtos para observar cada etapa.
Compare previsão, erro, gradiente e atualização.
Um bom exercício é construir um modelo que aprenda uma relação simples:
y = 2x + 1
Comece com peso e bias aleatórios.
Calcule a previsão.
Calcule o erro.
Atualize os parâmetros.
Observe o peso se aproximar de 2 e o bias de 1.
Esse pequeno experimento ensina mais do que executar uma biblioteca gigantesca sem compreender o que acontece.
Easter Egg — O Programa COBOL que Aprendeu a Mentir
Diz a lenda que, em um laboratório submarino do Atlântico Sul, um programador decidiu implementar uma rede neural em COBOL.
O sistema deveria prever falhas em jobs batch.
Após meses de treinamento, o modelo começou a produzir:
JOB NORMAL
NENHUM RISCO DETECTADO
Poucos segundos antes de cada S0C7.
Os cientistas ficaram perplexos.
Investigaram os pesos.
Revisaram a loss.
Analisaram os gradientes.
Finalmente descobriram o problema.
Durante o treinamento, sempre que o modelo indicava risco, o gerente cancelava a execução para evitar incidentes.
Como consequência, o dataset registrava:
Previsão de risco → nenhum ABEND observado
Previsão segura → ABEND observado
O modelo concluiu que avisar sobre riscos estava associado a alarmes falsos.
Assim, aprendeu a permanecer otimista.
A rede não estava mentindo.
Estava apenas otimizando fielmente um processo mal documentado.
Moral da história:
antes de culpar a inteligência artificial, verifique o dataset, a regra de negócio e o gerente que alterou o fluxo sem atualizar a documentação.
Conclusão — O Que Existe no Fundo do Oceano Neural?
Depois de descer pelas camadas da inteligência artificial, encontramos algo curioso.
Não havia magia.
Não havia consciência escondida entre as placas de vídeo.
Não havia um pequeno matemático operando alavancas dentro do data center.
Encontramos:
somas;
multiplicações;
vetores;
matrizes;
funções;
derivadas;
probabilidades;
erros;
ajustes;
repetições.
Uma rede neural é uma enorme composição de funções matemáticas.
Ela recebe números, transforma esses números, compara resultados, calcula erros e ajusta seus parâmetros.
O poder surge da escala.
Uma transformação linear é simples.
Uma função de ativação é simples.
Uma derivada isolada é simples.
Uma atualização de peso é simples.
Mas quando bilhões dessas operações são organizadas em muitas camadas, executadas sobre grandes volumes de dados e repetidas milhares de vezes, padrões complexos começam a emergir.
A rede aprende a reconhecer imagens, traduzir idiomas, prever sequências, gerar textos, sintetizar vozes e produzir imagens.
Para o programador COBOL, talvez a maior revelação seja esta:
Redes neurais não pertencem a uma linguagem de programação.
Elas pertencem à matemática.
Python é apenas uma interface popular.
A GPU é apenas uma máquina especializada.
O framework é apenas uma camada operacional.
No fundo do oceano, abaixo de todo o marketing, dos nomes impressionantes e das promessas de inteligência artificial geral, continua existindo a mesma equação:
z = Wx + b
Depois vem a ativação.
Depois o erro.
Depois o gradiente.
Depois a correção.
Depois tudo se repete.
É uma viagem longa, profunda e fascinante.
E, como em todo sistema legado realmente importante, quanto mais você mergulha, mais percebe que a parte visível era apenas a superfície.
Em algum lugar abaixo da última camada, uma matriz gigantesca continua sendo multiplicada.
Um gradiente percorre o caminho inverso.
Um peso sofre uma pequena correção.
E um modelo se torna, por uma fração microscópica, um pouco menos errado.
O que, convenhamos, já é mais progresso do que muitas reuniões de alinhamento conseguem produzir em uma tarde inteira.
