Translate

Mostrar mensagens com a etiqueta transformers. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta transformers. Mostrar todas as mensagens

quarta-feira, 18 de março de 2026

O Que Todo Programador COBOL Precisa Saber Sobre os "Thinking Tokens"

 

Bellacosa Mainframe introduz thinking tokens em ia

☕ Um Café no Bellacosa Mainframe

O Que Todo Programador COBOL Precisa Saber Sobre os "Thinking Tokens"

Você Não Está Pagando por um Cérebro Artificial. Está Pagando por Tokens de Saída que Você Nunca Vê.

"Toda geração de programadores cria novos nomes para conceitos antigos. O desafio não é decorar a nova terminologia, mas compreender a engenharia que continua existindo por trás dela."

Durante décadas trabalhando com IBM Mainframe aprendemos uma lição importante.

Os nomes mudam.

A tecnologia evolui.

As interfaces ficam mais bonitas.

Mas os princípios fundamentais da computação continuam praticamente os mesmos.

Foi assim quando surgiram os bancos de dados relacionais.

Foi assim quando apareceram as CASE Tools.

Foi assim com Java.

Com SOA.

Com APIs.

Com Microservices.

Com Cloud.

E agora está acontecendo novamente com a Inteligência Artificial.

Um dos melhores exemplos dessa confusão moderna é a expressão Thinking Tokens.

Se você acompanha anúncios da OpenAI, Anthropic, Google, xAI ou DeepSeek, provavelmente já viu frases como:

  • O modelo utilizou 2.500 reasoning tokens.

  • Foram consumidos 8.000 thinking tokens.

  • O modelo pensou antes de responder.

  • O raciocínio interno foi ocultado.

Para quem está chegando agora ao universo dos LLMs, parece que existe uma nova categoria de tokens.

Como se o Transformer tivesse criado uma espécie de memória secreta onde a IA realmente "pensa".

Mas isso não é exatamente verdade.

Hoje vamos desmontar esse mito.

E, como sempre fazemos aqui no Bellacosa Mainframe, vamos explicar tudo usando conceitos familiares para quem passou anos desenvolvendo sistemas COBOL no IBM Z.

Pegue seu café.

Porque, no final deste artigo, você provavelmente enxergará os modelos de IA de uma maneira completamente diferente.


O primeiro erro é acreditar que existem três tipos de tokens

Muita documentação simplifica o assunto dizendo que existem:

  • Input Tokens

  • Output Tokens

  • Thinking Tokens

Parece lógico.

Mas essa classificação mistura arquitetura com marketing.

Na prática, um Transformer trabalha apenas com duas grandes fases:

Entrada (Prefill)

e

Saída (Decode)

Todo o resto são interpretações sobre aquilo que acontece durante a geração da resposta.


Vamos lembrar como funciona um programa COBOL

Imagine um programa extremamente simples.

ACCEPT WS-CLIENTE

PERFORM PROCESSA-DADOS

DISPLAY RESULTADO

STOP RUN.

Ninguém diria que existem três tipos de processamento.

Existe apenas:

entrada

processamento

saída.

A IA segue exatamente essa lógica.


O Pipeline de um Transformer

Todo Large Language Model moderno funciona aproximadamente assim:

Prompt

↓

Tokenização

↓

Embeddings

↓

Transformer

↓

Prefill

↓

KV Cache

↓

Decode

↓

Resposta

Observe uma coisa interessante.

Não existe nenhuma etapa chamada:

Thinking Engine

Nem:

Reasoning Processor

Nem:

Artificial Brain

Esses nomes simplesmente não existem dentro da arquitetura.


O Prefill é parecido com a leitura de um arquivo VSAM

Imagine um programa COBOL lendo um cadastro inteiro.

READ CLIENTES

Antes de tomar qualquer decisão, seu programa precisa conhecer o conteúdo.

O Transformer faz algo semelhante.

Quando você envia um prompt como:

Explique a arquitetura do CICS.

O modelo primeiro lê tudo.

Essa leitura acontece em paralelo.

Todas as palavras são analisadas simultaneamente.

Esse processo chama-se Prefill.

É como se o modelo dissesse:

"Primeiro vou entender completamente o problema."


O Decode lembra um programa Batch escrevendo registros

Depois que termina o Prefill, começa uma fase completamente diferente.

Agora o modelo precisa escrever.

E escreve exatamente como um programa COBOL grava registros.

Um por vez.

Token 1

↓

Token 2

↓

Token 3

↓

Token 4

Não existe paralelismo aqui.

Cada novo token depende do anterior.

Da mesma forma que um programa COBOL não consegue escrever o registro 500 antes de criar o registro 499.


É aqui que nasce o famoso "raciocínio"

Imagine que você perguntou:

Quanto é 27 × 34?

O modelo poderia gerar internamente algo parecido com:

27 × 30 = 810

27 × 4 = 108

810 + 108 = 918

Depois entregar apenas:

918

A pergunta é:

Onde aconteceu o raciocínio?

A resposta surpreende muita gente.

No mesmo lugar onde nasceu a resposta final.

Durante o Decode.

Não existe um mecanismo separado.


O maior mito da IA moderna

Muitas pessoas imaginam algo parecido com isto.

Prompt

↓

Cérebro Artificial

↓

Resposta

Bonito.

Mas incorreto.

Na realidade acontece algo muito mais simples.

Prompt

↓

Decode

↓

Token

↓

Token

↓

Token

↓

Token

↓

Resposta

O chamado raciocínio nada mais é do que uma sequência maior de tokens produzidos antes da resposta definitiva.


Os Thinking Tokens são apenas Output Tokens

Esse talvez seja o conceito mais importante deste artigo.

Do ponto de vista da arquitetura Transformer, não existe diferença entre escrever:

Vou resolver passo a passo...

e escrever:

A resposta é 918.

Os dois são produzidos exatamente pelo mesmo algoritmo.

Mesmo Softmax.

Mesmo Sampling.

Mesma GPU.

Mesmo Decoder.

Mesma KV Cache.

Mesmo mecanismo autoregressivo.

A única diferença é o destino dado a esses tokens.


Quem esconde os Thinking Tokens?

Essa é outra dúvida comum.

Muita gente acredita que o próprio Transformer possui um compartimento secreto onde guarda pensamentos.

Não possui.

Quem decide ocultar esses tokens é a aplicação que envolve o modelo.

Imagine um programa COBOL gerando um relatório.

Durante o processamento ele escreve dezenas de mensagens no SYSOUT.

Lendo arquivo...

Registro encontrado...

Validando CPF...

Atualizando saldo...

Fim do processamento.

Mas o usuário recebe apenas:

Processamento concluído com sucesso.

As mensagens existiram.

Foram produzidas.

Consumiram CPU.

Consumiram I/O.

Mas nunca apareceram na tela do usuário.

É exatamente isso que acontece com os Thinking Tokens.


Por que eles custam dinheiro?

Aqui chegamos ao ponto que interessa às empresas.

Imagine duas respostas.

Resposta A

100 tokens.

Resposta B

900 tokens ocultos

100 tokens visíveis.

Qual delas custa mais?

A segunda.

Mesmo que você nunca veja os 900 tokens.

Por quê?

Porque a GPU precisou calcular todos eles.

Cada token exige milhares de operações matemáticas.

Multiplicações matriciais.

Atenção.

Softmax.

Sampling.

Atualização do KV Cache.

Nada disso é gratuito.

A infraestrutura trabalhou para gerar cada token, mesmo aqueles descartados antes da entrega.


