Supervised vs Unsupervised — Label Trap That Kills

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# Supervised learning: classification with labelled data
# Dataset: predict whether a customer will churn (1) or stay (0)
# Features: usage_minutes, support_tickets, months_active

X = np.array([
    [120, 3, 24],   # moderate usage, few tickets, long tenure
    [45,  8,  6],   # low usage, many tickets, new customer
    [200, 1, 36],   # high usage, few tickets, long tenure
    [30, 12,  3],   # very low usage, many tickets, very new
    [180, 2, 18],   # high usage, few tickets, mid tenure
    [60,  7,  8],   # low usage, several tickets, new
    [250, 0, 48],   # very high usage, zero tickets, veteran
    [40, 10,  4],   # low usage, many tickets, new
])

# Labels: 0 = stayed, 1 = churned (the answer key)
# These labels were sourced from historical CRM records — not invented
y = np.array([0, 1, 0, 1, 0, 1, 0, 1])

# Split into training and test sets
# stratify=y preserves the class ratio in both splits
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42, stratify=y
)

# Train the model — it learns the mapping X -> y during fit()
model = RandomForestClassifier(
    n_estimators=100,
    max_depth=5,          # prevent overfitting on small dataset
    random_state=42
)
model.fit(X_train, y_train)

# Predict on new data the model has never seen
predictions = model.predict(X_test)
print(f'Predictions: {predictions}')
print(f'Actual:      {y_test}')

# classification_report shows per-class precision, recall, F1
# Never rely only on accuracy — it hides class imbalance problems
print(classification_report(y_test, predictions,
      target_names=['stayed', 'churned']))

# Feature importance — which inputs drove predictions most?
for feature, importance in zip(
    ['usage_minutes', 'support_tickets', 'months_active'],
    model.feature_importances_
):
    print(f'  {feature}: {importance:.3f}')

import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score

# Unsupervised learning: clustering without labels
# Dataset: customer behaviour data — no predefined segments exist
# Features: annual_spend ($), visit_frequency (visits/year), avg_cart_value ($)

X = np.array([
    [5000,  50,  100],   # moderate spend, frequent, small carts
    [4800,  48,  100],
    [5200,  52,  100],
    [200,   12,   17],   # low spend, infrequent, very small carts
    [180,   10,   18],
    [220,   14,   16],
    [12000,  8, 1500],   # high spend, rare visits, very large carts
    [11500,  7, 1643],
    [12500,  9, 1389],
    [300,   45,    7],   # low spend, frequent, tiny carts (browse-heavy)
    [250,   40,    6],
    [280,   42,    7],
])

# IMPORTANT: scale features before clustering
# KMeans uses Euclidean distance — unscaled spend (0-12000) will
# completely dominate cart value (6-1643) and crush the signal
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Find optimal K using silhouette score
print('Searching for optimal K:')
print('K | Silhouette Score | Inertia')
print('--|-------------------|--------')
best_k, best_score = 2, -1
for k in range(2, 6):
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(X_scaled)
    score = silhouette_score(X_scaled, labels)
    print(f'{k} | {score:.4f}             | {km.inertia_:.1f}')
    if score > best_score:
        best_score, best_k = score, k

print(f'\nBest K = {best_k} (silhouette = {best_score:.4f})')

# Fit with best K and inspect discovered segments
kmeans = KMeans(n_clusters=best_k, random_state=42, n_init=10)
clusters = kmeans.fit_predict(X_scaled)

print('\nDiscovered cluster assignments:')
for i, cluster in enumerate(clusters):
    print(f'  Customer {i+1}: spend=${X[i][0]}, '
          f'visits={X[i][1]}, cart=${X[i][2]} -> Cluster {cluster}')

print('\nCluster profiles (domain expert interpretation needed):')
for i in range(best_k):
    members = X[clusters == i]
    print(f'  Cluster {i}: {len(members)} customers | '
          f'avg spend=${members[:, 0].mean():.0f} | '
          f'avg visits={members[:, 1].mean():.0f} | '
          f'avg cart=${members[:, 2].mean():.0f}')

