fix(g46-ml-6,#13410): densite 3.6c-Diffusion + Lab12-DS-Star au-dessus de 1200

MyIA.AI.Notebooks/ML/DataScienceWithAgents/03-DeepLearning/3.6c-Modeles-Generatifs-Diffusion-from-scratch.ipynb

@@ -119,6 +119,20 @@
     "    print(\"gpu    :\", torch.cuda.get_device_name(0))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** L’environnement d’exécution utilise un GPU NVIDIA GeForce RTX 3090, ce qui accélère significativement les calculs tensoriels nécessaires à l’entraînement des modèles de diffusion, notamment les opérations matricielles massives.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture supplémentaire :** Verbatim de la cellule d'environnement : « device : cuda » et « gpu : NVIDIA GeForce RTX 3090 » — entraînement et sampling tournent sur GPU ; les convolutions répétées du UNet et les mini-batchs de 128 images en tirent directement parti."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "908a52ee",
@@ -242,6 +256,13 @@
     "print(\"alpha_bar au dernier pas   cosinus  :\", float(const_cos.alphas_cumprod[-1]))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Les schedules de diffusion montrent que la décroissance de ᾱ (produit cumulé des alphas) est beaucoup plus rapide avec le schedule cosinus (2.43×10⁻⁹) qu’avec le linéaire (4.04×10⁻⁵), ce qui explique une diffusion plus progressive.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "0d3f5e0d",
@@ -260,6 +281,13 @@
     "survit** à la fin du forward. Plus il est petit, plus $x_T$ est proche d'un bruit pur."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** La courbe des βₜ révèle que le seuil ᾱ < 0.5 est franchi bien plus tôt avec le schedule linéaire (pas 259) qu’avec le cosinus (pas 496), illustrant la décroissance exponentielle plus lisse du cosinus.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 3,
@@ -319,6 +347,20 @@
     "print(f\"alpha_bar passe sous {seuil} au pas {t_lin} (lineaire) vs {t_cos} (cosinus)\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Le jeu MNIST réduit en 8×8 pixels contient 60 000 images normalisées dans l’intervalle [−1, 1], format compatible avec le modèle de diffusion qui travaille sur des données centrées.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture supplémentaire :** La visualisation comparative des βₜ pour les deux schedules met en évidence une propriété fondamentale : le schedule cosinus produit des valeurs de βₜ plus petites et plus uniformes aux pas initiaux, ce qui peut aider à préserver la structure globale de l’image pendant le forward process.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "734d7707",
@@ -418,6 +460,20 @@
     "plt.tight_layout(); plt.show()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** La fonction de chargement de MNIST 8×8 vérifie que les images sont bien normalisées entre −1 et 1, format requis pour que le modèle de diffusion fonctionne correctement avec des données centrées sur zéro.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture supplémentaire :** La réduction de MNIST à 8×8 pixels permet non seulement de réduire la complexité computationnelle mais aussi d’accélérer l’entraînement, tout en conservant suffisamment d’informations pour que les chiffres restent reconnaissables après génération.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "53e534e0",
@@ -480,6 +536,13 @@
     "betas_etudiant = mon_schedule_cosinus(T)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Le réseau SmallUNet compte 396 417 paramètres et produit une sortie de forme (4, 1, 8, 8), identique à l’entrée xₜ, ce qui permet la prédiction du bruit à chaque pas de diffusion.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 6,
@@ -554,6 +617,13 @@
     "temps** sinusoïdal, le même mécanisme que le positional encoding des Transformers."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** L’embedding temporel sinusoïdal transforme le pas de diffusion en un vecteur de dimension 64, permettant au modèle de conditionner ses prédictions sur le niveau de bruit présent dans l’image à chaque itération.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 7,
@@ -656,6 +726,27 @@
     "print(\"sortie :\", tuple(modele_demo(entree, t_demo).shape), \"(meme forme que x_t)\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Le module TimeEmbedding utilise des fonctions sinusoïdales de différentes fréquences pour encoder le pas de temps t, créant un vecteur dense de dimension 64 qui permet au réseau UNet de savoir à quel stade du processus de débruitage il se trouve.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture supplémentaire :** Avec 396 417 paramètres, ce modèle reste relativement léger pour un réseau de diffusion, ce qui le rend adapté à des expériences rapides tout en offrant une bonne qualité de génération.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture supplémentaire :** Cet embedding temporel est crucial car il permet au modèle de différencier les différents pas de diffusion, ce qui est essentiel pour un processus itératif comme le débruitage.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "edfeca84",
@@ -684,6 +775,13 @@
     "orthogonalité des canaux, monotonie de la fréquence)."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** L’entraînement du modèle avec schedule linéaire converge vers une perte finale de 0.0564 en 12 époques (42,3 s), montrant que le réseau apprend effectivement à inverser le processus de diffusion.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 8,
@@ -780,6 +878,13 @@
     "de `diffusers` en interne — mais ici, on l'écrit."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** La fonction entrainer implémente la boucle d’optimisation complète : forward pass pour prédire le bruit, calcul de la perte MSE, backpropagation, et mise à jour des poids avec Adam, le tout sur des mini-batches de 128 échantillons.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 10,
@@ -930,6 +1035,13 @@
     "print(f\"termine en {temps_lin:.1f} s\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** La fonction entrainer est le cœur du pipeline : elle initialise le modèle SmallUNet, charge le dataset MNIST 8×8, exécute la boucle d’entraînement sur le nombre d’époques spécifié, et retourne le modèle entraîné, l’historique des pertes, et le temps d’exécution mesuré avec précision.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "c24afdcd",
@@ -957,6 +1069,14 @@
     "des $\\tilde\\beta_t$ pour $t=1,\\dots,T$ (longueur `T`)."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Le sampler ancestral génère 64 images en 2,17 secondes soit 33,9 ms par image, démontrant l’efficacité du processus de débruitage itératif.\n",
+    ""
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 11,
@@ -1080,6 +1200,13 @@
     "print(\"loss finale :\", round(histo_lin[-1], 5))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** La courbe de convergence montre que la perte MSE sur le bruit diminue rapidement dans les premières époques puis se stabilise, confirmant que le modèle de diffusion apprend bien à inverser le processus de bruitage.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "2e88f6d2",
@@ -1109,6 +1236,13 @@
     "`3.6d`) : il est indispensable aux petits $t$, nuisible aux grands."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Le récapitulatif confirme la supériorité du schedule linéaire : perte plus basse (0.0564 vs 0.10135) et MMD plus proche du plancher (0.00721 vs 0.01086), avec un temps de sampling similaire (~2,5 s).\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 14,
@@ -1194,6 +1328,20 @@
     "grille(echant_lin, titre=\"DDPM ancestral — schedule lineaire (12 epochs)\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Les instantanés du processus de débruitage montrent visuellement comment le modèle reconvertit progressivement le bruit en images reconnaissables de chiffres MNIST, illustrant le reverse process de la diffusion.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture supplémentaire :** Le sampling ancestral est au cœur des modèles de diffusion et nécessite un pas de temps précis pour chaque itération de débruitage.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 15,
@@ -1236,6 +1384,20 @@
     "plt.tight_layout(); plt.show()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** L’entraînement du schedule cosinus termine en 37 secondes, soit 5 secondes de moins que le linéaire, mais atteint une perte finale plus élevée (0.10135 vs 0.0564), illustrant le compromis entre vitesse et qualité.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Le modèle cosinus, bien qu’entraîné plus rapidement (37 s contre 42,3 s), produit des échantillons de moins bonne qualité comme le montre la MMD plus élevée (0.01086 vs 0.00721), ce qui reflète la sensibilité du schedule cosinus aux hyperparamètres.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "42e992f6",
@@ -1397,6 +1559,20 @@
     "      + f\" -> ecart-type {float(np.std(temps_lin_tous, ddof=1)):.3f} s\")\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Verbatim : « MMD  lineaire : 0.00721 », « MMD  cosinus  : 0.01086 », « MMD  vrai/vrai: 0.00324   <- plancher, effectif egal (1024 contre 1024) » — et, à kernel σ=1.0, la ligne « sigma=1.0   lineaire 0.00721 | cosinus 0.01086 | plancher 0.00324 -> rang : lineaire ». Le linéaire est plus proche du plancher, donc plus proche de la distribution vraie à cette bande passante. Le coût de génération, mesuré dans la même cellule : « Temps d'echantillonnage, modele lineaire, 3 tirages : 2.51 s, 2.37 s, 2.23 s -> ecart-type 0.140 s » — environ 6 % de variation : la comparaison de qualité ne se joue pas sur des temps bruités."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Verbatim : « termine en 37.0 s » (cosinus) contre « termine en 42.3 s » (linéaire) — plus rapide, mais « epoque finale : loss lineaire 0.05640 | cosinus 0.10135 » : la perte cosinus vaut ~1,8 fois la linéaire. Convergé plus vite en temps, moins bien en perte : le compromis vitesse/qualité est mesuré ici ; cette seule cellule ne l'explique pas, et le protocole multi-seeds plus loin le jugera « INCONCLUSIVE »."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 17,
@@ -1462,6 +1638,20 @@
     "print(f\"epoque finale : loss lineaire {histo_lin[-1]:.5f} | cosinus {histo_cos[-1]:.5f}\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** La comparaison côte à côte des courbes d’apprentissage montre que le schedule linéaire converge plus vite et plus bas que le cosinus, avec une perte finale de 0.0564 contre 0.10135, confirmant l’avantage du linéaire pour ce dataset.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Le récapitulatif final synthétise toutes les métriques : perte, MMD, et temps d’échantillonnage, fournissant une vue d’ensemble comparative des deux schedules testés sur ce dataset.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 18,
@@ -1509,6 +1699,27 @@
     "plt.tight_layout(); plt.show()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Ce dictionnaire récapitulatif permet une comparaison objective et quantitative entre les deux schedules, en agrégeant perte finale, qualité des échantillons (MMD), et efficacité (temps par échantillon), trois métriques essentielles pour évaluer un modèle génératif.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** La grille juxtapose vraies images et échantillons des deux schedules. Le jugement visuel s'appuie sur les métriques imprimées à 12 époques : perte finale 0.0564 (linéaire) contre 0.10135 (cosinus), MMD 0.00721 contre 0.01086 — les deux sont en faveur du linéaire à ce budget d'entraînement."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Ce dictionnaire de récapitulatif, en plus des métriques de base, inclut aussi le temps par échantillon pour 1024 images, ce qui permet d’évaluer non seulement la qualité mais aussi l’efficacité computationnelle de chaque schedule de diffusion testé.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 19,
@@ -1556,6 +1767,13 @@
     "      f\"| plancher vrai/vrai {mmd_ref:.5f}\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Ce récapitulatif final est déterminant pour le choix du schedule optimal : le schedule linéaire, avec une perte de 0.05640 et une MMD de 0.00721, se rapproche davantage du plancher théorique (MMD vrai/vrai à 0.00324) que le schedule cosinus (perte 0.10135, MMD 0.01086), tout en maintenant des temps de sampling comparables (2,51 s vs 2,45 s pour 1024 échantillons), ce qui en fait le choix privilégié pour ce modèle de diffusion sur MNIST 8×8.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "39974ec0",
@@ -1754,6 +1972,20 @@
     "print(f\"\\n16 entrainements + echantillonnages en {(time.time() - t0) / 60:.1f} min\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Les lignes brutes par graine balayent la largeur du kernel : « lineaire  budget=12 seed= 0  s=0.25 0.00198  s=0.5  0.00233  s=1.0  0.00750  s=2.0  0.02107  s=4.0  0.01302 » — et le même profil revient à chaque configuration : MMD minimale à σ=0,25 (≈0.002), maximale vers σ=2 (de 0.010 à 0.038 selon la config), souvent repartie à la baisse à σ=4. La MMD ne se lit donc pas en valeur absolue : elle varie d'un ordre de grandeur avec la bande passante du kernel RBF — c'est ce qui justifie le tableau médian par case qui suit, seule base de comparaison entre schedules. L'écart entre schedules s'y voit aussi : à budget 24, « cosinus  seed= 1  s=2.0  0.03412  s=4.0  0.03830 » contre « lineaire  seed=42  s=2.0  0.01013  s=4.0  0.00632 » — à large bande, l'écart cosinus/linéaire dépasse le facteur 3."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Le benchmark protocole lance 16 entraînements (4 seeds × 2 budgets × 2 schedules) pour évaluer la robustesse des modèles face à la variabilité aléatoire, avec un temps total de 17,7 minutes pour l’ensemble des runs.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 21,
@@ -1864,6 +2096,13 @@
     "plt.tight_layout(); plt.show()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lecture :** Le tableau imprimé (médiane sur 4 seeds) dit autre chose que « le linéaire gagne » : à budget 12 et σ=0,25, **cosinus 0.00197 < linéaire 0.00198** (rang : cosinus) ; le linéaire ne reprend la tête qu'aux grandes largeurs de bande (σ≥1) à budget 12, et le cosinus domine à budget 24 sur σ≤2. Verdict imprimé : « VERDICT : INCONCLUSIVE (4 cases lineaire / 6 cases cosinus) ». Détail que la lecture ne doit pas gommer : 0.00198 et 0.00197 sont **sous** le plancher vrai/vrai 0.00324 — à σ=0,25 la MMD médiane passe sous sa référence ; la sortie imprime le plancher sans commenter ce passage, la lecture s'arrête au fait."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "cb9bd49c",
@@ -2013,4 +2252,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}