CircleStar commited on
Commit
5fb8847
·
verified ·
1 Parent(s): f3ba8fe

Replace linear regression with logistic regression tab (proper classifier), move it before KNN tab, neutral framing

Browse files
Files changed (1) hide show
  1. app.py +68 -64
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 LinearRegression
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 train_and_predict_regression(student_labels):
138
- """Train a plain linear regression on the same 23 labeled polygons, treating
139
- the class numbers as a continuous target. Class numbers are nominal
140
- categories, not an ordered scale, so this is the wrong tool for the job —
141
- predictions are rounded to the nearest class to see just how wrong."""
 
 
 
 
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
- reg = LinearRegression()
154
- reg.fit(scaler.transform(X_train), y_train)
155
 
156
  gt_mask = ground_truth > 0
157
  X_gt = bands[gt_mask]
158
- pred_gt = np.clip(np.rint(reg.predict(scaler.transform(X_gt))), 1, 7).astype(int)
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
- raw_full = reg.predict(scaler.transform(bands.reshape(-1, n_bands)))
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: Entraînement du modèle KNN ──────────────────────────────
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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 précédent) combinées
453
- aux vraies valeurs spectrales des 7 bandes satellite, puis évalué sur les
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 on_train_regression(current_labels):
637
- """Train a plain linear regression on the student's own labels, to show
638
- why a model not designed for categorical classes performs poorly."""
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 = train_and_predict_regression(current_labels)
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 précédent — "
657
- f"la régression linéaire prédit un nombre continu puis l'arrondit à la classe la plus "
658
- f"proche, ce qui n'a pas de sens pour des catégories non ordonnées.)*"
659
  )
660
  matrix_fig = fig_confusion_matrix(
661
  model_matrix, model_oa,
662
- "Matrice de confusion – Régression linéaire vs Vérité terrain",
663
  cmap='Reds',
664
  )
665
- full_fig = fig_full_maps((pred_full, "Régression linéaire — carte complète"))
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
- btn_train_reg.click(
738
- on_train_regression,
739
  inputs=[labels],
740
  outputs=[
741
- reg_warning_md,
742
- reg_accuracy_md,
743
- reg_matrix_plot,
744
- reg_full_plot,
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