Introdução ao scikit-learn com Python — 2026

O scikit-learn é a biblioteca de machine learning clássico mais usada em Python. Se você já domina NumPy e Pandas, o scikit-learn é o próximo passo natural para transformar dados em previsões: classificar e-mails como spam, prever o preço de um imóvel, identificar clientes com risco de cancelamento ou agrupar produtos por similaridade.

Praticamente todo profissional brasileiro de ciência de dados passa pelo scikit-learn. A biblioteca cobre regressão, classificação, agrupamento, redução de dimensionalidade e pré-processamento, tudo com uma API consistente e fácil de testar. Neste tutorial prático, você vai treinar modelos de verdade, avaliar resultados com métricas corretas e entender o fluxo que o mercado espera. Para uma definição mais conceitual do tema, confira nossa entrada sobre machine learning no glossário; aqui o foco é colocar a mão na massa com a biblioteca.

Instalação e importação

Instale o scikit-learn com o pip:

pip install scikit-learn

Quem usa gerenciadores de pacotes modernos como o uv pode rodar uv add scikit-learn, que resolve dependências com NumPy e SciPy de forma bem mais rápida.

O scikit-learn não se importa como um bloco só. A convenção é importar cada submódulo no momento de usar:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

Essa prática mantém o código explícito e evita carregar funções que você não vai usar.

A API do scikit-learn: fit, predict e transform

O segredo do scikit-learn é a API uniforme. Quase todo objeto é um estimador com três métodos centrais:

• fit(X, y) — ajusta o modelo aos dados de entrada X (features) e, no caso supervisionado, aos alvos y.
• predict(X) — gera previsões para novos dados.
• transform(X) — usado por etapas de pré-processamento, como normalizar ou codificar variáveis.

Isso vale para uma regressão linear, uma floresta aleatória ou um normalizador: a mesma interface. Por isso, aprender bem três métodos destrava dezenas de algoritmos.

Dividindo os dados em treino e teste

Antes de treinar qualquer modelo, separe parte dos dados para avaliação. Treinar e testar no mesmo conjunto engana: o modelo pode só decorar as respostas. A função train_test_split faz isso de forma aleatória e controlada:

from sklearn.model_selection import train_test_split

X = dados.drop(columns=["alvo"])  # features
y = dados["alvo"]                  # variável que queremos prever

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

Detalhes importantes:

• test_size=0.2 reserva 20% dos dados para teste.
• random_state=42 garante reprodutibilidade — sem ele, cada execução divide diferente.
• stratify=y mantém a proporção das classes nos dois conjuntos, essencial em dados desbalanceados.

A convenção X maiúsculo (matriz de features, normalmente um DataFrame ou array 2D) e y minúsculo (vetor de alvos) é padrão em tutoriais, documentação e provas técnicas.

Primeiro modelo: classificação

Vamos classificar espécies de flores usando o dataset Iris, clássico e embutido na biblioteca:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42, stratify=iris.target
)

modelo = RandomForestClassifier(random_state=42)
modelo.fit(X_train, y_train)

previsoes = modelo.predict(X_test)
print("Acurácia:", accuracy_score(y_test, previsoes))

Para entender não só a taxa de acerto, mas onde o modelo erra, use a matriz de confusão e o relatório de classificação:

print(confusion_matrix(y_test, previsoes))
print(classification_report(y_test, previsoes, target_names=iris.target_names))

O classification_report traz precisão, revocação (recall) e F1-score por classe. Em problemas reais, acurácia sozinha engana: um modelo que acerta 95% pode ser péssimo se a classe importante aparece em só 5% dos dados. Revocação e F1 mostram esse viés.

Regressão: prevendo números contínuos

Quando o alvo é um número contínuo (preço, temperatura, tempo), usamos regressão. As métricas mudam: em vez de acurácia, avaliamos erro médio quadrático (MSE) e o coeficiente de determinação (R²):

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# Exemplo sintético: área (m²) e preço (R$ mil) de imóveis
area = np.array([[35], [50], [62], [80], [100], [120], [45], [75], [90], [110]])
preco = np.array([180, 240, 310, 420, 520, 610, 220, 380, 470, 560])

X_train, X_test, y_train, y_test = train_test_split(
    area, preco, test_size=0.3, random_state=42
)

reg = LinearRegression()
reg.fit(X_train, y_train)
previsoes = reg.predict(X_test)

print("MSE:", mean_squared_error(y_test, previsoes))
print("R²:", r2_score(y_test, previsoes))
print("Preço por m²:", reg.coef_[0])

O R² varia de 0 a 1 e indica quanto da variação do alvo o modelo explica. Um R² de 0,90 significa que 90% da variação no preço é capturada pela área. Para relações mais complexas, troque LinearRegression por RandomForestRegressor ou GradientBoostingRegressor, sem mudar o restante do código.

