How to Choose the Right Algorithm as a Beginner

# TheCodeForge — Algorithm Selection Decision Flow
# Run this to map your problem to the right algorithm family

def choose_algorithm(has_labels: bool, goal: str, n_classes: int = None) -> str:
    """
    A structured decision flow for algorithm family selection.

    Parameters:
    -----------
    has_labels : bool
        True if your dataset has a target variable (supervised learning).
    goal : str
        One of: 'predict_number', 'predict_category',
                'find_groups', 'reduce_dimensions'
    n_classes : int or None
        Number of unique target classes (for classification problems).

    Returns:
    --------
    str : Recommended algorithm family and starting point.
    """
    if has_labels:
        if goal == 'predict_number':
            return (
                "Regression family.\n"
                "Start with: Linear Regression\n"
                "Evaluate with: MAE, RMSE (not accuracy)\n"
                "Watch for: outliers skewing coefficients"
            )
        elif goal == 'predict_category':
            if n_classes == 2:
                return (
                    "Binary Classification.\n"
                    "Start with: Logistic Regression\n"
                    "Evaluate with: Precision, Recall, F1-score, AUC-ROC\n"
                    "Watch for: class imbalance inflating accuracy"
                )
            elif n_classes and n_classes > 2:
                return (
                    "Multi-class Classification.\n"
                    "Start with: Logistic Regression (multi_class='auto')\n"
                    "Or: Decision Tree for non-linear boundaries\n"
                    "Evaluate with: Macro F1-score, per-class precision/recall"
                )
        else:
            return "Check your goal definition — labeled data implies supervised learning."
    else:
        if goal == 'find_groups':
            return (
                "Clustering family.\n"
                "Start with: K-Means (if K is known or estimable)\n"
                "Alternative: DBSCAN (if cluster shapes are irregular)\n"
                "Evaluate with: Silhouette Score, Inertia (elbow method)"
            )
        elif goal == 'reduce_dimensions':
            return (
                "Dimensionality Reduction.\n"
                "Start with: PCA for linear reduction\n"
                "Alternative: t-SNE or UMAP for visualization\n"
                "Note: scale features first — PCA is sensitive to magnitude"
            )
        else:
            return "Need more problem definition — can you obtain any labels?"

# Example usage
print(choose_algorithm(has_labels=True, goal='predict_category', n_classes=2))
print()
print(choose_algorithm(has_labels=False, goal='find_groups'))
print()
print(choose_algorithm(has_labels=True, goal='predict_number'))

# TheCodeForge — Regression: Predicting Continuous Values
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np

# Load dataset — predicting median house values
X, y = fetch_california_housing(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(f'Target range: ${y.min():.2f} to ${y.max():.2f} (units: $100k)')
print(f'Training samples: {len(X_train)}, Test samples: {len(X_test)}')

# Model 1: Linear Regression (always start here)
lr_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', LinearRegression())
])
lr_pipeline.fit(X_train, y_train)
y_pred_lr = lr_pipeline.predict(X_test)

mae_lr = mean_absolute_error(y_test, y_pred_lr)
rmse_lr = np.sqrt(mean_squared_error(y_test, y_pred_lr))
r2_lr = r2_score(y_test, y_pred_lr)

print(f'\n=== Linear Regression (Baseline) ===')
print(f'MAE:  {mae_lr:.4f} (avg error: ${mae_lr * 100:.0f}k)')
print(f'RMSE: {rmse_lr:.4f}')
print(f'R²:   {r2_lr:.4f} (explains {r2_lr:.1%} of variance)')

# Model 2: Decision Tree Regressor (for non-linear relationships)
dt_pipeline = Pipeline([
    ('model', DecisionTreeRegressor(max_depth=6, random_state=42))
])
dt_pipeline.fit(X_train, y_train)
y_pred_dt = dt_pipeline.predict(X_test)

mae_dt = mean_absolute_error(y_test, y_pred_dt)
rmse_dt = np.sqrt(mean_squared_error(y_test, y_pred_dt))
r2_dt = r2_score(y_test, y_pred_dt)

print(f'\n=== Decision Tree Regressor (max_depth=6) ===')
print(f'MAE:  {mae_dt:.4f} (avg error: ${mae_dt * 100:.0f}k)')
print(f'RMSE: {rmse_dt:.4f}')
print(f'R²:   {r2_dt:.4f} (explains {r2_dt:.1%} of variance)')

# Residual check — patterns in residuals indicate missed structure
residuals = y_test - y_pred_lr
print(f'\n=== Residual Diagnostics (Linear Regression) ===')
print(f'Mean residual:   {residuals.mean():.4f} (should be near 0)')
print(f'Residual std:    {residuals.std():.4f}')
print(f'Max over-pred:   {residuals.min():.4f}')
print(f'Max under-pred:  {residuals.max():.4f}')
print(f'\nIf residuals show patterns, the relationship is non-linear.')
print(f'Consider Decision Tree, Random Forest, or feature engineering.')

# TheCodeForge — Classification: Predicting Categories
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import (
    classification_report, confusion_matrix,
    roc_auc_score, accuracy_score
)
import numpy as np

# Binary classification with moderate class imbalance
X, y = make_classification(
    n_samples=1000, n_features=10,
    weights=[0.75, 0.25],  # 75% class 0, 25% class 1
    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
)

