Bellacosa Mainframe do jcl ao json laboratorio pratico

🧪 LABORATÓRIO — DO JCL AO JSON

🐍 Missão: Dominar dados reais com Python

👉 Formato: desafios práticos
👉 Nível: iniciante → intermediário
👉 Ideal para 1–2 dias de hands-on
👉 Pode virar curso ou workshop

---

🔹 BLOCO 1 — Arquivos (I/O)

🧩 Desafio 1 — Leitor de arquivo sequencial

Crie um programa que:

• Leia clientes.txt
• Mostre número total de linhas
• Mostre a primeira e última linha

💡 Analog: processamento sequencial COBOL

---

🧩 Desafio 2 — Contador de registros válidos

Arquivo contém linhas vazias e comentários iniciados por #.

Conte apenas registros válidos.

---

🧩 Desafio 3 — Gerador de arquivo batch

Crie um arquivo relatorio.txt contendo:

• Data/hora atual
• Total de registros processados
• Status “OK”

---

🧩 Desafio 4 — Conversor TXT → CSV

Entrada:

123;Ana;1200
456;João;950

Produza um CSV com cabeçalho.

---

🧩 Desafio 5 — Copiador com filtro

Copie transacoes.txt para aprovadas.txt
apenas registros com valor > 1000.

---

🔹 BLOCO 2 — Pandas (Dados tabulares)

🧩 Desafio 6 — Carregar dataset

Use Pandas para:

• Ler um CSV
• Mostrar as 5 primeiras linhas
• Mostrar número de registros

---

🧩 Desafio 7 — Filtro de negócios

Mostre apenas clientes com saldo > 1000.

Ordene por saldo decrescente.

---

🧩 Desafio 8 — Estatísticas rápidas

Calcule:

• Média do saldo
• Máximo
• Mínimo
• Total

---

🧩 Desafio 9 — Agrupamento

Agrupe clientes por cidade e conte quantos há em cada uma.

💡 Similar a GROUP BY

---

🧩 Desafio 10 — Pipeline batch moderno

Leia um CSV → filtre → salve novo CSV com resultados.

---

🔹 BLOCO 3 — NumPy (Processamento numérico)

🧩 Desafio 11 — Operações vetoriais

Crie dois arrays e calcule:

• Soma elemento a elemento
• Produto elemento a elemento
• Produto escalar

---

🧩 Desafio 12 — Matriz de desempenho

Simule vendas por região:

• Matriz 3×4
• Calcule totais por linha e coluna

---

🔹 BLOCO 4 — APIs (Integração moderna)

🧩 Desafio 13 — Consumidor de API

Use uma API pública (ex.: cotação de moedas).

Exiba:

• Valor atual
• Data/hora
• Fonte

💡 Biblioteca: requests

---

🧩 Desafio 14 — API → DataFrame

Obtenha dados JSON de uma API e:

• Converta para Pandas
• Mostre estatísticas
• Salve em CSV

---

🔹 BLOCO 5 — Web Scraping

🧩 Desafio 15 — Minerador de dados web

Extraia dados de uma página pública:

• Títulos de notícias OU
• Tabela da Wikipedia

Salve em arquivo estruturado.

💡 Bibliotecas:

requests
BeautifulSoup
pandas.read_html()

---

🏆 DESAFIO EXTRA (Modo Arquitetura)

🔥 Mega-missão — Pipeline completo

Construa um fluxo:

👉 Coletar dados de API
👉 Complementar com dados de arquivo local
👉 Processar com Pandas
👉 Salvar resultado final

💥 Isso simula um ETL moderno.

---

🎯 O que você dominará ao concluir

✔ Manipulação de arquivos
✔ Processamento tabular
✔ Computação numérica
✔ Integração com sistemas externos
✔ Coleta de dados da web
✔ Data pipelines
✔ Base para Data Science

---

🚀 Tradução para linguagem mainframe

Arquivos → Dataset sequencial