Pense como um gerente de CPD dos anos 1980

Quem trabalhou com IBM Mainframe lembra muito bem.

O usuário não pagava apenas pelas páginas impressas.

Pagava pelo tempo de CPU.

Pelo canal.

Pelo DASD.

Pela memória.

Pelos acessos ao banco.

Com IA acontece exatamente o mesmo.

Você não paga apenas pelo texto recebido.

Você paga por todo o processamento necessário para produzir esse texto.

Mesmo quando parte dele nunca chega até você.


Existe realmente pensamento?

Agora entramos numa questão filosófica.

Quando o modelo escreve:

Vou resolver primeiro a multiplicação.

Depois farei a soma.

Agora posso responder.

Ele realmente está pensando?

Depende da definição de pensamento.

Do ponto de vista computacional, isso é apenas texto sendo gerado.

Não existe consciência.

Não existe intenção.

Não existe uma voz interior.

Existe apenas previsão estatística do próximo token mais provável.

Ainda assim, esse processo produz um comportamento que lembra muito o raciocínio humano.

É um exemplo clássico de comportamento emergente.

A inteligência não aparece porque existe um módulo chamado "pensamento".

Ela emerge da sequência de bilhões de operações matemáticas executadas ao longo da geração dos tokens.


Uma analogia que todo programador COBOL entenderá

Imagine um analista experiente escrevendo um programa.

Primeiro ele faz um rascunho.

Abrir arquivo.

Validar cliente.

Atualizar saldo.

Fechar arquivo.

Depois escreve comentários.

Depois reorganiza os parágrafos.

Depois remove código.

No final entrega apenas o programa limpo.

Ninguém vê o rascunho.

Mas ele existiu.

Consumiu tempo.

Consumiu esforço.

Os Thinking Tokens são exatamente esse rascunho.


O papel da auditabilidade

Em ambientes corporativos, especialmente bancos, seguradoras e órgãos governamentais, entender esse processo é essencial.

Imagine um modelo aprovando um empréstimo.

Ele responde apenas:

Aprovado.

Mas internamente gerou centenas de tokens avaliando renda, histórico, garantias e inconsistências.

Esses tokens podem ser úteis para auditoria, depuração e análise de qualidade. Ao mesmo tempo, expô-los integralmente pode revelar detalhes do funcionamento do modelo, facilitar ataques ou criar interpretações equivocadas. Por isso, muitos fornecedores optam por ocultá-los e fornecer mecanismos de explicação específicos em vez da cadeia completa de raciocínio.

Essa distinção é especialmente importante em ambientes regulados, onde transparência e segurança precisam coexistir.


O verdadeiro modelo mental

Depois de tudo isso, talvez seja melhor abandonar a ideia de três tipos de tokens.

Pense apenas assim.

Entrada

O modelo lê.

(Prefill)

Saída

O modelo escreve.

(Decode)

Dentro da saída podem existir:

  • tokens mostrados;

  • tokens resumidos;

  • tokens ocultados;

  • tokens descartados.

Mas continuam sendo apenas saída.


O que um Programador COBOL Padawan deve aprender com isso?

Se você está começando sua jornada em Inteligência Artificial depois de anos trabalhando com COBOL, CICS, JCL e DB2, a principal lição é simples:

não se deixe impressionar pela terminologia de marketing.

Sempre procure entender a arquitetura por trás dos nomes.

Foi assim com:

  • CASE Tools;

  • Orientação a Objetos;

  • SOA;

  • ESB;

  • APIs REST;

  • Microservices;

  • Cloud Computing.

Agora acontece novamente com os LLMs.

Os nomes mudam.

Os princípios permanecem.

Quem entende arquitetura enxerga além das buzzwords.


O Café Terminou...

Durante décadas, os profissionais de Mainframe aprenderam a separar interface de implementação. Um operador via apenas uma tela do CICS; por trás dela existiam TCBs, filas, buffers, logs, gerenciamento de memória e milhares de instruções executadas silenciosamente. Da mesma forma, um usuário conversa com um chatbot e recebe uma resposta elegante, mas por trás dela ocorreu uma longa sequência de cálculos matriciais e geração de tokens.

Os chamados Thinking Tokens não são uma terceira categoria mágica de dados. Eles não representam um "cérebro oculto" nem um mecanismo especial de raciocínio. São, simplesmente, tokens de saída gerados durante o Decode, produzidos pelo mesmo algoritmo que gera a resposta final. A diferença não está na arquitetura do Transformer, mas na política da plataforma: alguns tokens são entregues ao usuário; outros permanecem ocultos.

Para o programador COBOL, essa distinção soa familiar. Assim como um JOB Batch pode produzir centenas de mensagens no SYSOUT enquanto o usuário recebe apenas um relatório resumido, um LLM pode gerar centenas de tokens intermediários antes de apresentar sua resposta. O processamento aconteceu. A CPU — ou, neste caso, a GPU — trabalhou. O custo foi incorrido. Apenas a visibilidade mudou.

No fim das contas, a maior habilidade continua sendo a mesma que diferenciou bons profissionais de Mainframe durante décadas: compreender os mecanismos internos, e não apenas decorar os nomes das tecnologias da moda. Quem domina os fundamentos consegue atravessar gerações de plataformas, linguagens e arquiteturas sem perder a capacidade de entender o que realmente está acontecendo dentro da máquina.

Porque, ontem como hoje, a engenharia continua sendo muito mais interessante do que o marketing.

segunda-feira, 16 de março de 2026

Transformers: O Que Todo Programador COBOL Precisa Saber Sobre a Arquitetura que Está Revolucionando a Inteligência Artificial

 

Bellacosa Mainframe e os segredos dos transformers 

☕ Um Café no Bellacosa Mainframe

Transformers: O Que Todo Programador COBOL Precisa Saber Sobre a Arquitetura que Está Revolucionando a Inteligência Artificial

Você Não Está Diante de Mágica. Está Diante de Engenharia de Software em Escala Nunca Vista.

"Toda geração de programadores encontra uma tecnologia que parece mágica. Para quem programava em Assembly, COBOL parecia mágico. Para quem vivia de cartões perfurados, o CICS parecia magia. Hoje, muitos olham para o ChatGPT da mesma forma. Mas, como todo bom sistema, basta abrir a tampa para descobrir que existe muita engenharia por baixo."


Existe uma pergunta que recebo frequentemente quando converso com profissionais de Mainframe:

"Como exatamente um ChatGPT funciona?"

A maioria das respostas que encontramos na Internet são superficiais.

Dizem apenas:

"Ele usa Transformers."

Excelente.

Mas isso é como responder que um IBM Z funciona porque possui processadores.

Não explica absolutamente nada.

Neste artigo vamos desmontar um Transformer da mesma forma que um Programador COBOL gosta de aprender: entendendo cada etapa do processamento.

Você perceberá que muitos conceitos não são tão diferentes do que já conhece há décadas.

A diferença está na escala.

Muito mais do que na ideia.

Pegue seu café.

Hoje vamos abrir o capô do motor.


O maior equívoco sobre IA

Existe uma crença bastante difundida.

Que o ChatGPT "pensa".

Não.

Ele calcula.

Isso muda completamente a forma de enxergar um LLM (Large Language Model).

O Transformer é, essencialmente, uma gigantesca máquina de estatística, álgebra linear e otimização.

Seu trabalho consiste em responder apenas uma pergunta:

"Qual é o próximo token mais provável?"

Nada além disso.

E, surpreendentemente, essa pergunta simples produz resultados extraordinários.


