Supervised vs Unsupervised vs Reinforcement Learning – Simple Explanation

# TheCodeForge — Supervised Learning: Real-World Examples
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
from sklearn.ensemble import RandomForestClassifier, GradientBoostingRegressor
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import (
    accuracy_score, f1_score, classification_report,
    mean_absolute_error, r2_score
)

np.random.seed(42)

# EXAMPLE 1: CLASSIFICATION — Predict customer churn (binary label)
# Each customer has features and a known outcome: churned (1) or retained (0)
print('=== CLASSIFICATION: Customer Churn Prediction ===')
n = 1000
X_clf = pd.DataFrame({
    'tenure_months':    np.random.randint(1, 72, n),
    'monthly_charges':  np.random.uniform(20, 100, n),
    'support_tickets':  np.random.poisson(2, n),
    'contract_type':    np.random.choice([0, 1, 2], n),
    'num_products':     np.random.randint(1, 5, n)
})
y_clf = ((X_clf['tenure_months'] < 12) & (X_clf['monthly_charges'] > 65)).astype(int)

X_train, X_test, y_train, y_test = train_test_split(
    X_clf, y_clf, test_size=0.2, random_state=42, stratify=y_clf
)

clf_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', RandomForestClassifier(n_estimators=200, class_weight='balanced', random_state=42))
])
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
cv_scores = cross_val_score(clf_pipeline, X_train, y_train, cv=cv, scoring='f1')
clf_pipeline.fit(X_train, y_train)
preds = clf_pipeline.predict(X_test)
print(f'CV F1: {cv_scores.mean():.3f} (+/- {cv_scores.std():.3f})')
print(f'Test F1: {f1_score(y_test, preds):.3f}')
print(f'Test Accuracy: {accuracy_score(y_test, preds):.3f}')

# Feature importance — supervised learning is interpretable
importances = clf_pipeline.named_steps['model'].feature_importances_
for feat, imp in sorted(zip(X_clf.columns, importances), key=lambda x: -x[1]):
    print(f'  {feat}: {imp:.3f}')

# EXAMPLE 2: REGRESSION — Predict house price (continuous label)
print('\n=== REGRESSION: House Price Prediction ===')
X_reg = pd.DataFrame({
    'sqft':        np.random.randint(800, 4000, n),
    'bedrooms':    np.random.randint(1, 6, n),
    'bathrooms':   np.random.randint(1, 4, n),
    'age_years':   np.random.randint(0, 50, n),
    'distance_km': np.random.uniform(1, 30, n)
})
y_reg = (X_reg['sqft'] * 150 - X_reg['age_years'] * 1000 +
         X_reg['bathrooms'] * 10000 - X_reg['distance_km'] * 2000 +
         np.random.normal(0, 20000, n))

X_r_train, X_r_test, y_r_train, y_r_test = train_test_split(
    X_reg, y_reg, test_size=0.2, random_state=42
)
reg_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', GradientBoostingRegressor(n_estimators=200, random_state=42))
])
reg_pipeline.fit(X_r_train, y_r_train)
y_pred_reg = reg_pipeline.predict(X_r_test)
print(f'MAE: ${mean_absolute_error(y_r_test, y_pred_reg):,.0f}')
print(f'R-squared: {r2_score(y_r_test, y_pred_reg):.3f}')

print('\nSupervised learning: every example has a known correct answer.')

# TheCodeForge — Unsupervised Learning: Real-World Examples
import numpy as np
from sklearn.cluster import KMeans, DBSCAN
from sklearn.decomposition import PCA
from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score, davies_bouldin_score
from sklearn.datasets import make_blobs

np.random.seed(42)

# EXAMPLE 1: CLUSTERING — Discover customer segments without predefined categories
print('=== CLUSTERING: Customer Segment Discovery ===')
X_customers, _ = make_blobs(
    n_samples=600, centers=4, n_features=5,
    cluster_std=1.2, random_state=42
)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_customers)

# Find the optimal number of clusters using silhouette score
print('Silhouette scores by cluster count:')
best_k, best_score = 2, -1
for k in range(2, 8):
    km = KMeans(n_clusters=k, n_init=15, random_state=42)
    labels = km.fit_predict(X_scaled)
    score = silhouette_score(X_scaled, labels)
    db_score = davies_bouldin_score(X_scaled, labels)
    marker = ' <-- best so far' if score > best_score else ''
    print(f'  K={k}: silhouette={score:.3f}, davies_bouldin={db_score:.3f}{marker}')
    if score > best_score:
        best_score, best_k = score, k

