GenAI - Écosystème IA Générative

Ce parcours vous forme à la maîtrise de l’IA générative dans toute sa diversité : générer des images, synthétiser la voix, composer de la musique, produire des vidéos, orchestrer des agents autonomes, et déployer des applications en production. Chaque modalité suit une progression en quatre niveaux, du premier pas avec une API jusqu’aux pipelines multi-modèles de production. Les décomptes par sous-domaine et la maturité de chaque notebook se lisent dans le marqueur CATALOG-STATUS en fin de fichier (source autoritative régénérée chaque nuit par catalog-cron.yml à 03:37 UTC sur main).

Hook — pourquoi cette série

L’IA générative a transformé la création de contenu en 2024-2026. Un développeur qui sait piloter gpt-image-1 pour générer une illustration, Whisper pour transcrire un podcast, MusicGen pour composer un fond sonore, et orchestrer tout cela via des agents autonomes, possède un avantage décisif sur le marché. Ce parcours ne se contente pas d’énumérer des APIs : il vous apprend à comprendre les modèles (leurs forces, leurs limites, leurs pièges), à comparer les approches (open-source vs cloud, local vs API), et à combiner les modalités dans des pipelines réels.

À qui s’adresse cette série

Étudiants en IA, développeurs full-stack souhaitant monter en compétence sur les modèles génératifs multi-modaux, enseignants cherchant un parcours structuré clé-en-main (Docker Compose, credentials préconfigurés, ~141 notebooks balisés), et ingénieurs R&D explorant l’orchestration d’agents LLM en production. Prérequis : Python intermédiaire, containers Docker de base, et une familiarité avec les API REST.

Objectifs d’apprentissage

À l’issue du parcours, vous êtes capable de :

  • Sélectionner le bon modèle pour une tâche donnée — connaître les forces/faiblesses des modèles cloud (DALL-E, GPT, Whisper, Sora) face aux modèles open-source locaux (FLUX, SD 3.5, Qwen-Image, Whisper-local, MusicGen, HunyuanVideo) et arbitrer sur coût / qualité / souveraineté des données.
  • Combiner les modalités dans des pipelines cohérents — texte vers image, image vers vidéo, audio vers texte vers audio, sans casser la chaîne d’inférence ni perdre le contexte sémantique.
  • Orchestrer des agents via Semantic Kernel (plugins, agents, filtres, vector stores, processus multi-étapes) en Python et en C#/.NET Interactive.
  • Industrialiser une application GenAI avec authentification ComfyUI, graceful degradation cloud/local, tests E2E Playwright sur Open WebUI, et intégration MCP.
  • Développer avec des agents IA (Claude Code, Roo Code) en mode “vibe coding” — formuler les besoins, itérer sur les diffs, automatiser les workflows de développement.
  • Évaluer la qualité des sorties générées — métriques objectives (FID, WER, BLEU), validation subjective structurée, comparaison de pipelines.

Notebooks

# Sous-série README Charge Fil rouge
1 00-GenAI-Environment - Votre point de départ README complet ~4h Configuration Docker ComfyUI/Qwen, Whisper, MusicGen, Forge
2 Image - Générer, éditer et orchestrer des images README complet ~6-8h Construire un générateur de contenu visuel pour l’éducation
3 Audio - Parler, écouter, composer README complet ~14-16h Produire un podcast automatique avec voix synthétique + fond musical
4 Video - Comprendre, générer et produire README complet ~14h Créer une vidéo pédagogique automatisée depuis un script texte
5 Texte - Maîtriser les LLMs et les APIs OpenAI README complet ~10h Arc agentique 13-20 + Open WebUI live
6 SemanticKernel - Orchestration agentique avec Microsoft README complet ~20h SDK Python + .NET, MCP, multi-modalité
7 FineTuning - Adapter un modèle à votre tâche README complet (durée libre) LoRA → QLoRA → SFT → DPO → fusion MoE
8 PostTraining - La chaîne SOTA du post-entraînement README complet (durée libre) SFT → RLHF → DPO → GRPO → RLVR (DeepSeek-R1)
9 Vibe-Coding - Développer avec des agents IA README complet ~30h Claude Code + Roo Code + Claw-Systems + Claudish
10 RAG et Mémoire Sémantique - Le backend de grounding des agents README complet ~6h Qdrant + embeddings + notebook pratique hors ligne
11 Plateformes-Conversationnelles - OWUI & AI-Engine README catégorie ~14h+ Tour OWUI + Playwright E2E (30+ tests) + AI-Engine WordPress
12 CaseStudies - Projets étudiants README complet (durée libre) Barbie/Shrek, recettes, chatbot médical, Fort Boyard
13 Security - Oversight, contrôle et surface d’attaque des outils README complet (durée libre) Scaling laws d’oversight, interprétabilité du refus, attaques/défenses MCP