# Decision framework: supervised vs unsupervised
def recommend_approach(has_labels, goal, label_quality_validated,
                       labeling_budget_days):
    """
    Return the recommended ML paradigm based on your actual situation.

    Parameters
    ----------
    has_labels              : bool  — do labelled examples exist?
    goal                    : str   — what are you trying to accomplish?
    label_quality_validated : bool  — have labels been audited for quality?
    labeling_budget_days    : int   — days available for labelling effort
    """

    if has_labels and label_quality_validated and labeling_budget_days > 0:
        if goal in ['classify', 'predict_category', 'detect']:
            return {
                'approach': 'Supervised — Classification',
                'algorithms': [
                    'Logistic Regression (interpretable baseline)',
                    'Random Forest (robust, handles nonlinearity)',
                    'XGBoost (high performance, competition favourite)'
                ],
                'evaluation': 'Accuracy, Precision, Recall, F1, AUC-ROC',
                'watch_out': 'Class imbalance — always use stratified splits',
                'data_requirement': '500+ validated labelled examples per class'
            }
        elif goal in ['predict_number', 'forecast', 'estimate']:
            return {
                'approach': 'Supervised — Regression',
                'algorithms': [
                    'Linear Regression (interpretable baseline)',
                    'Gradient Boosting Regressor (high performance)',
                    'XGBoost / LightGBM (production default)'
                ],
                'evaluation': 'MAE, RMSE, R-squared — report all three',
                'watch_out': 'Outliers inflate RMSE — check both MAE and RMSE',
                'data_requirement': '1000+ labelled examples'
            }

    elif not has_labels or labeling_budget_days == 0:
        if goal in ['group', 'segment', 'discover_structure', 'explore']:
            return {
                'approach': 'Unsupervised — Clustering',
                'algorithms': [
                    'K-Means (fast, interpretable, assumes spherical clusters)',
                    'DBSCAN (finds arbitrarily shaped clusters, handles noise)',
                    'Hierarchical (no K needed, good for small datasets)'
                ],
                'evaluation': 'Silhouette Score, Inertia, Domain Expert Validation',
                'watch_out': 'Scale features first — distance metrics break on raw data',
                'data_requirement': 'Any volume — more data = more stable clusters'
            }
        elif goal in ['reduce_dimensions', 'visualize', 'compress',
                      'feature_engineering']:
            return {
                'approach': 'Unsupervised — Dimensionality Reduction',
                'algorithms': [
                    'PCA (linear, fast, variance explained is interpretable)',
                    't-SNE (nonlinear, good for visualization, slow on large data)',
                    'UMAP (nonlinear, faster than t-SNE, preserves global structure)'
                ],
                'evaluation': 'Variance Explained (PCA), Visual Cluster Separation',
                'watch_out': 't-SNE is for visualization only — do not use as features',
                'data_requirement': 'Any volume'
            }

    elif has_labels and not label_quality_validated:
        return {
            'approach': 'Audit labels first before choosing paradigm',
            'reason': 'Unvalidated labels may be arbitrary — training on them '
                      'produces a model that confidently predicts the wrong thing.',
            'next_step': 'Measure inter-annotator agreement. If kappa < 0.6, '
                         'your labels are not reliable enough for supervised training.'
        }

    # Hybrid: no labels and complex goal
    return {
        'approach': 'Hybrid — start unsupervised, then label discovered groups',
        'steps': [
            '1. Cluster the unlabelled data to discover natural groups.',
            '2. Validate clusters with domain experts.',
            '3. Label cluster centroids instead of individual records.',
            '4. Train a supervised classifier on the validated cluster labels.',
            '5. Use the classifier to assign new records to discovered segments.'
        ]
    }


# Examples
print(recommend_approach(
    has_labels=True, goal='classify',
    label_quality_validated=True, labeling_budget_days=10
))
print()
print(recommend_approach(
    has_labels=False, goal='segment',
    label_quality_validated=False, labeling_budget_days=0
))
print()
print(recommend_approach(
    has_labels=True, goal='classify',
    label_quality_validated=False, labeling_budget_days=5
))

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

# Generate a realistic imbalanced classification dataset
# 90% class 0, 10% class 1 — typical of fraud or churn scenarios
X, y = make_classification(
    n_samples=1000,
    n_features=10,
    n_informative=5,
    n_redundant=2,
    n_classes=2,
    weights=[0.9, 0.1],   # 900 negative, 100 positive
    random_state=42
)

# stratify=y is mandatory on imbalanced data
# Without it, the test set might have no positive examples at all
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

print(f'Train class distribution: '
      f'{dict(zip(*np.unique(y_train, return_counts=True)))}')
print(f'Test class distribution:  '
      f'{dict(zip(*np.unique(y_test, return_counts=True)))}')
print()

