📋 Copy All scikit-learn Commands 📄 Generate scikit-learn PDF Guide

Scikit-learn Cheatsheet

Installation

Platform	Command
pip (all platforms)	pip install scikit-learn
conda	conda install scikit-learn
Ubuntu/Debian	sudo apt-get install python3-sklearn
macOS (Homebrew)	brew install python && pip3 install scikit-learn
Specific version	pip install scikit-learn==1.3.0
With dependencies	pip install scikit-learn numpy scipy matplotlib pandas
Virtual environment	python -m venv env && source env/bin/activate && pip install scikit-learn
Verify installation	python -c "import sklearn; print(sklearn.__version__)"

Basic Commands - Data Loading & Splitting

Command	Description
from sklearn import datasets	Import datasets module
iris = datasets.load_iris()	Load iris dataset
X, y = iris.data, iris.target	Extract features and labels
datasets.load_digits()	Load handwritten digits dataset
datasets.load_wine()	Load wine classification dataset
datasets.load_breast_cancer()	Load breast cancer dataset
from sklearn.model_selection import train_test_split	Import train/test split function
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)	Split data 80/20 train/test
train_test_split(X, y, test_size=0.3, random_state=42)	Split with fixed random seed
train_test_split(X, y, stratify=y)	Stratified split (preserves class distribution)

Basic Commands - Preprocessing

Command	Description
from sklearn.preprocessing import StandardScaler	Import standardization scaler
scaler = StandardScaler()	Create scaler instance
scaler.fit(X_train)	Compute mean and std from training data
X_scaled = scaler.transform(X_train)	Apply scaling transformation
X_scaled = scaler.fit_transform(X_train)	Fit and transform in one step
from sklearn.preprocessing import MinMaxScaler	Import min-max normalizer
normalizer = MinMaxScaler(feature_range=(0, 1))	Create normalizer for 0-1 range
from sklearn.preprocessing import LabelEncoder	Import label encoder
encoder = LabelEncoder()	Create encoder instance
y_encoded = encoder.fit_transform(y)	Encode categorical labels to integers
encoder.inverse_transform(y_encoded)	Decode integers back to original labels
from sklearn.preprocessing import OneHotEncoder	Import one-hot encoder
OneHotEncoder(sparse=False).fit_transform(X)	Create dummy variables from categories

Basic Commands - Classification

Command	Description
from sklearn.linear_model import LogisticRegression	Import logistic regression
model = LogisticRegression()	Create logistic regression model
model.fit(X_train, y_train)	Train model on training data
predictions = model.predict(X_test)	Make predictions on test data
probabilities = model.predict_proba(X_test)	Get prediction probabilities
from sklearn.tree import DecisionTreeClassifier	Import decision tree classifier
tree = DecisionTreeClassifier(max_depth=5)	Create decision tree with max depth
from sklearn.neighbors import KNeighborsClassifier	Import K-nearest neighbors
knn = KNeighborsClassifier(n_neighbors=5)	Create KNN with 5 neighbors
from sklearn.naive_bayes import GaussianNB	Import Gaussian Naive Bayes
nb = GaussianNB()	Create Naive Bayes classifier

Basic Commands - Regression

Command	Description
from sklearn.linear_model import LinearRegression	Import linear regression
model = LinearRegression()	Create linear regression model
model.fit(X_train, y_train)	Train regression model
predictions = model.predict(X_test)	Predict continuous values
model.coef_	Access model coefficients
model.intercept_	Access model intercept
from sklearn.linear_model import Ridge	Import Ridge regression (L2)
ridge = Ridge(alpha=1.0)	Create Ridge with regularization strength
from sklearn.linear_model import Lasso	Import Lasso regression (L1)
lasso = Lasso(alpha=0.1)	Create Lasso with regularization

Basic Commands - Model Evaluation

Command	Description
from sklearn.metrics import accuracy_score	Import accuracy metric
accuracy_score(y_test, predictions)	Calculate accuracy percentage
from sklearn.metrics import classification_report	Import detailed classification metrics
classification_report(y_test, predictions)	Get precision, recall, F1-score
from sklearn.metrics import confusion_matrix	Import confusion matrix
confusion_matrix(y_test, predictions)	Create confusion matrix
from sklearn.metrics import mean_squared_error	Import MSE metric
mean_squared_error(y_test, predictions)	Calculate mean squared error
mean_squared_error(y_test, predictions, squared=False)	Calculate RMSE
from sklearn.metrics import r2_score	Import R² metric
r2_score(y_test, predictions)	Calculate R² score
model.score(X_test, y_test)	Get default score (accuracy or R²)