Imagine um Batch COBOL

Vamos fazer uma analogia.

Considere um programa COBOL clássico.

INPUT

↓

Validação

↓

Conversão

↓

Regras de negócio

↓

Atualização do banco

↓

Relatórios

O Transformer segue exatamente essa filosofia.

O texto entra.

Passa por diversas etapas.

Cada etapa transforma um pouco a informação.

No final, surge uma resposta.


Etapa 1 — Tokenização

Nenhum computador entende palavras.

Computadores entendem números.

Quando digitamos

O gato dorme.

Nós enxergamos quatro palavras.

O modelo enxerga algo parecido com:

502

18472

913

25

Cada número representa um token.

Aqui aparece uma surpresa.

Token não significa palavra.

Pode representar:

  • uma palavra inteira;

  • metade de uma palavra;

  • um caractere;

  • pontuação;

  • espaços.

Por exemplo:

Mainframe

↓

Main

frame

Ou

Bellacosa

↓

Bella

cosa

Isso reduz enormemente o vocabulário.

Em vez de decorar milhões de palavras, o modelo aprende milhares de pequenas peças reutilizáveis.

É como reutilizar COPYBOOKs.


O Token é o novo Campo

Pense em um registro VSAM.

Você não grava um texto inteiro como um único bloco.

Você possui campos.

Cada campo possui significado.

O Transformer faz algo semelhante.

Cada token torna-se uma unidade independente de processamento.


Etapa 2 — Embeddings

Agora temos números.

Mas ainda não existe significado.

Entra o Embedding.

Imagine uma tabela gigantesca.

Algo como:

TOKEN

↓

VETOR

Só que esse vetor pode possuir milhares de posições.

Algo parecido com:

0.83

-1.24

3.91

0.18

...

2048 posições

Esse vetor representa características aprendidas durante o treinamento.

Curiosamente ninguém programa isso.

O próprio treinamento descobre essas relações.


O "Espaço" onde as palavras vivem

Imagine um mapa.

Nele existem milhões de pontos.

Palavras semelhantes ficam próximas.

Por exemplo:

COBOL

PL/I

Assembler

ficariam relativamente próximas.

Enquanto

Pizza

Astronomia

Dinossauro

estariam muito mais distantes.

Esse espaço vetorial é uma das maiores descobertas da IA moderna.


Etapa 3 — Positional Encoding

Existe um problema.

O Transformer não sabe ordem.

Para ele,

A B C

e

C B A

seriam quase iguais.

Mas ordem importa.

Então adicionamos informação de posição.

É como numerar linhas de um arquivo sequencial.

Cada token recebe:

Embedding

+

Posição

Agora ele sabe:

"Sou a quarta palavra."

Sem isso a linguagem desapareceria.


O Coração do Transformer

Chegamos ao conceito mais importante.

Self-Attention.

Se você entender isso, compreenderá por que os Transformers mudaram toda a Inteligência Artificial.


Self-Attention

Imagine a frase:

João entregou o livro para Maria porque ela precisava estudar.

Quem precisava estudar?

João?

Maria?

O modelo precisa descobrir.

É exatamente isso que a Self-Attention faz.

Cada palavra pergunta:

"Quais outras palavras desta frase são importantes para mim?"

Não existe regra fixa.

Cada frase produz um conjunto diferente de relações.


Parece um JOIN Inteligente

Quem trabalha com DB2 pode imaginar algo semelhante.

Cada token consulta os demais.

Mas não procura igualdade.

Procura relevância.

É como um JOIN baseado em significado.


Queries, Keys e Values

Aqui aparece um conceito inspirado em recuperação de informação.

Cada token gera três vetores.

Query

O que estou procurando?


Key

Quem sou eu?


Value

Qual informação entrego?

Imagine uma biblioteca.

Você chega procurando:

"Livros sobre COBOL."

Essa é sua Query.

Cada livro possui uma Key.

Quando uma Key combina com sua Query...

...o conteúdo daquele livro (Value) é utilizado.


Attention Scores

Agora entra matemática.

O Transformer mede a semelhança entre Query e Key.

Quanto maior a semelhança...

Maior a atenção.

Imagine algo assim:

COBOL

92%

DB2

84%

JCL

70%

Linux

12%

Sorvete

0%

O modelo naturalmente concentra esforço onde existe maior relevância.


Softmax

Esses valores ainda precisam virar probabilidades.

Entra o Softmax.

Ele transforma qualquer conjunto de números em probabilidades cuja soma é exatamente 100%.

Exemplo:

COBOL

61%

JCL

24%

Assembler

9%

Java

6%

Agora o modelo sabe exatamente quanto deve "prestar atenção" em cada token.


Multi-Head Attention

Agora imagine uma equipe inteira de analistas.

Um especialista observa gramática.

Outro observa tempo verbal.

Outro procura relações semânticas.

Outro identifica sujeito e objeto.

Todos trabalham simultaneamente.

Depois unem suas descobertas.

Isso é Multi-Head Attention.

Em vez de uma única visão da frase...

Existem dezenas delas.

Ao mesmo tempo.


Por que isso revolucionou a IA?

Antes dos Transformers existiam as RNNs.

Depois vieram as LSTMs.

Ambas liam texto sequencialmente.

Palavra por palavra.

Como um READ NEXT.

Os Transformers mudaram completamente essa abordagem.

Eles conseguem analisar toda a frase simultaneamente.

Isso permitiu enorme paralelismo.

GPUs adoram processamento paralelo.

Resultado?

Treinamentos centenas de vezes mais rápidos.


Feed-Forward Network

Depois da atenção, cada token entra em uma pequena rede neural.

Ela refina a informação.

É semelhante a uma rotina interna.

Imagine:

PERFORM PROCESSA-TOKEN

Para cada token.

Independentemente dos demais.

Essa etapa extrai padrões mais complexos e prepara os dados para a próxima camada.


Residual Connections

Programadores COBOL antigos conhecem uma boa prática.

Nunca destruir a informação original.

As Residual Connections seguem essa ideia.

Em vez de substituir completamente o resultado anterior...

O Transformer soma:

Entrada

+

Saída

Assim nenhuma informação importante se perde.

Esse pequeno detalhe permitiu construir redes com centenas de camadas.


Layer Normalization

Quem trabalha com processamento numérico conhece problemas de overflow.

Na IA existe algo semelhante.

Valores podem crescer demais.

Ou diminuir demais.

A Layer Normalization mantém tudo equilibrado.

Ela impede que o treinamento fique instável.

É um mecanismo silencioso.

Mas indispensável.


Context Window

Imagine ler um livro.

Se você esquecer tudo que aconteceu duas páginas atrás...

A história deixa de fazer sentido.

O Context Window representa exatamente essa memória temporária.

Modelos antigos:

2 mil tokens.

Depois:

8 mil.

32 mil.

128 mil.

Hoje encontramos modelos capazes de trabalhar com milhões de tokens.

Quanto maior o contexto...

Maior a capacidade de manter conversas longas.

Mas existe um preço.

O custo computacional cresce aproximadamente com o quadrado da quantidade de tokens.

É por isso que surgiram otimizações como FlashAttention e Sliding Window Attention.


Encoder

Alguns Transformers apenas leem.

Eles não escrevem.

Seu objetivo é compreender.

É o caso do BERT.

Imagine um auditor lendo um programa COBOL.

Ele não modifica nada.

Apenas entende.

Esse é o Encoder.


Decoder

Já o GPT pertence à família dos Decoders.

Seu trabalho consiste em gerar texto.

Token após token.

