fix(density,#17040): redressement paquet P04 - 41 lectures dupliquees retirees

MyIA.AI.Notebooks/GenAI/Image/05-History/05-2-CLIPasso-Semantic-Sketching.ipynb

@@ -693,15 +693,6 @@
     "    print(f\"{label} | baseline source-source : {round(clip_cos(src_path, src_path), 4)}\")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**LECTURE ANCRÉE — Interprétation des métriques de similarité CLIP**\n",
-    "\n",
-    "Les scores de similarité CLIP calculés et affichés ci-dessus révèlent une relation non linéaire complexe entre le nombre de traits et la préservation de la sémantique. Pour l'image chameau, la similarité cosinus passe de 0.7183 avec seulement 4 traits à 0.7637 avec 8 traits, puis à 0.8643 avec 16 traits, et atteint 0.876 avec 32 traits (baseline source-source : 1.0). Les gains ne sont pas monotones : +0.0454 entre 4 et 8, le plus grand saut +0.1006 entre 8 et 16, puis seulement +0.0117 entre 16 et 32 — la courbe s'aplatit nettement au-delà de 16 traits. Pour l'image robot avec masque de fond, les scores sont systématiquement inférieurs et culminent avant la fin : 0.6172 à 4 traits, 0.6182 à 8 traits, 0.6519 à 16 traits, puis 0.6455 à 32 traits — le pic est à 16 traits et les 32 retombent légèrement en dessous (baseline : 0.9995). L'écart entre chameau et robot pour un même nombre de traits s'explique par plusieurs facteurs : la complexité accrue du sujet robot, la nature du masque de fond qui modifie la répartition des informations sémantiques, et sa géométrie plus fine. Ces mesures objectives, extraites directement des sorties commitées, permettent de quantifier précisément la qualité des esquisses générées. Elles offrent une base solide pour comparer différentes configurations de l'algorithme et pour comprendre comment la similarité sémantique évolue avec la simplification de la représentation visuelle. Ces métriques, parce qu'elles sont objectives, reproductibles et directement extraites des sorties commitées de la cellule précédente, forment la base solide, fiable et vérifiable des comparaisons quantitatives entre différentes approches d'esquisse sémantique dans la littérature scientifique actuelle, et ce notamment dans les domaines en plein essor de la vision par ordinateur, de l'apprentissage profond moderne, ainsi que de la compréhension sémantique automatisée par les réseaux de neurones profonds. Ces avancées technologiques permettent des applications innovantes en générations d'esquisses."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "4dd70f74",

MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire/09-Aspire-Harness-CopilotSdk.ipynb

@@ -212,13 +212,6 @@
     "**Lecture** : L'amorçage a réussi et a créé le projet compagnon `CopilotHarness.App` dans l'arborescence. Ce projet .NET 10 sera utilisé pour démontrer l'intégration du SDK GitHub Copilot."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture** : Le projet compagnon créé dans `MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire/CopilotHarness.App` suit la structure standard d'un projet .NET avec SDK style. Le fichier .csproj utilise le SDK `Microsoft.NET.Sdk` et cible le framework net10.0, ce qui permet l'utilisation des dernières fonctionnalités de C# et .NET."
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -356,19 +349,12 @@
     "**Lecture** : Le fichier `CopilotHarness.App.csproj` montre la configuration du projet : ciblage .NET 10.0, avec la référence au package `GitHub.Copilot.SDK` version 1.0.13. Ce SDK embarque son propre runtime natif (FFI), aucune CLI externe n'est nécessaire."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture** : Le projet `CopilotHarness.App` a été restauré avec succès, ce qui signifie que toutes les dépendances NuGet ont été téléchargées et installées dans le cache local. Le temps écoulé de 00:00:01.37 indique une connexion réseau rapide. La génération a réussi avec 0 avertissement et 0 erreur, confirmant la compatibilité parfaite entre le SDK Copilot et le runtime .NET 10."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "76d90fe2",
    "metadata": {},
    "source": [
-    "### Interprétation\n",
+    "### Interprétation — la dépendance du `.csproj`\n",
     "\n",
     "Le `.csproj` ne déclare qu'une dépendance inhabituelle : `GitHub.Copilot.SDK` 1.0.13. C'est la seule ligne qui change tout — le runtime agent, ses outils et sa couche de permissions arrivent avec le package. Le reste est un `net10.0` ordinaire."
    ]
@@ -414,20 +400,6 @@
     "**Lecture** : Le fichier `Program.cs` est le point d'entrée du harness. Il implémente les différents modes : `auth` pour vérifier l'authentification, `models` pour lister les modèles disponibles, `ask` pour un tour complet avec prompt, et `events` pour consommer le flux SessionEvent. Chaque mode démontre une capacité différente du SDK Copilot."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture** : La sortie `cat` affiche le contenu complet du fichier `Program.cs`, incluant les commentaires détaillant les différents modes du harness. On remarque les using directives pour System.Text, System.Text.Json et GitHub.Copilot, ainsi que la configuration des CopilotClientOptions avec le répertoire de travail courant."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture** : Le code source de Program.cs illustre parfaitement l'architecture du SDK Copilot. L'utilisation de `CopilotClientOptions` avec `WorkingDirectory = Environment.CurrentDirectory` montre que le client est configuré pour opérer dans le contexte du répertoire courant, ce qui est essentiel pour les applications qui doivent interagir avec des fichiers locaux."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "8ee88732",
@@ -743,20 +715,6 @@
     "Harness.ShowFile(\"MyIA.AI.Notebooks/GenAI/Integrations-DotNet/Aspire/CopilotHarness.App/Program.cs\", 1, 40);"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture** : La sortie affiche le code source complet de `Program.cs` avec les using directives pour `System.Text`, `System.Text.Json` et `GitHub.Copilot`. La structure switch/case permet de sélectionner le mode d'exécution."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture supplémentaire** : L'affichage du fichier Program.cs révèle la structure complète de l'application de démonstration du SDK Copilot. On note l'instantiation du `CopilotClient` avec des options (`CopilotClientOptions`, `WorkingDirectory = Environment.CurrentDirectory`) configurées pour le répertoire de travail courant. Le code gère tous les modes via un switch statement clair et concis."
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -804,26 +762,12 @@
     "**Lecture** : Le statut d'authentification confirme que l'utilisateur `jsboige` est authentifié via `gh-cli` sur `https://github.com`. Le harness peut maintenant interagir avec l'API GitHub Copilot."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture** : Le statut d'authentification retourne un objet JSON complet avec les champs : isAuthenticated (true), authType (gh-cli), host (https://github.com), login (jsboige), statusMessage. Cela confirme que l'environnement est correctement configuré pour interagir avec l'API GitHub Copilot sans nécessiter d'authentification supplémentaire."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture supplémentaire** : L'authentification via `gh-cli` est une méthode pratique et sécurisée pour accéder à l'API GitHub Copilot. Le SDK utilise les tokens d'accès personnel stockés par l'outil `gh` pour authentifier les requêtes, ce qui évite d'avoir à gérer manuellement les clés d'API ou les tokens OAuth dans le code de l'application."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "583bbaa7",
    "metadata": {},
    "source": [
-    "### Interprétation\n",
+    "### Interprétation — une authentification héritée, sans secret\n",
     "\n",
     "`isAuthenticated: true`, `authType: \"gh-cli\"` : le harness **hérite l'authentification de la machine** — ici la session `gh` locale — sans qu'aucune clé ne figure dans le code ou dans l'environnement du projet. Le SDK propose aussi la voie BYOK (`LlmInferenceAdapter`, échange `LlmInferenceExchange`) pour déporter l'inférence vers votre propre endpoint ; elle n'est pas exercée ici et reste documentée par sa signature publique.\n",
     "\n",
@@ -889,26 +833,12 @@
     "**Lecture** : Le catalogue des 15 modèles disponibles est affiché, avec pour chacun l'identifiant, le nom et la capacité de vision. On note la présence de modèles Claude (Sonnet 5, Haiku 4.5), GPT-5 (mini, 5.3-codex, 5.4, 5.4-mini, 5.6-luna/terra), Grok (4.5, 4.6) et Kimi (K2.7 Code, K3), tous avec vision sauf Auto et MAI-Code-1-Flash."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture** : La commande `dotnet run models` a généré la liste complète des 15 modèles disponibles, triés par identifiant. Chaque modèle est présenté avec son nom et sa capacité de vision (oui/non). Cette liste est dynamique et reflète les modèles actuellement accessibles via l'API Copilot, incluant les dernières versions de Claude, GPT-5, Grok et Kimi."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture supplémentaire** : La liste des 15 modèles disponibles montre l'étendue de l'écosystème Copilot. Chaque modèle a ses propres caractéristiques : certains excellent dans le raisonnement (comme Claude Sonnet 5), d'autres dans la génération de code (comme GPT-5.3-Codex), et d'autres encore dans les tâches multilingues ou multimodales. La colonne vision indique si le modèle peut traiter des images en plus du texte."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "217b44d8",
    "metadata": {},
    "source": [
-    "### Interprétation\n",
+    "### Interprétation — quinze modèles derrière une seule API\n",
     "\n",
     "Quinze modèles — Claude Sonnet 5, Haiku 4.5, la famille GPT-5.x, Grok, Kimi, MAI — derrière une seule API locale. L'entrée `auto` est le sélecteur par défaut : le harness choisit. Pour un notebook pédagogique, ce catalogue est aussi l'occasion d'un exercice LINQ (voir Exercice 3)."
    ]
@@ -971,26 +901,12 @@
     "**Lecture** : Au prompt « En une seule phrase de 12 mots maximum : que represente le package GitHub.Copilot.SDK pour un developpeur .NET ? », le modèle `claude-sonnet-5` répond exactement : « Le SDK officiel .NET pour intégrer GitHub Copilot dans ses applications. » — avec un `apiCallId` unique. Le harness a géré la session complète : authentification, envoi de la requête, réception de la réponse."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture** : La réponse JSON de Copilot contient des métadonnées complètes : `apiCallId`, `interactionId`, `messageId`, `model`, `rte` (booléen, à `true` dans cette réponse), `toolRequests`, et `turnId`. Ces informations permettent de tracer chaque interaction avec le service."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture supplémentaire** : La réponse JSON retournée par Copilot contient non seulement le contenu textuel généré, mais aussi des métadonnées précieuses pour le débogage et l'audit : l'apiCallId permet de corrélér les logs côté serveur, l'interactionId identifie la session complète, et le messageId est unique à ce message spécifique. Ces identifiants sont essentiels pour le traçage dans un environnement de production."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "c0bee5d9",
    "metadata": {},
    "source": [
-    "### Interprétation\n",
+    "### Interprétation — un tour d'agent complet, pas un client LLM brut\n",
     "\n",
     "La réponse arrive enrichie : `model` (ici `claude-sonnet-5` — le sélecteur `auto` a tranché), `toolRequests` (vide : ce tour n'a déclenché aucun outil), `apiCallId`/`turnId` pour la traçabilité. Ce n'est **pas** un client LLM brut : c'est un tour d'agent complet, avec sa politique d'outils et ses identifiants de tour."
    ]
@@ -1049,26 +965,12 @@
     "**Lecture** : L'histogramme des `SessionEvent` montre les différentes étapes du tour : `session.start`, `system.message`, `user.message`, `assistant.turn_start`, `assistant.message`, `assistant.turn_end`, `session.usage_checkpoint`, `session.model_change`. Le texte assemblé à partir des deltas est `BONJOUR HARNESS`, confirmant le bon fonctionnement du flux."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture** : La commande `dotnet run events` a exécuté un tour complet avec le prompt `BONJOUR HARNESS`. La sortie montre l'histogramme de 8 types d'événements SessionEvent distincts (un de chaque), confirmant que le flux a été correctement consommé. Le texte final assemblé depuis les deltas est `BONJOUR HARNESS`, validant le bon fonctionnement du mode events du harness."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Lecture supplémentaire** : Le mode `events` du harness est particulièrement utile pour comprendre le flux d'interaction avec Copilot. En consommant les SessionEvent au fil de l'eau, on peut suivre en temps réel les différentes étapes du traitement : initialisation de session, envoi du message utilisateur, génération de la réponse par l'assistant, et finalisation du tour. Chaque événement contient des métadonnées précieuses pour le monitoring et le débogage."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "049e52d0",
    "metadata": {},
    "source": [
-    "### Interprétation\n",
+    "### Interprétation — le canal événementiel du tour\n",
     "\n",
     "L'histogramme raconte le tour dans l'ordre : `session.start` → `session.model_change` (résolution de `auto`) → `system.message` → `user.message` → `assistant.turn_start` → `assistant.message` → `assistant.turn_end` → `session.usage_checkpoint`. Le texte `BONJOUR HARNESS` a été ré-assemblé depuis le champ `content` des événements d'assistant — la preuve que le contenu transite bien par le canal événementiel, pas seulement par la valeur de retour."
    ]