Basic Commands - Cross-Validation

Command	Description
from sklearn.model_selection import cross_val_score	Import cross-validation
cross_val_score(model, X, y, cv=5)	Perform 5-fold cross-validation
scores = cross_val_score(model, X, y, cv=10)	10-fold cross-validation
scores.mean()	Get mean cross-validation score
scores.std()	Get standard deviation of scores
from sklearn.model_selection import cross_validate	Import multi-metric CV
cross_validate(model, X, y, cv=5, scoring=['accuracy', 'precision'])	CV with multiple metrics
from sklearn.model_selection import KFold	Import K-fold splitter
kfold = KFold(n_splits=5, shuffle=True, random_state=42)	Create K-fold object

Advanced Usage - Ensemble Methods

Command	Description
from sklearn.ensemble import RandomForestClassifier	Import random forest
rf = RandomForestClassifier(n_estimators=100, max_depth=10, n_jobs=-1)	Create random forest with 100 trees
rf.feature_importances_	Get feature importance scores
from sklearn.ensemble import GradientBoostingClassifier	Import gradient boosting
gb = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1)	Create gradient boosting model
from sklearn.ensemble import AdaBoostClassifier	Import AdaBoost
ada = AdaBoostClassifier(n_estimators=50, learning_rate=1.0)	Create AdaBoost classifier
from sklearn.ensemble import VotingClassifier	Import voting ensemble
VotingClassifier(estimators=[('lr', model1), ('rf', model2)], voting='soft')	Combine multiple models
from sklearn.ensemble import BaggingClassifier	Import bagging ensemble
BaggingClassifier(base_estimator=tree, n_estimators=10)	Create bagging ensemble
from sklearn.ensemble import StackingClassifier	Import stacking ensemble
StackingClassifier(estimators=[...], final_estimator=LogisticRegression())	Stack models with meta-learner

Advanced Usage - Support Vector Machines

Command	Description
from sklearn.svm import SVC	Import SVM classifier
svm = SVC(kernel='rbf', C=1.0, gamma='scale')	Create RBF kernel SVM
SVC(kernel='linear')	Linear kernel SVM
SVC(kernel='poly', degree=3)	Polynomial kernel SVM
SVC(probability=True)	Enable probability estimates
from sklearn.svm import SVR	Import SVM regressor
svr = SVR(kernel='rbf', C=1.0, epsilon=0.1)	Create SVM regressor
from sklearn.svm import LinearSVC	Import linear SVM (faster)
LinearSVC(C=1.0, max_iter=1000)	Linear SVM for large datasets

Advanced Usage - Clustering

Command	Description
from sklearn.cluster import KMeans	Import K-means clustering
kmeans = KMeans(n_clusters=3, random_state=42)	Create K-means with 3 clusters
clusters = kmeans.fit_predict(X)	Fit and get cluster labels
kmeans.cluster_centers_	Get cluster centroids
kmeans.inertia_	Get within-cluster sum of squares
from sklearn.cluster import DBSCAN	Import DBSCAN clustering
DBSCAN(eps=0.5, min_samples=5).fit_predict(X)	Density-based clustering
from sklearn.cluster import AgglomerativeClustering	Import hierarchical clustering
AgglomerativeClustering(n_clusters=3, linkage='ward')	Hierarchical clustering
from sklearn.cluster import MeanShift	Import mean shift clustering
MeanShift(bandwidth=2.0).fit_predict(X)	Mean shift clustering

Advanced Usage - Dimensionality Reduction

Command	Description
from sklearn.decomposition import PCA	Import PCA
pca = PCA(n_components=2)	Create PCA with 2 components
X_pca = pca.fit_transform(X)	Transform to principal components
pca.explained_variance_ratio_	Get variance explained by each component
pca.components_	Get principal component vectors
PCA(n_components=0.95)	Keep components explaining 95% variance
from sklearn.manifold import TSNE	Import t-SNE
TSNE(n_components=2, perplexity=30).fit_transform(X)	t-SNE dimensionality reduction
from sklearn.decomposition import TruncatedSVD	Import truncated SVD
TruncatedSVD(n_components=100).fit_transform(X)	SVD for sparse matrices
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis	Import LDA
LDA(n_components=2).fit_transform(X, y)	Supervised dimensionality reduction