Ele escreve:

Hoje

↓

Hoje vamos

↓

Hoje vamos estudar

↓

Hoje vamos estudar COBOL

Cada palavra exige um novo processamento completo.


Masked Attention

Existe uma regra fundamental.

Durante o treinamento o modelo não pode olhar o futuro.

Imagine um exame.

O aluno não pode consultar o gabarito.

Da mesma forma, quando precisa prever a próxima palavra, o modelo só pode enxergar as anteriores.

Essa restrição torna o aprendizado muito mais realista.


Cross-Attention

Em tarefas como tradução automática, um Decoder consulta constantemente as informações produzidas pelo Encoder.

Imagine:

Entrada:

The Mainframe is reliable.

Encoder:

Compreende toda a frase.

Decoder:

Produz

O Mainframe é confiável.

Enquanto escreve, consulta continuamente o significado construído pelo Encoder.


O Grande Treinamento

Antes de responder qualquer pergunta, o modelo passou meses aprendendo.

São trilhões de tokens.

Livros.

Artigos.

Código-fonte.

Documentação técnica.

Sites.

Papers.

Repositórios.

A tarefa parece simples.

Prever o próximo token.

Mas essa simplicidade força o modelo a aprender:

  • gramática;

  • lógica;

  • sintaxe;

  • programação;

  • matemática;

  • estilo;

  • contexto;

  • relações de causa e efeito.

É um gigantesco treinamento estatístico.


Fine-Tuning

Depois disso, surgem especializações.

Imagine pegar um programador COBOL.

Depois treiná-lo apenas em seguros.

Ou apenas em bancos.

Ou apenas em telecomunicações.

É exatamente isso.

O conhecimento geral permanece.

Mas surge especialização.

Hoje existem modelos treinados especificamente para:

  • medicina;

  • direito;

  • engenharia;

  • segurança;

  • programação;

  • IBM Z;

  • documentação técnica.

Além disso, técnicas como Instruction Tuning e RLHF (Reinforcement Learning from Human Feedback) refinam o comportamento do modelo para seguir instruções, responder de forma útil e reduzir respostas inadequadas.


Next Token Prediction

Aqui está a maior surpresa.

O modelo não escreve um texto inteiro.

Ele apenas responde:

Qual é o próximo token?

Depois repete.

Depois repete.

Depois repete novamente.

Em velocidade impressionante.

Uma resposta de 800 palavras pode representar milhares de ciclos de previsão consecutivos.


Inference

É a fase em que você conversa com o modelo.

Você digita:

Explique VSAM.

Internamente acontecem bilhões de multiplicações matriciais.

Tudo isso para escolher...

Uma única palavra.

Depois outra.

Depois outra.

Até formar a resposta completa.


O que o infográfico não mostra

O excelente infográfico que inspirou este artigo apresenta o fluxo principal, mas um Transformer moderno ainda possui diversos componentes fundamentais que trabalham nos bastidores.

Entre eles estão:

  • Funções de ativação, como GELU e SiLU, que permitem à rede aprender relações complexas.

  • Backpropagation, responsável por ajustar bilhões de parâmetros durante o treinamento.

  • Otimizadores, como AdamW, que definem como os pesos serão atualizados.

  • Dropout, utilizado para evitar overfitting.

  • Temperature, Top-k e Top-p Sampling, que controlam criatividade e diversidade na geração de texto.

  • Mixture of Experts (MoE), onde apenas parte da rede é ativada para cada token, aumentando eficiência.

  • RAG (Retrieval-Augmented Generation), que permite consultar documentos externos durante a inferência.

  • Quantização, que reduz o tamanho dos modelos para execução em hardware mais modesto.

  • FlashAttention, uma otimização que diminui drasticamente o custo da atenção em contextos longos.

Esses elementos ajudam a explicar por que os modelos atuais conseguem ser ao mesmo tempo maiores, mais rápidos e mais eficientes do que os primeiros Transformers apresentados em 2017.


O que um Programador COBOL pode aprender com tudo isso?

Talvez a maior lição não seja técnica.

Seja filosófica.

Durante décadas, nós, desenvolvedores Mainframe, aprendemos que bons sistemas são construídos em camadas.

Entrada.

Validação.

Processamento.

Persistência.

Saída.

Os Transformers seguem exatamente essa filosofia.

A diferença é que, em vez de registros VSAM e tabelas DB2, trabalham com vetores em espaços de milhares de dimensões. Em vez de IFs escritos por programadores, utilizam bilhões de parâmetros ajustados durante o treinamento. Em vez de regras de negócio explícitas, aprendem padrões estatísticos a partir de volumes gigantescos de dados.

Ainda assim, os princípios continuam familiares: modularidade, processamento em etapas, reutilização de informação, otimização de desempenho e preocupação constante com escalabilidade.


Um Café Antes de Ir...

Quando ouvimos falar em Inteligência Artificial, é fácil imaginar algo misterioso ou quase mágico.

Mas, depois de abrir o capô de um Transformer, percebemos que não existe magia.

Existe engenharia.

Existe matemática.

Existe arquitetura.

Existe otimização.

E existe uma ideia brilhante: permitir que cada palavra "converse" com todas as outras para construir contexto antes de decidir qual será a próxima.

Talvez seja justamente por isso que tantos profissionais experientes em Mainframe conseguem compreender rapidamente essa tecnologia. Quem passou anos projetando sistemas robustos, escaláveis e confiáveis reconhece os mesmos princípios fundamentais, apenas aplicados em uma escala sem precedentes.

No fim das contas, um Transformer não substitui a engenharia de software. Ele é uma das maiores realizações da engenharia de software moderna.

E, para um Programador COBOL Padawan, entender essa arquitetura não significa abandonar décadas de experiência. Significa descobrir que muitos dos conceitos que sustentam a Inteligência Artificial já faziam parte do seu repertório — apenas ganharam novas formas, novos algoritmos e uma capacidade de processamento que transformou a maneira como interagimos com computadores.

Porque, como sempre dizemos aqui no Bellacosa Mainframe, tecnologias mudam. Bons princípios de engenharia permanecem.


segunda-feira, 14 de outubro de 2024

O Guia Definitivo para um Programador COBOL Padawan Entender Como a Inteligência Artificial Aprendeu a Pensar — e Como Você Pode Acompanhar Essa Jornada Sem Medo

 

Bellacosa Mainframe e as redes neurais

☕ Um Café no Bellacosa Mainframe

Redes Neurais sem Mistérios

O Guia Definitivo para um Programador COBOL Padawan Entender Como a Inteligência Artificial Aprendeu a Pensar — e Como Você Pode Acompanhar Essa Jornada Sem Medo

"Durante décadas os programadores COBOL ensinaram computadores a executar regras de negócio. Agora estamos ensinando computadores a descobrir regras sozinhos. Parece uma revolução. Na verdade, é apenas mais um capítulo da evolução da Computação."


Introdução

Existe uma pergunta que recebo praticamente todas as semanas.

"Bellacosa, eu programo COBOL há anos. Ainda dá tempo de aprender Inteligência Artificial?"

Minha resposta sempre é a mesma.

Não apenas dá tempo. Você possui uma vantagem enorme.

Pode parecer estranho ouvir isso justamente quando o mercado parece girar exclusivamente em torno de Python, GPUs, Transformers, ChatGPT e modelos gigantescos.

Mas existe uma verdade que poucos comentam.

Os profissionais que realmente conseguem construir soluções de IA corporativa são aqueles que entendem de sistemas.

