## Détection d'Objets et Alternatives Architecturales

Reconnaître un objet, c'est bien. Dire où il est et lequel c'est en une seule passe sur l'image, c'est mieux. YOLO fait cela en pari sur une régression directe ; les Capsule Networks font mieux encore en retenant aussi la géométrie des relations entre les parties détectées.

La détection d'objets — localiser et classer simultanément des objets dans une image — constitue l'une des tâches les plus exigeantes de la vision par ordinateur. Elle a suscité deux lignes architecturales majeures : les détecteurs à **régression directe** (YOLO) et les architectures à **équivariance vectorielle** (Capsule Networks) [@Konyrev2023; @Sabour2017; @CS231n2026].

### YOLO en Régression Globale

YOLO divise l'image en grille et demande à chaque case : "y a-t-il quelque chose ici, et si oui quoi ?" — tout cela en une seule lecture de l'image, sans étape intermédiaire de proposition de régions.

YOLO (*You Only Look Once*, Redmon et al., 2016) révolutionne la détection en la reformulant comme un **problème de régression unique** sur toute l'image, éliminant les pipelines en deux étapes (proposition de régions + classification) des approches R-CNN [@Konyrev2023; @Pawangfg2025; @Kili2023].

**Principe :** L'image est divisée en une grille $S \times S$. Chaque cellule prédit $B$ boîtes englobantes (*bounding boxes*) avec leur score de confiance et $C$ probabilités de classe. La sortie est un tenseur de taille $S \times S \times (B \times 5 + C)$.