# Train two models: a simple baseline and a stronger model
models = [
    ('Logistic Regression (baseline)',
     LogisticRegression(class_weight='balanced', random_state=42, max_iter=1000)),
    ('Random Forest',
     RandomForestClassifier(n_estimators=100, class_weight='balanced',
                            random_state=42))
]

for name, model in models:
    model.fit(X_train, y_train)
    predictions = model.predict(X_test)
    probabilities = model.predict_proba(X_test)[:, 1]

    auc = roc_auc_score(y_test, probabilities)

    print(f'=== {name} ===')
    print(f'AUC-ROC: {auc:.4f}  '
          f'(0.5 = random, 1.0 = perfect)')
    print(classification_report(y_test, predictions,
                                target_names=['stayed', 'churned']))
    print(f'Confusion Matrix:')
    cm = confusion_matrix(y_test, predictions)
    print(f'  True Negatives:  {cm[0][0]:4d} | False Positives: {cm[0][1]:4d}')
    print(f'  False Negatives: {cm[1][0]:4d} | True Positives:  {cm[1][1]:4d}')
    print()

# KEY LESSON: a model that always predicts class 0 achieves 90% accuracy
# but AUC-ROC of 0.5 and recall of 0 for the positive class
class_zero_baseline = np.zeros(len(y_test), dtype=int)
print('=== Always-Predict-Zero Baseline ===')
print(f'Accuracy: {(class_zero_baseline == y_test).mean():.2%}  '
      f'(looks great — but catches zero positives)')
print(classification_report(y_test, class_zero_baseline,
                             target_names=['stayed', 'churned'],
                             zero_division=0))

import numpy as np
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

# Generate regression data with noise and some informative features
X, y = make_regression(
    n_samples=500,
    n_features=8,
    n_informative=4,   # only 4 of 8 features actually predict y
    noise=25,
    random_state=42
)

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

def evaluate_regression(name, model, X_train, X_test, y_train, y_test):
    """Fit a model and print all three regression metrics."""
    model.fit(X_train, y_train)
    predictions = model.predict(X_test)

    mae  = mean_absolute_error(y_test, predictions)
    rmse = np.sqrt(mean_squared_error(y_test, predictions))
    r2   = r2_score(y_test, predictions)

    print(f'=== {name} ===')
    print(f'  MAE:  {mae:.2f}  (avg absolute error, same units as target)')
    print(f'  RMSE: {rmse:.2f}  (penalises large errors more than MAE)')
    print(f'  R²:   {r2:.4f}  (1.0 = perfect, 0.0 = predicts mean, <0 = bad)')
    print()

# Model 1: Linear Regression without scaling — naive baseline
evaluate_regression(
    'Linear Regression (no scaling)',
    LinearRegression(), X_train, X_test, y_train, y_test
)

# Model 2: Ridge Regression with scaling inside a Pipeline
# Pipeline ensures the scaler is fit on training data only,
# preventing data leakage into the validation set
ridge_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('ridge',  Ridge(alpha=1.0))
])
evaluate_regression(
    'Ridge Regression (scaled, L2 regularisation)',
    ridge_pipeline, X_train, X_test, y_train, y_test
)

# Model 3: Gradient Boosting — handles nonlinearity and feature interactions
evaluate_regression(
    'Gradient Boosting Regressor',
    GradientBoostingRegressor(n_estimators=200, learning_rate=0.05,
                              max_depth=4, random_state=42),
    X_train, X_test, y_train, y_test
)

# Cross-validation: more reliable than a single train/test split
gb = GradientBoostingRegressor(n_estimators=200, learning_rate=0.05,
                               max_depth=4, random_state=42)
cv_scores = cross_val_score(gb, X, y, cv=5, scoring='neg_mean_absolute_error')
print(f'5-Fold CV MAE: {-cv_scores.mean():.2f} +/- {cv_scores.std():.2f}')
print('(More reliable than a single test split)')

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans, DBSCAN
from sklearn.metrics import silhouette_score
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

# Customer behaviour data — 3 natural segments exist in this dataset
# Features: annual_spend ($), visit_frequency (visits/year), avg_cart_value ($)
np.random.seed(42)
X = np.array([
    # Segment A: moderate spend, frequent, small carts
    [5000, 50, 100], [4800, 48, 100], [5200, 52, 100],
    [4900, 49,  98], [5100, 51, 102], [4700, 47,  99],
    # Segment B: low spend, infrequent, tiny carts
    [200, 12, 17], [180, 10, 18], [220, 14, 16],
    [190, 11, 17], [210, 13, 16], [230, 15, 15],
    # Segment C: high spend, rare visits, large carts
    [12000, 8, 1500], [11500, 7, 1643], [12500, 9, 1389],
    [11800, 8, 1475], [12200, 9, 1356], [11200, 7, 1600],
    # Segment D (browse-heavy): low spend, very frequent, tiny carts
    [300, 45, 7], [250, 40, 6], [280, 42, 7],
    [260, 41, 6], [310, 46, 7], [270, 43, 6],
])

