---
title: "Palmer Penguins kNN Classification (Python)"
format: html
engine: knitr
---

This Quarto document runs the Python translation of `kNN_example_penguins.qmd`
through `reticulate`.

```{r}
library(reticulate)
py_require(c("pandas", "numpy", "scikit-learn", "matplotlib",
             "seaborn", "palmerpenguins"))
```

## Load and inspect the data

```{python}
from pathlib import Path

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from sklearn.metrics import accuracy_score, ConfusionMatrixDisplay, confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

DATA_FILE = Path("penguins.csv")

if DATA_FILE.exists():
    penguins = pd.read_csv(DATA_FILE)
else:
    try:
        from palmerpenguins import load_penguins
        penguins = load_penguins()
    except ImportError:
        penguins = sns.load_dataset("penguins")

penguins = penguins.drop(columns=["island", "sex"])
print(penguins.head())
print(penguins["species"].value_counts().sort_index())
print(penguins.isna().sum())
```

## Visualize the data

```{python}
sns.scatterplot(data=penguins, x="bill_length_mm", y="bill_depth_mm")
plt.tight_layout()
plt.show()

sns.scatterplot(
    data=penguins, x="bill_length_mm", y="bill_depth_mm", hue="species"
)
plt.tight_layout()
plt.show()

g = sns.FacetGrid(penguins, col="species")
g.map_dataframe(sns.scatterplot, x="bill_length_mm", y="bill_depth_mm")
g.tight_layout()
plt.show()
```

## Fit and evaluate the kNN model

The original tutorial uses an unweighted kNN model with `k = 4`. Python's
scikit-learn requires complete predictor rows, so missing rows are removed
before fitting.

```{python}
penguins_complete = penguins.dropna().copy()

X = penguins_complete.drop(columns="species")
y = penguins_complete["species"]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, stratify=y, random_state=123
)

knn_model = KNeighborsClassifier(n_neighbors=4, weights="uniform")
knn_model.fit(X_train, y_train)

def evaluate(X_data, y_data, label):
    predictions = knn_model.predict(X_data)
    cm = confusion_matrix(y_data, predictions, labels=knn_model.classes_)
    print(f"{label} accuracy: {accuracy_score(y_data, predictions):.4f}")
    print(pd.DataFrame(cm, index=knn_model.classes_, columns=knn_model.classes_))
    ConfusionMatrixDisplay(cm, display_labels=knn_model.classes_).plot(cmap="Blues")
    plt.title(f"{label} confusion matrix")
    plt.tight_layout()
    plt.show()
    return predictions, cm

train_predictions, train_cm = evaluate(X_train, y_train, "Training")
test_predictions, test_cm = evaluate(X_test, y_test, "Testing")
```