Pipeline: pré-processamento e modelo juntos

Em projetos reais, os dados precisam de ajustes antes do modelo: normalizar escalas, preencher valores faltantes, codificar categorias. Fazer isso manualmente vira bagunça e abre espaço para um erro grave chamado vazamento de dados (data leakage), quando informações do teste “vazam” para o treino.

A solução é o Pipeline, que encadeia etapas e ajusta tudo corretamente dentro da validação:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("modelo", LogisticRegression(max_iter=200, random_state=42)),
])

pipeline.fit(X_train, y_train)
print("Acurácia:", pipeline.score(X_test, y_test))

O StandardScaler normaliza as features para média zero e desvio-padrão um, o que ajuda algoritmos sensíveis à escala (regressão logística, SVM, KNN). Florestas aleatórias, por outro lado, lidam bem com escalas diferentes e costumam dispensar esse passo. Use o Pipeline mesmo em projetos pequenos: ele deixa o código limpo e evita erros difíceis de rastrear.

Validação cruzada

Uma única divisão treino/teste depende do acaso. A validação cruzada (k-fold) divide os dados em k partes, treina em k-1 e testa em 1, repetindo k vezes. A média das execuções dá uma estimativa mais confiável:

from sklearn.model_selection import cross_val_score

notas = cross_val_score(pipeline, X, y, cv=5)
print("Notas por fold:", notas)
print("Média:", notas.mean())

Esse passo é indispensável antes de confiar em um número de desempenho, principalmente com poucos dados. Para uma discussão mais profunda de viés, variância e validação, leia nosso artigo de machine learning para iniciantes.

Salvando e carregando modelos

Depois de treinar, você vai querer guardar o modelo para usá-lo em uma API, um dashboard ou um script de inferência. O padrão do ecossistema é o joblib, otimizado para arrays do NumPy:

import joblib

joblib.dump(pipeline, "modelo.pkl")
modelo_carregado = joblib.load("modelo.pkl")
print(modelo_carregado.predict(X_test[:5]))

Salve sempre o Pipeline completo, não só o modelo final. Assim, o pré-processamento (escalas, codificações) acompanha o modelo e a inferência nova é tratada da mesma forma que o treino. Para colocar esse modelo no ar como serviço, veja o guia de deploy de aplicação Python e o exemplo com AWS Lambda.

Mini-projeto: prever cancelamento de clientes

Vamos juntar tudo em um problema típico do mercado brasileiro: prever se um cliente vai cancelar o serviço (churn) com base no tempo de contrato, valor mensal e número de chamadas no suporte. Usamos dados sintéticos para o exemplo ser reproduzível:

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report

# 1.000 clientes, 3 features, ~30% de churn
X, y = make_classification(
    n_samples=1000, n_features=3, n_informative=3, n_redundant=0,
    n_clusters_per_class=1, weights=[0.7, 0.3], random_state=42
)

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

pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("modelo", GradientBoostingClassifier(random_state=42)),
])

pipeline.fit(X_train, y_train)
print(classification_report(y_test, pipeline.predict(X_test)))

notas = cross_val_score(pipeline, X, y, cv=5, scoring="f1")
print("F1 médio (cross-val):", notas.mean())

Repare no uso do scoring="f1" na validação cruzada. Em churn, o F1 (e a revocação da classe positiva) costuma importar mais que a acurácia, porque identificar quem vai cancelar é o objetivo de negócio. Escolher a métrica certa para o problema é uma decisão que separa um tutorial de uma solução útil.

scikit-learn no mercado brasileiro

O scikit-learn é exigência frequente em vagas de analista de dados, cientista de dados e engenheiro de dados com Python. Vale acompanhar os caminhos de carreira: confira o guia para virar analista de dados com Python, a trilha de engenheiro de dados e a faixa de salários de Python no Brasil. Para acompanhar oportunidades em tempo real, acompanhe nossas vagas de Python.

Próximos passos

Para evoluir depois deste tutorial:

1. Aplique em dados reais — carregue um CSV com Pandas, trate valores faltantes e treine um modelo de ponta a ponta.
2. Domine pré-processamento — OneHotEncoder, SimpleImputer e StandardScaler resolvem a maior parte dos problemas tabulares.
3. Estude ajuste de hiperparâmetros — GridSearchCV e RandomizedSearchCV procuram as melhores configurações de forma automatizada.

O scikit-learn é a porta de entrada mais sólida para machine learning com Python. Treine modelos, avalie com métricas honestas, use Pipeline e validação cruzada, e você terá uma base que sustenta desde projetos de portfólio até decisões reais de negócio. Quando os dados crescerem demais para a memória, vale conhecer o Polars como alternativa ao Pandas; e para visualizar resultados, o Matplotlib integra direto com os arrays que o scikit-learn produz.