Activités de cours

Les activités pédagogiques des cours d’IA — vulgarisation (exploration, contraintes, probabilités, théorie des jeux…) et TP d’IA générative avec leur corrigé — vivent dans activites/. Elles étaient auparavant enfouies dans Vibe-Coding/docs/ et une partie n’existait que sur le Drive (#18223).

Parcours recommandés

Découvreur (initiation rapide, ~20h)

Commencez par 00-GenAI-Environment/ pour le setup, puis choisissez une modalité qui vous intéresse : Image/01-Foundation/ pour le visuel, ou Audio/01-Foundation/ pour le son. L’objectif est de générer votre premier contenu en moins d’une journée.

Praticien (maîtrise multi-modale, ~50h)

Couvrez les quatre modalités de base (Image, Audio, Video, Texte) au niveau Foundation, puis approfondissez une ou deux modalités au niveau Advanced. Vous serez capable de combiner texte, image et son dans un projet cohérent.

Agentiste (full-stack agentic, ~90h)

Ajoutez SemanticKernel pour l’orchestration et Vibe-Coding pour le développement assisté. Vous construirez pipelines multi-modèles autonomes et des agents capables de chaînes de traitement complexes.

Expert (avec production, ~120h+)

Complétez avec Playwright pour les tests E2E et les notebooks Applications de chaque modalité. Vous maîtrisez le cycle complet : génération, orchestration, tests, déploiement.

Prérequis

Avant de commencer, vérifiez votre configuration :

Matériel

  • GPU : non obligatoire pour les notebooks Texte (API cloud) ; ComfyUI est hébergé sur un serveur RTX 3090 dédié accessible via API. Les notebooks Audio et Video peuvent tourner en CPU pour les démos (latence plus élevée).
  • RAM : 16 GB minimum (32 GB recommandé pour PostTraining avec LoRA sur petits modèles).
  • Stockage : 50 GB libres pour les modèles open-source (FLUX, SD 3.5, Qwen-Image, MusicGen).

Logiciel

  • Python 3.10+ + pip + venv
  • Docker Desktop en cours d’exécution (services ComfyUI, Whisper, MusicGen, Forge)
  • Jupyter Lab ou VSCode avec extension Jupyter
  • Git pour cloner le dépôt

Credentials

  • OPENAI_API_KEY — gpt-image-1, GPT-5, Whisper, TTS (Image, Audio, Texte)
  • ANTHROPIC_API_KEY — Claude Vision (Video)
  • HUGGINGFACE_TOKEN — modèles HF open-source (Image, Video)
  • COMFYUI_API_TOKEN (alias accepté : COMFYUI_AUTH_TOKEN) — services locaux ComfyUI (Image local, Video) ; fourni par l’enseignant

Sans COMFYUI_API_TOKEN, les notebooks locaux se connectent sans authentification (comfyui_client.py l’affiche) et reçoivent 401 si le service en exige une. La génération cloud (OPENAI_API_KEY) est portée par des notebooks distincts de la série — il n’y a pas de bascule automatique local→cloud dans un même notebook.

Limitations connues

Coûts API attendus

La série est conçue pour minimiser les coûts. Les notebooks Texte utilisent principalement GPT-4o-mini (~0.15\(/1M input tokens) et GPT-4o (~2.50\)/1M input tokens). Les notebooks Image utilisent gpt-image-1 uniquement pour les exercices (les exemples utilisent ComfyUI/Qwen gratuit). Budget estimé : 5-15$ total pour l’ensemble de la série, sauf appels itératifs intensifs.

GPU non disponible localement

Si vous n’avez pas de GPU local, les notebooks Image et Video s’exécutent via ComfyUI distant (déjà configuré sur RTX 3090 partagée). Les notebooks Audio (MusicGen, Demucs) peuvent nécessiter un GPU pour les modèles >1B paramètres ; un fallback CPU lent est documenté dans chaque notebook.

Parallelisation avec d’autres séries

Chaque sous-domaine (Image, Audio, Video, Texte, SemanticKernel) est indépendant. Le parcours recommandé est de commencer par Texte (nécessaire pour comprendre les prompts utilisés partout) puis de choisir un sous-domaine selon votre projet.

Erreurs fréquentes

  • ComfyUI 401 Unauthorized : vérifier COMFYUI_API_TOKEN dans .env (token fourni par l’enseignant). Sans token, le notebook se connecte sans authentification et le service refuse — ce n’est pas un secret mal configuré.
  • Docker services ne démarrent pas : python scripts/genai-stack/genai.py docker status puis genai.py docker start. Détails : docs/genai/genai-services.md.

Concepts clés

Concept Description Série principale
Latent space Espace compressé où le modèle “pense” — toute génération commence ici Image, Video
Diffusion Processus itératif : bruit → image/audio/vidéo en N étapes Image, Video, Audio
VAE / VAE-Decoder Encodeur/décodeur entre pixel space et latent space Image
CFG (Classifier-Free Guidance) Paramètre contrôlant la fidélité au prompt vs liberté créatrice Image
LoRA / QLoRA Adaptateurs légers pour spécialiser un modèle sans ré-entraîner tout le poids FineTuning
DPO / RLHF Alignement des modèles sur les préférences humaines PostTraining
RAG Retrieval-Augmented Generation : injecter des documents externes dans le contexte LLM Texte, RAG et Mémoire Sémantique
Grounding / Mémoire sémantique Ancrer un agent dans un corpus indexé (conversations, code) pour éviter l’hallucination hors-contexte RAG et Mémoire Sémantique
Base vectorielle (Qdrant / HNSW) Stocker des embeddings et rechercher les plus proches voisins approchés à grande échelle RAG et Mémoire Sémantique
Quantization (TurboQuant) Comprimer les vecteurs (4 bits) pour réduire l’empreinte mémoire sans perte de rappel RAG et Mémoire Sémantique
Function Calling Le LLM appelle vos fonctions — passerelle vers les outils et APIs Texte
Structured Outputs Forcer le LLM à respecter un schéma JSON précis Texte
SFT / GRPO / RLVR Post-training : Supervised Fine-Tuning, Group Relative Policy Optimization, RL with Verifiable Rewards PostTraining
Semantic Kernel SDK d’orchestration : plugins, agents, filtres, processus SemanticKernel
MCP (Model Context Protocol) Standard de connexion outils-modèles — le LLM découvre vos outils dynamiquement SemanticKernel
Whisper / STT Speech-to-Text : transcrire l’audio en texte avec timestamps Audio
TTS Text-to-Speech : synthétiser la voix depuis un texte Audio
ComfyUI Interface visuelle pour chaîner les modèles génératifs en workflows Image, Video
Playwright Framework de test E2E pour applications web GenAI Playwright-OWUI

Contenu détaillé

Structure des sous-domaines

GenAI/
├── 00-GenAI-Environment/    # Setup et configuration
├── Image/                   # Génération d'images
├── Audio/                   # Speech, TTS, musique, séparation
├── Video/                   # Génération et compréhension vidéo
├── Texte/                   # LLMs et génération de texte
├── SemanticKernel/          # Microsoft Semantic Kernel
├── FineTuning/              # Fine-tuning de modèles : LoRA/QLoRA/SFT/DPO
├── PostTraining/            # Post-training SOTA : SFT/RLHF/DPO/GRPO/RLVR
├── Aspire/                  # Hosting/observabilité .NET (AppHost, services, OpenTelemetry)
├── CaseStudies/             # Études de cas étudiants GenAI (4 projets agentiques)
├── FallacyDetection/        # Taxonomie + datasets + couverture cross-notebooks fallacy
├── Integrations-DotNet/     # Hub d'intégrations .NET GenAI (EFCore + CopilotSDK, voir PR #14431)
├── Plateformes-Conversationnelles/  # Interfaces GenAI conversationnelles (nommées par fonction)
│   ├── Open-WebUI/          # Tour guidé plateforme + série QA Playwright (6 modules, 30+ tests)
│   └── AI-Engine-WordPress/ # WordPress comme surface GenAI (Copilot, RAG, serveur MCP)
├── Vibe-Coding/             # Tutoriels Claude Code et Roo Code
└── RAG-et-Memoire-Semantique/  # Mémoire sémantique : Qdrant, embeddings, grounding (SDDD)

Note d’arborescence (mars 2026) : EFCore/ et CopilotSDK/ (mono-notebook chacun) seront absorbés dans Integrations-DotNet/ via PR #14431 — répertoire pas encore créé sur main à la rédaction de cette note (en attente du merge de #14431). Le hub Integrations-DotNet sera le point de chute canonique des futurs bindings .NET GenAI. Aspire/ reste au niveau racine : 8 notebooks, série pédagogique majeure avec sous-série catalog. La provenance des réalisations étudiantes EPF est portée par la section « Généalogie » de CaseStudies/README.md.

00-GenAI-Environment - Votre point de départ

Avant de générer la moindre image ou le moindre son, il faut configurer l’environnement : clés API, services Docker, et validation que tout fonctionne. Ces 6 notebooks sont le passage obligatoire. Ils couvrent le setup Python, la gestion des conteneurs Docker (ComfyUI, Whisper, MusicGen), la configuration des endpoints API, et un test complet de validation.

Image - Générer, éditer et orchestrer des images

On commence par les fondamentaux : appeler gpt-image-1 et GPT-5 pour générer des images depuis un prompt texte, puis manipuler ces images avec PIL et OpenCV. Le niveau avancé introduit les modèles open-source hébergés localement (Qwen Image Edit pour l’édition, FLUX pour la qualité, Stable Diffusion 3.5 pour la production, Z-Image/Lumina pour l’expérimental). En orchestration, on compare les modèles entre eux et on enchaîne les workflows. Les applications métier montrent comment intégrer tout cela dans des cas réels : contenu éducatif, workflows créatifs, motifs décoratifs.

Audio - Parler, écouter, composer

Cette série couvre le spectre complet de l’audio IA : reconnaissance vocale (Whisper V3, OpenAI API), synthèse vocale (Kokoro, OpenAI TTS, Chatterbox), clonage de voix (XTTS v2), génération musicale (MusicGen, YuE), séparation de sources (Demucs), et pipelines complets (podcast automatique, transcription batch, synchronisation audio-vidéo). Le détail de chaque niveau et les services utilisés se trouve dans le README Audio.

Video - Comprendre, générer et produire

La vidéo est la modalité la plus exigeante en ressources mais aussi la plus spectaculaire. On commence par comprendre des vidéos existantes (GPT-5, Qwen-VL), puis on génère (HunyuanVideo, Wan, Sora, et LTX-2 pour la génération audiovisuelle jointe — image et son synchronisés dans un même passage de diffusion). Les notebooks d’orchestration combinent compréhension et génération dans des workflows de production vidéo. La série couvre aussi le surcadrage d’images (ESRGAN) et la synchronisation audio-vidéo.

Texte - Maîtriser les LLMs et les APIs OpenAI

Le texte est le socle de toute interaction avec l’IA générative. Cette série va au-delà du simple “prompt engineering” : structured outputs pour des réponses fiables, function calling pour connecter les LLMs à vos outils, RAG pour injecter de la connaissance externe, code interpreter pour l’exécution dynamique, et les modèles de raisonnement (o-series) pour les tâches complexes. Le milieu de série couvre les patterns de production et les LLMs locaux (llama.cpp, quantization, vLLM). Le dernier tiers (notebooks 13-18) forme un arc agentique et test-time compute : orchestration d’agents, mémoire persistante, Tree-of-Thoughts, scaling du calcul à l’inférence et raisonnement natif vs scaling ; les notebooks 19-20 raccordent le tout à la plateforme Open WebUI (orchestration et API native, endpoints authentifiés live).

SemanticKernel - Orchestration agentique avec Microsoft

Semantic Kernel est le SDK Microsoft pour construire des applications agentiques. Il fournit les briques pour orchestrer les LLMs avec des plugins, des agents, des filtres, des vector stores, et des processus multi-étapes. Cette série couvre le SDK en Python et en C# (.NET Interactive), avec une progression qui va des fondamentaux aux patterns avancés (MCP, multi-modalité, interop CLR).

FineTuning - Adapter un modèle à votre tâche

Un modèle généraliste ne connaît pas votre domaine, et le ré-entraîner de zéro coûterait des millions. Le fine-tuning l’adapte à moindre frais. Cette série progressive de 5 notebooks part des adaptateurs légers — LoRA, puis QLoRA qui quantifie le modèle en 4 bits pour tenir sur un GPU grand public (T4/V100) —, passe par le supervised fine-tuning (SFT) au format ChatML qui transforme un base model en modèle conversationnel, l’alignement sur les préférences humaines (RLHF/DPO), et culmine avec la fusion de plusieurs modèles spécialisés en un seul (TIES, DARE, routage MoE). C’est la boîte à outils pratique pour spécialiser un LLM.

PostTraining - La chaîne SOTA du post-entraînement

Là où FineTuning donne la boîte à outils, PostTraining en est le pendant théorique et SOTA (2024-2025) : il remonte toute la chaîne conceptuelle du post-entraînement — SFT vers RLHF, DPO, GRPO, puis RLVR. Ces 7 notebooks prennent le parti d’expliquer d’abord la mathématique du loss, puis l’intuition, puis l’implémentation (TRL/HuggingFace) — l’ordre inverse des tutoriels habituels. Le fil rouge reproduit les techniques récentes, jusqu’au raisonnement à la Deepseek-R1 (janvier 2025), sur de petits modèles qui tiennent sur un GPU 8 Go, avec évaluation comparative et détection du reward hacking — la série migre progressivement de Qwen2.5-0.5B/1.5B vers Qwen3.5-0.8B (PT-03 déjà migré, #5078 : évaluation DPO en vraie forward pass au lieu d’une métrique codée en dur). À suivre après FineTuning pour la profondeur méthodologique.

Vibe-Coding - Développer avec des agents IA

Le “vibe coding” est la compétence la plus demandée de 2026 : décrire ce qu’on veut à un agent IA et le laisser écrire, tester et déployer le code. Cette série couvre les deux outils majeurs du marché : Claude Code (Anthropic) et Roo Code (communautaire), chacun abordé en 5 modules, de la découverte à l’automatisation avancée. Deux modules d’infrastructure complètent le tableau : Claw-Systems (agents autonomes conteneurisés — les bots reviewers Hermes/NanoClaw qui auditent réellement les PRs de ce dépôt) et Claudish (proxy multi-provider qui fait tourner Claude Code sur des modèles alternatifs).

RAG et Mémoire Sémantique - Le backend de grounding des agents

Là où Vibe-Coding montre les front-ends d’agents, cette section documente la couche d’en dessous : la mémoire sémantique qui ancre un agent dans des faits vérifiables plutôt que dans des suppositions. C’est le récit d’une infrastructure réelle — une base vectorielle Qdrant qui indexe conversations et code, interrogée à chaque tâche pour retrouver « ce qui a déjà été dit, écrit, décidé ». Quatre documents (le besoin et la méthode SDDD, l’infrastructure Docker/WSL2, l’usage via MCP, les incidents réels et leurs leçons) et un notebook pratique exécutable hors ligne (Qdrant en mémoire + fastembed, sans clé d’API ni Docker). Le pendant applicatif du RAG sur documents reste la série Texte.

Plateformes-Conversationnelles - Interfaces GenAI conversationnelles

Cette catégorie regroupe les plateformes GenAI réelles qui apportent une couche de conversation par-dessus les modèles : Open WebUI (serveur auto-hébergé multi-tenant, avec son tour guidé et la série QA Playwright-OWUI de tests de bout en bout) et AI-Engine (extension WordPress, chatbots + Copilot Gutenberg + RAG + WordPress comme serveur MCP). Un comparatif aide à choisir selon le terrain.

CaseStudies - Projets étudiants

Projets réalisés par les étudiants : génération d’images style Barbie/Shrek, générateur de recettes, chatbot médical éducatif, challenges style Fort Boyard. Ces notebooks illustrent la diversité des applications possibles après le parcours. Le détail des 4 cas canoniques est dans CaseStudies/README.md. À ne pas confondre avec la série interdisciplinaire MyIA.AI.Notebooks/CaseStudies/ (Diagnostic-Medical, Oncology-Planning, SmartGrid-Energy) — voir la note de clarification.

FallacyDetection - Taxonomie et couverture des fallacies

Série récente (2026) qui s’attaque à un angle mort de l’évaluation GenAI : la détection de fallacies dans les sorties de modèles. Démarre par une introduction à la taxonomie (01_taxonomy_intro.ipynb), parcourt les jeux de données publics (02_fallacy_datasets_landscape.ipynb — dont l’inventaire SAE Qwen3.5), mesure la couverture taxonomique (03_taxonomy_coverage_gap.ipynb), puis croise N×M avec les autres notebooks GenAI via une matrice de couverture (04_coverage_matrix.ipynb). Le script de génération de la matrice vit dans scripts/notebook_tools/fallacy_coverage_matrix.py. À consulter après les séries agentiques pour avoir une lecture transverse.

Aspire - Hosting et observabilité .NET

Série pédagogique sur .NET Aspire appliquée à l’IA générative : AppHost (composition de services), OpenTelemetry (traces distribuées), health-checks, intégration avec les services GenAI locaux (ComfyUI, vLLM, Qdrant). 8 notebooks — la série la plus technique du hub, à aborder avec un bagage C#/.NET 9 ou après les notebooks SemanticKernel C#.

Integrations-DotNet - Hub d’intégrations .NET GenAI

Hub thématique dédié aux bindings .NET des API GenAI : EFCore (requêtes compilées sur metadata), CopilotSDK (intégration Microsoft Copilot), et les futurs arrivants (TUnit.Testcontainers, AppHost configurations). Voir PR #14431 pour le contexte de création et la liste à venir.

Théorie — Stack self-hosted ⇄ Cloud API

La série GenAI a un parti pris structurant que les autres hubs n’ont pas : chaque notebook déclare explicitement quelle infrastructure il exécute. La légende utilisée dans le tableau ci-dessous :

Légende Signification Trade-off
● self-hosted Modèle open-source exécuté via Docker local (ComfyUI/Qwen/Whisper/MusicGen/Forge) Gratuit, contrôle total, GPU RTX 3090 dédiée requise
◐ Cloud API API propriétaire (OpenAI/Anthropic/HuggingFace) Coût par token/image, zéro GPU, qualité par défaut élevée
◯ Hybride Les deux chemins sont démontrés (au choix selon contexte) Notebooks basculent automatiquement si .env configuré

Cette partition traverse les 14 sous-séries du marqueur CATALOG-STATUS en fin de fichier et structure le déploiement concret. Les volumes détaillés par sous-série et par maturité restent dans ce marqueur autoritatif ; le tableau ci-dessous en reprend les volumes sous l’angle pédagogique « qui consomme quoi » plutôt que « qui contient combien ». Le périmètre du compte est le catalogue (pedagogical_count) : 215 notebooks — jamais l’arbre versionné (220) ni le parcours étudiant (200) ; les trois périmètres et leurs instruments sont nommés dans docs/reference/notebook-counters.md.

Sous-série Notebooks au catalogue Stack dominante Service / modèle phare
00-GenAI-Environment 6 ◯ Hybride Docker Compose : ComfyUI/Qwen, Whisper, MusicGen, Forge
Image 17 ◯ Hybride Qwen Image Edit (self-hosted) ⇄ gpt-image-1 (Cloud)
Audio 31 ◯ Hybride Whisper V3 + Kokoro TTS (self-hosted) ⇄ OpenAI TTS (Cloud)
Video 22 ◯ Hybride HunyuanVideo + Wan (self-hosted) ⇄ Sora (Cloud)
Texte 30 ◐ Cloud API GPT-4o-mini (~0,15 $/M tokens) ; Structured Outputs + Function Calling
SemanticKernel 20 ◯ Hybride SDK Microsoft .NET 9 + plugins Python ; orchestration multi-agents
Integrations-DotNet 11 ◯ Hybride .NET Aspire + OpenTelemetry (services GenAI locaux) ; EFCore + Copilot SDK
FineTuning 7 ● self-hosted LoRA/QLoRA/SFT/DPO sur GPU local ; PEFT + Transformers
PostTraining 16 ● self-hosted SFT/GRPO/RLVR (rewardspy 0.1.0 git install)
CaseStudies 5 ◯ Hybride Projets étudiants bout-en-bout
FallacyDetection 4 ◐ Cloud API HuggingFace datasets — taxonomie + couverture des fallacies
Plateformes-Conversationnelles 28 ◯ Hybride Plateforme Open WebUI + Playwright E2E (30+ tests) ; AI-Engine (WordPress)
Vibe-Coding 8 ◯ Hybride Claude Code + Roo Code ; Claw-Systems (bots Hermes/NanoClaw) + Claudish (proxy multi-provider)
RAG-et-Memoire-Semantique 10 ● self-hosted Qdrant + embeddings + grounding SDDD
Total 215 — = pedagogical_count du marqueur CATALOG-STATUS

LLMs texte : le chemin self-hosted existe aussi. La ligne Texte est ◐ Cloud API en dominante, mais les notebooks 10-12 (llama.cpp, quantization GPTQ/AWQ, vLLM) montrent comment servir localement les mêmes capacités — c’est exactement la voie que le cluster CoursIA emprunte en production, avec ses propres endpoints vLLM internes qui alimentent les sous-agents des workflows d’automatisation.

Le principe à retenir : un notebook GenAI n’est jamais « juste un appel API ». Il montre comment l’API s’intègre dans une stack self-hosted (Docker Compose, GPU partagé, monitoring) et comment basculer entre les deux selon le contexte (budget, latence, qualité, conformité). Cette discipline d’hybridation systématique est ce qui distingue la série d’un tutoriel API classique.

Self-hosted ⇄ orchestration cluster : la stack ComfyUI/Qwen est elle-même orchestrée par scripts/genai-stack/genai.py (validation pre-commit + état services). Voir docs/genai/genai-services.md pour le détail par service, modèle, GPU et quantization (ComfyUI Qwen Phase 29 — VAE 16 channels, scheduler beta, CFG 1.0, TextEncodeQwenImageEdit).

Portée scientifique — Fil rouge transverse

Les sous-domaines ne sont pas isolés. Un projet final typique enchaîne :

  1. Texte produit un script structuré (function calling, structured outputs)
  2. Image illustre les concepts (DALL-E, FLUX, ou Qwen Image Edit pour les retouches)
  3. Audio synthétise la narration (Kokoro/OpenAI TTS) + fond musical (MusicGen)
  4. Video assemble le tout (HunyuanVideo pour la génération, Demucs pour la sync A/V)
  5. SemanticKernel orchestre le pipeline en agents autonomes
  6. Playwright-OWUI teste l’interface utilisateur du produit final

C’est ce parcours d’intégration qui différencie une démonstration jouet d’un produit déployable.

Le schéma ci-dessous visualise ce fil rouge transverse : les quatre modalités génératives (Texte, Image, Audio, Video) produisent le contenu, puis SemanticKernel orchestre le tout en agents autonomes et Playwright-OWUI valide l’interface utilisateur finale.

flowchart LR
    T["Texte<br/>script structuré"]
    I["Image<br/>illustrations"]
    A["Audio<br/>narration + musique"]
    V["Video<br/>assemblage A/V"]
    S["SemanticKernel<br/>orchestration agents"]
    P["Playwright-OWUI<br/>tests E2E"]
    Prod["Produit déployable"]
    T --> I --> A --> V --> S --> P --> Prod

FAQ

Faut-il un GPU pour cette série ?

Non. Les notebooks Image utilisent ComfyUI hébergé sur un serveur distant (RTX 3090 dédiée, accessible via API). Les notebooks Texte utilisent les API cloud (OpenAI, Anthropic). Les notebooks Audio et Video peuvent tourner en CPU pour les démos (avec une latence plus élevée). Si vous avez un GPU local, les notebooks montrent aussi comment l’utiliser.

Quels sont les coûts API attendus ?

La série est conçue pour minimiser les coûts. Les notebooks Texte utilisent principalement GPT-4o-mini (~0.15\(/1M input tokens) et GPT-4o (~2.50\)/1M input tokens). Les notebooks Image utilisent gpt-image-1 uniquement pour les exercices (les exemples utilisent ComfyUI/Qwen gratuit). Budget estimé : 5-15$ total pour l’ensemble de la série, sauf appels itératifs intensifs.

Quelle est la différence entre ComfyUI et gpt-image-1 ?

ComfyUI est un serveur open-source hébergé localement qui exécute des modèles open-source (FLUX, SD 3.5, Qwen Image Edit). Avantages : gratuit, contrôle total sur les paramètres (seed, steps, CFG), pipelines personnalisables. gpt-image-1 est l’API cloud d’OpenAI. Avantages : qualité élevée par défaut, simplicité d’usage (un appel API = une image). La série montre les deux et vous apprend à choisir selon le contexte.

Peut-on suivre cette série en parallèle d’une autre ?

Oui. Chaque sous-domaine (Image, Audio, Video, Texte, SemanticKernel) est indépendant. Le parcours recommandé est de commencer par Texte (nécessaire pour comprendre les prompts utilisés partout) puis de choisir un sous-domaine selon votre projet.

Erreur ComfyUI 401 Unauthorized

Vérifiez que COMFYUI_API_TOKEN est configuré dans .env. Le token est disponible auprès de l’enseignant. Sans token, les notebooks locaux se connectent sans authentification (401 si le service en exige une) ; la génération cloud se fait dans les notebooks dédiés, avec OPENAI_API_KEY.

Docker services ne démarrent pas

Vérifiez que Docker Desktop est en cours d’exécution et que les conteneurs sont actifs :

python scripts/genai-stack/genai.py docker status

Si les services sont DOWN, relancez avec genai.py docker start. Détails : docs/genai/genai-services.md.

Pour le troubleshooting avancé (timeout Papermill, OOM GPU, .NET), consultez le README de chaque sous-domaine.

Conclusion / Prochaines étapes

Version 1.3.0 — Juillet 2026 — blurbs sous-domaines actualisés (LTX-2 audiovisuel, arc agentique Texte 13-20, Claw-Systems/Claudish, migration Qwen3.5 PT-03 #5078, chemin LLM self-hosted). Voir #4959.

Les prochaines étapes recommandées après ce parcours : explorer les épics transverses #3801 (registre SOTA par famille, GenAI en tête) et #1385 (stack GenAI self-hosting complète ComfyUI/Qwen/Forge/vLLM), ou approfondir une sous-série en particulier via son README feuille. Le hub central indexe les passerelles vers les autres séries (ML, RL, GameTheory, SymbolicAI) pour des compositions multi-paradigmes.

Annexes

Guides, outillage et validation

  • tutorials/ — guides pratiques approfondis (DALL-E 3, GPT-5 image, écosystème OpenRouter, workflows éducatifs) : la vue d’ensemble réutilisable là où les notebooks démontrent pas à pas.
  • shared/helpers/ — bibliothèque partagée Python de la série (clients services GenAI, helpers audio/vidéo, tests).
  • _research/e2e_quant_validation.ipynb — validation bout-en-bout des services quantifiés post-migration (Z-Image vLLM GGUF Q4_KM, Qwen Image Edit Nunchaku INT4, Wan 2.1 T2V) : health check, latence de génération, VRAM GPU. Artefact de référence de la stack, complémentaire à python scripts/genai-stack/genai.py validate --full.

Démarrage rapide

1. Configuration

cd MyIA.AI.Notebooks/GenAI
cp .env.example .env
# Éditez .env avec vos clés API (token fourni par l'enseignant)

2. Installation

pip install -r requirements.txt
python -c "import jupyter_client; print('Jupyter OK')"

3. Premier pas

Lancez Jupyter Lab et commencez par 00-GenAI-Environment/00-1-Environment-Setup.ipynb. Ce notebook vérifie que votre environnement est opérationnel et guide la configuration des services.

Authentification ComfyUI

Les services GenAI locaux (Qwen Image Edit, Z-Image, Whisper, etc.) sont protégés par authentification Bearer Token.

  1. Obtenir le token : contactez votre enseignant
  2. Configuration : ajoutez COMFYUI_API_TOKEN dans .env
  3. Utilisation : les notebooks chargent automatiquement les credentials via comfyui_client.py

Sans token, comfyui_client.py se connecte sans authentification (401 si le service en exige une) — il n’y a pas de bascule cloud automatique ; les notebooks cloud sont des notebooks distincts.

Variables d’environnement

Les clés essentielles dans .env :

Variable Usage Requis pour
OPENAI_API_KEY gpt-image-1, GPT-5, Whisper, TTS Image, Audio, Texte
ANTHROPIC_API_KEY Claude Vision Video
HUGGINGFACE_TOKEN Modèles HF open-source Image, Video
COMFYUI_API_TOKEN Services locaux ComfyUI (alias COMFYUI_AUTH_TOKEN) Image (local), Video

Template complet : .env.example

Outils de validation

# Validation structure (metadata, outputs, kernel)
python scripts/notebook_tools/notebook_tools.py validate <path>

# Exécution complète (Papermill)
python scripts/notebook_tools/notebook_tools.py execute <path>

# Analyse structure (stats cellules, outputs)
python scripts/notebook_tools/notebook_tools.py analyze <path>

Écosystème MCP et notebooks GPU

Les notebooks GenAI exposent trois familles d’outils d’infrastructure que les autres séries n’ont pas :

Outil Rôle Référence
MCP Jupyter (mcp__jupyter-papermill__*) Exécution kernelisée des notebooks (Python, .NET Interactive, WSL). NB : bug #835 connu — mcp__jupyter-papermill__* ne doit jamais être appelé naïvement ; re-exécution = nbconvert --execute Bash timeout-wrap (cf règle F du CLAUDE.md). CLAUDE.md
MCP GenAI hosting (scripts/genai-stack/genai.py) Validation pre-commit de l’environnement GenAI (services Docker, .env, secrets) .claude/rules/genai-config.md
MCP QC Cloud (mcp__qc-mcp-lite__*) Backtest cloud pour notebooks QuantConnect — pas de re-exec locale fictive docs/qc/quantconnect.md

Notebooks GPU-only : certains notebooks Image/Video sont CUDA-requis (ComfyUI/Qwen) et ne s’exécutent que sur les machines GPU du cluster (po-2023 et po-2024 typiquement). Sur machine CPU-only, ces notebooks sont documentés explicitement et la re-exécution est routée via dashboard workspace + dispatch. Cf règle F du CLAUDE.md — réparer, jamais contourner.

Note éditoriale sur les décomptes

À propos des décomptes : le marqueur CATALOG-STATUS en fin de fichier est la source de vérité autoritative pour les volumes (notebooks par sous-série, maturité). Il est régénéré chaque nuit par le workflow catalog-cron.yml à 03:37 UTC sur main (commit [skip ci] par github-actions[bot]). Si vous observez un décalage entre ce marqueur et une phrase en prose de ce README — par exemple si une sous-série a reçu de nouveaux notebooks mergés après la dernière régénération —, fiez-vous au marqueur ; la prose sera ré-alignée manuellement lors du prochain passage.

Ressources complémentaires

Trois sous-dossiers complètent la série sans être des notebooks :

  • tutorials/ — guides pratiques transverses (écosystème OpenRouter, prompt engineering DALL-E 3, workflows pédagogiques, accessibilité GPT-5 multimodal). Quatre guides approfondissent un fournisseur ou un cas d’usage qui déborde d’une seule modalité. À consulter en parallèle d’un notebook quand on cherche un éclairage transverse.
  • _research/ — documents de recherche bruts en cours de maturation (gate Phase 3-5 de l’Epic ICT). Non destiné à un parcours étudiant ; citer depuis les notebooks qui les exploitent (ex. FallacyDetection/02_fallacy_datasets_landscape.ipynb pour l’inventaire SAE Qwen3.5).

Archive : le fichier historique VALIDATION_SUMMARY.md (daté 2026-02-25, états de validation pré-catalog-cron.yml) a été retiré du dépôt le 2026-09-03 — la source de vérité autoritative pour les volumes est désormais le marqueur CATALOG-STATUS (auto-régénéré chaque nuit, voir catalog-pr-hygiene.md R1).

Retour au sommet