Pandas → DB2 em memória

NumPy → cálculo científico

APIs → integração online

Scraping → coleta automática

 

Bellacosa Mainframe apresenta a biblioteca matematica do Python

🔥 NumPy: O “PACKED DECIMAL” do Python que Vai Explodir sua Cabeça COBOL

Se você veio do mundo COBOL, onde cada byte importa, cada campo tem propósito e cada processamento precisa ser eficiente… então prepare-se: você está prestes a conhecer o coração matemático do Python — a biblioteca NumPy.

E sim… ela é MUITO mais próxima do seu mundo do que você imagina.

---

☕ O choque de realidade: Python puro vs processamento “mainframe-like”

No COBOL, você já sabe:

• COMPUTE é rápido
• PERFORM VARYING é controlado
• Estruturas são previsíveis

Agora veja isso no Python “cru”:

lista = [1, 2, 3, 4]
resultado = [x * 2 for x in lista]

Funciona… mas não é exatamente eficiente nível mainframe, certo?

Agora entra o NumPy:

import numpy as np

array = np.array([1, 2, 3, 4])
resultado = array * 2

💥 BOOM.

Você acabou de fazer processamento vetorial, algo muito mais próximo de um:

“loop implícito otimizado em assembler por baixo dos panos”

Sim… isso cheira a z/Architecture.

---

🧠 Origem: quando cientistas reinventaram o “processamento batch”

O NumPy nasceu oficialmente em 2006, mas sua raiz vem de duas bibliotecas:

• Numeric
• Numarray

Ambas criadas para resolver um problema clássico:

“Python era bom… mas lento para matemática pesada”

A fusão virou NumPy — e trouxe um conceito poderoso:

👉 Arrays homogêneos de alta performance

Se você pensa em:

• tabelas VSAM
• buffers de memória
• áreas de trabalho

Você já entendeu metade do NumPy.

---

⚙️ O conceito que muda tudo: ndarray

O coração do NumPy é o ndarray (N-dimensional array).

Pense nisso como:

COBOL	NumPy
OCCURS	array
PIC 9(5)V99	dtype=float64
Tabela indexada	ndarray
Área contígua memória	buffer otimizado

Exemplo:

import numpy as np

dados = np.array([10, 20, 30])
print(dados * 2)

Saída:

[20 40 60]

Sem loop explícito. Sem PERFORM.

👉 Isso é chamado de vectorization.

---

🚀 Performance: aqui mora o espírito do mainframe

NumPy é rápido porque:

• Escrito em C (baixo nível)
• Usa operações vetorizadas
• Evita overhead de loops Python

📌 Tradução para o mundo COBOL:

“Você está rodando um SORT interno com exit em assembler… sem escrever assembler.”

---

🔍 Curiosidades que todo coboleiro vai amar

🧩 1. NumPy evita loops como você evita GO TO

Loops em Python são lentos.

NumPy resolve isso com operações vetoriais:

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

print(a + b)

Resultado:

[5 7 9]

👉 Isso é equivalente a um loop automático altamente otimizado.

---

🧠 2. Broadcasting: o PERFORM invisível

a = np.array([1,2,3])
print(a + 10)

Resultado:

[11 12 13]

Sem loop. Sem stress.

👉 O NumPy “espalha” o valor automaticamente.

---

🏎️ 3. Memória contígua = performance absurda

Diferente de listas Python, NumPy usa:

• memória contínua
• tipos fixos

👉 Isso lembra:

• buffers de I/O
• áreas de WORKING-STORAGE bem definidas

---

🧪 Exemplos práticos (modo COBOL mindset ON)

📊 Soma de um dataset

COBOL:

PERFORM VARYING I FROM 1 BY 1 UNTIL I > 100
   ADD VALOR(I) TO TOTAL
END-PERFORM

NumPy:

np.sum(array)

💥 1 linha. Otimizado. Vetorizado.

---

📈 Média (sem reinventar roda)

