Translate

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

quinta-feira, 26 de março de 2026

🧪 LABORATÓRIO — DO JCL AO JSON

 

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


sexta-feira, 20 de fevereiro de 2026

🔥 “Pandas: O ‘SORT’ do Python que Vai Fazer Você Repensar Tudo que Sabe sobre Arquivos Sequenciais”

 

Bellacosa Mainframe apresenta Pandas a Biblioteca poderosa do Python

🔥 “Pandas: O ‘SORT’ do Python que Vai Fazer Você Repensar Tudo que Sabe sobre Arquivos Sequenciais”


Se você vem do mundo COBOL, prepare-se: este não é apenas mais um artigo sobre Python.

É um choque de paradigma.

É como sair do SORT FIELDS=(...) no JCL e descobrir que você pode fazer tudo isso… e mais… em uma única linha de código.

Hoje vamos falar da biblioteca pandas — mas no estilo Bellacosa Mainframe: com história, bastidores, comparações práticas com COBOL, exemplos reais e até alguns easter eggs que vão te surpreender.


☕ 1. A Origem do Pandas — Não, Não Tem Nada a Ver com o Animal 🐼

O nome pandas vem de:

PANel DAta Structure

Criada em 2008 por Wes McKinney, a biblioteca nasceu dentro de um problema real:

👉 manipular dados financeiros de forma eficiente (algo que qualquer sistema em COBOL faz há décadas).

Ou seja…

💡 Pandas nasceu resolvendo problemas que você já resolve no mainframe.

A diferença?

👉 Ele fez isso com uma abordagem muito mais dinâmica e interativa.


🧠 2. O “choque cultural” para quem vem do COBOL

Se você trabalha com:

  • Arquivos VSAM
  • Sequential files
  • SORT / ICETOOL
  • DFSORT
  • DB2 queries

Então o pandas vai parecer… estranho no começo.

Mas depois:

🔥 viciante

Veja essa comparação:

COBOL / JCLPandas
SORT FIELDSsort_values()
READ FILEread_csv()
WRITE FILEto_csv()
IF / EVALUATEfiltros (query / loc)
FILE LAYOUTDataFrame

👉 O DataFrame é o seu novo “registro + tabela + dataset + tudo junto”


📊 3. O coração do Pandas: DataFrame

Imagine isso:

01 CLIENTE.
05 ID PIC 9(05).
05 NOME PIC X(30).
05 SALDO PIC 9(10)V99.

Agora pense nisso como uma tabela inteira carregada na memória.

👉 Isso é um DataFrame

Exemplo em Python:

import pandas as pd

dados = {
"ID": [1, 2, 3],
"NOME": ["ANA", "JOAO", "CARLA"],
"SALDO": [1500.50, 230.00, 9999.99]
}

df = pd.DataFrame(dados)

print(df)

Resultado:

ID NOME SALDO
0 1 ANA 1500.50
1 2 JOAO 230.00
2 3 CARLA 9999.99

💡 Pense assim:

👉 Você carregou um arquivo inteiro na WORKING-STORAGE… mas com superpoderes.


⚡ 4. Filtrando dados — o “IF” mais poderoso que você já viu

COBOL:

IF SALDO > 1000
DISPLAY CLIENTE
END-IF

Pandas:

df[df["SALDO"] > 1000]

Sim.

Só isso.

🔥 Sem loop. Sem READ. Sem controle manual.


🔀 5. Ordenação — adeus SORT JCL?

JCL:

SORT FIELDS=(SALDO, D)

Pandas:

df.sort_values(by="SALDO", ascending=False)

👉 Em memória
👉 Instantâneo
👉 Encadeável com outras operações


🧩 6. JOIN (sim, tipo DB2)

COBOL tradicional sofre aqui…

Mas pandas:

df1.merge(df2, on="ID", how="inner")

💡 É como um:

SELECT *
FROM A, B
WHERE A.ID = B.ID

🧠 7. Agrupamento (o famoso SUM + BREAK logic)

COBOL:

  • Sort
  • Control break
  • Acumuladores
  • Mil linhas de código 😅

Pandas:

df.groupby("NOME")["SALDO"].sum()

🔥 Isso substitui um programa inteiro de batch.


🥚 8. Easter Eggs do Pandas (sim, existem!)

🐼 1. Representação visual amigável

O pandas automaticamente formata tabelas no estilo “relatório bonito”.

👉 Parece um mini-ISPF tabular 😄