E ninguém entende sistemas corporativos melhor do que quem passou anos trabalhando com:

  • COBOL

  • CICS

  • Db2

  • MQ

  • VSAM

  • Batch

  • JCL

  • z/OS

O mercado fala muito sobre modelos.

Mas as empresas vivem de processos.

E IA sem processos não resolve problemas reais.

Neste café vamos entender como nasceram as Redes Neurais, por que cada arquitetura surgiu, quais problemas resolveram e, principalmente, como um Programador COBOL Padawan pode construir sua própria trilha rumo ao universo da Inteligência Artificial.

Pegue sua caneca.

Hoje vamos atravessar quarenta anos de evolução tecnológica.


O cérebro sempre foi a inspiração

Desde os anos 1940 os cientistas tentavam responder uma pergunta simples.

Como um cérebro aprende?

Eles perceberam que um neurônio faz algo extremamente simples.

Recebe sinais.

Processa.

Decide.

Envia um novo sinal.

Visualmente:

Entradas

↓

Neurônio

↓

Saída

Individualmente parece pouco.

Mas agora imagine:

100 bilhões de neurônios.

Cada um conectado a milhares de outros.

É assim que nosso cérebro funciona.

As Redes Neurais tentam reproduzir exatamente essa ideia.


O primeiro erro dos iniciantes

Quando alguém vê IA pela primeira vez costuma imaginar:

"Existe uma única Inteligência Artificial."

Não existe.

Na verdade existem dezenas de arquiteturas diferentes.

Cada uma foi criada para resolver um problema específico.

É exatamente igual ao mundo Mainframe.

Você nunca usaria:

  • CICS para processamento Batch.

Nem

  • JCL para criar uma API REST.

Nem

  • Db2 para substituir MQ.

Cada tecnologia nasceu para uma finalidade.

Com Redes Neurais acontece exatamente o mesmo.


Primeira geração — MLP

Tudo começou aqui.

Multi-Layer Perceptron.

O famoso MLP.

Se existisse um equivalente no Mainframe seria algo assim:

READ CLIENTE

↓

VALIDAR

↓

CALCULAR

↓

WRITE

A informação sempre anda para frente.

Nunca volta.

Nunca olha para trás.

É por isso que chamamos esse tipo de arquitetura de Feed Forward.

Ela é extremamente eficiente quando os dados são organizados em tabelas.

Por exemplo:

Idade

Salário

Estado Civil

Cidade

↓

Chance de inadimplência

É praticamente o mesmo problema que bancos resolvem há décadas.


Dica Bellacosa

Se você trabalha com Db2, provavelmente mais de 70% dos seus modelos iniciais poderiam ser resolvidos apenas com MLP.

Nem todo problema precisa de um GPT.


Segunda geração — CNN

A MLP era excelente.

Até aparecer uma fotografia.

Ela via isto:

255

128

90

45

...

Ela não fazia ideia de que aquilo representava um gato.

Foi então que surgiu uma ideia brilhante.

Ao invés de analisar a imagem inteira...

Por que não olhar pequenos pedaços?

Nascia a Convolutional Neural Network.


Imagine um inspetor de qualidade em uma fábrica.

Ele não olha o carro inteiro de uma vez.

Primeiro observa:

✔ roda

Depois

✔ porta

Depois

✔ retrovisor

Depois

✔ pintura

Depois

✔ farol

A CNN trabalha exatamente assim.

Ela identifica padrões simples.

Depois combina esses padrões.

Até reconhecer objetos extremamente complexos.


Curiosidade

Hoje praticamente todo exame médico envolvendo IA utiliza CNN em alguma etapa.

Radiologia.

Mamografia.

Tomografia.

Retina.

Dermatologia.

A maioria começou usando CNN.


Terceira geração — RNN

Agora apareceu outro problema.

Texto.

Veja estas frases.

Maria ama João.

Agora troque.

João ama Maria.

As mesmas palavras.

Significados completamente diferentes.

A MLP não entendia isso.

Ela tratava tudo como números.

Foi então que surgiu a Rede Neural Recorrente.

Ela ganhou memória.

Cada palavra influencia a próxima.


Analogia COBOL

Imagine um programa Batch processando extratos.

Cada registro depende do saldo anterior.

Saldo Inicial

↓

Débito

↓

Crédito

↓

Novo Saldo

Esse estado precisa ser carregado.

A RNN faz exatamente isso.


O problema do esquecimento

Mas apareceu outro desafio.

Quanto maior o texto...

Mais difícil lembrar do começo.

Imagine ler um livro inteiro e esquecer quem era o protagonista.

Era isso que acontecia.

Chamamos isso de:

Vanishing Gradient.


LSTM — A memória inteligente

Foi então criada a Long Short-Term Memory.

A ideia é maravilhosa.

Ela criou "porteiros".

Toda informação pergunta:

Posso entrar?

↓

Guardar?

↓

Esquecer?

↓

Mostrar?

Esses controles fizeram uma enorme diferença.

Agora a rede conseguia lembrar eventos ocorridos centenas de palavras antes.


Easter Egg Mainframe

Quem trabalha com CICS conhece bem o conceito de COMMAREA.

Ela transporta contexto entre transações.

A LSTM faz algo parecido.

Ela leva contexto de uma etapa para outra.


GRU

Depois alguém perguntou:

"Será que precisamos de tanta complexidade?"

Nasceu a GRU.

Ela faz quase o mesmo.

Mas usando menos portas.

Resultado:

✔ treinamento mais rápido

✔ menos memória

✔ menos parâmetros


Hoje ela aparece bastante em:

IoT.

Sensores.

Equipamentos industriais.

Dispositivos embarcados.


O terremoto chamado Transformer

Então chegou 2017.

Um artigo mudou completamente a história da IA.

Attention Is All You Need

Esse artigo talvez seja para IA o equivalente ao System/360 para a computação empresarial.

Mudou tudo.


Antes

As redes liam:

Palavra

↓

Palavra

↓

Palavra

Uma por vez.


Agora...

Todas as palavras são analisadas simultaneamente.

Todas

↓

Todas conversam entre si

↓

Resultado

Isso permitiu usar milhares de GPUs em paralelo.

Foi aí que nasceram:

GPT

Claude

Gemini

Llama

Mistral

DeepSeek

Qwen

Phi


Self-Attention

Aqui está a verdadeira mágica.

Imagine:

O gerente entregou o relatório ao diretor porque ele solicitou.

Quem solicitou?

O gerente?

Ou o diretor?

O Transformer calcula relações entre todas as palavras.

Ao mesmo tempo.

É quase como construir um enorme grafo de relacionamentos.


Curiosidade

Quando o ChatGPT responde sua pergunta...

Ele está realizando bilhões de operações matemáticas envolvendo Attention.

A resposta não vem de um banco de dados.

Ela surge desses cálculos.


Autoencoders

Existe outra família extremamente importante.

Os Autoencoders.

Eles aprendem a compactar informação.

Pense em um enorme VSAM.

Imagine reduzir milhões de registros para poucas variáveis que representam todo o comportamento do sistema.

É isso que eles fazem.


Onde aparecem?

Detecção de fraude.

Anomalias.

Compressão.

Stable Diffusion.

Representação Latente.

Sistemas de recomendação.


O que os iniciantes normalmente estudam errado?

Quase todos querem começar aprendendo:

Transformer.

Erro.

É como querer aprender Sysplex antes de entender JCL.

Existe uma ordem natural.


A trilha Bellacosa Mainframe

Se eu estivesse começando hoje...

Minha trilha seria exatamente esta.


