Machine & Deep Learning

Comece com Python scikit-learn: seu primeiro passo concreto hoje

Python scikit Learn : o essencial em um artigo — código real, diagramas e etapas concretas, extratos de um curso de 33 lições.

REHOUMA Haythem

12 Jun 2026 • 12 min read

A melhor forma de aprender Python scikit Learn é fazendo. Este artigo te dá o pontapé inicial com trechos práticos extraídos de um curso de 33 lições — o suficiente para obter um primeiro resultado já hoje.

tl;dr

Introdução e instalação
Fundamentos de Machine Learning
Pré-processamento dos dados
Regressão supervisionada
Classificação supervisionada

~$ cat ./parcours.md # Python scikit Learn — 10 capítulos

Introdução e instalação

→ O que é machine learning ?→ Instalar scikit-learn e o ecossistema+ 1 mais lições

Bases do Machine Learning

→ Vocabulário ML — features, labels, overfitting→ A API uniforme de scikit-learn+ 1 mais lições

Pré-processamento dos dados

→ Valores ausentes e imputação→ Codificação de variáveis categóricas+ 2 mais lições

Regressão supervisionada

→ Regressão linear e regularização→ Árvores e RandomForest para regressão+ 1 mais lições

Classificação supervisionada

→ Regressão logística→ k-NN e SVM+ 2 mais lições

Aprendizado não supervisionado

→ Clustering — K-Means, DBSCAN, Agglomerative→ Escolher o K ideal+ 1 mais lições

Redução de dimensionalidade

→ PCA — componentes principais→ t-SNE e UMAP — visualização não linear+ 1 mais lições

Validação e hiperparâmetros

→ Validação cruzada→ GridSearchCV e RandomizedSearchCV+ 1 mais lições

🏁

Projeto final (+ 2 capítulos no caminho)

→ Você sai com um projeto concreto e demonstrável

Primeiro modelo em 10 linhas (Iris)

NOTEObjetivo — Realizar seu primeiro modelo de machine learning end-to-end em menos de 10 linhas de código, no dataset histórico iris.

O dataset Iris

150 flores de íris distribuídas em 3 espécies (setosa, versicolor, virginica). 4 features medidas: comprimento e largura das sépalas e pétalas.

output

from sklearn.datasets import load_iris

iris = load_iris()
print("Features :", iris.feature_names)
print("Classes :", iris.target_names)
print("Shape X :", iris.data.shape)   # (150, 4)
print("Shape y :", iris.target.shape) # (150,)

O código completo (10 linhas)

output

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

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

model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)
score = model.score(X_test, y_test)
print(f"Accuracy : {score:.2%}")  # ~96.7%

É só isso. Você acabou de criar um modelo de classificação que distingue 3 espécies de íris com ~97% de precisão.

Decodificação linha por linha

Linha	Função
`load_iris(return_X_y=True)`	Carrega X (features) e y (labels) diretamente
`train_test_split(...)`	Divide 80% train / 20% test
`random_state=42`	Reprodutibilidade (sempre a mesma divisão)
`KNeighborsClassifier(...)`	Escolha do algoritmo: k-NN com k=5
`model.fit(...)`	Treinamento: memoriza os exemplos
`model.score(...)`	Avalia a acurácia no teste

Fazer uma previsão em uma nova flor

output

import numpy as np

# Uma flor: sépala 5.1 x 3.5, pétala 1.4 x 0.2
nouvelle_fleur = np.array([[5.1, 3.5, 1.4, 0.2]])
prediction = model.predict(nouvelle_fleur)

print("Predit :", iris.target_names[prediction[0]])
# > 'setosa'

# Probabilidades para cada classe
proba = model.predict_proba(nouvelle_fleur)
print("Probabilites :", proba)
# > [[1.0, 0.0, 0.0]]  -> 100% setosa

Visualizar o resultado

output

