Scikit-learn Introduction

Scikit-learn (sklearn) is Python's most widely-used machine learning library. It provides simple and efficient tools for data analysis and modeling, built on NumPy, SciPy, and Matplotlib. Whether you're building a spam classifier, predicting house prices, or clustering customers, sklearn has you covered.

Why Scikit-learn?

Installing Scikit-learn

Scikit-learn is typically installed via pip or conda. It's included in most data science distributions like Anaconda.

# Install via pip
# pip install scikit-learn

# Import the library
import sklearn
print(f"Scikit-learn version: {sklearn.__version__}")

# Common imports you'll use frequently
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

The beauty of scikit-learn is its consistent API. Every model (called an "estimator") follows the same pattern. Learn it once, and you can use any of the 50+ algorithms without reading new documentation.

The Universal Pattern: fit → predict → score

# The universal sklearn pattern
from sklearn.linear_model import LogisticRegression

# Step 1: Create the model (estimator)
model = LogisticRegression()

# Step 2: Train on data
model.fit(X_train, y_train)

# Step 3: Make predictions
predictions = model.predict(X_test)

# Step 4: Evaluate
accuracy = model.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2%}")

Estimators vs Transformers

Sklearn has two main types of objects: Estimators (models that predict) and Transformers (objects that transform data).

# Transformer example: StandardScaler
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

# fit_transform on training data (learn mean/std, then transform)
X_train_scaled = scaler.fit_transform(X_train)

# transform only on test data (use learned mean/std)
X_test_scaled = scaler.transform(X_test)

# Now X_train_scaled and X_test_scaled have mean=0, std=1

# Fitting on test data = DATA LEAKAGE!
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.fit_transform(X_test)

# Same parameters applied to both
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

Scikit-learn comes with several toy datasets perfect for learning and experimentation. No need to download anything — they're ready to use immediately.

Classification Datasets

from sklearn.datasets import load_iris, load_wine, load_breast_cancer

# Load the famous Iris dataset
iris = load_iris()

# It's a Bunch object (like a dictionary)
print(iris.keys())
# dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename'])

# Features (X) and target (y)
X = iris.data           # Shape: (150, 4)
y = iris.target         # Shape: (150,)

# Feature names
print(iris.feature_names)
# ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

# Target classes
print(iris.target_names)
# ['setosa' 'versicolor' 'virginica']

Regression Datasets

from sklearn.datasets import load_diabetes, fetch_california_housing

# Diabetes dataset (regression)
diabetes = load_diabetes()
X, y = diabetes.data, diabetes.target

print(f"Features: {diabetes.feature_names}")
print(f"Target: disease progression (continuous)")

# California Housing (larger dataset)
housing = fetch_california_housing()
X, y = housing.data, housing.target

print(f"Samples: {X.shape[0]}, Features: {X.shape[1]}")
print(f"Target: median house value")

Generating Synthetic Datasets

Need a custom dataset for testing? Sklearn can generate synthetic data with known properties.

from sklearn.datasets import make_classification, make_regression, make_blobs

# Generate classification data
X, y = make_classification(
    n_samples=1000,
    n_features=20,
    n_informative=10,    # Features actually useful for classification
    n_classes=2,
    random_state=42
)

# Generate regression data
X, y = make_regression(
    n_samples=1000,
    n_features=10,
    noise=10,            # Add some noise
    random_state=42
)

# Generate clustering data (blobs)
X, y = make_blobs(
    n_samples=500,
    n_features=2,
    centers=4,           # 4 clusters
    random_state=42
)

Let's build a complete machine learning model from start to finish. We'll use the Iris dataset to classify flower species using Logistic Regression.

Complete Workflow Example

# Step 1: Import everything we need
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# Step 2: Load the data
iris = load_iris()
X, y = iris.data, iris.target
print(f"Dataset shape: {X.shape}")  # (150, 4)

# Step 3: Split into training and test sets
X_train, X_test, y_train, y_test = train_test_split(
    X, y, 
    test_size=0.2,       # 20% for testing
    random_state=42,     # Reproducibility
    stratify=y           # Keep class balance
)
print(f"Training: {X_train.shape[0]}, Test: {X_test.shape[0]}")

# Step 4: Scale the features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Step 5: Create and train the model
model = LogisticRegression(random_state=42)
model.fit(X_train_scaled, y_train)

# Step 6: Make predictions
y_pred = model.predict(X_test_scaled)

