K-Nearest Neighbors (KNN) & Distance-Based Learning

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, StratifiedKFold, GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    confusion_matrix, classification_report
)

# ==============================================================================
# STEP 1 & 2: Load Dataset & Inspect Dimensions
# ==============================================================================
iris = load_iris()
X, y = iris.data, iris.target
print(f"Dataset shape: {X.shape[0]} samples, {X.shape[1]} features.")
print(f"Target classes: {iris.target_names}")

# ==============================================================================
# STEP 3: Stratified Split (70% Train, 15% Validation, 15% Test)
# ==============================================================================
X_dev, X_test, y_dev, y_test = train_test_split(
    X, y, test_size=0.15, stratify=y, random_state=42
)
X_train, X_val, y_train, y_val = train_test_split(
    X_dev, y_dev, test_size=0.17647, stratify=y_dev, random_state=42  # ~15% holdout
)
print(f"Partition sizes -> Train: {len(X_train)}, Val: {len(X_val)}, Test: {len(X_test)}")

# ==============================================================================
# STEP 4: Encapsulate Preprocessing & Model into a Leak-Free Pipeline
# ==============================================================================
knn_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('knn', KNeighborsClassifier())
])

# ==============================================================================
# STEP 5 & 6: Stratified 5-Fold Cross-Validation Grid Search
# ==============================================================================
param_grid = {
    'knn__n_neighbors': [3, 5, 7, 9, 11, 13],
    'knn__weights': ['uniform', 'distance'],
    'knn__p': [1, 2]  # 1 = Manhattan, 2 = Euclidean
}

cv_strategy = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid_search = GridSearchCV(
    estimator=knn_pipeline,
    param_grid=param_grid,
    scoring='accuracy',
    cv=cv_strategy,
    n_jobs=-1
)

grid_search.fit(X_train, y_train)
print(f"\nBest Cross-Validation Hyperparameters: {grid_search.best_params_}")
print(f"Best CV Mean Accuracy: {grid_search.best_score_ * 100:.2f}%")

# ==============================================================================
# STEP 7 & 8: Evaluate on Holdout Validation Set
# ==============================================================================
val_preds = grid_search.predict(X_val)
print(f"Holdout Validation Accuracy: {accuracy_score(y_val, val_preds) * 100:.2f}%")

# ==============================================================================
# STEP 9: Refit Best Architecture on Combined Development Set (Train + Val)
# ==============================================================================
final_knn = Pipeline([
    ('scaler', StandardScaler()),
    ('knn', KNeighborsClassifier(
        n_neighbors=grid_search.best_params_['knn__n_neighbors'],
        weights=grid_search.best_params_['knn__weights'],
        p=grid_search.best_params_['knn__p']
    ))
])
final_knn.fit(X_dev, y_dev)

# ==============================================================================
# STEP 10: Final Evaluation on Untouched Out-of-Sample Test Set
# ==============================================================================
y_test_pred = final_knn.predict(X_test)
test_acc = accuracy_score(y_test, y_test_pred)
test_prec = precision_score(y_test, y_test_pred, average='macro', zero_division=0)
test_rec = recall_score(y_test, y_test_pred, average='macro', zero_division=0)
test_f1 = f1_score(y_test, y_test_pred, average='macro', zero_division=0)

print("\n" + "=" * 50)
print("FINAL TEST SET AUDIT:")
print("=" * 50)
print(f"Accuracy:  {test_acc * 100:.2f}%")
print(f"Precision: {test_prec * 100:.2f}%")
print(f"Recall:    {test_rec * 100:.2f}%")
print(f"F1-Score:  {test_f1:.4f}")

# Confusion Matrix & Classification Report
print("\nConfusion Matrix:")
print(confusion_matrix(y_test, y_test_pred))
print("\nClassification Report:")
print(classification_report(y_test, y_test_pred, target_names=iris.target_names))

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

# 1. Synthesize Housing Area (sq ft) vs Price (Lakh BDT)
rng = np.random.default_rng(42)
area = rng.uniform(600, 3200, size=500)
# Non-linear relationship with Gaussian noise
price = 12.0 + 0.045 * area + 0.000008 * (area ** 2) + rng.normal(0, 4.0, size=500)
X = area.reshape(-1, 1)
y = price

# 2. Partition 80% Train, 20% Test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)

# 3. Construct Weighted KNN Regressor Pipeline
reg_pipe = make_pipeline(
    StandardScaler(),
    KNeighborsRegressor(n_neighbors=5, weights='distance', p=2)
)
reg_pipe.fit(X_train, y_train)

# 4. Evaluate Test Set Performance
y_pred = reg_pipe.predict(X_test)
mae = mean_absolute_error(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2 = r2_score(y_test, y_pred)

print(f"KNN Regressor MAE:  {mae:.2f} Lakh BDT")
print(f"KNN Regressor RMSE: {rmse:.2f} Lakh BDT")
print(f"KNN Regressor R²:   {r2:.4f}")

# 5. Predict on Novel Unseen House (1,800 sq ft)
query_house = np.array([[1800]])
pred_val = reg_pipe.predict(query_house)
print(f"Predicted price for 1,800 sq ft property: {pred_val[0]:.2f} Lakh BDT")