import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# Verdadeiros rótulos
axes[0].scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap="viridis")
axes[0].set_title("Vraies classes")
axes[0].set_xlabel("Longueur sepale")
axes[0].set_ylabel("Largeur sepale")

# Previsões
predictions = model.predict(X_test)
axes[1].scatter(X_test[:, 0], X_test[:, 1], c=predictions, cmap="viridis")
axes[1].set_title("Predictions du modele")
axes[1].set_xlabel("Longueur sepale")

plt.tight_layout()
plt.show()

O padrão fit / predict / score

TIPAPI uniforme — Esta estrutura (fit → predict → score) é a mesma para TODOS os modelos scikit-learn. Uma vez aprendida, você pode testar 30 algoritmos alterando apenas o import.

output

# Mesmo código, modelo diferente:
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)
print(model.score(X_test, y_test))

# Mesmo código, mais um:
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
print(model.score(X_test, y_test))

Boas práticas desde o início

WARNINGArmadilha — No iris, quase tudo funciona muito bem (97%). É um dataset de brinquedo. Na vida real, você vai sofrer mais — e isso é normal!

Desafio prático

TIPExercício — Pegue o código de 10 linhas e:

Teste 3 algoritmos diferentes (KNN, DecisionTree, RandomForest)
Varie random_state e observe se o score muda
Teste k=1 e depois k=10 no KNeighborsClassifier

Salvar um modelo em produção

NOTEObjetivo — Persistir um modelo treinado e recarregá-lo depois (API, batch, monitoramento).

joblib : o método recomendado

output

import joblib

# Salvar
joblib.dump(pipe, "model.joblib")

# Carregar
loaded_pipe = joblib.load("model.joblib")
preds = loaded_pipe.predict(X_new)

Com compressão

output

# Nível 0 (rápido) a 9 (compressão máxima)
joblib.dump(pipe, "model.joblib.gz", compress=3)
loaded = joblib.load("model.joblib.gz")

pickle (alternativa)

output

import pickle

with open("model.pkl", "wb") as f:
    pickle.dump(pipe, f)

with open("model.pkl", "rb") as f:
    pipe = pickle.load(f)

WARNINGjoblib vs pickle — joblib é mais eficiente para grandes arrays NumPy (o que caracteriza o sklearn). pickle continua compatível com todo Python.

Produção : empacotamento completo

output

import joblib
import sklearn
import numpy as np

# Salvar modelo + metadados
artifact = {
    "model": pipe,
    "feature_names": feature_names,
    "target_names": target_names,
    "sklearn_version": sklearn.__version__,
    "numpy_version": np.__version__,
    "training_date": "2026-05-15",
    "metrics": {"f1": 0.94, "auc": 0.97}
}
joblib.dump(artifact, "model_v1.joblib")

API FastAPI mínima

output

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI()
artifact = joblib.load("model_v1.joblib")
model = artifact["model"]

class Input(BaseModel):
    features: list[float]

@app.post("/predict")
def predict(data: Input):
    pred = model.predict([data.features])
    proba = model.predict_proba([data.features])[0].tolist()
    return {"prediction": int(pred[0]), "probabilities": proba}

Versionar com MLflow

output

import mlflow
import mlflow.sklearn

with mlflow.start_run():
    pipe.fit(X_tr, y_tr)
    
    # Registrar params, métricas, modelo
    mlflow.log_params({"max_depth": 10, "n_estimators": 200})
    mlflow.log_metric("f1", 0.94)
    mlflow.sklearn.log_model(pipe, "model", registered_model_name="my_model")

O que é machine learning?

NOTEObjetivo — Compreender o que é machine learning, distinguir as 3 grandes famílias (supervisionado / não supervisionado / reforço) e saber quando usar ML versus uma lógica clássica.

Definição pragmática

O machine learning (ou aprendizado de máquina) consiste em construir um programa que aprende a executar uma tarefa a partir de exemplos em vez de regras escritas manualmente.

