2 👁️ Deep Learning & Vision

2.1 Perspective Historique

La vision par ordinateur s’est imposée comme le pont technologique entre la perception biologique et l’intelligence artificielle. En tant qu’architecte système, il ne faut pas voir cette discipline comme un simple algorithme de tri, mais comme une tentative complexe d’extraction automatisée et de compréhension sémantique à partir de flux visuels purs (Network Optix 2024).

Fukushima	Le Neocognitron
	Concept : Fukushima propose une architecture hiérarchique utilisant des “champs récepteurs” locaux. C’est le précurseur direct des CNN modernes.

Yann LeCun	La Consécration Industrielle
	Application : Stabilisation avec le modèle LeNet, utilisé par la poste américaine pour lire automatiquement les codes postaux. Première preuve de viabilité à grande échelle (Network Optix 2024).

Équipe Hinton	La Révolution AlexNet
	Basculement : AlexNet pulvérise les algorithmes traditionnels au concours ImageNet, prouvant que la profondeur (Deep Learning) est la clé (Wikipedia contributors 2026a).

2.1.1 La Rupture Stratégique

Avant le Deep Learning, les ingénieurs devaient créer mathématiquement leurs propres filtres (ex: filtre de Sobel pour les bords verticaux). Cette approche, le Feature Engineering manuel, était extrêmement limitée par l’intuition humaine.

La rupture fondamentale des Réseaux Convolutifs (CNN) réside dans le passage aux filtres appris par optimisation. Le réseau découvre par essai-erreur quels filtres mathématiques sont les plus pertinents pour extraire les caractéristiques d’une image (Wikipedia contributors 2026b).

2.2 🏗️ Fondamentaux et Supériorité des CNN sur les Modèles Traditionnels

Pourquoi ne pas simplement utiliser un réseau de neurones classique (MLP - Multi-Layer Perceptron) pour reconnaître des objets ? La réponse tient en un mot : le fléau de la dimensionnalité (Rosebrock 2021).

2.2.1 ❌ L’échec des réseaux classiques (MLP)

Dans un réseau classique, chaque neurone est connecté à tous les pixels. Imaginons une image de 250x250 pixels en couleur (RGB). L’explosion des paramètres rend l’apprentissage instable, lent et gourmand en mémoire vive

Le Fléau de la Dimensionnalité

resolutions = [28, 250, 1080, 3840];
labels = ["28x28 (MNIST)", "250x250 (Standard)", "1920x1080 (Full HD)", "3840x2160 (4K UHD)"];

viewof res_idx = ui.slider({
  label: "Résolution d'Entrée",
  labels: labels,
  value: 1,
  min: 0,
  max: 3
})

res_choice = resolutions[res_idx];
mlp_weights_per_neuron = res_choice * res_choice * 3;
mlp_total_weights = mlp_weights_per_neuron * 100;
cnn_total_weights = 3 * 3 * 3 * 100;

{
  const fixed_cnn_size = 20; 
  const weight_ratio = mlp_total_weights / cnn_total_weights;
  const size_ratio = Math.pow(weight_ratio, 1/6); 
  
  const s_cnn = fixed_cnn_size;
  const s_mlp = Math.min(200, s_cnn * size_ratio);
  
  const mlp_color = mlp_total_weights > 5000000 ? theme.red : theme.orange;
  const cnn_color = theme.green;

  const cube_html = (size, color, label) => {
    const offset = size * 0.35;
    const darken = (c, amt) => `color-mix(in srgb, ${c}, black ${amt}%)`;
    return html`
      <div class="flex-centered-col" style="gap: 8px;">
        <div style="position: relative; width: ${size + offset}px; height: ${size + offset}px; transition: all 0.5s ease;">
          <div style="position: absolute; left: 0; top: 0; width: ${size}px; height: ${offset}px; background: ${darken(color, 15)}; border: 1px solid rgba(0,0,0,0.1); transform: skewX(-45deg); transform-origin: bottom;"></div>
          <div style="position: absolute; left: ${size}px; top: ${offset}px; width: ${offset}px; height: ${size}px; background: ${darken(color, 30)}; border: 1px solid rgba(0,0,0,0.1); transform: skewY(-45deg); transform-origin: left;"></div>
          <div style="position: absolute; left: 0; top: ${offset}px; width: ${size}px; height: ${size}px; background: ${color}; border: 1px solid rgba(0,0,0,0.1); box-shadow: 2px 2px 10px rgba(0,0,0,0.1);"></div>
        </div>
        <span style="font-size: 0.8em; font-weight: bold; color: var(--sol-base01);">${label}</span>
      </div>
    `;
  };

  return html`
    <div style="display: flex; gap: 40px; justify-content: center; align-items: flex-end; min-height: 250px; width: 100%;">
      ${cube_html(s_cnn, cnn_color, "CNN")}
      ${cube_html(s_mlp, mlp_color, "MLP")}
    </div>
  `;
}