Advanced Usage - Pipeline Construction

Command	Description
from sklearn.pipeline import Pipeline	Import pipeline
Pipeline([('scaler', StandardScaler()), ('clf', LogisticRegression())])	Create processing pipeline
pipeline.fit(X_train, y_train)	Fit entire pipeline
pipeline.predict(X_test)	Predict using pipeline
from sklearn.pipeline import make_pipeline	Import pipeline maker
make_pipeline(StandardScaler(), PCA(10), LogisticRegression())	Auto-name pipeline steps
pipeline.named_steps['scaler']	Access specific pipeline step
from sklearn.compose import ColumnTransformer	Import column transformer
ColumnTransformer([('num', StandardScaler(), [0,1]), ('cat', OneHotEncoder(), [2])])	Different preprocessing per column
pipeline.get_params()	Get all pipeline parameters
pipeline.set_params(clf__C=0.1)	Set nested pipeline parameters

Advanced Usage - Hyperparameter Tuning

Command	Description
from sklearn.model_selection import GridSearchCV	Import grid search
GridSearchCV(model, param_grid, cv=5, n_jobs=-1)	Exhaustive parameter search
grid_search.fit(X_train, y_train)	Run grid search
grid_search.best_params_	Get best parameters found
grid_search.best_score_	Get best cross-validation score
grid_search.best_estimator_	Get best model
grid_search.cv_results_	Get detailed CV results
from sklearn.model_selection import RandomizedSearchCV	Import randomized search
RandomizedSearchCV(model, param_distributions, n_iter=100, cv=5)	Random parameter sampling
from scipy.stats import randint, uniform	Import distributions for random search
param_distributions = {'n_estimators': randint(50, 200)}	Define parameter distribution

Advanced Usage - Feature Selection

Command	Description
from sklearn.feature_selection import SelectKBest	Import K-best selector
SelectKBest(k=10).fit_transform(X, y)	Select top 10 features
from sklearn.feature_selection import chi2, f_classif	Import scoring functions
SelectKBest(score_func=chi2, k=5)	Chi-squared feature selection
from sklearn.feature_selection import RFE	Import recursive feature elimination
RFE(estimator=model, n_features_to_select=10).fit(X, y)	Recursive feature elimination
from sklearn.feature_selection import SelectFromModel	Import model-based selection
SelectFromModel(RandomForestClassifier()).fit(X, y)	Select features by importance
selector.get_support()	Get boolean mask of selected features
selector.transform(X)	Transform to selected features only

Advanced Usage - Model Persistence

Command	Description
import joblib	Import joblib for model saving
joblib.dump(model, 'model.pkl')	Save model to file
model = joblib.load('model.pkl')	Load model from file
import pickle	Import pickle module
pickle.dump(model, open('model.pkl', 'wb'))	Save with pickle
model = pickle.load(open('model.pkl', 'rb'))	Load with pickle
joblib.dump(model, 'model.pkl', compress=3)	Save with compression

Configuration

Model Parameters Configuration

# Logistic Regression parameters
LogisticRegression(
    penalty='l2',           # Regularization type: 'l1', 'l2', 'elasticnet', 'none'
    C=1.0,                  # Inverse regularization strength (smaller = stronger)
    solver='lbfgs',         # Algorithm: 'lbfgs', 'liblinear', 'newton-cg', 'sag', 'saga'
    max_iter=100,           # Maximum iterations
    random_state=42,        # Random seed for reproducibility
    n_jobs=-1               # Use all CPU cores
)

# Random Forest parameters
RandomForestClassifier(
    n_estimators=100,       # Number of trees
    criterion='gini',       # Split quality: 'gini' or 'entropy'
    max_depth=None,         # Maximum tree depth (None = unlimited)
    min_samples_split=2,    # Minimum samples to split node
    min_samples_leaf=1,     # Minimum samples in leaf
    max_features='sqrt',    # Features per split: 'sqrt', 'log2', int, float
    bootstrap=True,         # Bootstrap sampling
    oob_score=False,        # Out-of-bag score estimation
    n_jobs=-1,              # Parallel jobs
    random_state=42,
    class_weight='balanced' # Handle imbalanced classes
)