**Fonction de perte SSE stratégiquement pondérée** — La perte combine plusieurs termes avec des poids distincts pour éviter l'instabilité d'apprentissage ([voir le Glossaire](../../glossaire.qmd#symboles-mathématiques-notations)) [@AraIntelligence2022; @Educative2026] :

$$
\mathcal{L} = \lambda_{\text{coord}} \sum_{\text{box}} \left[(x - \hat{x})^2 + (y - \hat{y})^2 + (\sqrt{w} - \sqrt{\hat{w}})^2 + (\sqrt{h} - \sqrt{\hat{h}})^2\right]

+ \lambda_{\text{obj}} \mathcal{L}_{\text{conf}} + \lambda_{\text{noobj}} \mathcal{L}_{\text{conf,vide}} + \mathcal{L}_{\text{classe}}
$$

* **$x, y, w, h$** : les coordonnées réelles de la boîte (centre $x, y$, largeur $w$, hauteur $h$).
* **La notation chapeau $\hat{}$** (ex: $\hat{x}, \hat{y}, \hat{w}, \hat{h}$) : représente la prédiction estimée par le modèle.
* **$\sum_{\text{box}}$** : sommation sur toutes les boîtes prédites.
* **$\lambda_{\text{coord}}, \lambda_{\text{obj}}, \lambda_{\text{noobj}}$ (lettres grecques lambda)** : facteurs de pondération (hyperparamètres) de la perte (avec $\lambda_{\text{coord}} = 5$ et $\lambda_{\text{noobj}} = 0{,}5$).
* **$\mathcal{L}_{\text{conf}}, \mathcal{L}_{\text{conf,vide}}, \mathcal{L}_{\text{classe}}$** : les composants de la fonction de perte pour la confiance (objet présent), la confiance (boîte vide), et la classe.

**L'astuce de la racine carrée pour $w$ et $h$ :** Plutôt que de pénaliser directement $(w - \hat{w})^2$, YOLO pénalise $(\sqrt{w} - \sqrt{\hat{w}})^2$. Puisque $\frac{d}{dx}\sqrt{x} = \frac{1}{2\sqrt{x}}$, la pente est plus forte pour les petites valeurs de $x$. Ainsi, une erreur de 10 pixels sur une petite boîte est pénalisée bien plus sévèrement que sur une grande boîte — comportement souhaitable pour préserver la précision sur les petits objets [@AIknow2026].

**NMS et IoU :** En post-traitement, le *Non-Maximum Suppression* (NMS) élimine les boîtes redondantes. Pour chaque paire de boîtes, l'*Intersection over Union* (IoU) est calculée ([voir le Glossaire](../../glossaire.qmd#symboles-mathématiques-notations)) :

$$
\text{IoU} = \frac{\text{Aire}(B_1 \cap B_2)}{\text{Aire}(B_1 \cup B_2)}
$$

* **$\cap$ (opérateur d'intersection)** : représente la zone où les deux boîtes $B_1$ et $B_2$ se chevauchent.
* **$\cup$ (opérateur d'union)** : représente la zone totale englobée par l'union des deux boîtes.

Si l'IoU dépasse un seuil (typiquement 0,5), la boîte avec le score de confiance le plus faible est supprimée.

::: {.card .card-window .mb-4}

:::: {.card-header}
🎯 Grille YOLO
::::

:::: {.card-control-row .sim-controls-row}
```{ojs}
//| echo: false
viewof yolo_S    = Inputs.range([2, 7], { value: 3, step: 1, label: "Grille S×S" })
viewof yolo_iou  = Inputs.range([0.1, 0.9], { value: 0.5, step: 0.05, label: "Seuil IoU (NMS)" })
```
::::

:::: {#plot-yolo-grid .plot-wrapper .yolo-grid-wrapper}
::::

:::

```{ojs}
//| echo: false
import { mountYoloGrid } from "../../assets/js/simulations/detection.js"
mountYoloGrid("#plot-yolo-grid", { size: yolo_S, iou: yolo_iou })
```

### Capsule Networks

Là où un neurone classique ne retient qu'une intensité ("y a-t-il un bord ?"), une capsule retient également sa position, son orientation et son échelle — comme un GPS qui donne non seulement "tu es sur Paris" mais aussi "tu es à 45° nord-est, à 100m d'altitude".

Les Capsule Networks (Sabour, Frosst & Hinton, 2017) constituent une réponse architecturale au Problème Picasso des CNN [@Sabour2017; @Pechyonkin2017; @Fritz2023]. Leur innovation fondamentale : remplacer les scalaires d'activation par des **vecteurs** dont la direction encode les paramètres de pose d'une entité (position, orientation, échelle, déformation).

**La fonction de squashing** : Pour garantir que la longueur du vecteur capsule représente une probabilité (entre 0 et 1) tout en préservant son orientation ([voir le Glossaire](../../glossaire.qmd#symboles-mathématiques-notations)) :

$$
\mathbf{v}_j = \frac{\|\mathbf{s}_j\|^2}{1 + \|\mathbf{s}_j\|^2} \cdot \frac{\mathbf{s}_j}{\|\mathbf{s}_j\|}
$$

* **$\mathbf{v}_j$** : le vecteur d'activation final de la capsule $j$.
* **$\mathbf{s}_j$** : le vecteur d'entrée pondéré reçu par la capsule $j$.
* **$\|\cdot\|$ (norme Euclidienne)** : mesure la longueur géométrique du vecteur.

Le premier terme compresse la magnitude dans $[0,1)$ ; le second préserve la direction unitaire du vecteur. Contrairement à la sigmoïde appliquée à des scalaires, cette opération maintient l'information directionnelle.

**Le routage dynamique** (*Dynamic Routing*) : Les capsules de bas niveau (détecteurs de primitives) "votent" pour les capsules de haut niveau (détecteurs de concepts complexes). Une capsule de bas niveau $i$ prédit l'état de la capsule parente $j$ via une transformation affine :

$$
\hat{\mathbf{u}}_{j|i} = \mathbf{W}_{ij} \mathbf{u}_i
$$

* **$\hat{\mathbf{u}}_{j|i}$** : le vecteur de prédiction de la capsule parente $j$ émis par la capsule enfant $i$.
* **La notation $j|i$ (indice $j$ sachant $i$)** : désigne une valeur relative ou une prédiction d'une entité $j$ calculée à partir d'une entité $i$.
* **$\mathbf{W}_{ij}$** : la matrice de poids de transformation affine entre les couches $i$ et $j$.
* **$\mathbf{u}_i$** : le vecteur d'activation de la capsule inférieure $i$.

Le mécanisme d'accord itératif renforce les connexions entre capsules dont les prédictions concordent et affaiblit celles qui divergent. Ce routage remplace avantageusement le pooling en préservant les **relations spatiales** entre les parties.

```{mermaid}
graph LR
    classDef low  fill:var(--sol-base03),stroke:var(--accent-info),stroke-width:2px,color:var(--accent-info);
    classDef high fill:var(--sol-base03),stroke:var(--sol-magenta),stroke-width:2px,color:var(--sol-magenta);
    classDef rout fill:var(--sol-base03),stroke:var(--accent-warning),stroke-width:2px,color:var(--accent-warning);

    E1["Capsule Bord\n(bas niveau)"]:::low
    E2["Capsule Courbe\n(bas niveau)"]:::low
    E3["Capsule Angle\n(bas niveau)"]:::low

    R["Routage Dynamique\n(accord par vote)"]:::rout

    F1["Capsule Visage\n(haut niveau)"]:::high
    F2["Capsule Main\n(haut niveau)"]:::high

    E1 & E2 & E3 --> R --> F1 & F2
```

**Synthèse : invariance vs équivariance** — Les CNN avec pooling obtiennent une **invariance** : l'objet est détecté quelle que soit sa position, mais son emplacement précis est perdu. Les Capsule Networks obtiennent une **équivariance** : si l'objet tourne, le vecteur d'activité tourne de concert dans l'espace des paramètres, préservant la fidélité spatiale. Cette distinction est fondamentale pour des tâches où la géométrie des relations entre parties est critique (reconnaissance de poses, chirurgie robotique, robotique de manipulation).

| Critère                   | CNN + Pooling | Capsule Networks    |
| :------------------------ | :------------ | :------------------ |
| Invariance spatiale       | ✅ Forte       | ✅ Contrôlée         |
| Équivariance de pose      | ❌             | ✅                   |
| Scalabilité               | ✅             | ❌ (coût de routage) |
| Robustesse aux occlusions | Faible        | Meilleure           |
| Données requises          | Modérées      | Élevées             |
