Spaces:
Sleeping
Sleeping
Replace linear regression with logistic regression tab (proper classifier), move it before KNN tab, neutral framing
Browse files
app.py
CHANGED
|
@@ -8,7 +8,7 @@ import rasterio
|
|
| 8 |
import json
|
| 9 |
import os
|
| 10 |
from sklearn.neighbors import KNeighborsClassifier
|
| 11 |
-
from sklearn.linear_model import
|
| 12 |
from sklearn.preprocessing import StandardScaler
|
| 13 |
|
| 14 |
# ─────────────────────────────────────────────────────────────────────────────
|
|
@@ -134,28 +134,30 @@ def train_and_predict(student_labels, k):
|
|
| 134 |
|
| 135 |
return model_oa, model_matrix, pred_gt, y_gt, knn_ref_gt, pred_full
|
| 136 |
|
| 137 |
-
def
|
| 138 |
-
"""Train a
|
| 139 |
-
|
| 140 |
-
|
| 141 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 142 |
bands = DATA['bands']
|
| 143 |
training_ids = DATA['training_ids']
|
| 144 |
ground_truth = DATA['ground_truth']
|
| 145 |
|
| 146 |
train_mask = training_ids > 0
|
| 147 |
X_train = bands[train_mask]
|
| 148 |
-
y_train = np.array(
|
| 149 |
-
[int(student_labels[pid - 1]) for pid in training_ids[train_mask]], dtype=np.float64
|
| 150 |
-
)
|
| 151 |
|
| 152 |
scaler = StandardScaler().fit(X_train)
|
| 153 |
-
|
| 154 |
-
|
| 155 |
|
| 156 |
gt_mask = ground_truth > 0
|
| 157 |
X_gt = bands[gt_mask]
|
| 158 |
-
pred_gt =
|
| 159 |
y_gt = ground_truth[gt_mask]
|
| 160 |
|
| 161 |
model_matrix = np.zeros((7, 7), dtype=np.int64)
|
|
@@ -163,8 +165,7 @@ def train_and_predict_regression(student_labels):
|
|
| 163 |
model_oa = model_matrix.diagonal().sum() / model_matrix.sum()
|
| 164 |
|
| 165 |
H, W, n_bands = bands.shape
|
| 166 |
-
|
| 167 |
-
pred_full = np.clip(np.rint(raw_full), 1, 7).astype(int).reshape(H, W)
|
| 168 |
|
| 169 |
return model_oa, model_matrix, pred_full
|
| 170 |
|
|
@@ -444,14 +445,47 @@ puis soumettez vos réponses pour générer la carte et la matrice de confusion.
|
|
| 444 |
with gr.Row(visible=False) as row_plots_student:
|
| 445 |
student_matrix_plot = gr.Plot(label="Votre interprétation vs Enseignant")
|
| 446 |
|
| 447 |
-
# ── Tab 4:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 448 |
with gr.Tab("Entraînement du modèle KNN"):
|
| 449 |
gr.Markdown("""
|
| 450 |
## Entraînez votre propre modèle KNN
|
| 451 |
|
| 452 |
-
Ce modèle est entraîné sur **vos** 23 étiquettes (onglet
|
| 453 |
-
aux vraies valeurs spectrales des 7 bandes satellite, puis évalué
|
| 454 |
-
pixels de vérité terrain (indépendants des polygones d'entraînement).
|
| 455 |
""")
|
| 456 |
train_warning_md = gr.Markdown(visible=False)
|
| 457 |
k_slider = gr.Slider(
|
|
@@ -482,36 +516,6 @@ pixels de vérité terrain (indépendants des polygones d'entraînement).
|
|
| 482 |
visible=False,
|
| 483 |
)
|
| 484 |
|
| 485 |
-
# ── Tab 5: Régression linéaire, pour comparaison ────────────────────
|
| 486 |
-
with gr.Tab("Régression linéaire (comparaison)"):
|
| 487 |
-
gr.Markdown("""
|
| 488 |
-
## Un algorithme de régression est-il adapté à ce problème ?
|
| 489 |
-
|
| 490 |
-
Les numéros de classe (1 à 7) sont des **catégories** (nominales), pas une
|
| 491 |
-
échelle continue : la classe 4 n'est pas "le double" de la classe 2. Un
|
| 492 |
-
algorithme de régression linéaire l'ignore complètement : il essaie de
|
| 493 |
-
prédire un nombre continu (par exemple 4.37) à partir des valeurs spectrales,
|
| 494 |
-
puis on arrondit à la classe la plus proche pour pouvoir comparer.
|
| 495 |
-
|
| 496 |
-
Entraînez-le ci-dessous sur les mêmes 23 étiquettes que votre modèle KNN,
|
| 497 |
-
pour voir comment un algorithme mal adapté au problème se comporte.
|
| 498 |
-
""")
|
| 499 |
-
reg_warning_md = gr.Markdown(visible=False)
|
| 500 |
-
btn_train_reg = gr.Button(
|
| 501 |
-
"Entraîner le modèle de régression linéaire",
|
| 502 |
-
variant="primary",
|
| 503 |
-
size="lg",
|
| 504 |
-
)
|
| 505 |
-
reg_accuracy_md = gr.Markdown(visible=False)
|
| 506 |
-
reg_matrix_plot = gr.Plot(
|
| 507 |
-
label="Régression linéaire vs Vérité terrain",
|
| 508 |
-
visible=False,
|
| 509 |
-
)
|
| 510 |
-
reg_full_plot = gr.Plot(
|
| 511 |
-
label="Carte complète — régression linéaire",
|
| 512 |
-
visible=False,
|
| 513 |
-
)
|
| 514 |
-
|
| 515 |
# ─────────────────────────────────────────────────────────────────────
|
| 516 |
# Event handlers
|
| 517 |
# ─────────────────────────────────────────────────────────────────────
|
|
@@ -633,9 +637,9 @@ pour voir comment un algorithme mal adapté au problème se comporte.
|
|
| 633 |
gr.update(value=full_fig, visible=True),
|
| 634 |
)
|
| 635 |
|
| 636 |
-
def
|
| 637 |
-
"""Train a
|
| 638 |
-
|
| 639 |
total = count_labeled(current_labels)
|
| 640 |
if total < N_POLYGONS:
|
| 641 |
warning = (
|
|
@@ -650,19 +654,19 @@ pour voir comment un algorithme mal adapté au problème se comporte.
|
|
| 650 |
gr.update(visible=False),
|
| 651 |
)
|
| 652 |
|
| 653 |
-
model_oa, model_matrix, pred_full =
|
| 654 |
acc_text = (
|
| 655 |
f"**Précision globale = {model_oa*100:.1f}%**\n\n"
|
| 656 |
-
f"*(Comparez ce chiffre à la précision de votre modèle KNN dans l'onglet
|
| 657 |
-
f"la régression
|
| 658 |
-
f"
|
| 659 |
)
|
| 660 |
matrix_fig = fig_confusion_matrix(
|
| 661 |
model_matrix, model_oa,
|
| 662 |
-
"Matrice de confusion – Régression
|
| 663 |
cmap='Reds',
|
| 664 |
)
|
| 665 |
-
full_fig = fig_full_maps((pred_full, "Régression
|
| 666 |
|
| 667 |
return (
|
| 668 |
gr.update(visible=False),
|
|
@@ -733,15 +737,15 @@ pour voir comment un algorithme mal adapté au problème se comporte.
|
|
| 733 |
],
|
| 734 |
)
|
| 735 |
|
| 736 |
-
# Wire up regression training (separate tab, for comparison against KNN)
|
| 737 |
-
|
| 738 |
-
|
| 739 |
inputs=[labels],
|
| 740 |
outputs=[
|
| 741 |
-
|
| 742 |
-
|
| 743 |
-
|
| 744 |
-
|
| 745 |
],
|
| 746 |
)
|
| 747 |
|
|
|
|
| 8 |
import json
|
| 9 |
import os
|
| 10 |
from sklearn.neighbors import KNeighborsClassifier
|
| 11 |
+
from sklearn.linear_model import LogisticRegression
|
| 12 |
from sklearn.preprocessing import StandardScaler
|
| 13 |
|
| 14 |
# ─────────────────────────────────────────────────────────────────────────────
|
|
|
|
| 134 |
|
| 135 |
return model_oa, model_matrix, pred_gt, y_gt, knn_ref_gt, pred_full
|
| 136 |
|
| 137 |
+
def train_and_predict_logreg(student_labels):
|
| 138 |
+
"""Train a multinomial logistic regression on the same 23 labeled polygons.
|
| 139 |
+
Unlike plain linear regression, logistic regression IS a real classifier —
|
| 140 |
+
it fits a separate linear decision function per class and makes no
|
| 141 |
+
assumption that the class numbers are ordered or continuous. Its decision
|
| 142 |
+
boundaries are linear (a hyperplane per class), unlike KNN's non-linear,
|
| 143 |
+
non-parametric boundaries; whether that makes it more or less accurate
|
| 144 |
+
here depends on how linearly separable the classes actually are in the
|
| 145 |
+
spectral feature space — not something to assume in advance."""
|
| 146 |
bands = DATA['bands']
|
| 147 |
training_ids = DATA['training_ids']
|
| 148 |
ground_truth = DATA['ground_truth']
|
| 149 |
|
| 150 |
train_mask = training_ids > 0
|
| 151 |
X_train = bands[train_mask]
|
| 152 |
+
y_train = np.array([int(student_labels[pid - 1]) for pid in training_ids[train_mask]])
|
|
|
|
|
|
|
| 153 |
|
| 154 |
scaler = StandardScaler().fit(X_train)
|
| 155 |
+
clf = LogisticRegression(max_iter=2000)
|
| 156 |
+
clf.fit(scaler.transform(X_train), y_train)
|
| 157 |
|
| 158 |
gt_mask = ground_truth > 0
|
| 159 |
X_gt = bands[gt_mask]
|
| 160 |
+
pred_gt = clf.predict(scaler.transform(X_gt))
|
| 161 |
y_gt = ground_truth[gt_mask]
|
| 162 |
|
| 163 |
model_matrix = np.zeros((7, 7), dtype=np.int64)
|
|
|
|
| 165 |
model_oa = model_matrix.diagonal().sum() / model_matrix.sum()
|
| 166 |
|
| 167 |
H, W, n_bands = bands.shape
|
| 168 |
+
pred_full = clf.predict(scaler.transform(bands.reshape(-1, n_bands))).reshape(H, W)
|
|
|
|
| 169 |
|
| 170 |
return model_oa, model_matrix, pred_full
|
| 171 |
|
|
|
|
| 445 |
with gr.Row(visible=False) as row_plots_student:
|
| 446 |
student_matrix_plot = gr.Plot(label="Votre interprétation vs Enseignant")
|
| 447 |
|
| 448 |
+
# ── Tab 4: Régression logistique, algorithme de base pour comparaison ──
|
| 449 |
+
with gr.Tab("Régression logistique (comparaison)"):
|
| 450 |
+
gr.Markdown("""
|
| 451 |
+
## Un algorithme de base : la régression logistique
|
| 452 |
+
|
| 453 |
+
Contrairement à la régression linéaire, la régression logistique est un vrai
|
| 454 |
+
algorithme de classification : elle apprend une fonction de décision linéaire
|
| 455 |
+
séparée pour chaque classe et ne suppose aucun ordre entre les numéros de
|
| 456 |
+
classe. Sa frontière de décision reste toutefois **linéaire** (un hyperplan
|
| 457 |
+
par classe), alors que le KNN (onglet suivant) peut apprendre des frontières
|
| 458 |
+
de n'importe quelle forme.
|
| 459 |
+
|
| 460 |
+
Entraînez-le ci-dessous sur les mêmes 23 étiquettes, et comparez sa précision
|
| 461 |
+
à celle de votre modèle KNN dans l'onglet suivant — un modèle plus simple
|
| 462 |
+
n'est pas automatiquement moins bon, tout dépend de si les classes sont
|
| 463 |
+
linéairement séparables ou non dans l'espace spectral.
|
| 464 |
+
""")
|
| 465 |
+
logreg_warning_md = gr.Markdown(visible=False)
|
| 466 |
+
btn_train_logreg = gr.Button(
|
| 467 |
+
"Entraîner le modèle de régression logistique",
|
| 468 |
+
variant="primary",
|
| 469 |
+
size="lg",
|
| 470 |
+
)
|
| 471 |
+
logreg_accuracy_md = gr.Markdown(visible=False)
|
| 472 |
+
logreg_matrix_plot = gr.Plot(
|
| 473 |
+
label="Régression logistique vs Vérité terrain",
|
| 474 |
+
visible=False,
|
| 475 |
+
)
|
| 476 |
+
logreg_full_plot = gr.Plot(
|
| 477 |
+
label="Carte complète — régression logistique",
|
| 478 |
+
visible=False,
|
| 479 |
+
)
|
| 480 |
+
|
| 481 |
+
# ── Tab 5: Entraînement du modèle KNN ────────��─────────────────────
|
| 482 |
with gr.Tab("Entraînement du modèle KNN"):
|
| 483 |
gr.Markdown("""
|
| 484 |
## Entraînez votre propre modèle KNN
|
| 485 |
|
| 486 |
+
Ce modèle est entraîné sur **vos** 23 étiquettes (onglet Interprétation)
|
| 487 |
+
combinées aux vraies valeurs spectrales des 7 bandes satellite, puis évalué
|
| 488 |
+
sur les pixels de vérité terrain (indépendants des polygones d'entraînement).
|
| 489 |
""")
|
| 490 |
train_warning_md = gr.Markdown(visible=False)
|
| 491 |
k_slider = gr.Slider(
|
|
|
|
| 516 |
visible=False,
|
| 517 |
)
|
| 518 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 519 |
# ─────────────────────────────────────────────────────────────────────
|
| 520 |
# Event handlers
|
| 521 |
# ─────────────────────────────────────────────────────────────────────
|
|
|
|
| 637 |
gr.update(value=full_fig, visible=True),
|
| 638 |
)
|
| 639 |
|
| 640 |
+
def on_train_logreg(current_labels):
|
| 641 |
+
"""Train a multinomial logistic regression on the student's own labels,
|
| 642 |
+
to show how a properly-specified but linear classifier compares to KNN."""
|
| 643 |
total = count_labeled(current_labels)
|
| 644 |
if total < N_POLYGONS:
|
| 645 |
warning = (
|
|
|
|
| 654 |
gr.update(visible=False),
|
| 655 |
)
|
| 656 |
|
| 657 |
+
model_oa, model_matrix, pred_full = train_and_predict_logreg(current_labels)
|
| 658 |
acc_text = (
|
| 659 |
f"**Précision globale = {model_oa*100:.1f}%**\n\n"
|
| 660 |
+
f"*(Comparez ce chiffre à la précision de votre modèle KNN dans l'onglet suivant — "
|
| 661 |
+
f"la régression logistique est un vrai classifieur, mais sa frontière de décision "
|
| 662 |
+
f"reste linéaire, contrairement au KNN.)*"
|
| 663 |
)
|
| 664 |
matrix_fig = fig_confusion_matrix(
|
| 665 |
model_matrix, model_oa,
|
| 666 |
+
"Matrice de confusion – Régression logistique vs Vérité terrain",
|
| 667 |
cmap='Reds',
|
| 668 |
)
|
| 669 |
+
full_fig = fig_full_maps((pred_full, "Régression logistique — carte complète"))
|
| 670 |
|
| 671 |
return (
|
| 672 |
gr.update(visible=False),
|
|
|
|
| 737 |
],
|
| 738 |
)
|
| 739 |
|
| 740 |
+
# Wire up logistic regression training (separate tab, for comparison against KNN)
|
| 741 |
+
btn_train_logreg.click(
|
| 742 |
+
on_train_logreg,
|
| 743 |
inputs=[labels],
|
| 744 |
outputs=[
|
| 745 |
+
logreg_warning_md,
|
| 746 |
+
logreg_accuracy_md,
|
| 747 |
+
logreg_matrix_plot,
|
| 748 |
+
logreg_full_plot,
|
| 749 |
],
|
| 750 |
)
|
| 751 |
|