Machine Learning Foundations

"""
AI Track Unit 8: Machine Learning Foundations
End-to-End Classification Pipeline: Preprocessing, KNN, and Evaluation Metrics
Author: DevAscent Engineering Team
"""

import math
from collections import Counter
from typing import List, Tuple, Dict

# =====================================================================
# 1. PREPROCESSING: STANDARD SCALER (Z-SCORE NORMALIZATION)
# =====================================================================
class CustomStandardScaler:
    def __init__(self):
        self.means = []
        self.stds = []

    def fit(self, X: List[List[float]]):
        num_features = len(X[0])
        n = len(X)
        self.means = [sum(X[i][j] for i in range(n)) / n for j in range(num_features)]
        
        self.stds = []
        for j in range(num_features):
            variance = sum((X[i][j] - self.means[j]) ** 2 for i in range(n)) / n
            self.stds.append(math.sqrt(variance) if variance > 1e-8 else 1.0)

    def transform(self, X: List[List[float]]) -> List[List[float]]:
        return [[(row[j] - self.means[j]) / self.stds[j] for j in range(len(row))] for row in X]

    def fit_transform(self, X: List[List[float]]) -> List[List[float]]:
        self.fit(X)
        return self.transform(X)

# =====================================================================
# 2. CLASSIFIER: K-NEAREST NEIGHBORS (KNN)
# =====================================================================
class CustomKNNClassifier:
    def __init__(self, k: int = 3):
        self.k = k
        self.X_train = []
        self.y_train = []

    def fit(self, X: List[List[float]], y: List[int]):
        self.X_train = X
        self.y_train = y

    def _euclidean_distance(self, pt1: List[float], pt2: List[float]) -> float:
        return math.sqrt(sum((a - b) ** 2 for a, b in zip(pt1, pt2)))

    def predict(self, X_test: List[List[float]]) -> List[int]:
        predictions = []
        for test_pt in X_test:
            # Compute distance to all training samples
            distances = []
            for i, train_pt in enumerate(self.X_train):
                dist = self._euclidean_distance(test_pt, train_pt)
                distances.append((dist, self.y_train[i]))
            
            # Sort by distance and pick top K
            distances.sort(key=lambda item: item[0])
            k_nearest_labels = [label for _, label in distances[:self.k]]
            
            # Majority voting
            most_common = Counter(k_nearest_labels).most_common(1)[0][0]
            predictions.append(most_common)
        return predictions

# =====================================================================
# 3. MODEL EVALUATION METRICS ENGINE
# =====================================================================
class ClassificationEvaluator:
    @staticmethod
    def confusion_matrix(y_true: List[int], y_pred: List[int]) -> Dict[str, int]:
        tp = sum(1 for yt, yp in zip(y_true, y_pred) if yt == 1 and yp == 1)
        tn = sum(1 for yt, yp in zip(y_true, y_pred) if yt == 0 and yp == 0)
        fp = sum(1 for yt, yp in zip(y_true, y_pred) if yt == 0 and yp == 1)
        fn = sum(1 for yt, yp in zip(y_true, y_pred) if yt == 1 and yp == 0)
        return {'TP': tp, 'TN': tn, 'FP': fp, 'FN': fn}

    @classmethod
    def evaluate(cls, y_true: List[int], y_pred: List[int]) -> Dict[str, float]:
        cm = cls.confusion_matrix(y_true, y_pred)
        tp, tn, fp, fn = cm['TP'], cm['TN'], cm['FP'], cm['FN']
        total = tp + tn + fp + fn

        accuracy = (tp + tn) / total if total > 0 else 0.0
        precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
        recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
        f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0.0

        return {
            'Accuracy': accuracy,
            'Precision': precision,
            'Recall': recall,
            'F1_Score': f1,
            'ConfusionMatrix': cm
        }

# =====================================================================
# DEMONSTRATION HARNESS
# =====================================================================
if __name__ == "__main__":
    print("=" * 68)
    print("DEMO: MACHINE LEARNING WORKFLOW FROM SCRATCH")
    print("Synthetic Medical Dataset: Features = [Age, BloodPressure], Label = Disease (0 or 1)")
    print("=" * 68)

    # 1. Synthetic Raw Data (Notice difference in scales: Age ~ 20-70, BP ~ 110-180)
    raw_X_train = [
        [25.0, 115.0], [29.0, 120.0], [35.0, 122.0], [42.0, 130.0],  # Healthy (0)
        [55.0, 160.0], [62.0, 168.0], [68.0, 175.0], [58.0, 155.0],  # Diseased (1)
        [31.0, 118.0], [60.0, 162.0]
    ]
    y_train = [0, 0, 0, 0, 1, 1, 1, 1, 0, 1]

    raw_X_test = [
        [28.0, 119.0],  # Should be 0
        [65.0, 170.0],  # Should be 1
        [50.0, 150.0],  # Should be 1
        [36.0, 125.0]   # Should be 0
    ]
    y_test = [0, 1, 1, 0]

    # 2. Preprocessing via Custom StandardScaler
    scaler = CustomStandardScaler()
    X_train_scaled = scaler.fit_transform(raw_X_train)
    X_test_scaled = scaler.transform(raw_X_test)

    print("Normalized Training Features (Mean ~ 0, Variance ~ 1):")
    for i, row in enumerate(X_train_scaled[:4]):
        print(f"  Sample {i}: Age = {row[0]:6.2f}, BP = {row[1]:6.2f}")

    # 3. Model Training & Prediction (KNN with K=3)
    knn = CustomKNNClassifier(k=3)
    knn.fit(X_train_scaled, y_train)
    predictions = knn.predict(X_test_scaled)

    print(f"\nGround Truth Labels : {y_test}")
    print(f"Model Predictions   : {predictions}")

    # 4. Evaluation Metrics
    metrics = ClassificationEvaluator.evaluate(y_test, predictions)
    cm = metrics['ConfusionMatrix']

    print("\nModel Evaluation Performance Report:")
    print(f"  Confusion Matrix : TP={cm['TP']}, TN={cm['TN']}, FP={cm['FP']}, FN={cm['FN']}")
    print(f"  Accuracy         : {metrics['Accuracy'] * 100:.1f}%")
    print(f"  Precision        : {metrics['Precision'] * 100:.1f}%")
    print(f"  Recall           : {metrics['Recall'] * 100:.1f}%")
    print(f"  F1 Score         : {metrics['F1_Score']:.4f}")