🧪 2. Você pode encadear tudo

df[df["SALDO"] > 1000] \
.sort_values(by="SALDO") \
.head(2)

💡 Isso seria:

  • filtro
  • sort
  • limitar registros

👉 tudo em pipeline


🧙 3. Pandas aceita dados de tudo

  • CSV (sequencial)
  • Excel
  • JSON
  • SQL
  • APIs

👉 É como se o COBOL lesse qualquer formato… sem FD.


🏛️ 9. Curiosidade histórica (nível mainframe)

Enquanto o mundo distribuído evoluía…

👉 o mainframe já fazia:

  • processamento massivo
  • batch
  • ETL
  • consistência

O pandas basicamente trouxe essa filosofia para o mundo Python.

💡 Em outras palavras:

Pandas é o “mini-mainframe” do desenvolvedor moderno


🚀 10. Onde isso muda sua carreira

Se você domina COBOL e aprende pandas:

🔥 você vira um profissional híbrido raríssimo

Você passa a atuar em:

  • Engenharia de dados
  • Data analytics
  • Integração legado + moderno
  • Automação de processos batch fora do mainframe

👉 E o melhor:

Você não joga fora seu conhecimento COBOL.

Você expande ele.


🧠 11. Mentalidade nova (o pulo do gato)

COBOL:

👉 Processamento linha a linha

Pandas:

👉 Processamento em conjunto (vetorizado)

Esse é o maior shift.


☕ Conclusão no estilo Bellacosa

Se o COBOL te ensinou disciplina…

Se o JCL te ensinou controle…

Se o SORT te ensinou performance…

Então o pandas vai te ensinar:

🔥 liberdade

Mas cuidado…

Depois que você fizer um groupby().sum() em uma linha…

👉 você nunca mais vai olhar um control-break da mesma forma.

domingo, 1 de fevereiro de 2026

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

 

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 / MainframePython
COPYBOOKimport module
CALL programimport + função
JCL EXECexecução via script
STEPLIBsys.path
Load Modulepacote 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.


domingo, 25 de agosto de 2024

☕💣 O DIA EM QUE O ESTAGIÁRIO DESCOBRIU QUE IA NÃO É MÁGICA — E QUE 90% DOS PROJETOS DE DADOS MORREM ANTES DE CHEGAR À PRODUÇÃO

 

Bellacosa Mainframe e desafio de analisar dados com Python e Pandas

☕💣 O DIA EM QUE O ESTAGIÁRIO DESCOBRIU QUE IA NÃO É MÁGICA — E QUE 90% DOS PROJETOS DE DADOS MORREM ANTES DE CHEGAR À PRODUÇÃO

Existe uma lenda moderna circulando pelos corredores das empresas.

Ela diz que basta instalar Python, importar Pandas, rodar meia dúzia de notebooks, colocar um gráfico colorido no Power BI e, de repente, a organização inteira se transforma em uma potência orientada por dados.

É uma história bonita.

Mas também é uma das maiores mentiras tecnológicas do século XXI.

Se você trabalhou alguns anos em Mainframe, sabe exatamente do que estou falando.

No mundo z/OS, ninguém acreditava que um programa COBOL estava pronto apenas porque compilou.

No entanto, na era dos notebooks e dashboards, muita gente acredita que um projeto está concluído apenas porque o gráfico ficou bonito.

E é exatamente aí que começam os problemas.

O nascimento do caos

Todo projeto de dados começa da mesma forma.

Alguém chega com uma frase aparentemente simples:

"Precisamos analisar nossos dados."

Parece inofensivo.

Então surgem os CSVs.

Planilhas.

Arquivos Excel.

Dados extraídos de APIs.

Tabelas SQL.

Arquivos JSON.

E, inevitavelmente, aquela planilha mantida por alguém do financeiro que ninguém sabe exatamente como foi construída.

Nesse momento, o profissional de dados descobre uma verdade brutal:

Os dados do mundo real são muito mais bagunçados do que qualquer exemplo de curso.

Muito mais.

O primeiro choque: os dados estão errados

A primeira lição de qualquer analista é simples.

Nunca confie nos dados.

Jamais.

Antes de qualquer gráfico, modelo ou dashboard, existe uma etapa fundamental:

Validação.

Em Python, isso normalmente começa com:

  • head()

  • info()

  • describe()

  • isnull().sum()

Esses comandos parecem simples.

Mas eles revelam coisas assustadoras.

