Vous jetez un coup d'œil à une photo et vous reconnaissez instantanément un chien, une voiture ou le visage de votre meilleur ami. Votre cerveau fait cela sans effort — mais pour un ordinateur, « voir » est une tâche incroyablement complexe.
La vision par ordinateur est le domaine de l'IA qui donne aux machines la capacité d'interpréter et de comprendre l'information visuelle du monde — images, vidéos et flux de caméras en direct.
Pour un ordinateur, une image n'est qu'une grille de nombres.
# Loading an image and viewing its pixel values
from PIL import Image
import numpy as np
img = Image.open("dog.jpg")
pixels = np.array(img)
print(f"Image shape: {pixels.shape}")
# Output example: (480, 640, 3) → 480 rows, 640 columns, 3 colour channels
print(f"Total pixel values: {pixels.size:,}")
# Output example: 921,600
# A single pixel in the top-left corner
print(f"Top-left pixel (R, G, B): {pixels[0, 0]}")
# Output example: [142, 178, 225] — a light blue sky pixel
Les valeurs brutes des pixels n'ont aucune signification en elles-mêmes. L'IA doit détecter des caractéristiques — des motifs significatifs :
C'est comme apprendre à lire : d'abord les lettres (bas niveau), puis les mots (niveau intermédiaire), puis les phrases et le sens (haut niveau).
Le cortex visuel humain traite aussi les images par couches ! Les neurones proches de vos yeux détectent les bords simples et les couleurs, tandis que les régions plus profondes du cerveau reconnaissent des objets et des visages complexes. Les CNN se sont littéralement inspirés de cette architecture biologique.
Le réseau de neurones convolutif est le pilier de la vision par ordinateur. Construisons une intuition de son fonctionnement — sans mathématiques complexes.
Imaginez que vous placez une petite loupe (disons 3×3 pixels) sur une image et que vous la faites glisser sur chaque position. À chaque position, le filtre recherche un motif spécifique — un bord vertical, une ligne horizontale, une courbe.
Chaque filtre produit une nouvelle image appelée carte de caractéristiques qui met en évidence les endroits où ce motif a été trouvé.
| Couche | Ce qu'elle fait | Analogie | |--------|----------------|----------| | Convolution | Fait glisser des filtres sur l'image pour détecter des caractéristiques | Un détective examinant chaque centimètre d'une scène de crime avec une loupe | | Activation (ReLU) | Conserve uniquement les signaux forts, élimine le bruit | Surligner les preuves clés et ignorer les distractions | | Pooling | Réduit les cartes de caractéristiques tout en conservant les informations importantes | Résumer un chapitre en points clés | | Entièrement connectée | Combine toutes les caractéristiques pour prendre une décision finale | Le jury délibère et rend son verdict |
# Building a simple CNN with TensorFlow/Keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
model = Sequential([
# First convolutional layer: 32 filters, 3x3 each
Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)),
MaxPooling2D(pool_size=(2, 2)),
# Second convolutional layer: 64 filters
Conv2D(64, (3, 3), activation='relu'),
MaxPooling2D(pool_size=(2, 2)),
# Flatten and classify
Flatten(),
Dense(128, activation='relu'),
Dense(10, activation='softmax'), # 10 classes
])
model.summary()
Inutile de concevoir les filtres à la main ! Pendant l'entraînement, le CNN apprend quels filtres sont les plus utiles. Les premières couches apprennent à détecter les bords, tandis que les couches plus profondes apprennent à détecter les oreilles, les yeux ou des visages entiers — le tout automatiquement à partir des données.
Question : « Qu'y a-t-il dans cette image ? »
Le modèle attribue une seule étiquette à l'image entière : « chat », « voiture », « pizza ».
C'est ce que vous avez appris dans AI Sprouts — on donne une image au modèle, il renvoie une étiquette.
Question : « Quels objets sont présents, et où se trouvent-ils ? »
Le modèle dessine des boîtes englobantes autour de chaque objet et les étiquette. C'est ce que les voitures autonomes utilisent pour localiser les piétons, les panneaux de signalisation et les autres véhicules.
Question : « Quels pixels exactement appartiennent à chaque objet ? »
Le modèle colore chaque pixel selon sa classe d'objet. Cela donne des contours au pixel près — indispensable pour l'imagerie médicale (délimitation de tumeurs) et les filtres AR (séparation de votre visage de l'arrière-plan).
# Using a pre-trained object detection model
# This uses YOLO (You Only Look Once) — one of the fastest detectors
# Pseudocode for clarity
def detect_objects(image_path):
"""Detect and label objects in an image."""
model = load_pretrained_model("yolov8")
image = load_image(image_path)
results = model.predict(image)
for detection in results:
print(f"Object: {detection.label}")
print(f" Confidence: {detection.confidence:.1%}")
print(f" Location: {detection.bounding_box}")
print()
# Example output:
# Object: person
# Confidence: 97.2%
# Location: (120, 50, 340, 480)
# Object: bicycle
# Confidence: 89.5%
# Location: (200, 300, 450, 520)
Les voitures autonomes doivent détecter des objets en temps réel — en traitant environ 30 images par seconde. Cela signifie que l'IA dispose d'environ 33 millisecondes pour analyser chaque image. Comment pensez-vous que les ingénieurs équilibrent précision et vitesse ? Que se passe-t-il si le modèle est précis à 99,9 % mais traite 1 million d'images par jour ?
Le modèle de détection d'objets YOLO (You Only Look Once) peut traiter plus de 45 images par seconde sur un GPU moderne. Son créateur, Joseph Redmon, a finalement arrêté ses recherches en raison de préoccupations éthiques quant à l'utilisation potentielle de la technologie à des fins de surveillance et d'applications militaires.
Pas besoin d'entraîner un modèle de zéro pour expérimenter avec la vision par ordinateur. Les modèles pré-entraînés comme ResNet, MobileNet ou EfficientNet ont déjà appris à partir de millions d'images.
# Using a pre-trained model to classify an image
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.applications.mobilenet_v2 import (
preprocess_input, decode_predictions
)
from tensorflow.keras.preprocessing import image
import numpy as np
# Load pre-trained MobileNetV2 (trained on ImageNet — 1000 classes)
model = MobileNetV2(weights='imagenet')
# Load and preprocess an image
img = image.load_img("photo.jpg", target_size=(224, 224))
img_array = preprocess_input(
np.expand_dims(image.img_to_array(img), axis=0)
)
# Get predictions
predictions = model.predict(img_array)
top_3 = decode_predictions(predictions, top=3)[0]
print("Top 3 Predictions:")
for rank, (id, label, confidence) in enumerate(top_3, 1):
bar = "█" * int(confidence * 40)
print(f" {rank}. {label}: {confidence:.1%} {bar}")
# Example output:
# 1. golden_retriever: 92.3% █████████████████████████████████████
# 2. Labrador_retriever: 4.1% ██
# 3. cocker_spaniel: 1.8% █
MobileNetV2 est spécifiquement conçu pour fonctionner sur les téléphones portables. Il ne possède que 3,4 millions de paramètres — contre 60 millions pour ResNet-152 — tout en maintenant une précision impressionnante. Cela est possible grâce aux « convolutions séparables en profondeur », une astuce architecturale ingénieuse qui réduit le volume de calculs.
Un grand pouvoir implique de grandes responsabilités :
La technologie en elle-même est neutre — c'est la manière dont nous choisissons de la déployer qui compte.
Vous avez maintenant exploré trois branches puissantes de l'IA : les applications en santé, le traitement du langage naturel et la vision par ordinateur. Ce sont les fondations sur lesquelles les ingénieurs en IA s'appuient au quotidien. Dans les prochaines leçons, nous plongerons dans l'IA dans les arts créatifs — comment les machines génèrent de la musique, de l'art et des histoires !