km_final = KMeans(n_clusters=best_k, n_init=15, random_state=42)
segments = km_final.fit_predict(X_scaled)
print(f'\nOptimal segments: {best_k}')
print(f'Segment sizes: {np.bincount(segments)}')
print(f'Best silhouette: {best_score:.3f}')

# EXAMPLE 2: DIMENSIONALITY REDUCTION — Compress 50 features to 2 for visualization
print('\n=== DIMENSIONALITY REDUCTION: PCA ===')
X_high = np.random.randn(400, 50)
# Inject structure: first 5 features carry real signal
X_high[:200, :5] += 3
pca = PCA(n_components=10)
X_pca = pca.fit_transform(X_high)
cumulative_variance = np.cumsum(pca.explained_variance_ratio_)
for i, var in enumerate(cumulative_variance, 1):
    print(f'  {i} components: {var:.1%} variance explained')
    if var >= 0.80:
        print(f'  --> {i} components capture 80%+ of variance')
        break

# EXAMPLE 3: ANOMALY DETECTION — Flag unusual transactions
print('\n=== ANOMALY DETECTION: Isolation Forest ===')
X_normal = np.random.randn(980, 6)            # normal transactions
X_anomalies = np.random.randn(20, 6) * 4 + 6  # anomalous transactions
X_all = np.vstack([X_normal, X_anomalies])

iso = IsolationForest(contamination=0.02, n_estimators=200, random_state=42)
predictions = iso.fit_predict(X_all)
n_detected = (predictions == -1).sum()
print(f'Total transactions: {len(X_all)}')
print(f'True anomalies: 20')
print(f'Detected anomalies: {n_detected}')

# EXAMPLE 4: DBSCAN — Handles arbitrary cluster shapes and noise
print('\n=== DBSCAN: Density-Based Clustering ===')
from sklearn.datasets import make_moons
X_moons, _ = make_moons(n_samples=300, noise=0.08, random_state=42)
dbscan = DBSCAN(eps=0.2, min_samples=5)
db_labels = dbscan.fit_predict(X_moons)
n_clusters = len(set(db_labels)) - (1 if -1 in db_labels else 0)
n_noise = (db_labels == -1).sum()
print(f'Clusters found: {n_clusters} (K-Means would force a fixed K)')
print(f'Noise points (no cluster): {n_noise}')
print('\nUnsupervised learning discovers structure without labeled data.')

# TheCodeForge — Reinforcement Learning: Q-Learning from Scratch
import numpy as np

# ENVIRONMENT: 4x4 grid navigation
# Agent starts at (0,0), goal is (3,3)
# Reward: -1 per step, +10 for reaching goal, -5 for hitting wall (no movement)
# Actions: 0=up, 1=down, 2=left, 3=right

class GridEnvironment:
    def __init__(self, size=4):
        self.size = size
        self.goal = (size - 1, size - 1)
        self.state = (0, 0)
        self.max_steps = 50
        self.steps = 0

    def reset(self):
        self.state = (0, 0)
        self.steps = 0
        return self.state

    def step(self, action):
        row, col = self.state
        prev = (row, col)
        if action == 0: row = max(0, row - 1)          # up
        elif action == 1: row = min(self.size-1, row+1) # down
        elif action == 2: col = max(0, col - 1)         # left
        elif action == 3: col = min(self.size-1, col+1) # right

        self.state = (row, col)
        self.steps += 1

        if self.state == self.goal:
            return self.state, 10.0, True   # reached goal
        if self.state == prev:
            return self.state, -2.0, False  # hit wall — wasted step
        if self.steps >= self.max_steps:
            return self.state, -1.0, True   # timeout
        return self.state, -0.1, False      # step penalty encourages efficiency

# Q-LEARNING: learn the value of each state-action pair
env = GridEnvironment(size=4)
q_table = np.zeros((4, 4, 4))  # Q[row][col][action]

# Hyperparameters
lr = 0.1             # learning rate
gamma = 0.95         # discount factor — how much to value future rewards
epsilon = 1.0        # start with full exploration
epsilon_decay = 0.995
epsilon_min = 0.05