Colunas vazias.

Valores negativos impossíveis.

Datas inválidas.

Campos misturando texto e números.

Duplicidades.

Informações faltando.

Em outras palavras:

A realidade.

No Mainframe, chamávamos isso de saneamento de entrada.

No mundo moderno, chamam de Data Quality.

Mudou o nome.

Não mudou o problema.

O terror dos valores ausentes

Todo iniciante aprende rapidamente o significado de NaN.

E descobre que ele aparece em todos os lugares.

A coluna AGE do Titanic?

Vazia para centenas de passageiros.

A coluna CABIN?

Mais vazia que sala de reunião numa sexta-feira às 18h.

É aí que surge uma das decisões mais importantes de qualquer projeto:

O que fazer com os valores ausentes?

Ignorar?

Excluir?

Preencher?

Usar média?

Mediana?

Modelos preditivos?

Não existe resposta universal.

Existe apenas análise crítica.

Quem acredita que existe uma receita mágica para limpeza de dados provavelmente nunca colocou um modelo em produção.

O dia em que o gráfico enganou todo mundo

Depois da limpeza surge a visualização.

E aqui acontece outro fenômeno interessante.

As pessoas começam a acreditar mais no gráfico do que nos dados.

Um gráfico bonito possui um poder quase hipnótico.

Mas gráficos também mentem.

Ou melhor:

Pessoas podem usá-los para mentir.

Um eixo mal configurado.

Uma escala inadequada.

Uma agregação incorreta.

E pronto.

Uma decisão milionária pode ser tomada baseada em uma interpretação equivocada.

Por isso o profissional sério aprende rapidamente:

Visualização não substitui análise.

Ela apenas ajuda a comunicar análise.

Histograma, Boxplot e a arte de enxergar padrões

Quando começamos a explorar dados, algumas ferramentas tornam-se indispensáveis.

O histograma mostra distribuição.

O boxplot revela dispersão.

O gráfico de dispersão mostra correlações.

Parece simples.

Mas esses gráficos respondem perguntas fundamentais:

  • Onde estão os valores mais frequentes?

  • Existem outliers?

  • Existe relação entre variáveis?

  • Há comportamento anormal?

No Mainframe fazíamos isso analisando relatórios gigantescos.

Hoje fazemos isso visualmente.

Mas o objetivo continua exatamente o mesmo.

Descobrir o que os dados estão tentando nos dizer.

Python não é só Pandas

Existe outro mito muito popular.

O de que Python se resume a Pandas.

Não.

Python é um ecossistema inteiro.

Pandas organiza os dados.

Matplotlib cria gráficos.

Plotly adiciona interatividade.

Requests conversa com APIs.

SQLite armazena informações.

Pytest valida comportamentos.

Logging registra eventos.

Time mede desempenho.

Cada biblioteca resolve um problema específico.

E quando utilizadas juntas criam algo poderoso.

Uma plataforma completa de automação e análise.

O inimigo invisível chamado exceção

Se existe algo que o Mainframe ensinou bem foi respeito pelo erro.

Quem já viu um ABEND em produção entende isso.

No Python o equivalente aparece em forma de exceções.

ZeroDivisionError.

ValueError.

TypeError.

FileNotFoundError.

E muitos outros.

A diferença entre um profissional experiente e um aventureiro normalmente aparece aqui.

O aventureiro ignora erros.

O profissional os trata.

Porque sabe que sistemas reais falham.

Arquivos desaparecem.

APIs ficam indisponíveis.

Usuários digitam valores absurdos.

E o software precisa sobreviver a tudo isso.

Logs: o diário secreto da aplicação

Outro hábito herdado do Mainframe é registrar eventos.

Durante décadas operadores analisaram logs.

Hoje continuamos fazendo exatamente a mesma coisa.

Apenas mudaram as ferramentas.

Logs ajudam a responder perguntas importantes:

  • O que aconteceu?

  • Quando aconteceu?

  • Quem executou?

  • Qual foi o erro?

Sem logs, investigar falhas é praticamente arqueologia digital.

Com logs, torna-se uma análise técnica.

Por isso aplicações profissionais usam logging.

Não print.

Testes: a diferença entre coragem e imprudência

Muitos programadores confundem confiança com sorte.

"Eu executei uma vez e funcionou."

Excelente.

Mas isso não significa nada.

É por isso que testes existem.

Pytest tornou essa tarefa extremamente simples.