# Step 7: Evaluate
accuracy = accuracy_score(y_test, y_pred)
print(f"\nAccuracy: {accuracy:.2%}")
print("\nClassification Report:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

Dataset shape: (150, 4)
Training: 120, Test: 30

Accuracy: 100.00%

Classification Report:
              precision    recall  f1-score   support
      setosa       1.00      1.00      1.00        10
  versicolor       1.00      1.00      1.00        10
   virginica       1.00      1.00      1.00        10
    accuracy                           1.00        30

Trying Different Models

The beauty of sklearn: switch models with just one line change!

# Try different classifiers
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier

models = {
    'Logistic Regression': LogisticRegression(random_state=42),
    'Decision Tree': DecisionTreeClassifier(random_state=42),
    'Random Forest': RandomForestClassifier(random_state=42),
    'SVM': SVC(random_state=42),
    'K-Nearest Neighbors': KNeighborsClassifier()
}

print("Model Comparison:")
print("-" * 40)

for name, model in models.items():
    model.fit(X_train_scaled, y_train)
    accuracy = model.score(X_test_scaled, y_test)
    print(f"{name:25} Accuracy: {accuracy:.2%}")

Real-world ML involves multiple preprocessing steps before training. Sklearn Pipelines chain these steps together, preventing data leakage and making code cleaner.

Common Preprocessing Steps

from sklearn.preprocessing import (
    StandardScaler,   # Mean=0, Std=1
    MinMaxScaler,     # Range [0, 1]
    RobustScaler      # Robust to outliers
)

# StandardScaler (most common)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

from sklearn.preprocessing import (
    LabelEncoder,      # For target labels
    OneHotEncoder,     # Nominal categories
    OrdinalEncoder     # Ordinal categories
)

# OneHotEncoder for categorical features
encoder = OneHotEncoder(sparse_output=False)
X_encoded = encoder.fit_transform(X_cat)

The Pipeline Solution

A Pipeline chains preprocessing and model into a single object. This ensures consistent preprocessing during training and prediction.

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

# Create a pipeline
pipe = Pipeline([
    ('scaler', StandardScaler()),         # Step 1: Scale
    ('classifier', LogisticRegression())  # Step 2: Classify
])

# Use it like any other model!
pipe.fit(X_train, y_train)              # Fits scaler, then classifier

predictions = pipe.predict(X_test)       # Scales X_test, then predicts

accuracy = pipe.score(X_test, y_test)    # All in one

print(f"Pipeline Accuracy: {accuracy:.2%}")

ColumnTransformer for Mixed Data

Real datasets have both numerical and categorical columns. ColumnTransformer applies different transformations to different columns.

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier

# Define column groups
numerical_cols = ['age', 'income', 'balance']
categorical_cols = ['gender', 'country', 'occupation']

# Create preprocessor
preprocessor = ColumnTransformer(
    transformers=[
        ('num', StandardScaler(), numerical_cols),
        ('cat', OneHotEncoder(handle_unknown='ignore'), categorical_cols)
    ]
)

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

Sklearn's model_selection module provides tools for splitting data, cross-validation, and hyperparameter tuning. These are essential for building robust models.

Cross-Validation

from sklearn.model_selection import cross_val_score, KFold

model = LogisticRegression()

# Simple 5-fold cross-validation
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f"CV Scores: {scores}")
print(f"Mean: {scores.mean():.3f} (+/- {scores.std()*2:.3f})")

# Custom KFold
kfold = KFold(n_splits=10, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=kfold)
print(f"10-Fold CV Mean: {scores.mean():.3f}")

Hyperparameter Tuning with GridSearchCV

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

# Define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 20, None],
    'min_samples_split': [2, 5, 10]
}

# Create grid search
grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,           # Use all CPU cores
    verbose=1
)

# Fit to find best parameters
grid_search.fit(X_train, y_train)

print(f"Best Parameters: {grid_search.best_params_}")
print(f"Best CV Score: {grid_search.best_score_:.3f}")

# Use best model
best_model = grid_search.best_estimator_
test_accuracy = best_model.score(X_test, y_test)
print(f"Test Accuracy: {test_accuracy:.3f}")

Saving and Loading Models

import joblib

# Save model to file
joblib.dump(best_model, 'random_forest_model.joblib')

# Load model later
loaded_model = joblib.load('random_forest_model.joblib')

# Use loaded model
predictions = loaded_model.predict(X_new)

# Save entire pipeline (recommended!)
joblib.dump(full_pipeline, 'complete_pipeline.joblib')

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

wine = load_wine()
X_train, X_test, y_train, y_test = train_test_split(
    wine.data, wine.target, test_size=0.2, random_state=42)

model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)
print(f"Accuracy: {model.score(X_test, y_test):.2%}")

from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier

iris = load_iris()
models = {
    'Logistic Regression': LogisticRegression(max_iter=200),
    'Decision Tree': DecisionTreeClassifier(),
    'Random Forest': RandomForestClassifier()
}

for name, model in models.items():
    scores = cross_val_score(model, iris.data, iris.target, cv=5)
    print(f"{name}: {scores.mean():.3f} (+/- {scores.std()*2:.3f})")

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier

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)

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('rf', RandomForestClassifier(random_state=42))
])

param_grid = {
    'rf__n_estimators': [50, 100, 200],
    'rf__max_depth': [5, 10, None]
}

grid = GridSearchCV(pipe, param_grid, cv=5, n_jobs=-1)
grid.fit(X_train, y_train)

print(f"Best params: {grid.best_params_}")
print(f"Test score: {grid.score(X_test, y_test):.3f}")