np.mean(array)

👉 Nada de controle manual. Nada de variáveis acumuladoras.

---

🔄 Transformação em massa

array * 1.15

👉 Isso é literalmente um:

“REDEFINES aplicado em lote com COMPUTE automático”

---

🧠 Easter Eggs e detalhes escondidos

🥚 1. O tipo float64 é padrão

👉 Isso significa precisão alta — quase como trabalhar com campos bem definidos no COBOL financeiro.

---

🥚 2. Você pode acessar o “layout de memória”

array.strides

👉 Sim… você pode ver como os dados estão distribuídos na memória.

Isso é nível:

“debug de storage layout no mainframe”

---

🥚 3. NumPy conversa com C diretamente

👉 Isso permite integrar com código de baixo nível.

Ou seja:

Python vira quase um “COBOL com superpoderes científicos”

---

⚔️ NumPy vs Python puro (visão mainframe)

Aspecto	Python puro	NumPy
Performance	Baixa	Altíssima
Tipagem	Dinâmica	Estática (dtype)
Memória	Fragmentada	Contígua
Loop	Manual	Vetorizado
Estilo	Script	Científico / batch-like

---

🌍 Onde isso entra na sua evolução?

Se você domina COBOL, NumPy é uma ponte natural para:

• 📊 Data Science
• 🤖 Machine Learning
• 📈 Analytics de alto volume
• 🧮 Simulações financeiras

E mais importante:

👉 Você não começa do zero
👉 Você reaproveita seu mindset de performance

---

🎯 Conclusão: o despertar do coboleiro moderno

NumPy não é só uma biblioteca.

É uma mudança de paradigma.

É quando você percebe que:

“O Python pode ser tão performático quanto um batch bem escrito — se você usar as ferramentas certas.”

E aqui vai a provocação final:

🔥 Se COBOL é o rei do processamento estruturado…
🔥 NumPy é o motor matemático que pode levar você além do mainframe.

 

Bellacosa Mainframe comenta sobre as Bibliotecas do Python

🔥 “IMPORT QUEBRANDO O JCL: As Bibliotecas Python que TODO COBOL Developer Precisa Conhecer (Antes que Seja Tarde!)”

Se você viveu anos dominando COBOL, JCL, SORT, VSAM e DB2, prepare-se: no mundo Python, tudo começa com uma única instrução que parece inocente… mas carrega um poder absurdo:

import alguma_coisa

Sim… o famoso IMPORT é o equivalente moderno do seu EXEC PGM=, do seu CALL, do seu COPYBOOK — só que MUITO mais flexível, dinâmico e (às vezes) até perigoso 😏

Hoje você vai conhecer as principais bibliotecas Python — no estilo Bellacosa Mainframe — com história, analogias com o mundo z/OS, exemplos práticos e até alguns easter eggs escondidos 👀

---

🧠 O que é o import para um COBOL Developer?

Antes de sair listando bibliotecas, vamos traduzir:

COBOL / Mainframe	Python
COPYBOOK	import module
CALL program	import + função
JCL EXEC	execução via script
STEPLIB	sys.path
Load Module	pacote instalado

👉 Em Python, tudo é módulo.
👉 E cada módulo é carregado com import.

---

🚀 1. math — O “COMPUTE TURBO” do Python

📜 Origem

Biblioteca padrão do Python, baseada na linguagem C. É tão antiga quanto o próprio Python (criado por Guido van Rossum nos anos 90).

💡 Analogia Mainframe

É o seu COMPUTE, só que com superpoderes científicos.

🔧 Exemplo

import math

print(math.sqrt(144))  # 12
print(math.pi)         # 3.14159...

🥚 Easter Egg

import this

💥 NÃO é math… mas imprime o Zen do Python (leitura obrigatória!)

---

📊 2. pandas — O “SORT + ICETOOL + FILE-AID” em Esteroides

📜 Origem

Criado por Wes McKinney enquanto trabalhava com dados financeiros.