Uma função.

Um assert.

Uma expectativa.

Se o comportamento mudar inesperadamente, o teste acusa.

Parece básico.

Mas salva projetos inteiros.

Toda alteração relevante deveria ser seguida por nova execução dos testes.

Sempre.

Sem exceções.

Clean Code não é frescura

Existe uma resistência curiosa ao conceito de código limpo.

Algumas pessoas acreditam que o importante é funcionar.

Errado.

Código é escrito uma vez.

Mas lido centenas de vezes.

Por isso nomes descritivos importam.

Funções pequenas importam.

Modularização importa.

Organização importa.

Código confuso custa dinheiro.

Muito dinheiro.

Especialmente quando o autor original já não trabalha mais na empresa.

O poder da modularização

Projetos pequenos sobrevivem ao caos.

Projetos grandes não.

Quando o sistema cresce, modularização deixa de ser luxo.

Passa a ser necessidade.

Cada função deve possuir responsabilidade clara.

Cada módulo deve resolver um problema específico.

Cada componente deve ser reutilizável.

Isso reduz complexidade.

Facilita manutenção.

E melhora a qualidade geral do software.

Performance: a verdade aparece no cronômetro

Existe uma frase clássica:

"Premature optimization is the root of all evil."

Mas ignorar performance também é perigoso.

É por isso que medir importa.

O módulo time permite descobrir exatamente quanto tempo uma operação leva.

Sem medições, toda otimização vira chute.

Com medições, ela vira engenharia.

E engenharia sempre vence opinião.

Escalabilidade: o momento da verdade

Todo código funciona com cem registros.

O desafio começa com cem milhões.

É aí que surge a palavra escalabilidade.

Um sistema escalável consegue crescer sem colapsar.

Consegue lidar com aumento de carga.

Com aumento de volume.

Com aumento de usuários.

Projetos que ignoram escalabilidade costumam funcionar perfeitamente.

Até o dia em que deixam de funcionar.

Machine Learning não é adivinhação

Chegamos então ao assunto favorito do mercado.

Machine Learning.

Aqui surgem métricas importantes.

Precision.

Recall.

RMSE.

MAPE.

WSS.

Cada uma responde perguntas diferentes.

Precision pergunta:

"Quando o modelo disse que era positivo, quantas vezes acertou?"

Recall pergunta:

"Quantos positivos reais o modelo encontrou?"

RMSE mede erro na unidade original.

MAPE mede erro percentual.

WSS avalia dispersão em clustering.

Sem métricas, modelos são apenas opiniões sofisticadas.

Com métricas, tornam-se sistemas mensuráveis.

Storytelling: a habilidade esquecida

Existe um erro comum.

Acreditar que análise termina quando o modelo termina.

Não termina.

Na verdade, ali começa a parte mais difícil.

Comunicar resultados.

Storytelling com dados significa transformar números em narrativa.

Explicar contexto.

Mostrar padrões.

Interpretar resultados.

Demonstrar relevância.

Porque uma análise perfeita que ninguém entende possui valor próximo de zero.

Dashboards: o cockpit da empresa

Finalmente chegamos aos dashboards.

Eles não existem para serem bonitos.

Existem para acelerar decisões.

Um dashboard bem construído responde perguntas rapidamente.

Mostra indicadores críticos.

Destaca anomalias.

Facilita ações.

Quando bem feito, torna-se o painel de controle da organização.

Quando mal feito, vira apenas decoração corporativa.

A grande lição

Depois de tudo isso surge uma conclusão interessante.

A tecnologia mudou.

As ferramentas mudaram.

Os nomes mudaram.

Mas os princípios continuam os mesmos.

Validação.

Controle.

Monitoramento.

Teste.

Documentação.

Performance.

Organização.

Disciplina.

Os profissionais de Mainframe aprenderam essas lições há décadas.

E agora a nova geração de cientistas de dados está redescobrindo exatamente os mesmos conceitos.

A diferença é que hoje usamos Python.

Ontem usávamos COBOL.

Mas a verdade permanece.

Dados ruins geram decisões ruins.

Código ruim gera sistemas ruins.

Processos ruins geram resultados ruins.

E nenhuma quantidade de Inteligência Artificial consegue corrigir isso.

Porque, no final das contas, a tecnologia mais importante de qualquer projeto continua sendo a mesma desde os tempos dos cartões perfurados:

O cérebro de quem está operando a máquina.

☕💣

 


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