Etapa 1

Matemática.

Não precisa virar matemático.

Mas domine:

✔ Álgebra Linear

✔ Vetores

✔ Matrizes

✔ Probabilidade

✔ Estatística


Etapa 2

Python.

Não para virar desenvolvedor Python.

Mas porque praticamente todo ecossistema de IA utiliza Python.

Aprenda:

if

for

listas

funções

classes

Nada além disso inicialmente.


Etapa 3

NumPy.

Aprenda:

arrays

broadcast

matrizes

Etapa 4

Pandas.

Manipulação de dados.

Quem conhece SORT e Db2 aprende Pandas muito rapidamente.


Etapa 5

Visualização.

Matplotlib.

Plotly.

Gráficos contam histórias.


Etapa 6

Machine Learning clássico.

Antes das Redes Neurais.

Aprenda:

Regressão.

Árvore.

Random Forest.

XGBoost.

SVM.

K-Means.


Etapa 7

MLP.

Aqui começa Deep Learning.


Etapa 8

CNN.

Visão Computacional.


Etapa 9

RNN.


Etapa 10

LSTM.


Etapa 11

GRU.


Etapa 12

Attention.


Etapa 13

Transformers.


Etapa 14

LLMs.


Etapa 15

Fine-Tuning.


Etapa 16

RAG.


Etapa 17

Agentes de IA.


Uma analogia com a evolução do Mainframe

Observe como as duas histórias se parecem.

MainframeIA
BatchMLP
CICSRNN
SysplexTransformer
MQAttention
Db2Embeddings
VSAMVetores
RACFGuardrails
WLMScheduler do treinamento
SMFObservabilidade
RMFMonitoramento de desempenho

Perceba algo interessante.

O Mainframe sempre trabalhou com integração.

A IA moderna também.


Cinco conselhos para o COBOL Padawan

1. Não tenha medo da matemática. Você não precisa provar teoremas. Precisa entender conceitos como vetores, matrizes e probabilidades para interpretar o comportamento dos modelos.

2. Preserve sua experiência em regras de negócio. Um modelo de IA pode aprender padrões, mas dificilmente conhece décadas de processos bancários, seguradoras ou governo como um analista experiente.

3. Estude arquitetura, não apenas ferramentas. Frameworks mudam rapidamente. Conceitos como atenção, embeddings, funções de ativação e treinamento permanecem relevantes.

4. Construa pequenos projetos. Um classificador de documentos, um detector de anomalias em transações ou um chatbot para consultar manuais ensinam muito mais do que apenas assistir vídeos.

5. Continue aprendendo continuamente. A evolução da IA é rápida, mas segue princípios fundamentais. Quem domina esses princípios consegue acompanhar as novidades com muito mais facilidade.


Curiosidades

  • O Perceptron, criado em 1958 por Frank Rosenblatt, foi um dos primeiros modelos de rede neural.

  • O termo Deep Learning só ganhou popularidade décadas depois, quando hardware e grandes volumes de dados tornaram possível treinar redes profundas.

  • O artigo "Attention Is All You Need", publicado em 2017, tem pouco mais de uma dezena de páginas e redefiniu praticamente toda a indústria de IA moderna.

  • Muitos modelos atuais utilizam bilhões de parâmetros, mas continuam baseados em conceitos matemáticos desenvolvidos ao longo de décadas.


Easter Eggs para quem vive no IBM Z

  • Embeddings podem ser comparados a índices inteligentes: em vez de procurar por igualdade exata, eles permitem encontrar informações por similaridade.

  • Attention lembra uma consulta complexa que cruza várias tabelas de uma só vez para decidir quais relacionamentos são mais importantes.

  • Fine-Tuning se parece com adaptar um sistema legado para uma nova legislação: você não reescreve tudo, apenas especializa o comportamento.

  • RAG (Retrieval-Augmented Generation) é como combinar um programa COBOL com consultas ao Db2 ou VSAM: o modelo raciocina, mas consulta uma base confiável para responder.

  • Agentes de IA lembram muito a arquitetura tradicional do mainframe: um coordenador orquestra vários componentes especializados, cada um responsável por uma função específica.


Conclusão

Durante muitos anos, o mercado acreditou que Inteligência Artificial substituiria a engenharia de software tradicional. O que estamos observando é justamente o contrário: os sistemas mais poderosos combinam modelos de IA com bancos de dados, filas de mensagens, APIs, regras de negócio, observabilidade, segurança e governança — exatamente os pilares que profissionais de mainframe dominam há décadas.

As redes neurais não eliminam a necessidade de arquitetura; elas ampliam sua importância. Saber quando usar um MLP, uma CNN, um Transformer ou um Autoencoder é tão importante quanto saber quando utilizar COBOL, CICS, Db2 ou MQ.

A verdadeira jornada de um Programador COBOL Padawan rumo à IA não começa decorando nomes de modelos, mas entendendo que cada arquitetura nasceu para resolver um problema específico. Quando você percebe essa evolução, deixa de enxergar a IA como uma caixa-preta e passa a vê-la como mais uma disciplina da Engenharia de Software.

No fim das contas, os princípios continuam os mesmos: compreender o problema, escolher a arquitetura adequada, construir soluções confiáveis e evoluí-las continuamente. Essa sempre foi a essência do desenvolvimento no IBM Z — e continua sendo a essência da Inteligência Artificial moderna.

segunda-feira, 27 de junho de 2016

Transformers no game

Final de tarde e a humanidade esta em perigo.


Somente o formiga e a Ju podem salvar a terra dos autobots, cada um pega sua arma e com a ajuda dos Transformers iniciam uma luta sem precedentes.



Tiros e explosoes para todos os lados, a duvida q persiste sera que estes dois iram sobreviver por mais que dois 2 minutos?

quarta-feira, 18 de junho de 2014

🌐 Da pergunta ao sistema autônomo: como transformar modelos de linguagem em soluções reais

Bellacosa Mainframe no mundo do Large Language Model com Python

🌐 Da pergunta ao sistema autônomo: como transformar modelos de linguagem em soluções reais

IA Generativa baseada em LLMs (Large Language Models) está transformando a forma como empresas e profissionais trabalham com informação, automação e conhecimento. 

Modelos como GPT, Claude, Gemini e LLaMA são capazes de gerar texto, responder perguntas, programar, resumir documentos e conversar em linguagem natural. Utilizados via APIs ou localmente com bibliotecas como Transformers e PyTorch, esses modelos permitem criar copilots, assistentes virtuais e sistemas inteligentes. 

Técnicas como Prompt Engineering, embeddings e RAG (Retrieval Augmented Generation) possibilitam respostas mais precisas e contextualizadas a partir de bases de dados corporativas. Além disso, agentes de IA podem executar tarefas complexas integrando sistemas, consultando bancos de dados e automatizando processos. 

Apesar dos benefícios, é essencial considerar segurança, viés e possíveis alucinações do modelo. A IA generativa já impacta áreas como desenvolvimento de software, atendimento ao cliente, análise de documentos e produtividade empresarial, tornando-se uma tecnologia estratégica na transformação digital.

🔥🤖🧠 Cheatsheet IA Generativa (LLMs — Large Language Models)

👉 O guia essencial para trabalhar com ChatGPT-like, copilots e IA moderna


🌐 O que são LLMs?

👉 Modelos gigantes treinados em texto para:

  • Gerar linguagem natural

  • Responder perguntas

  • Programar

  • Resumir documentos

  • Conversar

  • Analisar dados

  • Automatizar conhecimento

