Nous allons voir dans ce tutoriel comment faire de la reconnaissance d’objet avec Python en utilisant un réseau de neurones pré-entrainé grâce au deep learning.
Nous avons vu dans un précédent tutoriel comment reconnaitre des formes simples avec la vision par ordinateur. Cette méthode ne fonctionne que pour certaines formes simples prédéfinies. Si vous souhaitez reconnaitre une plus grande variété d’objet, le plus simple est d’utiliser l’intelligence artificielle.
Matériel
- Un ordinateur avec une installation de Python3
- Une caméra
Principe
L’intelligence artificielle est un domaine de l’informatique dans lequel le programme apprend par lui-même à effectuer certaines tâches. Notamment de la reconnaissance visuelle. Dans ce tutoriel, nous allons utiliser un réseau de neurones entrainé pour reconnaitre des formes particulières.
Il faut de nombreuse données pour pouvoir entrainer correctement un réseau de neurone. Il a été démontré que l’apprentissage était plus rapide sur un réseau de neurones entrainé pour autre chose. Par exemple, un réseau de neurones entrainé pour reconnaitre les chiens s’entrainera plus facilement à reconnaitre les chats.
Configuration de Python
Si ce n’est pas le cas, vous pouvez télécharger et installer Python 3
Vous pouvez ensuite installer les librairies nécessaires OpenCV, numpy et imutils
pip3 install opencv-python numpy imutilsou
python3 -m pip install opencv-python numpy imutilsTéléchargement du modèle ModelNet-SSD
- fichier prototxt : https://github.com/nikmart/pi-object-detection/blob/master/MobileNetSSD_deploy.prototxt.txt
- fichier caffemodel : https://github.com/nikmart/pi-object-detection/blob/master/MobileNetSSD_deploy.caffemodel
Placer les fichiers du modèle dans un dossier et créer le fichier ObjectRecognition.py
Script Python pour la reconnaissance d’Objet
Tout d’abord, nous créons un flux vidéo (vs) à l’aide de la librairie imutils qui va récupérer les images de la caméra.
vs = VideoStream(src=0, resolution=(1600, 1200)).start()Nous initialisons un réseau de neurones avec les paramètres du ModelNet-SSD (net) à l’aide de la librairie OpenCV.
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])Nous allons, ensuite, créer une boucle qui à chaque itération va lire l’image de la caméra et la passer en entrée du réseau de neurone pour faire la détection et reconnaissance d’objet.
while True:
# Get video stream. max width 800 pixels
frame = vs.read()
blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 0.007843, (300, 300), 127.5)
# Feed input to neural network
net.setInput(blob)
detections = net.forward()Enfin, le code affiche sur l’image la boite de détection et la probabilité de reconnaissance.
label = "{}: {:.2f}%".format(CLASSES[idx],confidence * 100)
cv2.rectangle(frame, (startX, startY), (endX, endY),COLORS[idx], 2)
y = startY - 15 if startY - 15 > 15 else startY + 15
cv2.putText(frame, label, (startX, y),cv2.FONT_HERSHEY_SIMPLEX, 0.5, COLORS[idx], 2)#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# ObjectRecognition.py
# Description:
# Use ModelNet-SSD model to detect objects
#
# www.aranacorp.com
# import packages
import sys
from imutils.video import VideoStream
from imutils.video import FPS
import numpy as np
import argparse
import imutils
import time
import cv2
# Arguments construction
if len(sys.argv)==1:
args={
"prototxt":"MobileNetSSD_deploy.prototxt.txt",
"model":"MobileNetSSD_deploy.caffemodel",
"confidence":0.2,
}
else:
#lancement à partir du terminal
#python3 ObjectRecognition.py --prototxt MobileNetSSD_deploy.prototxt.txt --model MobileNetSSD_deploy.caffemodel
ap = argparse.ArgumentParser()
ap.add_argument("-p", "--prototxt", required=True,
help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-m", "--model", required=True,
help="path to Caffe pre-trained model")
ap.add_argument("-c", "--confidence", type=float, default=0.2,
help="minimum probability to filter weak detections")
args = vars(ap.parse_args())
# ModelNet SSD Object list init
CLASSES = ["arriere-plan", "avion", "velo", "oiseau", "bateau",
"bouteille", "autobus", "voiture", "chat", "chaise", "vache", "table",
"chien", "cheval", "moto", "personne", "plante en pot", "mouton",
"sofa", "train", "moniteur"]
COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3))
# Load model file
print("Load Neural Network...")
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
if __name__ == '__main__':
# Camera initialisation
print("Start Camera...")
vs = VideoStream(src=0, resolution=(1600, 1200)).start()
#vs = VideoStream(usePiCamera=True, resolution=(1600, 1200)).start()
#vc = cv2.VideoCapture('./img/Splash - 23011.mp4') #from video
time.sleep(2.0)
fps = FPS().start()
#Main loop
while True:
# Get video sttream. max width 800 pixels
frame = vs.read()
#frame= cv2.imread('./img/two-boats.jpg') #from image file
#ret, frame=vc.read() #from video or ip cam
frame = imutils.resize(frame, width=800)
# Create blob from image
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)), 0.007843, (300, 300), 127.5)
# Feed input to neural network
net.setInput(blob)
detections = net.forward()
# Detection loop
for i in np.arange(0, detections.shape[2]):
# Compute Object detection probability
confidence = detections[0, 0, i, 2]
# Suppress low probability
if confidence > args["confidence"]:
# Get index and position of detected object
idx = int(detections[0, 0, i, 1])
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
# Create box and label
label = "{}: {:.2f}%".format(CLASSES[idx],
confidence * 100)
cv2.rectangle(frame, (startX, startY), (endX, endY),
COLORS[idx], 2)
y = startY - 15 if startY - 15 > 15 else startY + 15
cv2.putText(frame, label, (startX, y),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, COLORS[idx], 2)
# enregistrement de l'image détectée
cv2.imwrite("detection.png", frame)
# Show video frame
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# Exit script with letter q
if key == ord("q"):
break
# FPS update
fps.update()
# Stops fps and display info
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
cv2.destroyAllWindows()
vs.stop()
vc.release()
Sources d’image pour la détection d’objet
Vous pouvez utiliser ce script avec différentes sources d’image. Pour cela, il faut légèrement adapter le code précédent afin de modifier la variable « frame » contenant l’image à analyser.
- La webcam de votre ordinateur
vs = VideoStream(src=0, resolution=(1600, 1200)).start() while True: frame = vs.read()
- Une caméra IP
vc = cv2.VideoCapture('rtsp://user:password@ipaddress:rtspPort')
while True:
ret, frame=vc.read() #from ip cam- La Picam du Raspberry Pi
vs = VideoStream(usePiCamera=True, resolution=(1600, 1200)).start() while True: frame = vs.read()
- Un fichier vidéo
vc = cv2.VideoCapture('./img/Splash - 23011.mp4') #from video
while True:
ret, frame=vc.read() #from video- Un fichier image
frame= cv2.imread('./img/two-boats.jpg') Résultats
Pour cet exemple nous envoyons en entrée du réseau de neurones une image de deux bateaux qui sont reconnus correctement. Pour obtenir des résultats légèrement différents, vous pouvez modifier le paramètre confidence pour éviter les faux positifs.
Vous pouvez tester ce code avec votre webcam ou avec des photos, par exemple, pour voir les performances du modèle et de la reconnaissance d’objet
Une fois que votre script fonctionne, vous pouvez entrainer votre modèle pour qu’il puisse détecter d’autres objets.
Paquets et Modèles
Dans ce tutoriel, nous avons utiliser le modèle pré-entrainé ModelNet-SSD. Il est bon de noter qu’ils existent d’autres modèles de reconnaissance comme Coco et d’autres librairies de reconnaissance visuelle comme ImageIA.
N’hésitez pas à nous laisser un commentaire pour partager les outils que vous utilisez ou connaissez.