episode_rewards = []

for episode in range(2000):
    state = env.reset()
    total_reward = 0
    done = False

    while not done:
        row, col = state
        # Epsilon-greedy action selection
        if np.random.rand() < epsilon:
            action = np.random.randint(4)  # explore
        else:
            action = np.argmax(q_table[row, col])  # exploit

        next_state, reward, done = env.step(action)
        next_row, next_col = next_state
        total_reward += reward

        # Bellman equation: Q(s,a) <- Q(s,a) + lr * [r + gamma * max Q(s',a') - Q(s,a)]
        best_next_q = np.max(q_table[next_row, next_col])
        q_table[row, col, action] += lr * (
            reward + gamma * best_next_q - q_table[row, col, action]
        )
        state = next_state

    epsilon = max(epsilon_min, epsilon * epsilon_decay)
    episode_rewards.append(total_reward)

    if (episode + 1) % 500 == 0:
        avg = np.mean(episode_rewards[-100:])
        print(f'Episode {episode+1:4d} | Avg reward (last 100): {avg:.2f} | Epsilon: {epsilon:.3f}')

# Display learned policy
arrow_map = {0: '↑', 1: '↓', 2: '←', 3: '→'}
print('\nLearned policy (optimal action per cell):')
for row in range(4):
    row_display = ''
    for col in range(4):
        if (row, col) == (3, 3):
            row_display += ' [G] '
        else:
            best = np.argmax(q_table[row, col])
            row_display += f'  {arrow_map[best]}  '
    print(row_display)
print('\nAgent learned to navigate from (0,0) to goal via trial and error — no labeled examples.')

# TheCodeForge — Self-Supervised Learning: Conceptual Implementation
# Demonstrates the masking pretext task that powers BERT-style models
import numpy as np

# SELF-SUPERVISED PRETEXT TASK: Masked Token Prediction
# The model learns by predicting masked parts of its own input
# No human labels needed — the label is the original unmasked data

np.random.seed(42)

# Simulate a vocabulary and tokenized sentences
VOCAB_SIZE = 50
SEQ_LEN = 10
MASK_PROB = 0.15  # mask 15% of tokens — the BERT convention
MASK_TOKEN = 0    # special [MASK] token id

def create_masked_input(tokens, mask_prob=MASK_PROB):
    """Mask random tokens and return masked input + positions + true labels."""
    masked = tokens.copy()
    masked_positions = []
    true_labels = []
    for i, token in enumerate(tokens):
        if np.random.rand() < mask_prob:
            masked_positions.append(i)
            true_labels.append(token)   # the label IS the original token
            masked[i] = MASK_TOKEN      # replace with [MASK]
    return masked, masked_positions, true_labels

# Generate synthetic tokenized sentences
sentences = np.random.randint(1, VOCAB_SIZE, size=(5, SEQ_LEN))

print('Self-Supervised Masked Token Prediction (BERT pretext task)')
print('=' * 60)
for i, sentence in enumerate(sentences):
    masked, positions, labels = create_masked_input(sentence)
    print(f'\nSentence {i+1}:')
    print(f'  Original: {sentence.tolist()}')
    print(f'  Masked:   {masked.tolist()}')
    if positions:
        print(f'  Masked positions: {positions}')
        print(f'  True labels (what the model must predict): {labels}')
        print(f'  --> Model trains on {len(positions)} self-generated label(s) from 0 human annotations')
    else:
        print(f'  No tokens masked this sentence (random — can happen at 15% rate)')

print('\n' + '=' * 60)
print('Scale comparison:')
print('  Supervised (ImageNet):    1.2M images, ~22K human-labeled categories')
print('  Self-supervised (CLIP):   400M image-text pairs, no per-image human labels')
print('  Self-supervised (GPT-3):  300B tokens, zero human labels during pretraining')
print('\nSelf-supervised learning scales to data volumes impossible with human labeling.')
print('Fine-tuning the pretrained model with labeled data = supervised learning on top.')

# TheCodeForge — Learning Type Decision Framework
from typing import Optional