💡 Analogia Mainframe

👉 É o seu DFSORT + ICETOOL + JOINKEYS + relatório… tudo junto!

🔧 Exemplo

import pandas as pd

df = pd.read_csv("clientes.csv")
print(df.head())

🤯 Poder real

• JOIN de arquivos → 1 linha
• GROUP BY → instantâneo
• Filtros → estilo SQL

---

🔢 3. numpy — O “PACKED DECIMAL do Futuro”

📜 Origem

Baseado em bibliotecas matemáticas de alto desempenho (Fortran/C).

💡 Analogia Mainframe

👉 Pense em campos COMP-3 vetorizados absurdamente rápidos

🔧 Exemplo

import numpy as np

arr = np.array([1, 2, 3])
print(arr * 10)

⚡ Destaque

Operações são feitas em lote — como um SORT interno ultrarrápido.

---

🌐 4. requests — O “CICS + HTTP” Simplificado

📜 Origem

Criada para substituir a complexidade do urllib.

💡 Analogia Mainframe

👉 Um EXEC CICS WEB RECEIVE/SEND moderno

🔧 Exemplo

import requests

res = requests.get("https://api.github.com")
print(res.status_code)

🤯 Impacto

Hoje, integrar sistemas virou algo trivial com essa lib.

---

🗂️ 5. os — O “IDCAMS + TSO + ISPF” do Python

📜 Origem

Parte do core do Python — interface direta com o sistema operacional.

💡 Analogia Mainframe

👉 Mistura de:

• TSO commands
• IDCAMS
• JCL utilities

🔧 Exemplo

import os

print(os.getcwd())
os.mkdir("novo_diretorio")

---

⏱️ 6. datetime — O “DATE ROUTINE” sem dor

💡 Analogia Mainframe

👉 Chega de manipular data com substring 😅

🔧 Exemplo

from datetime import datetime

agora = datetime.now()
print(agora)

---

🤖 7. scikit-learn — O “AI Batch Job”

📜 Origem

Biblioteca de Machine Learning open source.

💡 Analogia Mainframe

👉 Um JOB que aprende sozinho com os dados 😳

🔧 Exemplo

from sklearn.linear_model import LinearRegression

---

📈 8. matplotlib — O “PRINT + GRAPHICS” moderno

💡 Analogia Mainframe

👉 Seus relatórios… só que agora VISUAIS

🔧 Exemplo

import matplotlib.pyplot as plt

plt.plot([1,2,3], [4,5,6])
plt.show()

---

🧪 9. random — O “TEST DATA GENERATOR”

🔧 Exemplo

import random

print(random.randint(1, 100))

👉 Perfeito para gerar massa de testes (adeus planilhas fake!)

---

🔥 10. sys — O “JCL PARM + REGION + EXEC CONTROL”

💡 Analogia Mainframe

👉 Controle total do runtime

🔧 Exemplo

import sys

print(sys.version)

---

🧠 Curiosidades que vão explodir sua cabeça COBOL

• Python tem biblioteca para TUDO — literalmente
• Você pode criar sua própria lib (tipo um COPYBOOK inteligente)
• O import pode ser dinâmico (isso assusta qualquer programador batch 😅)

__import__("math")

---

⚠️ Anti-pattern que COBOL Dev costuma fazer

❌ Escrever tudo em um único script (tipo programa monolítico COBOL)
✅ Em Python → modularize tudo com import

---

🎯 Conclusão: O verdadeiro SHIFT mental

Se no mainframe você pensa em:

👉 Programas
👉 Jobs
👉 Steps

No Python você precisa pensar em:

👉 Módulos
👉 Bibliotecas
👉 Ecossistema

---

☕ Mensagem final estilo Bellacosa

Python não é só uma linguagem…

É um ecossistema onde o poder está no import.

Se você domina as bibliotecas…
Você não escreve código — você orquestra soluções.

🔥 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.”