viewof monitor_dim = {
  const m = ui.org.monitor({ header: "Comparatif d'Architecture" });
  
  m.params = m.addVersus("Poids du Réseau", mlp_total_weights, cnn_total_weights, {
    labelA: "MLP (Full)",
    labelB: "CNN (Filtres)",
    colorA: theme.red,
    colorB: theme.green
  });
  
  m.status = m.addStatus("État de la Mémoire", "Calcul...", "info");
  
  return m;
}

// Real-time updates for the monitor
{
  // Explicitly depend on weights and the monitor's DOM element
  const weights = mlp_total_weights; 
  const monitor = viewof monitor_dim;
  
  const analysis = weights > 100000000 ? "Incalculable sur PC (Saturation)" : weights > 1000000 ? "Lent et Inefficace" : "Stable et Léger";
  const state = weights > 100000000 ? "danger" : weights > 1000000 ? "warning" : "success";
  
  if (monitor && monitor.params && monitor.status) {
    monitor.params.update(weights, cnn_total_weights);
    monitor.status.update(analysis, state);
  }
}

2.2.2 🏛️ Les trois piliers stratégiques des CNN

Les CNN exploitent la structure spatiale via three propriétés (Gurucharan 2026; Wikipedia contributors 2026b) :

Connectivité locale : Un neurone ne regarde qu’une petite zone limitée (champ récepteur), imitant le cortex visuel humain.
Partage de poids : Le réseau utilise le même filtre sur toute la surface, réduisant les paramètres et détectant un motif n’importe où.
Arrangement spatial en 3D : Les données circulent en tenseurs (Largeur x Hauteur x Profondeur des couleurs/filtres) (Rosebrock 2021).

2.3 🔍 Anatomie Technique d’un CNN

Un CNN transforme des pixels bruts en prédictions sémantiques.

2.3.1 🌀 Convolution et Pooling

La Couche de Convolution réalise un produit de Frobenius entre un noyau glissant et l’entrée pour extraire des traits. La Couche de Pooling (ex: Max Pooling) réduit la résolution spatiale pour contrôler le surapprentissage tout en conservant le signal le plus fort.

Max-Pooling : Distiller l'Essentiel

mutable poolGroup = -1;

{
  const gridInValues = [12, 20, 30, 0, 8, 12, 2, 0, 34, 70, 37, 4, 112, 100, 25, 12];
  const colors = [theme.red, theme.blue, theme.green, theme.yellow];
  const getGroup = (i) => {
    if ([0,1,4,5].includes(i)) return 0;
    if ([2,3,6,7].includes(i)) return 1;
    if ([8,9,12,13].includes(i)) return 2;
    return 3;
  };

  const container = html`<div class="matrix-grid-in" style="margin: 10px auto;">
    ${gridInValues.map((val, i) => {
      const group = getGroup(i);
      const isSelected = poolGroup === group;
      const values = gridInValues.filter((_, idx) => getGroup(idx) === group);
      const isMax = val === Math.max(...values);
      const cell = html`<div class="cell-in matrix-cell ${isSelected ? 'active is-group' : ''} ${isSelected && isMax ? 'is-max' : ''}" 
                        style="background: ${colors[group]}; color: ${theme.base3};">${val}</div>`;
      cell.onclick = () => mutable poolGroup = group;
      return cell;
    })}
  </div>`;
  return container;
}

➡️

