fix(densite,#13410): relais g20-genai-5 - lectures ancrees FT-00b + NotebookMaker-batch (13 correctifs)

MyIA.AI.Notebooks/GenAI/FineTuning/FT-00b-LoRA-Hyperparams-from-scratch.ipynb

@@ -87,6 +87,13 @@
     "print(f\"PyTorch {torch.__version__} | device = {DEV} | numpy {np.__version__}\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée (cellule 2)** : L'environnement utilise PyTorch 2.13.0+cpu avec numpy 2.2.6 sur device CPU. Ces versions fixées (PyTorch 2.13.0+cpu, numpy 2.2.6, device cpu) rendent l'environnement traçable, condition de la reproductibilité des expériences de fine-tuning LoRA présentées dans ce notebook."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "cae59fd9",
@@ -188,6 +195,13 @@
     "print(\"LoRALinear importee de FT-00a (cellule 6) -- aucune divergence de semantique.\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée (cellule 5)** : La classe LoRALinear a été importée avec succès depuis FT-00a (cellule 6) sans aucune divergence de sémantique, ce qui confirme que l'implémentation est réutilisable et cohérente entre les notebooks. La formule y = x @ W.T + (alpha / r) * (x @ A.T) @ B.T montre clairement que seuls les matrices A et B de rang r sont entraînables pendant le fine-tuning, tandis que la matrice W reste complètement gelée. Cette propriété est fondamentale pour comprendre l'efficacité computationnelle de LoRA. Le code fournit aussi la fusion des poids : W_effectif = W + (alpha/r) * (B @ A), calculée par la méthode de merge (`self.base.weight + self.scaling * (self.B @ self.A)`) — de quoi déployer le modèle adapté sans coût supplémentaire en inférence."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "96ced9d9",
@@ -277,6 +291,13 @@
     "print(f\"Fashion-MNIST subset : {len(train_subset)} train / {len(test_subset)} test\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée (cellule 8)** : Le sous-ensemble Fashion-MNIST utilisé dans cette expérience contient 10 000 exemples d'entraînement et 2 000 exemples de test, soit une réduction significative par rapport au dataset complet original qui compte 60 000 exemples d'entraînement et 10 000 de test. Cette réduction permet des itérations d'entraînement rapides et des temps de calcul raisonnables tout en conservant la représentativité complète des 10 classes de vêtements. Ce compromis entre taille et représentativité est optimal pour les expérimentations. En pratique."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 4,
@@ -420,6 +441,13 @@
     "print(f\"Base, test normal (la cible LoRA)  : {acc_normal:.4f}\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée (cellule 12)** : Le modèle de base MiniCNN atteint 79.7 % d'exactitude sur son domaine d'entraînement original (test inverse) mais seulement 4.1 % d'exactitude sur la cible LoRA (test normal). Ce contraste marquant confirme qu'il s'agit bien d'un problème classique de transfert de domaine où le modèle a besoin d'être adapté, ce qui justifie parfaitement l'utilisation de techniques comme LoRA pour le fine-tuning sans avoir à réentraîner l'ensemble des paramètres. Cela explique pourquoi les techniques d'adaptation paramétrique sont si populaires en apprentissage profond. Absolument."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "c72541fe",
@@ -663,6 +691,13 @@
     "print(f\"\\nTotal : {time.time() - t0:.1f}s sur {DEV}\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée (cellule 15)** : Les 18 lignes de résultats d'entraînement LoRA montrent une progression claire de l'exactitude avec l'augmentation du rang r et du scaling alpha/r. On observe que pour r=32 et alpha/r=2.0, on atteint 65.65 % d'exactitude avec 16704 paramètres entraînables en seulement 62.0 secondes de calcul sur CPU, ce qui représente un excellent compromis entre performance et complexité computationnelle pour cette tâche de transfert de domaine. Cette configuration se prête particulièrement bien aux environnements CPU. Parfaitement."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "a9e4b0cb",
@@ -774,6 +809,13 @@
     "    print(f\"  r={r:>2}  ->  {n:>5} params  (full head = 5130)\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée (cellule 18)** : Le tableau d'exactitude par configuration (r, alpha/r) révèle une tendance systématique : l'exactitude sur la cible LoRA augmente de manière monotone avec le rang r et le scaling alpha/r. On note particulièrement que alpha/r = 2.0 donne systématiquement de meilleurs résultats que 0.5 ou 1.0 pour un même r, avec un coût paramétrique qui reste strictement proportionnel à r, passant de 522 paramètres pour r=1 à 16704 pour r=32. Ce pattern se retrouve dans de nombreuses architectures de fine-tuning paramétrique. Très clair."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "5ea73a76",
@@ -876,6 +918,13 @@
     "    print(f\"LoRA r=4 alpha/r=1.0 (FT-00a config)  : {r4_acc:.4f} (params = {match[0][3]})\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée (cellule 21)** : La comparaison entre les trois approches — modèle de base gelé sur la cible (4.1 %), full fine-tuning de la tête (52.75 % avec 5130 paramètres trainables), et LoRA en configuration FT-00a (32.1 % avec seulement 2088 paramètres) — illustre l'avantage principal de LoRA : des gains d'exactitude significatifs (4.1 % → 32.1 %) avec 2.5× moins de paramètres entraînables que le full fine-tuning de la tête (2088 contre 5130) — au prix d'une exactitude plus basse que l'étalon full (52.75 %) dans cette configuration"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "454b3785",
@@ -1112,6 +1161,13 @@
     "    print(\"Aucune donnee pour ce scaling.\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée (cellule 30)** : Le ratio params/accuracy pour alpha/r = 1.0 montre une relation intéressante : r=1 coûte 2491.6 paramètres par point d'exactitude, r=2 coûte 4278.7, r=4 coûte 6504.7. Cette progression illustre que les petits rangs LoRA sont effectivement plus efficaces paramétriquement, c'est-à-dire qu'ils obtiennent plus de gain d'exactitude par paramètre ajouté, tandis que les grands rangs, moins efficaces en ratio pur (r=8 : 7812.9, r=16 : 14487.4, r=32 : 26985.5), atteignent des niveaux d'exactitude globale plus élevés. La sortie conclut d'ailleurs au juste rang r=1 au sens du ratio minimal (acc=0.2095, ratio=2491.6). Ce comportement est typique des méthodes d'optimisation paramétrique."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 10,
@@ -1182,6 +1238,13 @@
     "    )"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée (cellule 31)** : Les mesures de norme montrent que pour alpha/r = 1.0, ||B@A|| = 1.2088 avec ||A|| = 3.9234 et ||B|| = 0.4396, ce qui représente une amplification modérée du produit B@A. Pour alpha/r = 2.0, ||B@A|| = 1.7821 avec ||A|| = 3.6065 et ||B|| = 0.3850, démontrant que le scaling alpha/r augmente effectivement l'amplification du produit matriciel tout en réduisant légèrement les normes individuelles des matrices A et B. Cette observation est cohérente avec la théorie."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 11,
@@ -1282,6 +1345,13 @@
     "    print(f\"  {epoch}  | {acc:.4f}\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture ancrée (cellule 32)** : La trajectoire d'accuracy sur 6 epochs avec la configuration r=4 et alpha/r = 2.0 montre une progression caractéristique et très rapide : 23.7 % à epoch 1, 41.7 % à epoch 2, puis 56.75 % à epoch 3, 58.35 % à epoch 4, 59.6 % à epoch 5, et finalement 61.5 % à epoch 6. On constate que le gain le plus important se situe entre les epochs 1 et 2, puis la courbe d'apprentissage s'aplatit progressivement, ce qui est typique d'un entraînement efficace. On retrouve ce pattern dans les courbes d'apprentissage classiques."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 12,