iancr
YOLO + OpenCV : détecte n'importe quel objet avec ta webcam
← tutoriels

YOLO + OpenCV : détecte n'importe quel objet avec ta webcam

Tu as déjà vu des vidéos où une IA dessine des rectangles autour des voitures, des piétons ou des chats, avec des petits scores de confiance qui flottent au-dessus. Tu t'es dit : « C'est un truc de chercheurs, ça doit prendre des semaines à coder ». Spoiler : non. Avec YOLO et OpenCV, tu peux brancher ta webcam et afficher des détections en direct en moins de 50 lignes de code. Et le pire, c'est que ça tourne sans carte graphique.

Dans ce tutoriel, on va partir de zéro. Tu n'as jamais touché à la vision par ordinateur ? Parfait. On va installer Python et deux bibliothèques, écrire trois scripts de difficulté croissante, et finir par une appli complète qui détecte les objets en direct depuis ta webcam. Le tout en français, avec du code que tu peux copier-coller sans réfléchir.

Le plan d'attaque

Voici ce qu'on va construire, étape par étape :

  1. Comprendre ce qu'est YOLO et pourquoi c'est magique
  2. Installer Python, OpenCV et le modèle YOLO (3 minutes top chrono)
  3. Premier script : détecter les objets sur une photo
  4. Deuxième script : détecter en temps réel avec la webcam
  5. Troisième script : compteur d'objets avec interface visuelle propre
  6. Pièges classiques : ce qui peut planter et comment réparer
  7. Pour aller plus loin : 3 pistes pour aller encore plus loin

1. YOLO, c'est quoi exactement ?