{
  const colors = [theme.red, theme.blue, theme.green, theme.yellow];
  const pooledValues = [20, 30, 112, 37];
  
  const container = html`<div class="matrix-grid-out" style="margin: 10px auto;">
    ${pooledValues.map((val, i) => {
      const isSelected = poolGroup === i;
      const cell = html`<div class="cell-out matrix-cell-out ${isSelected ? 'active' : ''}" 
                        style="background: ${colors[i]}; color: ${theme.base3};">${val}</div>`;
      cell.onclick = () => mutable poolGroup = i;
      return cell;
    })}
  </div>`;
  return container;
}

{
  const gridInValues = [12, 20, 30, 0, 8, 12, 2, 0, 34, 70, 37, 4, 112, 100, 25, 12];
  const groupNames = ["Rouge", "Bleue", "Verte", "Jaune"];
  const getGroup = (i) => {
    if ([0,1,4,5].includes(i)) return 0;
    if ([2,3,6,7].includes(i)) return 1;
    if ([8,9,12,13].includes(i)) return 2;
    return 3;
  };

  if (poolGroup === -1) {
    return ui.card(md`💡 **Astuce :** Cliquez sur une zone colorée pour comprendre comment le chiffre est extrait.`, { title: "Fonctionnement", status: "debug" });
  }

  const values = gridInValues.filter((_, i) => getGroup(i) === poolGroup);
  const maxVal = Math.max(...values);
  const status = ["danger", "info", "success", "warning"][poolGroup];
  
  return ui.card(md`
Dans la zone **${groupNames[poolGroup]}**, on compare {${values.join(", ")}}.

Le plus grand est **${maxVal}**, c'est lui qui survit au Pooling !
  `, { title: "Détail du Calcul", status: status });
}

2.3.2 📐 Configuration Spatiale

Le dimensionnement d’un CNN repose sur une configuration géométrique stricte.

Stride (Pas) : Définit le saut du filtre. Un stride > 1 agit comme un compresseur de données.
Padding : Ajout de pixels aux bordures pour éviter la perte d’information sur les contours.

Règle d'or de l'Architecte : La Formule de Sortie

Pour une dimension d’entrée W, un filtre F, un padding P et un stride S, la taille de sortie est : \text{Sortie} = \frac{W - F + 2P}{S} + 1 Si le résultat n’est pas un entier, la configuration est invalide !

Calculateur de Sortie

viewof hyper_W = ui.slider({label: "Entrée (W)", value: 227, min: 10, max: 227, step: 1, state: 0})
viewof hyper_F = ui.slider({label: "Filtre (F)", value: 11, min: 1, max: 11, step: 1, state: 1})
viewof hyper_P = ui.slider({label: "Padding (P)", value: 0, min: 0, max: 5, step: 1, state: 2})
viewof hyper_S = ui.slider({label: "Stride (S)", value: 4, min: 1, max: 5, step: 1, state: 3})

output_size = (hyper_W - hyper_F + 2 * hyper_P) / hyper_S + 1
is_valid_arch = Number.isInteger(output_size)

viewof monitor_arch = {
  const m = ui.org.monitor({ header: "Diagnostic Géométrique" });
  
  m.status = m.addStatus("Validation", "Calcul en cours...", "info");
  
  m.output = m.addValue("Dimension de Sortie", "0 x 0", { 
    comment: "Taille de la carte d'activation",
    color: theme.blue 
  });
  
  return m;
}

// Logic for real-time updates
{
  const status = is_valid_arch ? "success" : "danger";
  const message = is_valid_arch 
    ? "Configuration Valide. Les neurones se répartissent parfaitement." 
    : "ERREUR : Le filtre va déborder ! Ajustez le Padding ou le Stride.";
  
  const monitor = viewof monitor_arch;
  if (monitor && monitor.status && monitor.output) {
    monitor.status.update(message, status);
    monitor.output.update(`${output_size} x ${output_size} px`);
  }
}

2.4 Étude de Cas

Si l’on devait dater le début de l’ère moderne de l’IA, ce serait 2012 avec le réseau AlexNet qui a pulvérisé les modèles traditionnels au concours ImageNet (Wikipedia contributors 2026a).