print('Class distribution (training):')
unique, counts = np.unique(y_train, return_counts=True)
for cls, cnt in zip(unique, counts):
    print(f'  Class {cls}: {cnt} samples ({cnt/len(y_train):.1%})')

# Model 1: Logistic Regression (start here for binary classification)
lr_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', LogisticRegression(class_weight='balanced', random_state=42))
])
lr_pipeline.fit(X_train, y_train)
y_pred_lr = lr_pipeline.predict(X_test)
y_prob_lr = lr_pipeline.predict_proba(X_test)[:, 1]

print(f'\n=== Logistic Regression ===')
print(f'Accuracy:  {accuracy_score(y_test, y_pred_lr):.2%}  <- often misleading')
print(f'AUC-ROC:   {roc_auc_score(y_test, y_prob_lr):.4f}  <- use this')
print(f'\nClassification Report:')
print(classification_report(y_test, y_pred_lr, target_names=['No Churn', 'Churn']))
print(f'Confusion Matrix:')
print(confusion_matrix(y_test, y_pred_lr))

# Model 2: Decision Tree (for interpretable non-linear boundaries)
dt_pipeline = Pipeline([
    ('classifier', DecisionTreeClassifier(
        max_depth=5, class_weight='balanced', random_state=42
    ))
])
dt_pipeline.fit(X_train, y_train)
y_pred_dt = dt_pipeline.predict(X_test)
y_prob_dt = dt_pipeline.predict_proba(X_test)[:, 1]

print(f'\n=== Decision Tree (max_depth=5) ===')
print(f'Accuracy:  {accuracy_score(y_test, y_pred_dt):.2%}')
print(f'AUC-ROC:   {roc_auc_score(y_test, y_prob_dt):.4f}')
print(f'\nClassification Report:')
print(classification_report(y_test, y_pred_dt, target_names=['No Churn', 'Churn']))

# Decision threshold tuning
print(f'\n=== Threshold Tuning (Logistic Regression) ===')
print(f'Default threshold (0.5): predicts class 1 if P(churn) > 0.5')
print(f'Lower threshold (0.3): catches more churners, more false alarms')
print(f'Higher threshold (0.7): fewer false alarms, misses more churners')
for threshold in [0.3, 0.5, 0.7]:
    y_pred_t = (y_prob_lr >= threshold).astype(int)
    from sklearn.metrics import precision_score, recall_score
    p = precision_score(y_test, y_pred_t)
    r = recall_score(y_test, y_pred_t)
    print(f'  Threshold {threshold}: Precision={p:.2%}, Recall={r:.2%}')

# TheCodeForge — Clustering: Finding Natural Groups
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans, DBSCAN
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score

# Simulated customer data — 3 natural segments
X, true_labels = make_blobs(
    n_samples=300, centers=3, cluster_std=1.2, random_state=42
)
# Scale features — critical for distance-based algorithms
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 1: Find the right K using the elbow method
print('=== Elbow Method: Finding the Right K ===')
inertias = []
silhouette_scores = []
K_range = range(2, 9)
for k in K_range:
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    kmeans.fit(X_scaled)
    inertias.append(kmeans.inertia_)
    score = silhouette_score(X_scaled, kmeans.labels_)
    silhouette_scores.append(score)
    print(f'  K={k}: Inertia={kmeans.inertia_:.1f}, Silhouette={score:.3f}')

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

# Step 2: Fit K-Means with the best K
kmeans_final = KMeans(n_clusters=best_k, random_state=42, n_init=10)
kmeans_final.fit(X_scaled)
km_labels = kmeans_final.labels_

print(f'\n=== K-Means Results (K={best_k}) ===')
for cluster_id in range(best_k):
    cluster_size = np.sum(km_labels == cluster_id)
    print(f'  Cluster {cluster_id}: {cluster_size} samples ({cluster_size/len(X):.1%})')
print(f'Final silhouette score: {silhouette_score(X_scaled, km_labels):.3f}')
print(f'  (0 = overlapping, 1 = well-separated — higher is better)')

# Step 3: DBSCAN for when K is unknown or clusters are irregular
print(f'\n=== DBSCAN (no K required) ===')
dbscan = DBSCAN(eps=0.5, min_samples=5)
db_labels = dbscan.fit_predict(X_scaled)
n_clusters = len(set(db_labels)) - (1 if -1 in db_labels else 0)
n_noise = np.sum(db_labels == -1)
print(f'  Clusters found: {n_clusters}')
print(f'  Noise points:   {n_noise} ({n_noise/len(X):.1%} of data)')
if n_clusters > 1:
    non_noise = db_labels != -1
    print(f'  Silhouette score: {silhouette_score(X_scaled[non_noise], db_labels[non_noise]):.3f}')

# Step 4: Profile the clusters — make them actionable
print(f'\n=== Cluster Profiles (K-Means) ===')
print('Always profile clusters — statistical groupings need business meaning.')
for cluster_id in range(best_k):
    mask = km_labels == cluster_id
    cluster_data = X[mask]
    print(f'\n  Cluster {cluster_id} ({np.sum(mask)} members):')
    print(f'    Feature 0 mean: {cluster_data[:, 0].mean():.2f}')
    print(f'    Feature 1 mean: {cluster_data[:, 1].mean():.2f}')