# Scale features BEFORE clustering
# Distance-based algorithms are dominated by the largest-scale feature
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# --- Method 1: Elbow plot (inertia vs K) ---
inertias = []
silhouettes = []
K_range = range(2, 8)

for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(X_scaled)
    inertias.append(km.inertia_)
    silhouettes.append(silhouette_score(X_scaled, labels))

print('K  | Inertia   | Silhouette')
print('---|-----------|----------')
for k, inertia, sil in zip(K_range, inertias, silhouettes):
    print(f'{k}  | {inertia:9.1f} | {sil:.4f}')

best_k = K_range[np.argmax(silhouettes)]
print(f'\nBest K by silhouette: {best_k}')

# --- Fit final model with best K ---
kmeans = KMeans(n_clusters=best_k, random_state=42, n_init=10)
clusters = kmeans.fit_predict(X_scaled)

print(f'\nCluster profiles (needs domain expert interpretation):')
for i in range(best_k):
    members = X[clusters == i]
    print(f'  Cluster {i} — {len(members)} customers:')
    print(f'    Avg spend:     ${members[:, 0].mean():,.0f}')
    print(f'    Avg visits:    {members[:, 1].mean():.0f}/year')
    print(f'    Avg cart:      ${members[:, 2].mean():,.0f}')

# --- Visualise clusters using PCA (2D projection) ---
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
print(f'\nPCA variance explained: '
      f'{pca.explained_variance_ratio_.sum():.1%} in 2 components')

fig, ax = plt.subplots(figsize=(8, 6))
colors = ['#e74c3c', '#2ecc71', '#3498db', '#f39c12']
for i in range(best_k):
    mask = clusters == i
    ax.scatter(X_pca[mask, 0], X_pca[mask, 1],
               c=colors[i], label=f'Cluster {i}',
               s=100, edgecolors='black', linewidth=0.5)
ax.set_title(f'Customer Segments (K={best_k}) — PCA Projection',
             fontweight='bold')
ax.set_xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.1%} variance)')
ax.set_ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.1%} variance)')
ax.legend()
fig.tight_layout()
fig.savefig('clusters_pca.png', dpi=300, bbox_inches='tight')
plt.close(fig)
print('Saved clusters_pca.png')

// io.thecodeforge
import pandas as pd
from sklearn.model_selection import train_test_split

# DANGER: using 'total_monthly_spend' which is computed AFTER the prediction date
df = pd.read_csv('customer_data.csv')
# Feature 'total_monthly_spend' includes future transactions
X = df[['age', 'tenure_days', 'total_monthly_spend']]
y = df['churned']

# Toxic split: no temporal guard
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Real fix: sort by timestamp, split by date, never random
# sorted_df = df.sort_values('prediction_timestamp')
# cutoff = int(len(sorted_df) * 0.8)
# X_train = sorted_df.iloc[:cutoff][['age', 'tenure_days']]  # no total_monthly_spend
# X_test = sorted_df.iloc[cutoff:][['age', 'tenure_days']]

// io.thecodeforge
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
import numpy as np

# 200 labeled, 9800 unlabeled
X_labeled = np.random.rand(200, 10)
y_labeled = np.random.randint(0, 2, 200)
X_unlabeled = np.random.rand(9800, 10)

model = SVC(probability=True, C=1.0)
model.fit(X_labeled, y_labeled)

# Self-training loop - max 5 iterations
for i in range(5):
    probs = model.predict_proba(X_unlabeled)
    max_probs = np.max(probs, axis=1)
    high_conf_mask = max_probs > 0.95
    if np.sum(high_conf_mask) == 0:
        break  # No more high-confidence samples
    X_pseudo = X_unlabeled[high_conf_mask]
    y_pseudo = np.argmax(probs[high_conf_mask], axis=1)
    # Append to labeled set
    X_labeled = np.vstack([X_labeled, X_pseudo])
    y_labeled = np.hstack([y_labeled, y_pseudo])
    model.fit(X_labeled, y_labeled)
    print(f'Iteration {i+1}: added {len(y_pseudo)} pseudo-labels')