🔥 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

Área	Bibliotecas
ML	Scikit-Learn
Deep Learning	PyTorch, TensorFlow
NLP	Transformers, spaCy
Visão	OpenCV
Dados	Pandas, NumPy
Visualização	Matplotlib, 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

Finalidade	Biblioteca
Dados	Pandas
Matemática	NumPy
Visualização	Matplotlib / Seaborn
ML	Scikit-Learn
Deep Learning	PyTorch / 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.”

Globo da Morte em Itatiba

Aventuras no globo da morte..

Um circo mambembe numa pequena cidade do interior paulista, audazes motociclistas aprontam vários truques em suas motocicletas.

O ronco do motor ensurdecedor, bagunça sobre duas rodas, o formiguinha pirou com o barulho, ficou louco com as peripécias dos pilotos.

O roncar dos motores, o silencio e atenção do publico tornam ainda mais magico a sensação. Rodando e subindo correndo e subindo pelas grades.

Globo da Morte em Itatiba

Aventuras no globo da morte..

Um circo mambembe numa pequena cidade do interior paulista, audazes motociclistas aprontam vários truques em suas motocicletas.

O ronco do motor ensurdecedor, bagunça sobre duas rodas, o formiguinha pirou com o barulho, ficou louco com as peripécias dos pilotos.

O roncar dos motores, o silencio e atenção do publico tornam ainda mais magico a sensação. Rodando e subindo correndo e subindo pelas grades.

 

🜂 El Jefe Midnight Lunch apresenta

O Dai Maou como Metáfora do Programador que Resolve Tudo às 3h da Manhã

Um tratado místico–mainframeiro para entendermos a verdadeira natureza dos heróis noturnos

Por Bellacosa Mainframe

---

Existem duas forças supremas no universo:

1. O Grande Rei Demônio (Dai Maou), soberano das trevas nas histórias japonesas.

2. O Programador Mainframe que acorda a empresa inteira quando decide “só ajustar rapidinho esse JCL” às 3h da manhã.

Ambos operam no silêncio absoluto, ambos manipulam poderes que mortais não compreendem, e ambos têm aquela aura de respeito misturado com medo reverente.

E, como todo bom filósofo da madrugada com café frio na mão e ISPF aceso, afirmo:
o programador noturno É o Dai Maou corporativo.

---

🜁 1. A Origem — quando cai o chamado

O Dai Maou não nasce vilão.
Ele é escolhido, invocado, empurrado por circunstâncias, destino ou… ticket crítico aberto no ServiceNow.

Assim também é o programador mainframe:

• ninguém dorme tranquilo;

• o telefone vibra com aquele “P1 - Sistema de Pagamentos Parado”;

• a iluminação do quarto vira o prelúdio do modo batalha;

• a alma desperta direto no nível épico.

É nesse instante que o programador assume seu destino:
“Se eu não for agora, ninguém vai.”

Isso, meu amigo, é a verdadeira coroação do Dai Maou da Madrugada.

---

🜃 2. Os Poderes Mágicos — a caixa preta arcana

Todo Dai Maou domina magia proibida.
Todo programador das 3h domina:

• reprocessamento de job com override obscuro,

• permutação de DDs sem documentação,

• JES2 como quem recita mantras,

• debugging mental na penumbra,

• e aquele talento secreto de descobrir onde está o maldito space abend sem print.

É magia?
É experiência?
É trauma?
É tudo junto.

O poder supremo do Dai Maou é manipular energia demoníaca.
O do programador:
manipular datasets compartilhados sem derrubar o sistema.

Ambos exigem pacto.

---

🜁 3. O Castelo — o Datacenter Mental

O castelo do Dai Maou é sombrio, cheio de livros proibidos e ecos de almas perdidas.

O castelo do programador noturno é:

• um terminal 3270 piscando;

• um caderno cheio de senhas riscadas;

• um monitor com tabs de JCLs ancestrais;

• e uma luminária queimada desde 2017.

Ali, no silêncio absoluto da madrugada, nasce o feitiço supremo:

/REPRO JOB .........................
/* NÃO MEXER - SÓ RODA EM PRODUÇÃO /

Pergunte para qualquer veterano:
esse é o verdadeiro grimório proibido.

---

🜄 4. A Solidão Épica — o fardo do soberano

Assim como o Dai Maou governa sozinho,
o programador das 3h enfrenta batalhas com a mesma solidão trágica:

• ninguém responde no Teams,

• o on-call sumiu,

• o líder mandou “boa sorte 👍” e voltou a dormir,

• a documentação está quase correta (e essa é a pior parte),

• e a única testemunha da batalha é um café de micro-ondas.

Essa solidão é o preço do poder.
E ambos aceitam.

---

🜂 5. A Aura — o respeito quando o sol nasce

Quando o Dai Maou aparece, o mundo treme.

Quando o programador aparece às 9h com olheira preta e cara de “revivi três vezes esta noite”, as pessoas desviam o olhar.
Há uma reverência natural.

E o diálogo é sempre o mesmo:

— Nossa, você veio hoje?
— Sistema voltou às 4h.
— Nossa, obrigado!

Ninguém comenta muito.
Ninguém pergunta detalhes.
É tabu.
É sagrado.

---

🜃 6. Fofoquices Demoníacas do Mundo Corporativo

(Se tem Bellacosa, tem fofura sombria.)

• Há empresas onde o programador noturno é chamado informalmente de “O senhor das trevas”.

• Em equipes mais jovens, virou moda dizer “fulano é o Maou do CICS”.

• Em grupos de zap, rola o sticker: “Chamem o Dai Maou — o batch caiu!”

• Alguns dizem que quando um job dá RC=0012 sem motivo, é porque o Dai Maou interior do programador está testando sua fé.

---

🜁 7. Conclusão — O Verdadeiro Significado

O Dai Maou, no fundo, é um arquétipo do poder solitário, da responsabilidade inevitável, do peso de manter o mundo girando.

Assim como o programador da madrugada.

Ambos são:

• temidos,

• respeitados,

• incompreendidos,

• e absolutamente essenciais.

Quando tudo falha,
quando ninguém sabe o que fazer,
quando o caos ameaça o reino…

é ele que surge,
cansado, mal-humorado, com café na mão,
mas capaz de restaurar a ordem no mundo.

Por isso, querido leitor,
deixo aqui meu mantra:

Dai Maou não é inimigo.
É guardião.
É mantenedor.
É o programador que salva o sistema quando todos estão dormindo.

E é por isso que, no universo do mainframe —
assim como nas lendas —
a noite pertence aos poderosos.

 

COBOL Estruturado: disciplina, elegância e sobrevivência no mundo mainframe

Ao melhor estilo Bellacosa Mainframe, direto dos porões do CPD para o El Jefe Midnight Lunch

---

☕ Introdução: quando o COBOL aprendeu a pensar

Durante décadas, o COBOL foi injustamente carimbado como uma linguagem verborrágica, rígida e cheia de GOTOs selvagens pulando de parágrafo em parágrafo como gremlins em madrugada de fechamento mensal. O COBOL estruturado surge justamente como a vacina contra esse caos.

Mais do que uma evolução sintática, COBOL estruturado é postura, disciplina mental e, acima de tudo, respeito ao próximo programador — normalmente você mesmo daqui a 6 meses.

---

🧠 O que é COBOL Estruturado, afinal?

COBOL estruturado é a aplicação dos princípios da programação estruturada ao COBOL clássico:

• Nada de saltos caóticos com GO TO

• Fluxo lógico previsível

• Blocos com início, meio e fim bem definidos

Ele se apoia em três pilares universais:

1. Sequência – código executado em ordem natural

2. Seleção – decisões claras (IF, EVALUATE)

3. Iteração – repetição controlada (PERFORM UNTIL, PERFORM VARYING)

Se você domina isso, domina qualquer código mainframe.

---

📜 Por que o COBOL estruturado é mais legível?

Porque ele conta uma história.

Compare:

• Parágrafos pequenos e objetivos

• END-IF, END-PERFORM explícitos

• Nomes semânticos (CALCULA-TOTAL, VALIDA-CPF)

O código deixa de ser um labirinto e vira um manual técnico executável.

💡 Dica Bellacosa: se o código parece um romance russo, algo está errado.

---

🛠️ Passo a passo para escrever COBOL estruturado

1️⃣ Planeje antes de codar

Desenhe o fluxo:

• O que entra?

• Quais decisões existem?

• Onde o processamento termina?

2️⃣ Quebre tudo em parágrafos pequenos

Um parágrafo = uma responsabilidade.

Errado:

• PROCESSA-TUDO

Certo:

• LE-ARQUIVO

• VALIDA-DADOS

• CALCULA-VALORES

• GRAVA-SAIDA

3️⃣ Use PERFORM como se fosse uma chamada de função

PERFORM VALIDA-DADOS
PERFORM CALCULA-TOTAL

Isso é COBOL estruturado em sua forma mais pura.

4️⃣ Elimine GO TO (sem dó)

Se você precisa de GO TO, provavelmente:

• O parágrafo está grande demais

• O fluxo está mal pensado

---

🧪 Segredos que veteranos não contam

🔹 Menos é mais: COBOL estruturado prefere muitos parágrafos pequenos a poucos gigantes.

🔹 IF aninhado demais é cheiro de problema: use EVALUATE.

🔹 Comentários explicam o porquê, não o como:

* Validação exigida pelo Bacen após incidente de 2009

🔹 Código bem estruturado envelhece melhor que documentação externa.

---

🧾 Curiosidades de bastidor (fofoca técnica)

• O impulso pela programação estruturada veio forte nos anos 70, após sistemas críticos se tornarem impossíveis de manter.

• Grandes bancos só aceitaram novas rotinas COBOL sem GO TO.

• Há sistemas em produção hoje que seguem padrões estruturados criados nos anos 80 — e funcionam melhor que muito microserviço moderno.

---

🥚 Easter Eggs do mundo mainframe

🕵️‍♂️ Já reparou que muitos sistemas usam parágrafos chamados MAIN-PARA ou 0000-INICIO? Isso é herança direta da transição do COBOL não estruturado.

🐘 Alguns compiladores modernos avisam quando você usa GO TO. É o mainframe te julgando silenciosamente.

☕ Programadores COBOL estruturado costumam dormir melhor em fechamento contábil.

---

✅ Boas práticas Bellacosa Mainframe (anote!)

✔ Um parágrafo não deve passar de uma tela
✔ Nomeie tudo com significado de negócio
✔ Prefira EVALUATE a IF encadeado
✔ Evite variáveis globais desnecessárias
✔ Código deve ser lido como um roteiro lógico

---

🌙 Conclusão: COBOL estruturado não é velho — é sábio

COBOL estruturado é como um bom uísque: não precisa de modinha, precisa de respeito. Ele entrega previsibilidade, estabilidade e clareza — exatamente o que sistemas críticos exigem.

No fim das contas, não é sobre COBOL.
É sobre engenharia, disciplina e responsabilidade.

E como todo bom código mainframe…

Ele não faz barulho. Ele simplesmente funciona.

— Bellacosa Mainframe, servido à meia-noite no El Jefe Midnight Lunch 🌙