TIPAnalogia — Ensinar uma criança a reconhecer um gato: você não dá uma regra ("o gato tem 4 patas, bigodes..."), você mostra fotos de gatos até que ela consiga generalizar.

Quando usar ML?

Problema	Abordagem
Converter Celsius em Fahrenheit	Fórmula clássica (sem ML)
Prever o preço de uma casa	ML supervisionado (regressão)
Detectar spam	ML supervisionado (classificação)
Agrupar clientes semelhantes	ML não supervisionado (clustering)
Reconhecer um rosto	Deep learning (variante de ML)
Vencer um humano no xadrez	ML por reforço

As 3 famílias de ML

1. Supervisionado

Temos dados com rótulos (X, y).

Objetivo: prever y a partir de X.

2. Não supervisionado

Temos dados sem rótulos (X sozinho).

Objetivo: descobrir estruturas ocultas.

3. Reforço

Um agente aprende por tentativa e erro em um ambiente.

Objetivo: maximizar uma recompensa.

Exemplos concretos por família

Supervisionado — Regressão

output

# X: área do imóvel, nº de quartos, bairro...
# y: preço de venda (número)
# Objetivo: prever o preço de uma nova casa

Supervisionado — Classificação

output

# X: conteúdo do e-mail
# y: "spam" ou "não-spam" (categoria)
# Objetivo: classificar um novo e-mail

Não supervisionado — Clustering

output

# X: compras dos clientes (valor, frequência...)
# Sem y
# Objetivo: agrupar em 3-5 segmentos de clientela

O fluxo de trabalho típico de um projeto ML

WARNINGArmadilha comum — 80% do tempo real de um projeto ML é dedicado às etapas 2-4 (dados), não ao treinamento. Essa é a realidade versus a imagem hollywoodiana.

Por que scikit-learn?

va-plus-loin

Este artigo cobre os trechos mais úteis — o curso completo Python scikit Learn (10 capítulos, 33 lições, exercícios corrigidos e projeto final) leva você até o fim.

./acceder-au-cours-complet curso gratuito: Maîtriser Claude Code

FAQ

Quanto tempo para aprender Python scikit Learn?

Com uma progressão estruturada (10 capítulos, 33 lições curtas e práticas), você atinge um nível operacional em algumas semanas dedicando 30 a 60 minutos por dia. O importante é praticar cada conceito imediatamente.

Precisa de pré-requisitos?

Básicos de informática são suficientes. Se você sabe usar um terminal e ler código simples, está pronto.

Por onde começar na prática?

Reproduza os comandos deste artigo e depois siga o curso completo Python scikit Learn: ele encadeia as 33 lições em ordem, com exercícios e projeto final.

./a-lire-aussi

→ Lance-toi en Machine Learning Débutants : ton premier pas concret aujourd'hui → Machine Learning Simplifié en pratique : le code et les commandes qui comptent vraiment → Apprentissage Automatique Python : les 9 étapes clés pour passer de zéro à opérationnel

📬 Você quer receber este tipo de guia toda semana? Inscreva-se gratuitamente — código real, zero enrolação.

Primeiro modelo em 10 linhas (Iris)

O dataset Iris

O código completo (10 linhas)

Decodificação linha por linha

Fazer uma previsão em uma nova flor

Visualizar o resultado

O padrão fit / predict / score

Boas práticas desde o início

Desafio prático

Salvar um modelo em produção

joblib : o método recomendado

Com compressão

pickle (alternativa)

Produção : empacotamento completo

API FastAPI mínima

Versionar com MLflow

O que é machine learning?

Definição pragmática

Quando usar ML?

As 3 famílias de ML

1. Supervisionado

2. Não supervisionado

3. Reforço

Exemplos concretos por família

Supervisionado — Regressão

Supervisionado — Classificação

Não supervisionado — Clustering

O fluxo de trabalho típico de um projeto ML

Por que scikit-learn?

FAQ

Stay up to date