💥 Exemplos: GPT-4/5, Claude, LLaMA, Mistral, Gemini


⚡ Stack essencial

pip install openai transformers torch accelerate

🤖 Usando um LLM via API

Exemplo (estilo OpenAI)

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
model="gpt-4.1",
input="Explique computação quântica em termos simples"
)

print(response.output_text)

🧠 Prompt Engineering (habilidade crítica)

👉 O LLM é programado por texto.

Prompt simples

Explique redes neurais.

Prompt melhor

Explique redes neurais para um engenheiro COBOL com exemplos práticos.

Prompt profissional

Explique redes neurais para um engenheiro COBOL sênior,
comparando com processamento batch e pipelines.
Inclua exemplos corporativos.

💥 Quanto melhor o prompt → melhor a resposta


🧾 Estrutura ideal de prompt

👉 Técnica poderosa

[Contexto]
[Tarefa]
[Formato]
[Restrições]

Exemplo

Você é um especialista em finanças.
Resuma o texto abaixo em 5 bullet points.
Use linguagem simples.

🔥 Chat com histórico (contexto)

messages = [
{"role": "user", "content": "O que é IA?"},
{"role": "assistant", "content": "IA é..."},
{"role": "user", "content": "Explique para crianças"}
]

👉 Conversas dependem do histórico


🎯 Parâmetros importantes

Temperature — criatividade

ValorComportamento
0.0Muito preciso
0.3Técnico
0.7Natural
1.0+Criativo

Max Tokens — tamanho da resposta

max_output_tokens=500

🧠 Uso local com Hugging Face

Carregar modelo

from transformers import pipeline

generator = pipeline("text-generation", model="gpt2")

print(generator("Era uma vez", max_length=50))

🚀 Modelos open-source populares

  • LLaMA

  • Mistral

  • Falcon

  • Phi

  • Mixtral

👉 Podem rodar localmente com GPU


🧩 Embeddings (memória semântica)

👉 Transformar texto em vetores

from openai import OpenAI
client = OpenAI()

emb = client.embeddings.create(
model="text-embedding-3-small",
input="Mainframe modernization"
)

🔎 Busca semântica

👉 Encontrar textos parecidos por significado

Usado em:

  • FAQ inteligentes

  • Pesquisa corporativa

  • RAG

  • Sistemas de conhecimento


🧠 RAG — Retrieval Augmented Generation

👉 LLM + base de dados externa

💥 Arquitetura dominante no mundo corporativo

Fluxo:

1️⃣ Usuário pergunta
2️⃣ Sistema busca documentos relevantes
3️⃣ LLM usa esses dados
4️⃣ Resposta fundamentada


📦 Pipeline RAG simplificado

query embeddings busca vetorial contexto LLM

🧠 Function Calling / Tools

👉 LLM pode chamar funções reais

Exemplo:

  • Consultar banco

  • Executar cálculo

  • Buscar clima

  • Integrar sistemas


🔥 Agentes de IA

👉 LLM que executa tarefas autonomamente

Exemplos:

  • Copilot

  • Assistentes corporativos

  • Automação inteligente

Frameworks populares:

  • LangChain

  • LlamaIndex

  • AutoGen

  • CrewAI


🧾 Fine-tuning

👉 Especializar modelo para domínio específico

Usado para:

  • Jurídico

  • Médico

  • Financeiro

  • Industrial

  • Código


🧠 Segurança e controle

Problemas comuns

⚠ Hallucinations (respostas inventadas)
⚠ Vazamento de dados
⚠ Prompt injection
⚠ Viés


📊 Casos de uso corporativos

💼 Produtividade

  • Assistentes internos

  • Resumo de documentos

  • Geração de relatórios


💻 Desenvolvimento

  • Copilots de código

  • Refatoração automática

  • Documentação


🏦 Negócios

  • Atendimento inteligente

  • Análise de contratos

  • Inteligência competitiva


⚡ Arquitetura moderna de IA

Usuário

Aplicação

Orquestração (RAG/Tools)

LLM

Resposta inteligente

💥 LLM vs ML tradicional

ML clássicoLLM
Modelos específicosModelo geral
Dados estruturadosTexto massivo
Treino caroUso via API
Pouca generalizaçãoAlta generalização

☕ Frase de guerra da IA generativa

👉 “LLMs não são bancos de dados —
são motores de raciocínio probabilístico.”


🚀 Super poderes dos LLMs

✔ Conversação natural
✔ Programação automática
✔ Tradução universal
✔ Análise semântica
✔ Criação de conteúdo
✔ Automação cognitiva

domingo, 11 de maio de 2014

🔥 O manual proibido da IA prática: Machine Learning, Deep Learning e LLMs em um só lugar

Bellacosa Mainframe publica o Manual Proibido da IA

🔥 O manual proibido da IA prática: Machine Learning, Deep Learning e LLMs em um só lugar

Este cheatsheet de Python para Inteligência Artificial reúne, em um único guia prático, as principais ferramentas usadas por engenheiros de IA, cientistas de dados e profissionais de Machine Learning.

Com foco em aplicações reais, o material aborda desde a base matemática com NumPy até manipulação de dados com Pandas, modelagem com Scikit-learn e redes neurais profundas com PyTorch e TensorFlow. Também inclui recursos para NLP com Transformers, visão computacional, IA generativa e implantação de modelos em produção. 

O conteúdo cobre todo o pipeline moderno de IA: coleta, limpeza, preparação, treinamento, avaliação e deploy. Ideal para iniciantes avançarem rapidamente e para profissionais consolidarem conhecimento, o guia mostra como Python se tornou a linguagem dominante em IA, Data Science e automação inteligente. 

Dominar esse ecossistema significa estar preparado para construir soluções preditivas, sistemas autônomos, chatbots e aplicações baseadas em dados no mercado atual orientado por Inteligência Artificial.

🧠🐍🔥 Cheatsheet Python para IA (Inteligência Artificial)

👉 Essencial para Machine Learning, Deep Learning e IA Generativa


🧠 Stack Principal de IA

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

import torch # PyTorch (Deep Learning)
import tensorflow as tf # TensorFlow / Keras
from sklearn import datasets

📊 Base Matemática — NumPy

IA = Álgebra linear + estatística + otimização

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

a + b
np.dot(a, b)
np.mean(a)
np.std(a)

📚 Dados — Pandas

df = pd.read_csv("dataset.csv")

df.head()
df.info()
df.describe()

🧹 Preparação de Dados (80% do trabalho real)

Tratar valores ausentes

df.fillna(0, inplace=True)

Converter categorias → números

pd.get_dummies(df, columns=["cidade"])

Normalização

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

👉 Essencial para redes neurais.


✂️ Dividir dados (Treino/Teste)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)

🤖 Machine Learning Clássico (Scikit-Learn)

Regressão Linear

from sklearn.linear_model import LinearRegression

model = LinearRegression()
model.fit(X_train, y_train)
pred = model.predict(X_test)

Classificação

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()
model.fit(X_train, y_train)

Avaliação

from sklearn.metrics import accuracy_score

accuracy_score(y_test, pred)

🧠 Deep Learning — PyTorch

Tensor (base do DL)

import torch

x = torch.tensor([1.0, 2.0, 3.0])

Modelo simples

import torch.nn as nn

model = nn.Linear(3, 1)

Forward pass

output = model(x)

🔥 Treinamento básico PyTorch

loss_fn = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(100):
pred = model(x)
loss = loss_fn(pred, y)

optimizer.zero_grad()
loss.backward()
optimizer.step()