def recommend_learning_type(
    has_labels: bool,
    label_count: int,
    is_sequential_decisions: bool,
    needs_structure_discovery: bool,
    pretrained_model_available: bool,
    domain: Optional[str] = None
) -> dict:
    """Recommend the appropriate ML learning type based on problem characteristics."""

    # Priority 1: Sequential decision problems with reward signal
    if is_sequential_decisions:
        return {
            'type': 'Reinforcement Learning',
            'reason': 'Problem requires optimizing a sequence of decisions over time',
            'algorithms': ['Q-Learning', 'PPO', 'DQN', 'SAC'],
            'difficulty': 'Hard',
            'data_requirement': 'Simulation environment or real-world interaction system',
            'warning': 'Only choose RL if decisions genuinely affect future states — most problems do not require it'
        }

    # Priority 2: NLP or vision with pretrained model available
    if pretrained_model_available and domain in ['nlp', 'vision', 'multimodal']:
        if has_labels and label_count >= 100:
            return {
                'type': 'Supervised Fine-Tuning (on self-supervised pretrained model)',
                'reason': 'Pretrained model available — fine-tune with labeled data',
                'algorithms': ['BERT fine-tuning', 'GPT fine-tuning', 'ViT fine-tuning'],
                'difficulty': 'Low-Medium',
                'data_requirement': f'As few as {label_count} labeled examples may be sufficient'
            }

    # Priority 3: Sufficient labeled data for classic supervised learning
    if has_labels and label_count >= 500:
        return {
            'type': 'Supervised Learning',
            'reason': 'Labeled data available — train directly on input-output pairs',
            'algorithms': ['Gradient Boosting', 'Random Forest', 'Logistic Regression', 'Neural Network'],
            'difficulty': 'Medium',
            'data_requirement': f'{label_count} labeled examples — consider data augmentation if fewer than 1000'
        }

    # Priority 4: Too few labels for classic supervised — consider semi-supervised
    if has_labels and label_count < 500:
        return {
            'type': 'Semi-Supervised or Transfer Learning',
            'reason': 'Too few labels for classic supervised — leverage unlabeled data or pretraining',
            'algorithms': ['Self-training', 'Label Propagation', 'Fine-tuning pretrained model'],
            'difficulty': 'Medium',
            'data_requirement': f'Use all {label_count} labeled examples plus unlabeled pool'
        }

    # Priority 5: No labels — unsupervised
    if needs_structure_discovery:
        return {
            'type': 'Unsupervised Learning',
            'reason': 'No labels available — discover hidden structure in the data',
            'algorithms': ['K-Means', 'DBSCAN', 'PCA', 'UMAP', 'Isolation Forest'],
            'difficulty': 'Medium',
            'data_requirement': 'Raw unlabeled data — more data improves cluster stability'
        }

    return {
        'type': 'Supervised Learning (after labeling)',
        'reason': 'Default recommendation — label a sample of data and start supervised',
        'algorithms': ['Start simple: Logistic Regression or Random Forest'],
        'difficulty': 'Low',
        'data_requirement': 'Label 500-1000 examples to start'
    }


# Test the decision framework on realistic scenarios
test_cases = [
    {'has_labels': True, 'label_count': 5000, 'is_sequential_decisions': False,
     'needs_structure_discovery': False, 'pretrained_model_available': False, 'domain': 'tabular'},
    {'has_labels': False, 'label_count': 0, 'is_sequential_decisions': False,
     'needs_structure_discovery': True, 'pretrained_model_available': False, 'domain': None},
    {'has_labels': False, 'label_count': 0, 'is_sequential_decisions': True,
     'needs_structure_discovery': False, 'pretrained_model_available': False, 'domain': None},
    {'has_labels': True, 'label_count': 500, 'is_sequential_decisions': False,
     'needs_structure_discovery': False, 'pretrained_model_available': True, 'domain': 'nlp'},
    {'has_labels': True, 'label_count': 200, 'is_sequential_decisions': False,
     'needs_structure_discovery': False, 'pretrained_model_available': False, 'domain': 'tabular'},
]

for i, case in enumerate(test_cases, 1):
    result = recommend_learning_type(**case)
    print(f'Case {i}: {result["type"]}')
    print(f'  Reason: {result["reason"]}')
    print(f'  Algorithms: {", ".join(result["algorithms"])}')
    print(f'  Difficulty: {result["difficulty"]}')
    if 'warning' in result:
        print(f'  WARNING: {result["warning"]}')
    print()