Ajout de sections de commentaires et de conclusions dans le notebook TP3 pour clarifier les résultats des expérimentations sur le dataset ijcnn1.

M2/Advanced Machine Learning/TP3/TP3.ipynb

@@ -1,5 +1,13 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a33ddd50",
+   "metadata": {},
+   "source": [
+    "# Expérimentations"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 97,
@@ -20,7 +28,7 @@
     "from sklearn.model_selection import train_test_split\n",
     "from sklearn.preprocessing import StandardScaler\n",
     "\n",
-    "rng = np.random.default_rng(42)"
+    "rng = np.random.default_rng(42)\n"
    ]
   },
   {
@@ -39,7 +47,7 @@
    ],
    "source": [
     "X, y = load_svmlight_file(\"./data/ijcnn1.bz2\")\n",
-    "print(X.shape, y.shape)"
+    "print(X.shape, y.shape)\n"
    ]
   },
   {
@@ -50,7 +58,7 @@
    "outputs": [],
    "source": [
     "scaler = StandardScaler(with_mean=False)\n",
-    "X_scaled = scaler.fit_transform(X)"
+    "X_scaled = scaler.fit_transform(X)\n"
    ]
   },
   {
@@ -78,7 +86,7 @@
     "    random_state=42,\n",
     ")\n",
     "\n",
-    "X_train.shape, X_test.shape"
+    "X_train.shape, X_test.shape\n"
    ]
   },
   {
@@ -97,7 +105,7 @@
     "clf.fit(X_train, y_train)\n",
     "training_time_svc = time.time() - start_time\n",
     "y_pred_svc = clf.predict(X_test)\n",
-    "accuracy_svc = accuracy_score(y_test, y_pred_svc)"
+    "accuracy_svc = accuracy_score(y_test, y_pred_svc)\n"
    ]
   },
   {
@@ -115,7 +123,7 @@
     "clf_rbf.fit(X_train, y_train)\n",
     "training_time_rbf = time.time() - start_time\n",
     "y_pred_rbf = clf_rbf.predict(X_test)\n",
-    "accuracy_rbf = accuracy_score(y_test, y_pred_rbf)"
+    "accuracy_rbf = accuracy_score(y_test, y_pred_rbf)\n"
    ]
   },
   {
@@ -174,7 +182,7 @@
     "training_time_rkf = time.time() - start_time\n",
     "\n",
     "y_pred_rkf = clf_rkf.predict(Z_test)\n",
-    "accuracy_rkf = accuracy_score(y_test, y_pred_rkf)"
+    "accuracy_rkf = accuracy_score(y_test, y_pred_rkf)\n"
    ]
   },
   {
@@ -309,9 +317,21 @@
     "results\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "efa5c31b",
+   "metadata": {},
+   "source": [
+    "- **Linear SVM (Baseline)** : C'est la méthode la plus rapide (0,08 s), mais elle présente la précision la plus faible (92,21 %). Cela confirme que les données `ijcnn1` ne sont pas parfaitement linéairement séparables dans leur espace d'origine.\n",
+    "\n",
+    "- **Full RBF SVM (Oracle)** : Elle offre la précision maximale de l'étude (97,38 %). Cependant, elle est environ 14 fois plus lente que le *Linear SVM*. Sur des jeux de données plus volumineux ($n>105$), ce temps d'entraînement deviendrait prohibitif en raison de la complexité quadratique du noyau.\n",
+    "\n",
+    "- **RKF - Random Kernel Features ($c=300$)** : Cette approximation permet de regagner une grande partie de la précision perdue par le modèle linéaire, atteignant 95,52 %. Le temps de calcul (0,71 s) reste inférieur au *RBF* complet, validant l'intérêt de la linéarisation par projection aléatoire pour le passage à l'échelle."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 106,
+   "execution_count": null,
    "id": "56a3bce6",
    "metadata": {},
    "outputs": [],
@@ -344,12 +364,12 @@
     "    X_subset = X_train[indices]\n",
     "\n",
     "    W = rbf_kernel(X_subset, X_subset, gamma=gamma)\n",
-    "    V, Sigma, _ = svd(W)\n",
+    "    V, sigma, _ = svd(W)\n",
     "\n",
     "    Vk = V[:, :k]\n",
-    "    Sigmak = Sigma[:k]\n",
+    "    sigmak = sigma[:k]\n",
     "\n",
-    "    Mk = Vk @ np.diag(1.0 / np.sqrt(Sigmak))\n",
+    "    Mk = Vk @ np.diag(1.0 / np.sqrt(sigmak))\n",
     "\n",
     "    C_train = rbf_kernel(X_train, X_subset, gamma=gamma)\n",
     "    C_test = rbf_kernel(X_test, X_subset, gamma=gamma)\n",
@@ -449,11 +469,45 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "fda0a41c",
+   "cell_type": "markdown",
+   "id": "8a36f584",
+   "metadata": {},
+   "source": [
+    "## Commentaires et comparaison des méthodes\n",
+    "\n",
+    "- **Linear SVM (Raw)** : méthode linéaire rapide et efficace en mémoire lorsque les données restent creuses. Bon compromis temps / précision pour des problèmes linéarisables. Utiliser comme baseline de référence.\n",
+    "- **Full RBF SVM** : donne souvent la meilleure précision (référence), mais est très coûteuse en temps et en mémoire sur ce jeu de données; non scalable pour de grandes tailles sans approximations.\n",
+    "- **RKF (Random Kitchen Features)** : approximation du noyau *RBF*. En variante `RKF (c=300)` (point baseline) on obtient une bonne précision proche du RBF complet avec un coût d'entraînement réduit; en augmentant `c` la précision s'améliore mais le temps augmente (trade‑off). Les *RKF* nécessitent la conversion en dense pour la transformation si on calcule $cos(Wx+b$), donc attention à la mémoire lors du choix de `c`.\n",
+    "- **Nyström** : autre approximation du noyau. Elle conserve le format dense pour les sous‑matrices de landmarks mais peut être plus stable/précise pour un même `c` selon le choix des landmarks; trade‑off similaire *RKF* (c vs temps).\n",
+    "\n",
+    "Observations générales :\n",
+    "- Les courbes en fonction de `c` montrent l'évolution précision/temps pour *RKF* et *Nyström* ; les lignes horizontales représentent les baselines indépendantes de `c` (*Linear SVM, RKF baseline, Full RBF*).\n",
+    "- Choisir *RKF* ou *Nyström* quand le *RBF* complet est trop coûteux en augmentant `c` jusqu'à obtenir un compromis acceptable entre précision et temps/mémoire.\n",
+    "- Pour un déploiement ou itération rapide, il faut préférer *Linear SVM* ou *RKF* avec petit `c` ; pour la meilleure précision sans contrainte de ressources, il faut utiliser le *RBF* complet si c'est faisable."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04e48b4f",
+   "metadata": {},
+   "source": [
+    "# Conclusion \n",
+    "\n",
+    "L'expérimentation menée sur le dataset `ijcnn1` permet de dégager des préconisations claires selon le contexte d'application :\n",
+    "\n",
+    "- **Phase d'exploration et itération rapide** : Le *Linear SVM* reste l'outil de référence. Sa rapidité d'exécution (0,08 s) et sa faible consommation mémoire en font la méthode idéale pour tester rapidement des pipelines de prétraitement ou établir une baseline de performance.\n",
+    "\n",
+    "- **Recherche de performance maximale (Offline)** : Le *Full RBF SVM* offre la précision la plus élevée (97,38 %). Il doit être privilégié lorsque le volume de données permet de supporter un coût computationnel quadratique et que la précision est le seul critère de succès.\n",
+    "\n",
+    "- **Déploiement en production et Scalabilité** : Les méthodes d'approximation (*RKF* et *Nyström*) offrent le meilleur compromis. Elles permettent d'approcher la précision du noyau *RBF* (95,52 % pour *RKF* avec $c=300$) tout en conservant la linéarité du modèle. Cela garantit des temps d'entraînement maîtrisés et, surtout, une latence d'inférence compatible avec des environnements de production à grande échelle.\n",
+    "\n",
+    "En synthèse, si le noyau *RBF* complet reste l'oracle statistique, la linéarisation via *Nyström* ou *RKF* est la stratégie gagnante pour concilier rigueur mathématique et efficacité logicielle."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb387777",
    "metadata": {},
-   "outputs": [],
    "source": []
   }
  ],