L’adoption de ReLU : Contourne le vanishing gradient, entraînement beaucoup plus rapide (Gurucharan 2026).
L’invention du Dropout : Technique contre le surapprentissage.
L’entraînement Multi-GPU : Modèle scindé sur deux puces NVIDIA GTX 580 car trop lourd pour la VRAM de l’époque.

Anecdote d'Architecte : L'énigme des 224 pixels

Les tutoriels disent qu’AlexNet prend des images de 224x224. Mais avec un filtre de 11, un stride de 4 et un padding de 0, la formule (vue au-dessus) ne tombe pas juste ! En réalité, le réseau recadrait secrètement à 227x227 pixels pour satisfaire les mathématiques (Rosebrock 2021).

2.5 🚨 Défis Critiques

Un CNN moderne possède des millions de paramètres. S’il s’entraîne trop longtemps, il fait du Surapprentissage (Overfitting) : il mémorise par cœur le Train set, mais échoue sur le Test set (Great Learning Editorial Team 2025; Nerchuko Academy 2026).

2.5.1 🔌 Le Dropout (Le Décrochage)

Le Dropout désactive aléatoirement un certain pourcentage de neurones à chaque passage pour forcer le réseau à répartir la connaissance (Wikipedia contributors 2026b).

Contrôle du Dropout

viewof drp_rate = ui.slider({label: "Taux de Dropout", value: 0.6, min: 0, max: 0.9, step: 0.01})

// Fonctions de calcul partagées pour la cohérence
calc_tr_loss = (dr, epoch) => 2 + 5 * Math.exp(-epoch / 15) + (dr * 0.5);

calc_val_loss = (dr, epoch) => {
  let tr = calc_tr_loss(dr, epoch);
  if (dr < 0.3) {
    return 2.1 + 5 * Math.exp(-epoch / 15) + (epoch * (0.3 - dr) * 0.1);
  } else if (dr > 0.7) {
    return tr + 1.5;
  } else {
    return tr + 0.3;
  }
}

data_loss = {
  const pts = [];
  for(let epoch = 1; epoch <= 50; epoch++) {
    pts.push({epoch: epoch, loss: calc_tr_loss(drp_rate, epoch), type: "Train Loss"});
    pts.push({epoch: epoch, loss: calc_val_loss(drp_rate, epoch), type: "Validation Loss (Réalité)"});
  }
  return pts;
}

data_dropout_curve = {
  const pts = [];
  for(let dr = 0; dr <= 0.9; dr += 0.02) {
    pts.push({dr: dr, loss: calc_val_loss(dr, 50)});
  }
  return pts;
}

html`<div style="display: flex; gap: 20px; width: 100%; align-items: stretch;">
  <div style="flex: 1; min-width: 0;">
    <div class="render-sub-header">📉 Évolution Temporelle</div>
    ${Plot.plot({
      height: 250,
      background: "transparent",
      grid: true,
      y: {domain: [1.5, 7], label: "Erreur (Loss)"},
      x: {label: "Époques"},
      color: {legend: false, domain: ["Train Loss", "Validation Loss (Réalité)"], range: [theme.blue, theme.red]},
      marks: [
        Plot.line(data_loss, {x: "epoch", y: "loss", stroke: "type", strokeWidth: 2})
      ]
    })}
  </div>
  <div style="flex: 1; min-width: 0;">
    <div class="render-sub-header">🎯 Impact du Taux</div>
    ${Plot.plot({
      height: 250,
      background: "transparent",
      grid: true,
      x: {label: "Taux de Dropout", domain: [0, 0.9]},
      y: {domain: [1.5, 7], axis: null},
      marks: [
        Plot.rectX([0], {x1: 0, x2: 0.2, fill: theme.red, fillOpacity: 0.1}),
        Plot.rectX([0], {x1: 0.68, x2: 0.9, fill: theme.yellow, fillOpacity: 0.1}),
        Plot.ruleX([0.28], {stroke: theme.green, strokeWidth: 2, strokeDasharray: "5,5"}),
        Plot.line(data_dropout_curve, {x: "dr", y: "loss", stroke: theme.red, strokeWidth: 2, strokeDasharray: "4,4", strokeOpacity: 0.5}),
        Plot.dot([{dr: drp_rate, loss: calc_val_loss(drp_rate, 50)}], {x: "dr", y: "loss", fill: theme.red, r: 7, stroke: "white", strokeWidth: 2})
      ]
    })}
  </div>
</div>`

