Add real KNN pipeline: train on your own polygon labels + spectral bands, evaluate against ground truth

.gitattributes

@@ -58,3 +58,10 @@ polygon_images/polygon_19.png filter=lfs diff=lfs merge=lfs -text
 polygon_images/polygon_20.png filter=lfs diff=lfs merge=lfs -text
 polygon_images/polygon_21.png filter=lfs diff=lfs merge=lfs -text
 polygon_images/polygon_23.png filter=lfs diff=lfs merge=lfs -text
+data/bands/band_1_uv.tif filter=lfs diff=lfs merge=lfs -text
+data/bands/band_2_blue.tif filter=lfs diff=lfs merge=lfs -text
+data/bands/band_3_green.tif filter=lfs diff=lfs merge=lfs -text
+data/bands/band_4_red.tif filter=lfs diff=lfs merge=lfs -text
+data/bands/band_5_nir.tif filter=lfs diff=lfs merge=lfs -text
+data/bands/band_6_swir1.tif filter=lfs diff=lfs merge=lfs -text
+data/bands/band_7_swir2.tif filter=lfs diff=lfs merge=lfs -text

app.py

@@ -6,11 +6,15 @@ import matplotlib.pyplot as plt
 import rasterio
 import json
 import os
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.preprocessing import StandardScaler
 
 # ─────────────────────────────────────────────────────────────────────────────
 # Constants
 # ─────────────────────────────────────────────────────────────────────────────
 N_POLYGONS = 23
