Scikit-learn (sklearn) Cheat Sheet: Folha de Consulta
Última atualização
Carregar e dividir os dados
Separe um conjunto de teste antes de qualquer coisa e só olhe para ele no final.
| Tarefa | Código |
|---|---|
| Importar a função de divisão | from sklearn.model_selection import train_test_split |
| Features e alvo a partir de um DataFrame | X = df.drop(columns="target")
y = df["target"] |
| Dataset nativo como pandas | from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True, as_frame=True) |
| Dados sintéticos para experimentar | from sklearn.datasets import make_classification
X, y = make_classification(n_samples=500, n_features=8, random_state=0) |
| Divisão 80/20 em treino e teste | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) |
| Manter a proporção das classes nas duas partes | train_test_split(X, y, test_size=0.2, stratify=y, random_state=42) |
| Treino, validação e teste (60/20/20) | X_tmp, X_test, y_tmp, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
X_train, X_val, y_train, y_val = train_test_split(X_tmp, y_tmp, test_size=0.25, random_state=0) |
Pré-processar features
Ajuste um transformer só nos dados de treino e depois transforme os dois conjuntos. Ajustar nos dados de teste vaza informação.
| Tarefa | Código |
|---|---|
| Imports | from sklearn.preprocessing import StandardScaler, MinMaxScaler, OneHotEncoder, OrdinalEncoder |
| Padronizar para média 0 e desvio padrão 1 | scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train[["age", "income"]])
X_test_s = scaler.transform(X_test[["age", "income"]]) |
| Escalar para o intervalo de 0 a 1 | MinMaxScaler().fit_transform(X_train[["age", "income"]]) |
| One-hot encoding de categorias | enc = OneHotEncoder(handle_unknown="ignore", sparse_output=False)
enc.fit_transform(X_train[["city"]]) |
| Codificar categorias ordenadas como números | OrdinalEncoder(categories=[["low", "mid", "high"]]).fit_transform([["mid"], ["high"]]) |
| Preencher valores ausentes | from sklearn.impute import SimpleImputer
SimpleImputer(strategy="median").fit_transform(X_train[["age", "income"]]) |
| Features polinomiais e de interação | from sklearn.preprocessing import PolynomialFeatures
PolynomialFeatures(degree=2, include_bias=False).fit_transform(X_train[["age", "income"]]) |
| Receber DataFrames em vez de arrays | scaler.set_output(transform="pandas") |
| Rótulos de texto para inteiros | from sklearn.preprocessing import LabelEncoder
LabelEncoder().fit_transform(["cat", "dog", "cat"]) |
Escolher um modelo
Comece simples e mantenha o modelo simples como a pontuação a ser batida.
| Problema | Comece com | Depois tente |
|---|---|---|
| Prever um número (regressão) | LinearRegression(), Ridge(alpha=1.0) | RandomForestRegressor(), HistGradientBoostingRegressor() |
| Prever uma classe (classificação) | LogisticRegression(max_iter=1000) | RandomForestClassifier(), HistGradientBoostingClassifier() |
| Poucos dados, pontos parecidos têm o mesmo rótulo | KNeighborsClassifier(n_neighbors=5) | SVC(kernel="rbf") |
| Regras que dá para ler | DecisionTreeClassifier(max_depth=3) | RandomForestClassifier() |
| Agrupar linhas sem rótulos | KMeans(n_clusters=3) | DBSCAN(eps=0.5) |
| Menos features para gráficos ou velocidade | PCA(n_components=2) | TSNE(n_components=2) |
| Encontrar linhas incomuns | IsolationForest(random_state=0) | LocalOutlierFactor() |
Treinar um modelo
Todo estimador segue o mesmo padrão: crie com suas configurações e depois chame fit.
| Tarefa | Código |
|---|---|
| O padrão para qualquer modelo | model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train) |
| Regressão linear | from sklearn.linear_model import LinearRegression
LinearRegression() |
| Regressão linear regularizada | from sklearn.linear_model import Ridge, Lasso
Ridge(alpha=1.0), Lasso(alpha=0.1) |
| Regressão logística (classificação) | from sklearn.linear_model import LogisticRegression
LogisticRegression(C=1.0, max_iter=1000) |
| k vizinhos mais próximos | from sklearn.neighbors import KNeighborsClassifier
KNeighborsClassifier(n_neighbors=5) |
| Árvore de decisão | from sklearn.tree import DecisionTreeClassifier
DecisionTreeClassifier(max_depth=3, random_state=0) |
| Random forest | from sklearn.ensemble import RandomForestClassifier
RandomForestClassifier(n_estimators=200, random_state=0) |
| Gradient boosting, rápido em dados grandes | from sklearn.ensemble import HistGradientBoostingClassifier
HistGradientBoostingClassifier(random_state=0) |
| Máquina de vetores de suporte (SVM) | from sklearn.svm import SVC
SVC(kernel="rbf", C=1.0) |
| Naive Bayes | from sklearn.naive_bayes import GaussianNB
GaussianNB() |
| Baseline que sempre chuta a classe majoritária | from sklearn.dummy import DummyClassifier
DummyClassifier(strategy="most_frequent") |
Prever e inspecionar
| Tarefa | Código |
|---|---|
| Prever classes ou valores | y_pred = model.predict(X_test) |
| Probabilidade da classe positiva | model.predict_proba(X_test)[:, 1] |
| Score rápido: acurácia ou R² | model.score(X_test, y_test) |
| Coeficientes de um modelo linear | model.coef_, model.intercept_ |
| Importância das features num modelo de árvore | pd.Series(forest.feature_importances_, index=X_train.columns).sort_values() |
| Importância embaralhando cada feature | from sklearn.inspection import permutation_importance
permutation_importance(model, X_test, y_test, random_state=0).importances_mean |
| Classes que o modelo conhece | model.classes_ |
| Ler e alterar configurações | model.get_params(), model.set_params(C=0.5) |
| Desenhar uma árvore de decisão | from sklearn.tree import plot_tree
plot_tree(tree, filled=True, feature_names=list(X_train.columns)) |
Métricas de classificação
A acurácia sozinha esconde os erros numa classe rara. Confira também precisão, recall e a matriz de confusão.
| Tarefa | Código |
|---|---|
| Imports | from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score |
| Acurácia | accuracy_score(y_test, y_pred) |
| Precisão, recall e F1 | precision_score(y_test, y_pred), recall_score(y_test, y_pred), f1_score(y_test, y_pred) |
| F1 para várias classes | f1_score(y_test, y_pred, average="macro") |
| Todas as métricas por classe | from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred)) |
| Matriz de confusão | from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_pred) |
| Plotar a matriz de confusão | from sklearn.metrics import ConfusionMatrixDisplay
ConfusionMatrixDisplay.from_estimator(model, X_test, y_test) |
| ROC AUC a partir de probabilidades | from sklearn.metrics import roc_auc_score
roc_auc_score(y_test, model.predict_proba(X_test)[:, 1]) |
| Plotar a curva ROC | from sklearn.metrics import RocCurveDisplay
RocCurveDisplay.from_estimator(model, X_test, y_test) |
| Acurácia para classes desbalanceadas | from sklearn.metrics import balanced_accuracy_score
balanced_accuracy_score(y_test, y_pred) |
| Seu próprio limiar de decisão | y_pred = (model.predict_proba(X_test)[:, 1] >= 0.3).astype(int) |
Métricas de regressão
Métricas de erro ficam na unidade do alvo (quanto menor, melhor). O R² é a fração da variância explicada (1 é perfeito).
| Tarefa | Código |
|---|---|
| Imports | from sklearn.metrics import mean_absolute_error, mean_squared_error, root_mean_squared_error, r2_score |
| Erro absoluto médio (MAE) | mean_absolute_error(y_test, y_pred) |
| Erro quadrático médio e sua raiz | mean_squared_error(y_test, y_pred), root_mean_squared_error(y_test, y_pred) |
| Score R² | r2_score(y_test, y_pred) |
| Erro percentual absoluto médio (MAPE) | from sklearn.metrics import mean_absolute_percentage_error
mean_absolute_percentage_error(y_test, y_pred) |
| Plotar previsto contra real | from sklearn.metrics import PredictionErrorDisplay
PredictionErrorDisplay.from_predictions(y_test, y_pred, kind="actual_vs_predicted") |
Pipelines
Um pipeline encadeia pré-processamento e modelo num único estimador, assim a validação cruzada e o grid search ajustam cada etapa só nos folds de treino.
| Tarefa | Código |
|---|---|
| Imports | from sklearn.pipeline import make_pipeline, Pipeline |
| Escalar e depois treinar um modelo | pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
pipe.fit(X_train, y_train) |
| Etapas com nomes próprios | pipe = Pipeline([("scale", StandardScaler()), ("model", LogisticRegression(max_iter=1000))]) |
| Acessar uma etapa interna | pipe.named_steps["model"], pipe[-1] |
| Etapas diferentes para colunas diferentes | from sklearn.compose import ColumnTransformer
pre = ColumnTransformer([
("num", StandardScaler(), ["age", "income"]),
("cat", OneHotEncoder(handle_unknown="ignore"), ["city"]),
]) |
| Pré-processamento e modelo num só objeto | model = make_pipeline(pre, RandomForestClassifier(random_state=0))
model.fit(X_train, y_train)
model.score(X_test, y_test) |
| Escolher colunas por tipo | from sklearn.compose import make_column_selector
make_column_selector(dtype_include="number")(X_train) |
| Imputar e depois escalar | make_pipeline(SimpleImputer(strategy="median"), StandardScaler()) |
| Nomes das features de saída | pre.get_feature_names_out() |
Validação cruzada
A validação cruzada treina e avalia o modelo em várias divisões, o que dá uma estimativa mais estável que um único conjunto de teste.
| Tarefa | Código |
|---|---|
| Imports | from sklearn.model_selection import cross_val_score, cross_validate, KFold, StratifiedKFold |
| Score em 5 folds | scores = cross_val_score(pipe, X, y, cv=5)
scores.mean(), scores.std() |
| Escolher a métrica | cross_val_score(pipe, X, y, cv=5, scoring="f1_macro") |
| Folds embaralhados | cv = KFold(n_splits=5, shuffle=True, random_state=0) |
| Mesmo equilíbrio de classes em cada fold | cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0) |
| Várias métricas e scores de treino | cross_validate(pipe, X, y, cv=cv, scoring=["accuracy", "f1"], return_train_score=True) |
| Uma previsão por linha, feita fora do fold | from sklearn.model_selection import cross_val_predict
cross_val_predict(pipe, X, y, cv=5) |
| Folds por grupo, folds em ordem temporal | from sklearn.model_selection import GroupKFold, TimeSeriesSplit
GroupKFold(n_splits=5), TimeSeriesSplit(n_splits=5) |
| Todos os nomes de scoring válidos | from sklearn.metrics import get_scorer_names
get_scorer_names() |
Grid search e ajuste
A busca treina o modelo para cada configuração com validação cruzada, fica com a melhor e a retreina em todos os dados de treino.
| Tarefa | Código |
|---|---|
| Imports | from sklearn.model_selection import GridSearchCV, RandomizedSearchCV |
| Testar todas as combinações | grid = GridSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": [50, 100], "max_depth": [None, 5]}, cv=5)
grid.fit(X_train, y_train) |
| Melhores configurações e seu score | grid.best_params_, grid.best_score_ |
| Usar o melhor modelo | grid.best_estimator_.predict(X_test), grid.score(X_test, y_test) |
| Ajustar uma etapa dentro do pipeline | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1, 10]}, cv=5).fit(X_train, y_train) |
| Configurações aleatórias de distribuições | from scipy.stats import randint
search = RandomizedSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": randint(50, 150)}, n_iter=5, cv=3, random_state=0)
search.fit(X_train, y_train) |
| Usar todos os núcleos da CPU | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1]}, cv=5, n_jobs=-1) |
| Todos os resultados como tabela | pd.DataFrame(grid.cv_results_).sort_values("rank_test_score") |
Clustering e redução de dimensionalidade
Modelos não supervisionados aprendem só com X. Escale as features antes, porque os dois usam distâncias.
| Tarefa | Código |
|---|---|
| Clusters com k-means | from sklearn.cluster import KMeans
km = KMeans(n_clusters=3, random_state=0)
labels = km.fit_predict(X) |
| Centros dos clusters e inércia | km.cluster_centers_, km.inertia_ |
| Quão bem separados estão os clusters | from sklearn.metrics import silhouette_score
silhouette_score(X, labels) |
| Clusters por densidade, ruído é -1 | from sklearn.cluster import DBSCAN
DBSCAN(eps=0.5, min_samples=5).fit_predict(X) |
| Projetar em 2 componentes | from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X) |
| Variância explicada por componente | pca.explained_variance_ratio_ |
| Manter 95% da variância | PCA(n_components=0.95).fit_transform(X) |
scikit-learn 1.9: formas antigas e o que escrever agora
Código copiado de tutoriais antigos pode falhar ou gerar avisos no scikit-learn 1.9. Use as formas da coluna scikit-learn 1.9.
| Tarefa | scikit-learn 1.9 | Forma antiga |
|---|---|---|
| Raiz do erro quadrático médio (RMSE) | root_mean_squared_error(y_test, y_pred) | mean_squared_error(y_test, y_pred, squared=False) |
| Saída one-hot densa | OneHotEncoder(sparse_output=False) | OneHotEncoder(sparse=False) |
| Regressão logística L1 (lasso) | LogisticRegression(l1_ratio=1, solver="liblinear") | LogisticRegression(penalty="l1", solver="liblinear") |
| Regressão logística sem regularização | LogisticRegression(C=np.inf) | LogisticRegression(penalty=None) |
Salvar, carregar e reproduzir
| Tarefa | Código |
|---|---|
| Salvar um modelo ou pipeline treinado | import joblib
joblib.dump(model, "model.joblib") |
| Carregar de volta | model = joblib.load("model.joblib") |
| Mesmo resultado a cada execução | random_state=0 |
| Qual versão está instalada | import sklearn
sklearn.__version__ |
O código scikit-learn por trás de um fluxo real de machine learning, na ordem em que você escreve: carregar e dividir os dados, pré-processar, escolher um modelo, treinar e prever, medir o resultado, encadear as etapas num pipeline, fazer validação cruzada e ajustar com grid search. Cada linha traz um trecho curto para colar e uma frase sobre o que ele faz.
Todo modelo do scikit-learn segue a mesma API: fit aprende com os dados de treino, predict e transform aplicam o que foi aprendido. Tudo aqui foi escrito para o scikit-learn 1.9, a versão que a Coddy roda, com X para as features e y para o alvo. O scikit-learn trabalha com arrays NumPy e DataFrames pandas, e a folha de consulta de Matplotlib cobre os gráficos. Está começando em Python? Comece pela folha de consulta Python.
Perguntas frequentes sobre a folha de consulta scikit-learn
Esta folha de consulta de scikit-learn é grátis?
Sim. Esta folha de consulta de scikit-learn é totalmente grátis, sem cadastro. Salve nos favoritos ou imprima em PDF pelo navegador, e volte sempre que precisar da chamada exata para um pipeline, uma métrica ou um grid search.
sklearn é o mesmo que scikit-learn?
Sim. scikit-learn é o nome da biblioteca e do pacote que você instala (
pip install scikit-learn), e sklearn é o nome que você importa no código (from sklearn.linear_model import LinearRegression). Uma folha de consulta de sklearn e uma de scikit-learn cobrem a mesma coisa.Qual é a diferença entre fit, transform e fit_transform?
fit aprende com os dados: um scaler aprende a média de cada coluna, um modelo aprende seus pesos. transform aplica o que foi aprendido, e fit_transform faz as duas coisas numa chamada. Use fit_transform no conjunto de treino e só transform no de teste, senão os dados de teste vazam para o treino. Um pipeline faz isso por você.Preciso escalar minhas features?
Para modelos que usam distâncias ou gradientes, sim: k vizinhos mais próximos, SVMs, k-means, PCA e regressões linear e logística regularizadas funcionam melhor com dados escalados. Modelos de árvore, como árvores de decisão, random forests e gradient boosting, não precisam de escala. Coloque o scaler num pipeline para que ele seja ajustado só nos dados de treino.
Com qual modelo do scikit-learn devo começar?
Comece com um modelo simples e rápido como baseline:
LinearRegression para prever números, LogisticRegression para prever classes. Depois tente RandomForestClassifier ou HistGradientBoostingClassifier (ou as versões de regressão), compare com validação cruzada e ajuste o melhor com GridSearchCV.Qual versão do scikit-learn esta folha de consulta cobre?
O scikit-learn 1.9, a versão que a Coddy roda, com NumPy 2 e pandas 3. Chamadas antigas que hoje falham ou geram avisos, como
squared=False em mean_squared_error, sparse=False em OneHotEncoder e o argumento penalty de LogisticRegression, estão na tabela de formas antigas, ao lado do que escrever no lugar.Posso rodar código scikit-learn online?
Sim. O playground de Matplotlib grátis roda Python com scikit-learn, pandas, NumPy e Matplotlib no navegador, então você pode colar qualquer trecho desta folha de consulta e rodar sem instalar nada. O curso de Machine Learning da Coddy ensina passo a passo todo o fluxo desta página, da divisão dos dados ao ajuste de um modelo.
Recursos relacionados
Mais folhas de consulta