viewof monitor_dropout = {
  const m = ui.org.monitor({ header: "Diagnostic d'Apprentissage" });
  m.status = m.addStatus("Régime", "Analyse en cours...", "info");
  m.error = m.addValue("Erreur Finale", "0.00", { 
    comment: "Validation Loss à l'époque 50",
    color: theme.red 
  });
  return m;
}

// Logic for real-time updates
{
  const status = drp_rate < 0.2 ? "danger" : drp_rate >= 0.25 && drp_rate <= 0.35 ? "success" : drp_rate >= 0.7 ? "warning" : "info";
  
  const message = drp_rate < 0.2 
    ? "SURAPPRENTISSAGE (Overfitting) : Le réseau mémorise trop, les courbes divergent." 
    : drp_rate >= 0.25 && drp_rate <= 0.35 
      ? "RÉGIME OPTIMAL : Généralisation maximale, les erreurs stagnent au plus bas." 
      : drp_rate >= 0.7 
        ? "SOUS-APPRENTISSAGE (Underfitting) : Trop de neurones coupés, le réseau stagne." 
        : "Apprentissage stable, mais l'optimisation peut être affinée.";
  
  const monitor = viewof monitor_dropout;
  if (monitor && monitor.status && monitor.error) {
    monitor.status.update(message, status);
    monitor.error.update(calc_val_loss(drp_rate, 50).toFixed(2));
  }
}

2.5.2 🖼️ L’Augmentation de Données (Data Augmentation)

La meilleure façon de combattre le surapprentissage est d’appliquer des transformations aléatoires à vos images d’entraînement à la volée. Le modèle voit une image légèrement différente à chaque fois (Wikipedia contributors 2026b).

Augmentation de Données

html`<div style="display: flex; gap: 30px; align-items: center; justify-content: center; width: 100%; height: 100%;">
  <div style="display: flex; flex-direction: column; gap: 15px; min-width: 180px;">
    ${viewof do_rot}
    ${viewof do_flip}
    ${viewof do_zoom}
  </div>

  <div class="separator"></div>
  
  <div class="viz-viewport" style="flex: 0 0 auto;">
    <div class="viz-emoji" style="
      transform: 
        rotate(${do_rot ? '25deg' : '0deg'}) 
        scaleX(${do_flip ? '-1' : '1'}) 
        scale(${do_zoom ? '2.5' : '1'});">
      🐶
    </div>
    <div class="viz-overlay"></div>
  </div>
</div>`

{
  const m = ui.org.monitor({ header: "Analyse Machine" });
  m.addStatus("Interprétation", "Pour la machine, l'information matricielle de ces variantes est totalement différente !", "warning");
  return m;
}

2.6 Horizon Actuel

2.6.1 Le Nouveau Challenger

Contrairement aux CNN qui regardent l’image petit bout par petit bout, les Vision Transformers (ViT) découpent l’image en “patchs” et utilisent un mécanisme d’attention globale. Ils comparent chaque patch avec tous les autres simultanément (Network Optix 2024).

Comparaison Architecturale : Local vs Global

html`
<div class="viz-container-sm viz-cnn-grid" style="position: relative;">
  <div class="viz-cnn-window"></div>
  ${Array(16).fill(0).map(() => `<div style="border: 1px solid rgba(0,172,193,0.1);"></div>`).join('')}
</div>
`

html`
<div class="viz-container-sm viz-vit-grid" style="position: relative;">
  ${Array(9).fill(0).map((_, i) => `<div style="background: rgba(108, 113, 196, 0.1); border: 1px solid ${theme.violet}; border-radius: 4px; position: relative; display: flex; align-items: center; justify-content: center;"><span style="position: absolute; width: ${i===4 ? '200%' : '0'}; height: 2px; background: ${theme.magenta}; z-index: 10; animation: flashNet 2s infinite;"></span></div>`).join('')}
  <div class="viz-vit-ring"></div>
</div>
`

Comparaison Architecturale : Local vs Global