YOLO signifie You Only Look Once (« tu ne regardes qu'une fois »). C'est un modèle d'intelligence artificielle spécialisé dans la détection d'objets : il regarde une image et, en une seule passe, il devine quels objets s'y trouvent ET où ils sont.

Concrètement, voici ce que YOLO produit :

plaintext
personne (confiance: 92%) → rectangle autour voiture (confiance: 88%) → rectangle autour chaise (confiance: 76%) → rectangle autour

La version qu'on va utiliser, YOLOv8n (le « n » pour nano), pèse seulement 6 Mo — oui, six mégaoctets — et tourne parfaitement sur un processeur classique. Pas besoin de carte graphique à 2000 €. C'est ça le vrai game-changer.

Pourquoi c'est plus simple qu'avant ? Jusqu'en 2022, faire de la détection d'objets demandait de compiler des bibliothèques C++, de gérer des dépendances infernales, et d'écrire 200 lignes de boilerplate. Aujourd'hui, la bibliothèque ultralytics fait tout le sale boulot pour toi.

💡 Idée d'illustration : Un schéma simple montrant une photo avec des boîtes englobantes colorées (personne en bleu, voiture en rouge, chien en vert) et des étiquettes de confiance, avec la mention « 1 seule passe du réseau de neurones ».

2. Installation : 3 commandes, et c'est parti

On va créer un dossier propre, un environnement virtuel Python, et installer les deux seules dépendances dont on a besoin.

Ouvre un terminal et tape :

bash
# 1. Crée un dossier dédié mkdir mon-detecteur-ia && cd mon-detecteur-ia # 2. Crée un environnement virtuel Python python3 -m venv venv # 3. Active l'environnement (Linux/Mac) source venv/bin/activate # Si tu es sur Windows, remplace la ligne du dessus par : # venv\Scripts\activate # 4. Installe les dépendances pip install ultralytics opencv-python

Ce que tu viens d'installer : - `ultralytics` : la boîte à outils YOLOv8, qui télécharge le modèle et fait tourner l'inférence - `opencv-python` : OpenCV, la bibliothèque reine pour manipuler des images et accéder à la webcam

Vérifie que tout est OK :

bash
python3 -c "from ultralytics import YOLO; print('YOLO prêt !')" python3 -c "import cv2; print('OpenCV prêt !')"

Tu devrais voir :

plaintext
YOLO prêt ! OpenCV prêt !

Si c'est le cas, tu es opérationnel. On passe au code.

3. Premier script : détecter des objets sur une image

On commence par le plus simple : une photo sur ton disque dur. YOLO va l'analyser et sauvegarder une version annotée avec les boîtes de détection.

Crée un fichier detecte_photo.py :

python
""" Mon premier détecteur d'objets avec YOLO Usage : python3 detecte_photo.py """ from ultralytics import YOLO # 1. Charger le modèle YOLOv8 nano (6 Mo, téléchargé auto au 1er run) print("⚡ Chargement du modèle YOLOv8n...") modele = YOLO("yolo11n.pt") # YOLO11n : le plus récent, ultra-léger # 2. Lancer la détection sur une image # Remplace "photo.jpg" par le chemin de ton image # Si tu n'as pas d'image sous la main, garde cette URL : resultats = modele("https://ultralytics.com/images/bus.jpg", save=True) # 3. Afficher ce qui a été trouvé for r in resultats: print(f"\n📸 {len(r.boxes)} objets détectés :") for box in r.boxes: classe = modele.names[int(box.cls[0])] # nom de l'objet confiance = float(box.conf[0]) * 100 # score en % print(f" → {classe} (confiance : {confiance:.1f}%)") print("\n✅ Image annotée sauvegardée dans runs/detect/predict/")

Lance le script :

bash
python3 detecte_photo.py

Ce que tu dois voir :

La première fois, YOLO télécharge automatiquement le modèle (6 Mo). Ensuite, il analyse l'image et t'affiche quelque chose comme :

plaintext
⚡ Chargement du modèle YOLOv8n... 📸 5 objets détectés : → person (confiance : 91.2%) → bus (confiance : 89.5%) → person (confiance : 85.0%) → person (confiance : 78.3%) → person (confiance : 66.7%) ✅ Image annotée sauvegardée dans runs/detect/predict/

Ouvre le dossier runs/detect/predict/ : tu y trouveras l'image avec les rectangles de détection dessinés dessus. Magique, non ?

Ce qui se passe dans le code, ligne par ligne :

  • YOLO("yolo11n.pt") charge le modèle nano. Le « 11 » signifie YOLOv11, la dernière itération (encore plus précise que YOLOv8)
  • modele("image.jpg", save=True) lance la détection et sauvegarde le résultat
  • r.boxes contient toutes les boîtes détectées, avec leur classe et leur score

4. Deuxième script : détection en direct avec la webcam

Maintenant, on passe à la vitesse supérieure. On va brancher ta webcam et afficher les détections en temps réel, image par image.

Crée un fichier detecte_webcam.py :

python
""" Détection d'objets en direct depuis la webcam Appuie sur 'q' pour quitter. """ import cv2 from ultralytics import YOLO # Charger le modèle print("⚡ Chargement du modèle...") modele = YOLO("yolo11n.pt") # Ouvrir la webcam print("🎥 Ouverture de la webcam...") cap = cv2.VideoCapture(0) # 0 = webcam par défaut if not cap.isOpened(): print("❌ Impossible d'ouvrir la webcam !") exit() print("✅ Détection en cours — appuie sur 'q' pour quitter\n") while True: # 1. Capturer une image ok, image = cap.read() if not ok: break # 2. Lancer la détection (on désactive l'affichage console) resultats = modele(image, verbose=False) # 3. Récupérer l'image annotée image_annotee = resultats[0].plot() # 4. Afficher la fenêtre cv2.imshow("Détecteur YOLO - Appuie sur Q pour quitter", image_annotee) # 5. Quitter si 'q' est pressée if cv2.waitKey(1) & 0xFF == ord('q'): break # Nettoyage cap.release() cv2.destroyAllWindows() print("👋 À bientôt !")

Lance le script :

bash
python3 detecte_webcam.py

Ce que tu dois voir :

Une fenêtre s'ouvre avec le flux de ta webcam. Chaque objet reconnu par YOLO est entouré d'un rectangle coloré avec son nom et son score de confiance. Promène ta webcam devant toi, ton téléphone, une tasse de café — regarde ce que YOLO détecte.

Appuie sur Q pour quitter.

Si tu es sur un Raspberry Pi ou un petit PC et que ça rame, ajoute cette ligne après le chargement du modèle :

python
modele = YOLO("yolo11n.pt") # Forcer l'inférence sur CPU avec une image plus petite pour la vitesse modele.predict(source=image, imgsz=320, verbose=False)

En réduisant la taille d'image à 320 pixels (imgsz=320), tu passes de 15 à 30 images par seconde même sur un vieux laptop.

5. Troisième script : compteur d'objets avec overlay

On va maintenant créer une version plus propre et plus utile : un compteur qui affiche en temps réel le nombre de chaque type d'objet détecté, avec un bel overlay.

Crée un fichier compteur_objets.py :

python
""" Compteur d'objets en temps réel avec overlay Affiche le décompte de chaque classe détectée """ import cv2 from ultralytics import YOLO from collections import Counter print("⚡ Chargement du modèle...") modele = YOLO("yolo11n.pt") print("🎥 Ouverture de la webcam...") cap = cv2.VideoCapture(0) if not cap.isOpened(): print("❌ Webcam introuvable !") exit() print("✅ Compteur actif — 'q' pour quitter\n") while True: ok, image = cap.read() if not ok: break # Détection resultats = modele(image, verbose=False) r = resultats[0] # Compter les objets par classe compteur = Counter() for box in r.boxes: nom_classe = modele.names[int(box.cls[0])] compteur[nom_classe] += 1 # Récupérer l'image annotée image_annotee = r.plot() # Afficher le compteur en overlay (coin supérieur gauche) y_offset = 30 # Fond semi-transparent overlay = image_annotee.copy() cv2.rectangle(overlay, (5, 5), (250, 40 + 25 * len(compteur)), (0, 0, 0), -1) image_annotee = cv2.addWeighted(overlay, 0.6, image_annotee, 0.4, 0) cv2.putText(image_annotee, "🔍 OBJETS DÉTECTÉS", (15, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2) y_offset += 25 if not compteur: cv2.putText(image_annotee, " (aucun)", (15, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (200, 200, 200), 1) else: for objet, nb in compteur.most_common(): texte = f" {objet} : {nb}" cv2.putText(image_annotee, texte, (15, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1) y_offset += 25 # Ajouter le nombre total en bas total = sum(compteur.values()) cv2.putText(image_annotee, f"Total : {total} objet(s)", (15, image.shape[0] - 15), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2) # Afficher cv2.imshow("Compteur d'objets YOLO", image_annotee) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows() print("👋 À bientôt !")

Lance le script :

bash
python3 compteur_objets.py

Ce que tu as accompli :

  • Un panneau en haut à gauche qui liste chaque type d'objet et son nombre
  • Un compteur total en bas de l'écran
  • Les rectangles de détection YOLO sur chaque objet reconnu
  • Le tout en temps réel, depuis ta webcam

Félicitations ! Tu as maintenant un vrai outil de vision par ordinateur qui tourne sur ta machine.

6. Pièges classiques (et comment les éviter)

Erreur n°1 : ModuleNotFoundError: No module named 'ultralytics'

Cause : Tu as oublié d'activer l'environnement virtuel ou d'installer la librairie.

Solution :

bash
source venv/bin/activate # ou venv\Scripts\activate sous Windows pip install ultralytics

Erreur n°2 : La webcam ne s'ouvre pas (écran noir ou erreur)

Cause : L'index 0 ne correspond pas à ta webcam (fréquent sur les laptops avec webcam externe, ou dans un container Docker).

Solution : Teste les indices 0, 1, 2...

python
for i in range(5): cap = cv2.VideoCapture(i) if cap.isOpened(): print(f"✅ Webcam trouvée à l'index {i}") break

Erreur n°3 : Les détections sont trop lentes (2-3 images/seconde)

Cause : Le modèle tourne sur CPU avec une image trop grande.

Solution : Réduis la taille d'inférence et passe au modèle nano :

python
resultats = modele(image, imgsz=320, verbose=False)

Tu sacrifies un peu de précision sur les petits objets lointains, mais tu passes à 20+ fps.

Erreur n°4 : AssertionError: Image not found sur la photo

Cause : Le chemin de l'image est incorrect ou l'URL n'est pas accessible.

Solution : Vérifie que le fichier existe avec ls -la ton_image.jpg. Si tu utilises une URL, teste-la d'abord dans ton navigateur.

7. Pour aller plus loin

Piste 1 : Ne détecter que les personnes

Tu n'as pas besoin de voir les chaises et les bouteilles ? Filtre par classe :

python
resultats = modele(image, classes=[0], verbose=False) # 0 = personne

La liste complète des classes est dans modele.names. La classe 0 correspond à person dans le dataset COCO.

Piste 2 : Sauvegarder une vidéo des détections

Ajoute ces lignes pour enregistrer ce que ta webcam voit :

python
# Avant la boucle largeur = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) hauteur = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) writer = cv2.VideoWriter( "detection.mp4", cv2.VideoWriter_fourcc(*"mp4v"), 20, # fps (largeur, hauteur) ) # Dans la boucle, après le plot writer.write(image_annotee) # Après la boucle writer.release()

Piste 3 : Envoie les détections par email ou notification

Quand un objet spécifique est détecté (exemple : un colis devant ta porte), déclenche une action :

python
if "person" in compteur and compteur["person"] >= 1: # Envoie une notification (à adapter avec ton système) print("⚠️ Personne détectée !")

Avec smtplib ou l'API Telegram, tu peux transformer ce détecteur en système de surveillance basique.

Piste bonus : Fine-tuner YOLO sur tes propres objets

Tu veux détecter des choses que YOLO ne connaît pas ? Avec 100-200 photos annotées, tu peux entraîner YOLO à reconnaître tes propres objets. La doc ultralytics a un guide complet pour ça.

Ce que tu as appris aujourd'hui

  • Installer Python + OpenCV + YOLO en 3 commandes
  • Charger un modèle de détection d'objets (6 Mo, pas de GPU)
  • Détecter des objets sur une photo
  • Faire tourner la détection en direct depuis ta webcam
  • Créer un compteur visuel avec overlay
  • Débugger les 4 erreurs les plus fréquentes

Tu es passé de « la vision par ordinateur c'est trop compliqué pour moi » à « je viens de coder un détecteur d'objets qui marche ». C'est exactement pour ça que ce tutoriel existe.

Maintenant, à toi de jouer. Modifie le code, filtre les classes qui t'intéressent, branche ça sur ta caméra de jardin ou sur des photos de vacances. Le code est à toi.

Tutoriel rédigé par Professeur pour iancr.com. Code testé sur Python 3.11 avec ultralytics 8.x et opencv-python 4.x. Toute ressemblance avec un vieux cours d'informatique serait purement fortuite — ici, on code pour de vrai.