👉 Loop de aprendizado da rede.


🧠 Deep Learning — TensorFlow / Keras

Modelo sequencial

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
Dense(64, activation="relu"),
Dense(1)
])

Compilar

model.compile(
optimizer="adam",
loss="mse"
)

Treinar

model.fit(X_train, y_train, epochs=10)

👁️ IA para Visão Computacional

from PIL import Image
import numpy as np

img = Image.open("foto.jpg")
img_array = np.array(img)

🗣️ IA para NLP (Processamento de Linguagem)

Tokenização simples

texto = "Python é incrível"
tokens = texto.split()

Com Transformers 🤯

from transformers import pipeline

classifier = pipeline("sentiment-analysis")
classifier("I love Python!")

🤖 IA Generativa (LLMs)

Exemplo básico com API

from openai import OpenAI

client = OpenAI()

resp = client.chat.completions.create(
model="gpt-4.1-mini",
messages=[{"role": "user", "content": "Explique IA"}]
)

print(resp.choices[0].message.content)

📊 Visualização de resultados

plt.plot(history.history["loss"])
plt.show()

🧪 Salvando modelos

Scikit-Learn

import joblib

joblib.dump(model, "modelo.pkl")

PyTorch

torch.save(model.state_dict(), "modelo.pt")

TensorFlow

model.save("modelo.h5")

⚡ Pipeline completo de IA

1️⃣ Coletar dados
2️⃣ Limpar e preparar
3️⃣ Dividir treino/teste
4️⃣ Treinar modelo
5️⃣ Avaliar
6️⃣ Ajustar hiperparâmetros
7️⃣ Implantar


🧠 Tipos principais de IA

📊 Machine Learning

  • Regressão

  • Classificação

  • Clustering

🧠 Deep Learning

  • Redes neurais

  • CNN (imagens)

  • RNN / Transformers (texto)

🤖 IA Generativa

  • Chatbots

  • Geração de imagens

  • Código automático


🔥 Bibliotecas essenciais

ÁreaBibliotecas
MLScikit-Learn
Deep LearningPyTorch, TensorFlow
NLPTransformers, spaCy
VisãoOpenCV
DadosPandas, NumPy
VisualizaçãoMatplotlib, Seaborn

💥 Superpoderes da IA com Python

🔥 Previsão de demanda
🔥 Detecção de fraude
🔥 Recomendação personalizada
🔥 Visão computacional
🔥 Chatbots inteligentes
🔥 Automação cognitiva
🔥 Análise de sentimentos
🔥 Sistemas autônomos


☕ Frase de guerra da IA

👉 “Dados são o combustível.
Algoritmos são o motor.
Python é o cockpit.”


Se quiser, posso criar algo ainda mais poderoso:

🔥 Cheatsheet Python para IA Generativa (LLMs)
🔥 Roadmap completo AI Engineer
🔥 Python para Machine Learning em produção
🔥 IA aplicada a negócios corporativos
🔥 IA para modernização de sistemas legados
🔥 Python + IA para Mainframe modernization

Só dizer — a próxima etapa é nível lendário 😎

🔥 Cheatsheet Python para Machine Learning

🔥🐍📊 Cheatsheet Python para Machine Learning

👉 O guia essencial para construir modelos preditivos do zero à produção


🧠 Stack Principal de Machine Learning

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, mean_squared_error

📊 Carregar e explorar dados

df = pd.read_csv("data.csv")

df.head()
df.info()
df.describe()

👉 Sempre faça EDA (Exploratory Data Analysis).


🧹 Limpeza de dados

Valores ausentes

df.fillna(0, inplace=True)
# ou
df.dropna(inplace=True)

Remover duplicados

df.drop_duplicates(inplace=True)

🔤 Converter dados categóricos

One-Hot Encoding

df = pd.get_dummies(df, columns=["categoria"])

Label Encoding

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
df["classe"] = le.fit_transform(df["classe"])

📐 Separar variáveis (X e y)

X = df.drop("target", axis=1)
y = df["target"]

✂️ Dividir treino e teste

X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.2,
random_state=42
)

👉 80% treino — 20% teste é padrão.


⚖️ Normalização (IMPORTANTÍSSIMO)

scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

👉 Essencial para:

  • SVM

  • KNN

  • Redes neurais

  • Regressões


🤖 Regressão (prever números)

Linear Regression

from sklearn.linear_model import LinearRegression

model = LinearRegression()
model.fit(X_train, y_train)

pred = model.predict(X_test)

Avaliação

mean_squared_error(y_test, pred)

🧠 Classificação (prever categorias)

🌳 Decision Tree

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()
model.fit(X_train, y_train)

pred = model.predict(X_test)

👥 K-Nearest Neighbors

from sklearn.neighbors import KNeighborsClassifier

model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)

🚀 Random Forest (super popular)

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier()
model.fit(X_train, y_train)

👉 Excelente baseline.


⚡ Support Vector Machine

from sklearn.svm import SVC

model = SVC()
model.fit(X_train, y_train)

📊 Avaliação de classificação

accuracy_score(y_test, pred)

Métricas mais completas

from sklearn.metrics import classification_report

print(classification_report(y_test, pred))

📉 Matriz de confusão

from sklearn.metrics import confusion_matrix

confusion_matrix(y_test, pred)

📈 Validação cruzada

from sklearn.model_selection import cross_val_score

scores = cross_val_score(model, X, y, cv=5)
scores.mean()

👉 Mede robustez do modelo.


🔍 Ajuste de hiperparâmetros

Grid Search

from sklearn.model_selection import GridSearchCV

params = {"n_estimators": [50, 100, 200]}

grid = GridSearchCV(RandomForestClassifier(), params)
grid.fit(X_train, y_train)

grid.best_params_

🧠 Clustering (sem rótulos)

K-Means

from sklearn.cluster import KMeans

kmeans = KMeans(n_clusters=3)
kmeans.fit(X)

labels = kmeans.labels_

👉 Descobrir padrões ocultos.


📊 Visualização

plt.scatter(X[:,0], X[:,1], c=labels)
plt.show()

🧪 Pipeline completo

from sklearn.pipeline import Pipeline

pipeline = Pipeline([
("scaler", StandardScaler()),
("model", RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

👉 Evita erros de pré-processamento.


💾 Salvar modelo treinado

import joblib

joblib.dump(model, "modelo.pkl")

📥 Carregar modelo

model = joblib.load("modelo.pkl")

⚡ Fazer previsão em novos dados

novo = [[5.1, 3.5, 1.4, 0.2]]

model.predict(novo)

🧠 Workflow ideal de Machine Learning

🔥 Pipeline profissional

1️⃣ Coleta de dados
2️⃣ Limpeza e preparação
3️⃣ Engenharia de features
4️⃣ Divisão treino/teste
5️⃣ Treinamento
6️⃣ Avaliação
7️⃣ Ajuste fino
8️⃣ Deploy


📦 Bibliotecas essenciais

FinalidadeBiblioteca
DadosPandas
MatemáticaNumPy
VisualizaçãoMatplotlib / Seaborn
MLScikit-Learn
Deep LearningPyTorch / TensorFlow

💥 Tipos principais de problemas

📊 Regressão

Prever valor contínuo
👉 preço, temperatura, demanda

🧠 Classificação

Prever categoria
👉 spam, fraude, diagnóstico

🔍 Clustering

Descobrir grupos
👉 segmentação de clientes


☕ Frase de guerra do Machine Learning

👉 “Dados são o novo petróleo —
Modelos são a refinaria.”

Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...