Observez la différence de philosophie. À gauche, le CNN scanne laborieusement l’image. À droite, le Transformer connecte toutes les informations simultanément.

2.7 🎭 Les Réseaux Antagonistes Génératifs (GANs)

Si les CNN et les ViT excellent pour comprendre une image, les GANs (Generative Adversarial Networks) ont été les premiers à exceller pour en créer. Inventés en 2014 par Ian Goodfellow, les GANs reposent sur une idée brillante : mettre en compétition deux réseaux de neurones.

Le Générateur (Le Faussaire) : Il crée des images à partir de bruit aléatoire et essaie de les rendre les plus réalistes possibles.
Le Discriminateur (Le Policier) : Il reçoit à la fois de vraies images et des fausses images du Générateur, et doit deviner lesquelles sont réelles.

L’entraînement est un jeu du chat et de la souris : le générateur s’améliore pour tromper le discriminateur, et le discriminateur s’améliore pour ne plus se faire avoir.

Simulation : L'entraînement d'un GAN

viewof gan_epoch = ui.slider({label: "Époques d'entraînement", value: 0, min: 0, max: 100, step: 1})

html`<div style="display: flex; gap: 30px; align-items: center; justify-content: center; width: 100%; padding: 20px;">
  <!-- Générateur -->
  <div style="display: flex; flex-direction: column; align-items: center; gap: 12px; flex: 1;">
    <div class="render-sub-header" style="color: ${theme.blue}">Faussaire</div>
    <div style="font-size: 64px; filter: blur(${Math.max(0, 10 - gan_epoch/10)}px); opacity: ${0.2 + gan_epoch/125}; transform: scale(${0.8 + gan_epoch/500}); transition: all 0.3s; height: 80px; display: flex; align-items: center;">🐶</div>
    <div style="font-size: 11px; opacity: 0.6; text-align: center;">Tente de créer du réalisme</div>
  </div>

  <div class="separator" style="font-size: 24px; opacity: 0.3;">⚔️</div>

  <!-- Discriminateur -->
  <div style="display: flex; flex-direction: column; align-items: center; gap: 12px; flex: 1;">
    <div class="render-sub-header" style="color: ${theme.red}">Policier</div>
    <div style="height: 80px; display: flex; align-items: center;">
      <div style="padding: 10px 20px; border-radius: 8px; background: ${gan_epoch > 80 ? theme.green : theme.red}; color: white; font-weight: 800; transition: all 0.3s; box-shadow: 0 4px 15px rgba(0,0,0,0.1); text-transform: uppercase; letter-spacing: 1px;">
        ${gan_epoch > 80 ? "Vrai ?" : "Faux !"}
      </div>
    </div>
    <div style="font-size: 11px; opacity: 0.6; text-align: center;">Tente de démasquer l'imposture</div>
  </div>
</div>`

viewof monitor_gan = {
  const m = ui.org.monitor({ header: "Analyse du Duel" });
  m.status = m.addStatus("Équilibre de Nash", "Initialisation...", "info");
  return m;
}

// Logic for real-time updates
{
  const status = gan_epoch < 30 ? "danger" : gan_epoch < 80 ? "warning" : "success";
  
  const message = gan_epoch < 30 
    ? "Le Faussaire produit du bruit informe. Le Policier gagne sans effort." 
    : gan_epoch < 80 
      ? "Le Faussaire commence à créer des formes. La compétition s'intensifie." 
      : "Le Faussaire a réussi ! Les images sont réalistes, le Policier est trompé.";
  
  const monitor = viewof monitor_gan;
  if (monitor && monitor.status) {
    monitor.status.update(message, status);
  }
}

Les GANs ont ouvert la voie aux “DeepFakes” et à la génération d’art avant d’être progressivement remplacés par les Modèles de Diffusion (comme Midjourney ou Stable Diffusion) qui sont plus stables à entraîner.

2.8 🌉 Conclusion et Transition

C’est d’ailleurs cette architecture Transformer qui a donné naissance à l’IA Générative et aux LLM. Les modèles ne se contentent plus de classifier des données, ils sont capables d’en créer de nouvelles.

Ce changement de paradigme nous amène directement à notre Chapitre 3 : GenAI & NLP !