+K_MIN, K_MAX, K_DEFAULT = 1, 15, 5
+MAP_MAX_DIM = 500  # downsample target for map visualizations (speed)
 
 CLASSES = {
     1: "Eau",
@@ -24,6 +28,17 @@ CLASSES = {
 
 CLASS_CHOICES = [f"{k} - {v}" for k, v in CLASSES.items()]
 
+# index 0 = fond / non classé, 1..7 = classes ci-dessus
+COLORS_RGB = np.array([
+    [20, 20, 20], [0, 100, 220], [0, 160, 60], [120, 220, 100],
+    [220, 50, 50], [255, 165, 0], [160, 90, 30], [240, 230, 140],
+], dtype=np.uint8)
+
+BAND_FILES = [
+    'band_1_uv.tif', 'band_2_blue.tif', 'band_3_green.tif', 'band_4_red.tif',
+    'band_5_nir.tif', 'band_6_swir1.tif', 'band_7_swir2.tif',
+]
+
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -37,11 +52,16 @@ def load_data():
 
     ground_truth  = read_tif('ground_truth.tif')
     knn_result    = read_tif('knn_result.tif')
+    training_ids  = read_tif('training_polygons.tif')
+
+    bands = np.stack(
+        [read_tif(os.path.join('bands', f)) for f in BAND_FILES], axis=-1
+    ).astype(np.float32)
 
     with open(os.path.join(BASE_DIR, 'data', 'polygon_teacher_classes.json')) as f:
         polygon_teacher = {int(k): v for k, v in json.load(f).items()}
 
-    # Pre-compute KNN confusion matrix (pixels where GT > 0)
+    # Pre-compute reference KNN confusion matrix (teacher labels, pixels where GT > 0)
     gt_flat  = ground_truth.flatten()
     knn_flat = knn_result.flatten()
     valid    = gt_flat > 0
@@ -49,29 +69,80 @@ def load_data():
     np.add.at(knn_matrix, (gt_flat[valid] - 1, knn_flat[valid] - 1), 1)
     knn_oa = knn_matrix.diagonal().sum() / knn_matrix.sum()
 
+    h, w = ground_truth.shape
+    stride = max(1, max(h, w) // MAP_MAX_DIM)
+
     return dict(
         polygon_teacher= polygon_teacher,
+        ground_truth   = ground_truth,
+        knn_result     = knn_result,
+        training_ids   = training_ids,
+        bands          = bands,
         knn_matrix     = knn_matrix,
         knn_oa         = knn_oa,
+        stride         = stride,
     )
 
 DATA = load_data()
 
 # ─────────────────────────────────────────────────────────────────────────────
-# Visualization helpers
+# Model training (from the student's own labels + real spectral bands)
 # ─────────────────────────────────────────────────────────────────────────────
+def train_and_predict(student_labels, k):
+    """Train a KNN classifier on the student's 23 labeled polygons (using the
+    real spectral bands), then evaluate it against Ground Truth and produce a
+    downsampled classification map for display."""
+    bands        = DATA['bands']
+    training_ids = DATA['training_ids']
+    ground_truth = DATA['ground_truth']
+    knn_result   = DATA['knn_result']
+    stride       = DATA['stride']
+
+    train_mask = training_ids > 0
+    X_train = bands[train_mask]
+    y_train = np.array([int(student_labels[pid - 1]) for pid in training_ids[train_mask]])
+
+    scaler = StandardScaler().fit(X_train)
+    clf = KNeighborsClassifier(n_neighbors=int(k), algorithm='kd_tree', n_jobs=-1)
+    clf.fit(scaler.transform(X_train), y_train)
+
+    # Accuracy / confusion matrix on the real Ground Truth pixels
+    gt_mask = ground_truth > 0
+    X_gt = bands[gt_mask]
+    pred_gt = clf.predict(scaler.transform(X_gt))
+    y_gt = ground_truth[gt_mask]
+
+    model_matrix = np.zeros((7, 7), dtype=np.int64)
+    np.add.at(model_matrix, (y_gt - 1, pred_gt - 1), 1)
+    model_oa = model_matrix.diagonal().sum() / model_matrix.sum()
+
+    # Downsampled full-image map for visualization (fast: predict only on the
+    # decimated grid, not the full 4.6M pixels)
+    bands_small = bands[::stride, ::stride]
+    hs, ws, _ = bands_small.shape
+    pred_small = clf.predict(scaler.transform(bands_small.reshape(-1, 7)))
+    student_map = pred_small.reshape(hs, ws)
+
+    gt_small  = ground_truth[::stride, ::stride]
+    knn_small = knn_result[::stride, ::stride]
+    # zero out predictions outside the study area so the map matches GT/KNN extent
+    student_map = np.where(knn_small > 0, student_map, 0)
+
+    return model_oa, model_matrix, student_map, knn_small, gt_small
 
-def fig_knn_matrix():
-    matrix = DATA['knn_matrix']
-    oa = DATA['knn_oa']
+# ─────────────────────────────────────────────────────────────────────────────
+# Visualization helpers
+# ─────────────────────────────────────────────────────────────────────────────
 
+def fig_confusion_matrix(matrix, oa, title, cmap='Blues'):
+    """Generic 7×7 confusion matrix plot: predicted classes vs Ground Truth."""
     short = ["Eau", "Vergers", "Δ-Cult.", "Bâti", "Irr.-Dés.", "Non-Irr.", "Sable"]
     fig, ax = plt.subplots(figsize=(9, 7))
 
     row_tot = matrix.sum(axis=1, keepdims=True)
     pct = np.where(row_tot > 0, matrix / row_tot * 100, 0)
 
-    im = ax.imshow(pct, cmap='Blues', vmin=0, vmax=100)
+    im = ax.imshow(pct, cmap=cmap, vmin=0, vmax=100)
     plt.colorbar(im, ax=ax, label="% de la classe réelle", shrink=0.8)
 
     ax.set_xticks(range(7)); ax.set_yticks(range(7))
@@ -79,8 +150,7 @@ def fig_knn_matrix():
     ax.set_yticklabels([f"C{i+1}\n{short[i]}" for i in range(7)], fontsize=8)
     ax.set_xlabel("Classe prédite (KNN)", fontsize=11, labelpad=8)
     ax.set_ylabel("Classe réelle (vérité terrain)", fontsize=11, labelpad=8)
-    ax.set_title(f"Matrice de confusion – KNN vs Vérité terrain\n"
-                 f"Précision globale = {oa*100:.1f}%",
+    ax.set_title(f"{title}\nPrécision globale = {oa*100:.1f}%",
                  fontsize=12, fontweight='bold', pad=12)
 
     for r in range(7):
@@ -93,6 +163,38 @@ def fig_knn_matrix():
     plt.tight_layout()
     return fig
 
+def fig_knn_matrix():
+    """Reference matrix: pre-computed KNN (trained on teacher labels) vs Ground Truth."""
+    return fig_confusion_matrix(
+        DATA['knn_matrix'], DATA['knn_oa'],
+        "Matrice de confusion – Modèle de référence (enseignant) vs Vérité terrain",
+        cmap='Blues',
+    )
+
+def fig_model_matrix(model_matrix, model_oa):
+    """Student's own trained KNN model vs Ground Truth."""
+    return fig_confusion_matrix(
+        model_matrix, model_oa,
+        "Matrice de confusion – VOTRE modèle KNN vs Vérité terrain",
+        cmap='Purples',
+    )
+
+def fig_three_panel_map(student_map, knn_map, gt_map):
+    """Side-by-side classification maps: student's trained model / teacher
+    reference KNN / Ground Truth."""
+    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+    for ax, rast, title in zip(
+        axes,
+        [student_map, knn_map, gt_map],
+        ["Votre modèle KNN", "Modèle de référence (enseignant)", "Vérité terrain"],
+    ):
+        rgb = COLORS_RGB[rast]
+        ax.imshow(rgb, interpolation='nearest')
+        ax.set_title(title, fontsize=11, fontweight='bold')
+        ax.axis('off')
+    plt.tight_layout()
+    return fig
+
 def fig_student_matrix(student_labels):
     """7×7 confusion matrix: student labels vs teacher labels."""
     matrix = np.zeros((7, 7), dtype=int)
@@ -222,8 +324,19 @@ puis soumettez vos réponses pour générer la carte et la matrice de confusion.
                     )
                     gr.Markdown("---")
                     progress_bar = gr.Markdown("**Progression : 0 / 23**")
+                    gr.Markdown("---")
+                    gr.Markdown("### Entraînement du modèle KNN")
+                    gr.Markdown(
+                        "*(Une fois les 23 polygones étiquetés, ce modèle sera "
+                        "entraîné sur VOS réponses + les vraies valeurs spectrales "
+                        "des 7 bandes satellite, puis évalué sur la vérité terrain)*"
+                    )
+                    k_slider = gr.Slider(
+                        minimum=K_MIN, maximum=K_MAX, value=K_DEFAULT, step=1,
+                        label="k (nombre de voisins)",
+                    )
                     btn_submit = gr.Button(
-                        "🚀 Soumettre toutes mes réponses",
+                        "🚀 Entraîner mon modèle KNN et voir les résultats",
                         variant="primary",
                         visible=False,
                         size="lg",
@@ -234,6 +347,7 @@ puis soumettez vos réponses pour générer la carte et la matrice de confusion.
             results_placeholder = gr.Markdown(
                 "*(Les résultats apparaîtront ici après soumission)*"
             )
+            gr.Markdown("## 1️⃣ Qualité de votre interprétation visuelle")
             accuracy_md  = gr.Markdown(visible=False)
             results_tbl  = gr.Dataframe(
                 headers=["Polygone", "Votre réponse", "Réponse enseignant", "Résultat"],
@@ -243,7 +357,14 @@ puis soumettez vos réponses pour générer la carte et la matrice de confusion.
             with gr.Row(visible=False) as row_plots_student:
                 student_matrix_plot = gr.Plot(label="Votre interprétation vs Enseignant")
 
-            knn_plot     = gr.Plot(label="Matrice de confusion KNN vs Vérité terrain", visible=False)
+            gr.Markdown("## 2️⃣ Votre modèle KNN entraîné sur vos étiquettes")
+            model_accuracy_md = gr.Markdown(visible=False)
+            with gr.Row(visible=False) as row_plots_model:
+                model_matrix_plot = gr.Plot(label="Votre modèle KNN vs Vérité terrain")
+                knn_plot = gr.Plot(label="Modèle de référence (enseignant) vs Vérité terrain")
+            three_panel_plot = gr.Plot(
+                label="Cartes de classification", visible=False,
+            )
 
     # ─────────────────────────────────────────────────────────────────────
     # Event handlers
@@ -287,9 +408,11 @@ puis soumettez vos réponses pour générer la carte et la matrice de confusion.
                 gr.update(value=overall),
                 gr.update(visible=show_submit))
 
-    def on_submit(current_labels):
-        """Compute and display all results."""
-        # Accuracy vs teacher
+    def on_submit(current_labels, k):
+        """Compute and display all results: labeling accuracy vs teacher, then
+        train a real KNN model on the student's labels + spectral bands and
+        evaluate it against Ground Truth."""
+        # 1) Accuracy of the visual interpretation vs teacher's answer key
         correct = sum(
             1 for pid in range(1, 24)
             if current_labels[pid-1] is not None
@@ -299,23 +422,39 @@ puis soumettez vos réponses pour générer la carte et la matrice de confusion.
         pct    = correct / total * 100 if total > 0 else 0
 
         acc_text = (
-            f"## 🎯 Résultat de votre interprétation\n\n"
             f"**{correct} / {total} polygones correctement identifiés ({pct:.0f}%)**\n\n"
             f"*(Comparaison avec la légende fournie par l'enseignant)*"
         )
 
         table = build_results_table(current_labels)
-
-        knn_fig     = fig_knn_matrix()
         student_fig = fig_student_matrix(current_labels)
 
+        # 2) Train a KNN model on the student's own labels + real spectral bands,
+        # then evaluate it against Ground Truth
+        model_oa, model_matrix, student_map, knn_map, gt_map = train_and_predict(
+            current_labels, k
+        )
+        model_acc_text = (
+            f"**Précision globale = {model_oa*100:.1f}%** "
+            f"(évaluée sur les {int((DATA['ground_truth'] > 0).sum())} pixels de vérité terrain, k={int(k)})\n\n"
+            f"*(C'est la précision réelle d'un modèle KNN entraîné uniquement sur VOS 23 polygones étiquetés — "
+            f"comparez-la à celle du modèle de référence de l'enseignant ci-dessous)*"
+        )
+        model_fig = fig_model_matrix(model_matrix, model_oa)
+        knn_fig   = fig_knn_matrix()
+        map_fig   = fig_three_panel_map(student_map, knn_map, gt_map)
+
         return (
             gr.update(value=""),
             gr.update(value=acc_text,   visible=True),
             gr.update(value=table,      visible=True),
             gr.update(visible=True),
             gr.update(value=student_fig),
-            gr.update(value=knn_fig,    visible=True),
+            gr.update(value=model_acc_text, visible=True),
+            gr.update(visible=True),
+            gr.update(value=model_fig),
+            gr.update(value=knn_fig),
+            gr.update(value=map_fig,    visible=True),
         )
 
     # Wire up navigation
@@ -337,17 +476,21 @@ puis soumettez vos réponses pour générer la carte et la matrice de confusion.
         outputs=[labels, progress_bar, progress_md, btn_submit],
     )
 
-    # Wire up submit
+    # Wire up submit (labeling accuracy + model training/evaluation)
     btn_submit.click(
         on_submit,
-        inputs=[labels],
+        inputs=[labels, k_slider],
         outputs=[
             results_placeholder,
             accuracy_md,
             results_tbl,
             row_plots_student,
             student_matrix_plot,
+            model_accuracy_md,
+            row_plots_model,
+            model_matrix_plot,
             knn_plot,
+            three_panel_plot,
         ],
     )