Neuromorphic Vision

La vision neuromorphique est une approche de la vision par ordinateur qui détecte et traite les images comme le font la rétine biologique et le cerveau. Son dispositif central, la caméra à événements ou capteur de vision dynamique (DVS), possède des pixels indépendants qui signalent chacun un changement de luminosité dès qu'il se produit, au lieu de capturer des images complètes à une fréquence fixe. La sortie est un flux clairsemé d'événements horodatés à la microseconde, avec une grande plage dynamique et presque aucun flou de mouvement ; une scène statique ne produit presque aucune donnée. Ce domaine est issu des travaux d'ingénierie neuromorphique du groupe de Carver Mead au Caltech, à la fin des années 1980, dont les puces analogiques imitaient les circuits neuronaux ; les réseaux de neurones à impulsions en sont le pendant naturel pour le traitement, car ils calculent avec le même type d'événements clairsemés et horodatés.

Fonctionnement des caméras à événements#

Chaque pixel mémorise le logarithme de la luminosité observée lors de son dernier événement. Lorsque le logarithme de la luminosité actuelle diffère de cette référence au-delà d'un seuil de contraste, le pixel émet un événement qui encode sa position, un horodatage et une polarité — ON pour une augmentation de luminosité ou OFF pour une diminution — puis réinitialise sa référence. Le traitement en espace logarithmique rend le pixel sensible au contraste relatif ; le même capteur gère donc les ombres profondes et la lumière directe du soleil, avec une plage dynamique d'environ 140 dB, contre environ 60 dB pour les caméras à images.

La même règle peut s'appliquer à une vidéo ordinaire pour voir à quel point la sortie est clairsemée :

import cv2
import numpy as np

# Read a clip of a person exercising in front of a fixed camera
cap = cv2.VideoCapture("https://github.com/ultralytics/assets/releases/download/v0.0.0/solution_ci_pose_demo.mp4")
ok, frame = cap.read()
reference = np.log1p(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY).astype(np.float32))
threshold = 0.2  # contrast threshold on log brightness
events, samples = 0, 0

while True:
    ok, frame = cap.read()
    if not ok:
        break
    brightness = np.log1p(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY).astype(np.float32))
    # A pixel fires an ON or OFF event only when its brightness changed by more than the threshold
    fired = np.abs(brightness - reference) >= threshold
    reference[fired] = brightness[fired]
    events += fired.sum()
    samples += fired.size

print(f"{events:,} events vs {samples:,} pixel values in frames ({100 * events / samples:.2f}%)")

Le programme affiche 233,492 events vs 13,593,600 pixel values in frames (1.72%) : avec une caméra fixe, seule la personne qui fait de l'exercice change d'une image à l'autre, si bien que le flux d'événements contient 1.72 % des valeurs qu'auraient les images complètes. Des simulateurs comme v2e convertissent les vidéos en données d'entraînement synthétiques de la même manière, avec la possibilité de les suréchantillonner au préalable par interpolation d'images et d'ajouter des écarts de seuil et du bruit par pixel.

Caméras à événements et caméras à images#

Les caméras à événements sont adaptées aux mouvements rapides, aux scènes à éclairage extrême et à la détection IA en périphérie toujours active où peu de choses changent ; leur bande passante suit l'activité de la scène. Elles n'enregistrent ni luminosité absolue ni couleur : une caméra immobile qui observe une scène immobile ne signale rien, tandis qu'une caméra en mouvement inonde la sortie d'événements provenant de chaque contour. Les capteurs hybrides, comme le DAVIS d'iniVation, capturent aussi des images standard à partir des mêmes pixels, et de nombreux systèmes associent une caméra à événements et une caméra à images par fusion de capteurs. Les modèles standard, comme les réseaux de neurones convolutifs (CNN), attendent des images denses ; les pipelines convertissent donc les événements en représentation dense ou les traitent directement :

• Images événementielles : Compter les événements ON et OFF par pixel sur une fenêtre temporelle donne une image à deux canaux que n'importe quel CNN peut lire.
• Surfaces temporelles et grilles voxel : Mémoriser le dernier horodatage de chaque pixel ou répartir les événements dans plusieurs tranches temporelles préserve les informations temporelles que de simples comptages éliminent.
• Réseaux à impulsions sur puces neuromorphiques : Des processeurs comme le Loihi 2 d'Intel consomment directement les événements sous forme d'impulsions et ne dépensent de l'énergie qu'à leur arrivée.
• Reconstruction d'intensité : Des réseaux comme E2VID reconstruisent une vidéo en niveaux de gris à partir du flux d'événements, ce qui permet d'y exécuter des modèles basés sur des images.

Ultralytics YOLO lit le nombre de canaux d'entrée à partir de la clé channels d'un fichier YAML de jeu de données, comme pour le jeu de données COCO8-Multispectral à 10 canaux ; un modèle de détection d'objets YOLO26 peut donc s'entraîner directement sur des images événementielles à deux canaux de comptages ON et OFF.

Applications concrètes#

• Perception automobile : Une étude publiée dans Nature en 2024 a associé une caméra couleur à 20 FPS à une caméra à événements et détecté les objets sur la route avec la latence d'une caméra à 5 000 FPS, tout en utilisant la bande passante d'une caméra à 45 FPS.
• Drones et robotique : Un quadricoptère équipé d'une caméra à événements de l'Université de Zurich a esquivé des obstacles lancés vers lui à des vitesses relatives allant jusqu'à 10 mètres par seconde, avec une latence totale de 3,5 millisecondes.
• Surveillance industrielle : Les caméras à événements comptent les pièces en mouvement rapide, mesurent les vibrations des machines et suivent les processus à grande vitesse ; des fabricants de caméras industrielles comme IDS vendent des modèles basés sur des capteurs Prophesee.