Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,28 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/ground_truth.tif filter=lfs diff=lfs merge=lfs -text
+data/knn_result.tif filter=lfs diff=lfs merge=lfs -text
+data/teacher_labels.tif filter=lfs diff=lfs merge=lfs -text
+data/training_polygons.tif filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_01.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_02.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_03.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_05.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_06.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_07.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_08.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_09.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_10.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_11.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_12.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_13.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_14.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_15.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_16.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_17.png filter=lfs diff=lfs merge=lfs -text
+polygon_images/polygon_18.png filter=lfs diff=lfs merge=lfs -text
+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

app.py

@@ -0,0 +1,421 @@
+import gradio as gr
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+import rasterio
+import json
+import os
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Constants
+# ─────────────────────────────────────────────────────────────────────────────
+N_POLYGONS = 23
+
+CLASSES = {
+    1: "Eau",
+    2: "Vergers",
+    3: "Cultures dans le Delta",
+    4: "Zones bâties",
+    5: "Cultures irriguées dans le désert",
+    6: "Cultures non irriguées en zone sèche",
+    7: "Zones sableuses",
+}
+
+CLASS_CHOICES = [f"{k} - {v}" for k, v in CLASSES.items()]
+
+# Distinctive color palette per class (index 0 = background)
+COLORS_RGB = np.array([
+    [20,  20,  20 ],   # 0 background
+    [0,   100, 220],   # 1 eau
+    [0,   160,  60],   # 2 vergers
+    [120, 220, 100],   # 3 cultures delta
+    [220,  50,  50],   # 4 zones bâties
+    [255, 165,   0],   # 5 cultures irriguées désert
+    [160,  90,  30],   # 6 cultures non irriguées
+    [240, 230, 140],   # 7 zones sableuses
+], dtype=np.uint8)
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Data loading (once at startup)
+# ─────────────────────────────────────────────────────────────────────────────
+def load_data():
+    def read_tif(name):
+        path = os.path.join(BASE_DIR, 'data', name)
+        with rasterio.open(path) as src:
+            return src.read(1)
+
+    training_ids  = read_tif('training_polygons.tif')
+    ground_truth  = read_tif('ground_truth.tif')
+    knn_result    = read_tif('knn_result.tif')
+    teacher_lbl   = read_tif('teacher_labels.tif')
+
+    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)
+    gt_flat  = ground_truth.flatten()
+    knn_flat = knn_result.flatten()
+    valid    = gt_flat > 0
+    knn_matrix = np.zeros((7, 7), dtype=np.int64)
+    np.add.at(knn_matrix, (gt_flat[valid] - 1, knn_flat[valid] - 1), 1)
+    knn_oa = knn_matrix.diagonal().sum() / knn_matrix.sum()
+
+    # Downsample rasters to ~500 px height for display
+    from PIL import Image as PILImage
+    h, w = training_ids.shape
+    new_h, new_w = 500, int(w * 500 / h)
+
+    def small(arr):
+        return np.array(PILImage.fromarray(arr).resize((new_w, new_h), PILImage.NEAREST))
+
+    return dict(
+        training_ids   = training_ids,
+        ground_truth   = ground_truth,
+        knn_result     = knn_result,
+        teacher_lbl    = teacher_lbl,
+        polygon_teacher= polygon_teacher,
+        knn_matrix     = knn_matrix,
+        knn_oa         = knn_oa,
+        tr_small       = small(training_ids),
+        gt_small       = small(ground_truth),
+        knn_small      = small(knn_result),
+    )
+
+DATA = load_data()
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Visualization helpers
+# ─────────────────────────────────────────────────────────────────────────────
+def raster_to_rgb(arr):
+    rgb = COLORS_RGB[arr]
+    return rgb
+
+def legend_patches():
+    return [mpatches.Patch(color=COLORS_RGB[i]/255, label=f"{i} – {CLASSES[i]}")
+            for i in range(1, 8)]
+
+def fig_maps(student_labels):
+    fig, axes = plt.subplots(1, 3, figsize=(18, 6))
+    fig.patch.set_facecolor('#f5f5f5')
+
+    student_map = np.zeros_like(DATA['tr_small'])
+    for pid, label in enumerate(student_labels, 1):
+        if label is not None:
+            student_map[DATA['tr_small'] == pid] = label
+
+    titles = [
+        "Votre interprétation\n(polygones d'entraînement)",
+        "Classification KNN\n(carte produite par l'IA)",
+        "Vérité terrain\n(zones de validation)",
+    ]
+    rasters = [student_map, DATA['knn_small'], DATA['gt_small']]
+    for ax, rast, title in zip(axes, rasters, titles):
+        ax.imshow(raster_to_rgb(rast), interpolation='nearest')
+        ax.set_title(title, fontsize=11, fontweight='bold', pad=8)
+        ax.axis('off')
+
+    fig.legend(handles=legend_patches(), loc='lower center', ncol=4,
+               bbox_to_anchor=(0.5, -0.06), fontsize=9, framealpha=0.9)
+    plt.tight_layout()
+    return fig
+
+def fig_knn_matrix():
+    matrix = DATA['knn_matrix']
+    oa = DATA['knn_oa']
+
+    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)
+    plt.colorbar(im, ax=ax, label="% de la classe réelle", shrink=0.8)
+
+    ax.set_xticks(range(7)); ax.set_yticks(range(7))
+    ax.set_xticklabels([f"C{i+1}\n{short[i]}" for i in range(7)], fontsize=8)
+    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}%",
+                 fontsize=12, fontweight='bold', pad=12)
+
+    for r in range(7):
+        for c in range(7):
+            v, p = matrix[r, c], pct[r, c]
+            color = 'white' if p > 50 else 'black'
+            ax.text(c, r, f"{v}\n({p:.0f}%)", ha='center', va='center',
+                    fontsize=7, color=color)
+
+    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)
+    for pid in range(1, 24):
+        s = student_labels[pid - 1]
+        t = DATA['polygon_teacher'].get(pid, 0)
+        if s is not None and t > 0:
+            matrix[t - 1][int(s) - 1] += 1
+
+    short = ["Eau", "Vergers", "Δ-Cult.", "Bâti", "Irr.-Dés.", "Non-Irr.", "Sable"]
+    fig, ax = plt.subplots(figsize=(8, 6))
+
+    row_tot = matrix.sum(axis=1, keepdims=True)
+    pct = np.where(row_tot > 0, matrix / row_tot * 100, 0)
+    im = ax.imshow(pct, cmap='Greens', vmin=0, vmax=100)
+    plt.colorbar(im, ax=ax, label="% de la classe enseignant", shrink=0.8)
+
+    ax.set_xticks(range(7)); ax.set_yticks(range(7))
+    ax.set_xticklabels([f"C{i+1}\n{short[i]}" for i in range(7)], fontsize=8)
+    ax.set_yticklabels([f"C{i+1}\n{short[i]}" for i in range(7)], fontsize=8)
+    ax.set_xlabel("Votre réponse", fontsize=11, labelpad=8)
+    ax.set_ylabel("Réponse de l'enseignant", fontsize=11, labelpad=8)
+    ax.set_title("Votre interprétation vs Réponse de l'enseignant\n(polygones d'entraînement)",
+                 fontsize=11, fontweight='bold', pad=12)
+
+    for r in range(7):
+        for c in range(7):
+            v, p = matrix[r, c], pct[r, c]
+            color = 'white' if p > 50 else 'black'
+            if v > 0:
+                ax.text(c, r, f"{v}\n({p:.0f}%)", ha='center', va='center',
+                        fontsize=8, color=color)
+
+    plt.tight_layout()
+    return fig
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Gradio helpers
+# ─────────────────────────────────────────────────────────────────────────────
+def polygon_image_path(idx):
+    return os.path.join(BASE_DIR, 'polygon_images', f'polygon_{idx+1:02d}.png')
+
+def count_labeled(labels):
+    return sum(1 for l in labels if l is not None)
+
+def build_results_table(student_labels):
+    rows = []
+    for pid in range(1, 24):
+        s = student_labels[pid - 1]
+        t = DATA['polygon_teacher'].get(pid, 0)
+        s_str = f"{s} – {CLASSES.get(int(s), '?')}" if s is not None else "—"
+        t_str = f"{t} – {CLASSES.get(t, '?')}"
+        match = "✅" if (s is not None and int(s) == t) else ("❌" if s is not None else "—")
+        rows.append([pid, s_str, t_str, match])
+    return rows
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Gradio Interface
+# ─────────────────────────────────────────────────────────────────────────────
+with gr.Blocks(title="Interprétation de polygones – Vallée du Nil") as demo:
+
+    # ── State ──────────────────────────────────────────────────────────────
+    cur_idx  = gr.State(value=0)
+    labels   = gr.State(value=[None] * N_POLYGONS)
+
+    # ── Header ─────────────────────────────────────────────────────────────
+    gr.Markdown("""
+# 🛰️ Interprétation de polygones d'entraînement – Vallée du Nil
+
+**Objectif :** Interprétez visuellement chacun des 23 polygones d'entraînement,
+puis soumettez vos réponses pour générer la carte et la matrice de confusion.
+
+> Cette application s'inscrit dans un TD sur la classification d'occupation du sol par IA (algorithme KNN).
+""")
+
+    with gr.Tabs() as tabs:
+
+        # ── Tab 1: Légende des classes ────────────────────────────────────
+        with gr.Tab("📋 Classes d'occupation du sol"):
+            gr.Markdown("""
+## Classes d'occupation du sol
+
+| N° | Classe | Couleur |
+|----|--------|---------|
+| 1 | Eau | 🔵 Bleu |
+| 2 | Vergers | 🟢 Vert foncé |
+| 3 | Cultures dans le Delta | 💚 Vert clair |
+| 4 | Zones bâties | 🔴 Rouge |
+| 5 | Cultures irriguées dans le désert | 🟠 Orange |
+| 6 | Cultures non irriguées en zone sèche | 🟤 Marron |
+| 7 | Zones sableuses | 🟡 Jaune clair |
+
+---
+**Conseils d'interprétation :**
+- L'image montre une composition colorée de l'image Landsat
+- Les zones bleues/sombres correspondent à l'eau
+- La végétation dense apparaît en vert (vergers, cultures dans le delta)
+- Les zones bâties apparaissent en teintes rosées ou grises
+- Les zones cultivées irriguées dans le désert forment des parcelles géométriques
+- Les zones sableuses apparaissent en jaune/beige
+""")
+
+        # ── Tab 2: Interprétation ─────────────────────────────────────────
+        with gr.Tab("🖊️ Interprétation des polygones"):
+            progress_md = gr.Markdown("**0 / 23 polygones étiquetés**")
+
+            with gr.Row():
+                with gr.Column(scale=3):
+                    polygon_title = gr.Markdown("### Polygone 1 / 23")
+                    polygon_img   = gr.Image(
+                        value=polygon_image_path(0),
+                        label="Image satellite",
+                        show_label=False,
+                        height=500,
+                    )
+                    with gr.Row():
+                        btn_prev = gr.Button("◀ Précédent", size="sm", variant="secondary")
+                        btn_next = gr.Button("Suivant ▶",   size="sm", variant="primary")
+
+                with gr.Column(scale=1):
+                    gr.Markdown("### Classe du polygone")
+                    gr.Markdown("*(Cochez la classe qui correspond le mieux à l'occupation du sol visible dans le polygone)*")
+                    class_radio = gr.Radio(
+                        choices=CLASS_CHOICES,
+                        label="Classe",
+                        value=None,
+                    )
+                    gr.Markdown("---")
+                    progress_bar = gr.Markdown("**Progression : 0 / 23**")
+                    btn_submit = gr.Button(
+                        "🚀 Soumettre toutes mes réponses",
+                        variant="primary",
+                        visible=False,
+                        size="lg",
+                    )
+
+        # ── Tab 3: Résultats ───────────────────────────────────────────────
+        with gr.Tab("📊 Résultats", id="tab_results") as tab_results:
+            results_placeholder = gr.Markdown(
+                "*(Les résultats apparaîtront ici après soumission)*"
+            )
+            accuracy_md  = gr.Markdown(visible=False)
+            results_tbl  = gr.Dataframe(
+                headers=["Polygone", "Votre réponse", "Réponse enseignant", "Résultat"],
+                visible=False,
+                wrap=True,
+            )
+            with gr.Row(visible=False) as row_plots_student:
+                student_matrix_plot = gr.Plot(label="Votre interprétation vs Enseignant")
+
+            maps_plot    = gr.Plot(label="Cartes", visible=False)
+            knn_plot     = gr.Plot(label="Matrice de confusion KNN vs Vérité terrain", visible=False)
+
+    # ─────────────────────────────────────────────────────────────────────
+    # Event handlers
+    # ─────────────────────────────────────────────────────────────────────
+
+    def nav_to(idx, current_labels):
+        """Render a polygon slide: image, title, current radio value."""
+        img   = polygon_image_path(idx)
+        title = f"### Polygone {idx + 1} / {N_POLYGONS}"
+        saved = current_labels[idx]
+        radio_val = None
+        if saved is not None:
+            radio_val = CLASS_CHOICES[int(saved) - 1]
+        n_done = count_labeled(current_labels)
+        prog   = f"**Progression : {n_done} / {N_POLYGONS}**"
+        return img, title, radio_val, prog
+
+    def on_prev(idx, current_labels):
+        new_idx = max(0, idx - 1)
+        img, title, radio_val, prog = nav_to(new_idx, current_labels)
+        return new_idx, img, title, radio_val, prog
+
+    def on_next(idx, current_labels):
+        new_idx = min(N_POLYGONS - 1, idx + 1)
+        img, title, radio_val, prog = nav_to(new_idx, current_labels)
+        return new_idx, img, title, radio_val, prog
+
+    def on_class_select(choice, idx, current_labels):
+        """Save selected class for current polygon."""
+        if choice is None:
+            return current_labels, gr.update(), gr.update(), gr.update()
+        cls_num = int(choice.split(" - ")[0])
+        new_labels = list(current_labels)
+        new_labels[idx] = cls_num
+        n_done = count_labeled(new_labels)
+        prog   = f"**Progression : {n_done} / {N_POLYGONS}**"
+        overall= f"**{n_done} / {N_POLYGONS} polygones étiquetés**"
+        show_submit = (n_done == N_POLYGONS)
+        return (new_labels,
+                gr.update(value=prog),
+                gr.update(value=overall),
+                gr.update(visible=show_submit))
+
+    def on_submit(current_labels):
+        """Compute and display all results."""
+        # Accuracy vs teacher
+        correct = sum(
+            1 for pid in range(1, 24)
+            if current_labels[pid-1] is not None
+            and int(current_labels[pid-1]) == DATA['polygon_teacher'].get(pid, 0)
+        )
+        total  = count_labeled(current_labels)
+        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)
+
+        maps_fig    = fig_maps(current_labels)
+        knn_fig     = fig_knn_matrix()
+        student_fig = fig_student_matrix(current_labels)
+
+        return (
+            gr.update(value=""),                          # hide placeholder
+            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=maps_fig,   visible=True),
+            gr.update(value=knn_fig,    visible=True),
+        )
+
+    # Wire up navigation
+    btn_prev.click(
+        on_prev,
+        inputs=[cur_idx, labels],
+        outputs=[cur_idx, polygon_img, polygon_title, class_radio, progress_bar],
+    )
+    btn_next.click(
+        on_next,
+        inputs=[cur_idx, labels],
+        outputs=[cur_idx, polygon_img, polygon_title, class_radio, progress_bar],
+    )
+
+    # Wire up class selection
+    class_radio.change(
+        on_class_select,
+        inputs=[class_radio, cur_idx, labels],
+        outputs=[labels, progress_bar, progress_md, btn_submit],
+    )
+
+    # Wire up submit
+    btn_submit.click(
+        on_submit,
+        inputs=[labels],
+        outputs=[
+            results_placeholder,
+            accuracy_md,
+            results_tbl,
+            row_plots_student,
+            student_matrix_plot,
+            maps_plot,
+            knn_plot,
+        ],
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

data/polygon_teacher_classes.json

@@ -0,0 +1,25 @@
+{
+  "1": 1,
+  "2": 2,
+  "3": 2,
+  "4": 1,
+  "5": 1,
+  "6": 3,
+  "7": 3,
+  "8": 3,
+  "9": 3,
+  "10": 3,
+  "11": 3,
+  "12": 3,
+  "13": 1,
+  "14": 4,
+  "15": 1,
+  "16": 5,
+  "17": 6,
+  "18": 7,
+  "19": 7,
+  "20": 7,
+  "21": 7,
+  "22": 1,
+  "23": 1
+}

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.0.0
+numpy>=1.24.0
+rasterio>=1.3.0
+matplotlib>=3.7.0
+Pillow>=9.0.0
+scipy>=1.10.0
+scikit-learn>=1.3.0