# Support Vector Machine parameters
SVC(
    C=1.0,                  # Regularization parameter
    kernel='rbf',           # Kernel: 'linear', 'poly', 'rbf', 'sigmoid'
    degree=3,               # Polynomial degree (for 'poly' kernel)
    gamma='scale',          # Kernel coefficient: 'scale', 'auto', or float
    coef0=0.0,              # Independent term in kernel
    probability=False,      # Enable probability estimates (slower)
    cache_size=200,         # Kernel cache size (MB)
    class_weight=None,      # Class weights
    max_iter=-1             # Iteration limit (-1 = no limit)
)

# Gradient Boosting parameters
GradientBoostingClassifier(
    loss='log_loss',        # Loss function
    learning_rate=0.1,      # Shrinks contribution of each tree
    n_estimators=100,       # Number of boosting stages
    subsample=1.0,          # Fraction of samples for fitting
    criterion='friedman_mse', # Split quality measure
    min_samples_split=2,
    min_samples_leaf=1,
    max_depth=3,            # Maximum tree depth
    max_features=None,      # Features per split
    validation_fraction=0.1, # Fraction for early stopping
    n_iter_no_change=None,  # Early stopping rounds
    random_state=42
)

Pipeline Configuration

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.ensemble import RandomForestClassifier

# Complete pipeline with preprocessing
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA(n_components=0.95)),
    ('classifier', RandomForestClassifier(
        n_estimators=100,
        max_depth=10,
        random_state=42
    ))
])

# Pipeline with column-specific preprocessing
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

preprocessor = ColumnTransformer(
    transformers=[
        ('num', StandardScaler(), ['age', 'income', 'score']),
        ('cat', OneHotEncoder(drop='first'), ['category', 'region'])
    ],
    remainder='passthrough'  # Keep other columns unchanged
)

full_pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier())
])

Cross-Validation Configuration

from sklearn.model_selection import cross_validate

# Multi-metric cross-validation
cv_results = cross_validate(
    estimator=model,
    X=X,
    y=y,
    cv=5,                           # Number of folds
    scoring={
        'accuracy': 'accuracy',
        'precision': 'precision_weighted',
        'recall': 'recall_weighted',
        'f1': 'f1_weighted',
        'roc_auc': 'roc_auc_ovr'
    },
    return_train_score=True,        # Include training scores
    return_estimator=True,          # Return fitted estimators
    n_jobs=-1,                      # Parallel processing
    verbose=1                       # Progress messages
)

Grid Search Configuration

from sklearn.model_selection import GridSearchCV

# Comprehensive parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
    'max_features': ['sqrt', 'log2'],
    'bootstrap': [True, False]
}

grid_search = GridSearchCV(
    estimator=RandomForestClassifier(),
    param_grid=param_grid,
    scoring='f1_weighted',          # Scoring metric
    cv=5,                           # Cross-validation folds
    n_jobs=-1,                      # Use all cores
    verbose=2,                      # Verbosity level
    refit=True,                     # Refit best model on full data
    return_train_score=True,        # Return training scores
    error_score='raise'             # How to handle errors
)

Common Use Cases

Use Case 1: Binary Classification with Imbalanced Data

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score
import numpy as np

# Generate imbalanced dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15,
                          n_redundant=5, weights=[0.9, 0.1], random_state=42)

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

# Scale features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train model with class balancing
model = RandomForestClassifier(
    n_estimators=100,
    class_weight='balanced',  # Handle imbalance
    random_state=42
)
model.fit(X_train_scaled, y_train)

# Evaluate
predictions = model.predict(X_test_scaled)
probabilities = model.predict_proba(X_test_scaled)[:, 1]

print(classification_report(y_test, predictions))
print(f"ROC-AUC Score: {roc_auc_score(y_test, probabilities):.3f}")
print("\nConfusion Matrix:")
print(confusion_matrix(y_test, predictions))

Use Case 2: Multi-Class Text Classification Pipeline

```python from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.pipeline import Pipeline from sklearn.linear_model import LogisticRegression from sklearn.model_selection import cross_val_score

Sample text data

texts = [ "Python is great for machine learning", "Java is used for enterprise applications", "JavaScript powers web development", # ... more texts ] labels = ['tech', 'tech', 'tech'] # Categories

Create text classification pipeline

text_clf = Pipeline([ ('tfidf', TfidfVectorizer( max_features=5000, ngram_range=(1, 2), stop_words='english'