Les conteneurs Docker sont des instances exécutables d’images Docker. Ils encapsulent l’application et son environnement, garantissant que l’application fonctionne de manière identique dans n’importe quel environnement Docker.

Exemples

• Exécution d’une instance Redis dans un conteneur Docker pour le développement.
• Utilisation de conteneurs Docker pour encapsuler les services d’une application microservices.

Exercices

1. Exécuter un conteneur Docker en mode interactif et explorer son système de fichiers.
2. Créer un réseau Docker et connecter plusieurs conteneurs pour permettre la communication entre eux.

Réseautage dans Docker

Le réseautage Docker permet aux conteneurs de communiquer entre eux et avec l’extérieur. Docker fournit plusieurs pilotes de réseau, tels que bridge, host, et overlay, pour différentes utilisations.

Exemples

• Réseau Bridge: Utilisé par défaut, permet aux conteneurs de communiquer entre eux et avec l’hôte.
• Réseau Overlay: Permet la communication entre conteneurs dans différents hôtes Docker, utilisé dans des clusters Docker Swarm.

Exercices

1. Créer un réseau bridge personnalisé et connecter des conteneurs à ce réseau.
2. Explorer la communication entre conteneurs sur le même réseau et entre différents réseaux

Stockage dans Docker

Le stockage dans Docker permet de persister et de partager des données entre conteneurs et entre conteneurs et hôte. Docker propose des volumes, des bind mounts, et des tmpfs mounts pour gérer les données.

Exemples

• Volumes: Stockent les données en dehors du système de fichiers du conteneur, gérés par Docker.
• Bind Mounts: Partagent des fichiers entre l’hôte et le conteneur, en spécifiant un chemin sur l’hôte.

Exercices

1. Créer un volume Docker et l’utiliser pour persister les données d’une base de données exécutée dans un conteneur.
2. Utiliser un bind mount pour partager des fichiers de configuration ou du code entre l’hôte et un conteneur pour un développement rapide.

Ces concepts fondamentaux de Docker fournissent une base solide pour comprendre et travailler avec des conteneurs, des images, du réseautage, et du stockage dans des environnements de développement et de production.

Les images Docker sont des modèles immuables utilisés pour créer des conteneurs. Une image contient tout le nécessaire pour exécuter une application, y compris le code, les bibliothèques, les variables d’environnement, et les fichiers de configuration.

Exemples

• Image Officielle Python: Utilisée pour créer des conteneurs capables d’exécuter des applications Python.
• Image personnalisée: Création d’une image Docker à partir d’un
  Dockerfile

  qui installe une application web spécifique et ses dépendances.

Exercices

1. Télécharger une image officielle depuis Docker Hub et exécuter un conteneur à partir de celle-ci.
2. Créer un
   Dockerfile

   pour une application simple, construire une image Docker à partir de ce fichier, et exécuter un conteneur utilisant cette image.

Les conteneurs Docker et les machines virtuelles (VMs) offrent des environnements isolés pour exécuter des applications, mais ils diffèrent par leur architecture et leurs performances.

• Machines Virtuelles: Chaque VM fonctionne avec un système d’exploitation complet, ce qui peut entraîner une utilisation importante des ressources. Les VMs sont isolées les unes des autres et de l’hôte par un hyperviseur.
• Conteneurs Docker: Les conteneurs partagent le même noyau du système d’exploitation de l’hôte mais s’exécutent dans des espaces utilisateurs isolés. Cela les rend plus légers et plus rapides que les VMs, car ils n’ont pas besoin de démarrer un système d’exploitation complet.

Exemples

• VM: Utilisation d’une VM pour exécuter une application Windows sur un hôte Linux.
• Conteneur Docker: Exécution d’une application web Python Flask dans un conteneur Docker sur n’importe quel hôte prenant en charge Docker.

Exercices

1. Créer une VM en utilisant un outil comme VirtualBox, installer un OS, puis une application simple.
2. Installer Docker sur votre machine, télécharger une image Docker (par exemple, nginx), et exécuter un conteneur Docker exécutant nginx.

La conversion d’un modèle du format .pt de PyTorch au format ONNX implique quelques étapes, nécessitant généralement de charger le modèle PyTorch puis d’utiliser une fonction ou une méthode pour l’exporter vers ONNX.

Installez la bibliothèque Ultralytics YOLO

Assurez-vous que la bibliothèque Ultralytics YOLO est installée dans votre environnement Python. Cette bibliothèque fournit les outils et méthodes nécessaires pour travailler avec les modèles YOLO. Vous pouvez l’installer en utilisant pip si elle n’est pas déjà installée :

“`
pip install ultralytics

“`

Importer la classe YOLO

Commencez votre script en important la classe YOLO du paquet ultralytics. Cette classe est conçue pour gérer les modèles YOLO, y compris leur chargement et leur exportation.

“`
from ultralytics import YOLO

“`

Charger votre modèle PyTorch personnalisé

Utilisez la classe YOLO pour charger votre modèle entraîné personnalisé. Vous devez spécifier le chemin d’accès à votre fichier de modèle .pt. Ce fichier doit contenir les poids entraînés et l’architecture du modèle. L’exemple utilise “best.pt”, en supposant qu’il s’agit du nom de votre fichier de modèle.

“`
model = YOLO(‘best.pt’) # load a custom trained model

“`

Exporter le modèle au format ONNX

 

Une fois le modèle chargé, vous pouvez l’exporter au format ONNX en utilisant la méthode d’exportation. Spécifiez le format ‘onnx’ dans l’appel de la méthode. Cela créera un fichier ONNX dans le répertoire de travail actuel ou dans le chemin spécifié (si vous en fournissez un).

 

“`
model.export(format=’onnx’)
“`

Vérifier le fichier modèle ONNX

Après avoir exécuté le script, vous devriez trouver un fichier de modèle ONNX dans votre répertoire de travail. Le nom du fichier sera généralement dérivé du nom de votre fichier .pt original, mais avec une extension .onnx.

La détection d’objets en temps réel, utilisant le modèle YOLOv8 via la bibliothèque OpenCV. Ce script illustre comment YOLOv8, une évolution du populaire modèle YOLO pour la détection d’objets, peut être appliqué aux flux vidéo de deux caméras simultanément, offrant une solution puissante et flexible pour la surveillance et l’analyse vidéo en temps réel.

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO(‘yolov8n.pt’)

# Open the video file
video_path = “path/to/your/video/file.mp4”
cap = cv2.VideoCapture(0)

# Loop through the video frames
while cap.isOpened():
# Read a frame from the video
success, frame = cap.read()

if success:
# Run YOLOv8 inference on the frame
results = model(frame)

# Visualize the results on the frame
annotated_frame = results[0].plot()

# Display the annotated frame
cv2.imshow(“YOLOv8 Inference”, annotated_frame)

# Break the loop if ‘q’ is pressed
if cv2.waitKey(1) & 0xFF == ord(“q”):
break
else:
# Break the loop if the end of the video is reached
break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

 

Une application pratique de la détection d’objets en temps réel en utilisant le modèle de deep learning YOLOv5 en combinaison avec OpenCV, une bibliothèque populaire pour le traitement d’images et de vidéos. Cette synergie permet de surveiller et d’analyser les flux vidéo de plusieurs caméras simultanément, offrant ainsi une solution robuste pour des applications telles que la surveillance de sécurité, le suivi du trafic ou même des études comportementales en temps réel. Voici une explication détaillée du fonctionnement du script :

 

import cv2
import torch

# Charger le modèle YOLOv5
model = torch.hub.load(‘ultralytics/yolov5’, ‘yolov5x’, pretrained=True)

camera1 = cv2.VideoCapture(0)
camera2 = cv2.VideoCapture(4)

if not camera1.isOpened():
print(‘Erreur …cam1’)

if not camera2.isOpened():
print(‘Erreur.. cam2’)

while True:
ret1, frame1 = camera1.read()
ret2, frame2 = camera2.read()

if ret1 and ret2:
# Appliquer YOLOv5 aux deux images
results1 = model(frame1)
results2 = model(frame2)

# Récupérer les images avec les détections
frame1 = results1.render()[0]
frame2 = results2.render()[0]

# Concaténer les images pour l’affichage
frame = cv2.hconcat([frame1, frame2])
cv2.imshow(“Cameras”, frame)

if cv2.waitKey(1) & 0xFF == ord(‘q’):
break

camera1.release()
camera2.release()
cv2.destroyAllWindows()

 

1. Importation des bibliothèques nécessaires : Le script commence par importer cv2 (OpenCV) pour la capture vidéo et le traitement d’images, ainsi que torch, une bibliothèque de machine learning qui permet de charger et d’utiliser le modèle YOLOv5.
2. Chargement du modèle YOLOv5 : Le modèle YOLOv5 est chargé depuis le dépôt ultralytics sur GitHub grâce à la fonction
   torch.hub.load

   , en spécifiant ‘yolov5x’ comme modèle pré-entraîné. ‘yolov5x’ est l’une des versions de YOLOv5, connue pour sa précision élevée, bien qu’elle soit plus gourmande en ressources que ses variantes plus petites.

3. Initialisation des caméras : Deux objets
   VideoCapture

   sont créés pour les deux caméras.

   cv2.VideoCapture(0)

   et

   cv2.VideoCapture(4)

   sont utilisés pour initialiser la première et la deuxième caméra, respectivement. Les indices des caméras (0 et 4 dans ce cas) dépendent de l’ordre dans lequel les caméras sont reconnues par le système.

4. Vérification de l’ouverture des caméras : Le script vérifie si chaque caméra a été correctement initialisée. Si une caméra ne peut pas être ouverte, un message d’erreur est affiché.
5. Boucle de traitement des images : Une boucle
   while True

   est utilisée pour lire les images de chaque caméra en continu.

   camera.read()

   renvoie un booléen qui indique si la lecture a été réussie (

   ret

   ) et l’image capturée (

   frame

   ).

6. Application de YOLOv5 aux images : Pour chaque image capturée, le modèle YOLOv5 est appliqué via
   model(frame)

   . Cela permet de détecter les objets dans l’image et de renvoyer les résultats, qui incluent les cadres de délimitation, les classes d’objets et les scores de confiance.

7. Rendu des détections : Les résultats de la détection sont rendus sur les images originales avec
   results.render()

   , qui superpose les cadres de délimitation et les étiquettes d’identification sur les objets détectés.

8. Affichage des images : Les images traitées de chaque caméra sont concaténées horizontalement avec
   cv2.hconcat

   et affichées dans une fenêtre nommée “Cameras”.

9. Sortie de la boucle : La boucle peut être interrompue par l’utilisateur en appuyant sur la touche ‘q’, permettant ainsi de fermer proprement les flux vidéo et de détruire toutes les fenêtres OpenCV ouvertes.

Ce script démontre la puissance et la flexibilité de combiner YOLOv5 et OpenCV pour la détection d’objets en temps réel sur plusieurs sources vidéo. L’application de telles technologies ouvre des horizons vastes pour des applications allant de la surveillance de sécurité avancée à des solutions innovantes dans le domaine de la recherche et au-delà.

OpenCV est une bibliothèque open-source largement utilisée pour le traitement d’images et la vision par ordinateur. Elle offre un large éventail de fonctions pour la reconstruction 3D et la stéréoscopie.

Stéréoscopie

La stéréoscopie est une technique permettant de créer une illusion de profondeur en combinant deux images prises à partir de points de vue légèrement différents. OpenCV propose plusieurs fonctions pour la stéréoscopie, notamment :

• Calibrage de la caméra: Cette étape est nécessaire pour déterminer les paramètres intrinsèques et extrinsèques des caméras utilisées pour capturer les images stéréo.
• Correspondance stéréo: Cette étape consiste à trouver les correspondances entre les pixels des deux images stéréo.
• Triangulation: Cette étape consiste à calculer les coordonnées 3D des points correspondants.

Reconstruction 3D

La reconstruction 3D est le processus de création d’un modèle 3D à partir d’images 2D. OpenCV propose plusieurs fonctions pour la reconstruction 3D, notamment :

• Nuage de points: Un nuage de points est un ensemble de points 3D qui représentent la surface d’un objet.
• Maillage: Un maillage est une collection de triangles qui connectent les points d’un nuage de points.
• Texture: La texture est une image qui est appliquée à la surface d’un maillage pour lui donner un aspect réaliste.

Exemple d’utilisation:

OpenCV peut être utilisé pour reconstruire un modèle 3D d’un objet à partir de deux images stéréo. La première étape consiste à calibrer les caméras et à trouver les correspondances entre les pixels des deux images. Ensuite, les coordonnées 3D des points correspondants peuvent être calculées par triangulation. Enfin, un nuage de points, un maillage et une texture peuvent être générés à partir des coordonnées 3D.

Ressources supplémentaires:

• Documentation d’OpenCV sur la stéréoscopie: https://docs.opencv.org/4.x/d9/db7/tutorial_py_table_of_contents_calib3d.html
• Documentation d’OpenCV sur la reconstruction 3D: <URL non valide supprimée>
• Tutoriel sur la reconstruction 3D avec OpenCV: <URL non valide supprimée>

N’hésitez pas à me poser des questions si vous avez besoin de plus d’informations.

L’égalisation d’histogramme est une méthode pour améliorer le contraste d’une image en redistribuant l’intensité des pixels.

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
equalized = cv2.equalizeHist(gray)

cv2.imshow(‘Original’, gray)
cv2.imshow(‘Equalized’, equalized)
cv2.waitKey(0)
cv2.destroyAllWindows()

 

Ce filtre transforme une image en un sketch en détectant les contours et en inversant les couleurs pour simuler un effet de dessin au crayon.

def sketch_effect(img):
# Convertir en gris
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Inverser l’image
inv_gray = 255 – gray

# Appliquer un flou gaussien
blurred_inv_gray = cv2.GaussianBlur(inv_gray, (21, 21), 0)

# Inverser le flou
inv_blur = 255 – blurred_inv_gray

# Créer l’effet de sketch
sketch = cv2.divide(gray, inv_blur, scale=256.0)

return sketch

sketch_image = sketch_effect(image)

cv2.imshow(‘Sketch’, sketch_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

 

 

 

Le filtre de détection de contours de Sketch est un outil puissant pour extraire les contours d’une image. Il est basé sur l’algorithme de Canny, qui est un algorithme de détection de contours largement utilisé.

Fonctionnement:

Le filtre de détection de contours de Sketch fonctionne en plusieurs étapes:

1. Lissage: L’image est d’abord lissée avec un filtre gaussien pour supprimer le bruit.
2. Calcul du gradient: Le gradient de l’image est ensuite calculé. Le gradient est un vecteur qui indique la direction et la magnitude du changement de couleur dans l’image.
3. Seuillage: Le gradient est ensuite seuillé pour identifier les pixels qui font partie des contours.
4. Hystérésis: L’hystérésis est ensuite utilisée pour supprimer les contours faibles et relier les contours forts.

Avantages:

• Le filtre de détection de contours de Sketch est simple à utiliser.
• Le filtre de détection de contours de Sketch est efficace pour détecter les contours d’une image.
• Le filtre de détection de contours de Sketch est robuste aux variations d’éclairage et de contraste.

Inconvénients:

• Le choix du seuil peut être difficile.
• Le filtre de détection de contours de Sketch peut être sensible au bruit.

Exemple d’utilisation:

Le filtre de détection de contours de Sketch peut être utilisé pour créer une image en noir et blanc qui ne montre que les contours de l’image originale. Cela peut être utile pour la segmentation d’image, la reconnaissance d’objets et d’autres applications.

Ressources supplémentaires:

• Tutoriel sur le filtre de Canny en Python: https://www.youtube.com/watch?v=gzkhGgzs7b4
• Implémentation du filtre de Canny en Python: https://github.com/mohamedherak/Canny-Edge-Detection/blob/main/canny.py

N’hésitez pas à me poser des questions si vous avez besoin de plus d’informations.

Note: Le filtre de détection de contours de Sketch est un outil puissant, mais il n’est pas parfait. Il est important de choisir les bons paramètres pour l’image que vous souhaitez traiter. Vous pouvez également expérimenter avec d’autres algorithmes de détection de contours pour trouver celui qui fonctionne le mieux pour votre application.

Les filtres de Gabor sont utilisés pour l’extraction de caractéristiques, notamment pour l’analyse de textures et la reconnaissance de formes.

def gabor_filter(img, kernel_size=21):
# Créer un ensemble de filtres de Gabor avec différentes orientations
gabor_kernels = [cv2.getGaborKernel((kernel_size, kernel_size), 4.0, theta, 10.0, 0.5, 0, ktype=cv2.CV_32F) for theta in np.arange(0, np.pi, np.pi / 4)]

# Appliquer les filtres de Gabor à l’image
filtered_images = [cv2.filter2D(img, cv2.CV_8UC3, kernel) for kernel in gabor_kernels]

return filtered_images

gabor_filtered_images = gabor_filter(gray)

for filtered_image in gabor_filtered_images:
cv2.imshow(‘Gabor Filtered’, filtered_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

 

Le filtre de Gabor est un outil puissant pour l’extraction de caractéristiques dans le domaine du traitement d’image. Il s’inspire du système visuel humain et s’avère particulièrement efficace pour capturer des textures et des orientations spécifiques dans les images.

Fonctionnement:

Le filtre de Gabor est une ondelette 2D définie par une fonction gaussienne modulée par une sinusoïde. Il est paramétré par plusieurs variables:

• Échelle: Détermine la taille du filtre et la grossièreté des textures qu’il peut capturer.
• Orientation: Détermine l’angle des structures que le filtre recherche.
• Fréquence: Détermine la finesse des détails que le filtre peut capturer.

Applications:

L’extraction de caractéristiques avec le filtre de Gabor trouve de nombreuses applications dans le traitement d’image, notamment:

• Détection de visage: Le filtre de Gabor peut être utilisé pour détecter des caractéristiques faciales telles que les yeux, le nez et la bouche.
• Classification de textures: Le filtre de Gabor peut être utilisé pour distinguer différentes textures, comme la peau, les cheveux et les vêtements.
• Segmentation d’image: Le filtre de Gabor peut être utilisé pour segmenter une image en différentes régions en fonction de leurs caractéristiques textuelles.

Avantages:

• Efficacité: Le filtre de Gabor est un outil efficace pour capturer des textures et des orientations spécifiques dans les images.
• Flexibilité: Les paramètres du filtre de Gabor peuvent être ajustés pour s’adapter à différentes applications.
• Interprétabilité: Les caractéristiques extraites par le filtre de Gabor sont faciles à interpréter et à visualiser.

Inconvénients:

• Calculatoire: Le calcul des réponses du filtre de Gabor peut être gourmand en temps de calcul.
• Sensibilité au bruit: Le filtre de Gabor est sensible au bruit présent dans l’image.

Conclusion:

Le filtre de Gabor est un outil puissant et flexible pour l’extraction de caractéristiques dans le domaine du traitement d’image. Il est particulièrement efficace pour capturer des textures et des orientations spécifiques dans les images.

Ressources supplémentaires:

• Vision par ordinateur – Filtres de Gabor: http://ahistace.chez-alice.fr/documents/rapport_gabor.pdf
• Extraction De Caractéristiques Avec Les Ondelettes De Gabor Pour La Détection Faciale: https://theses-algerie.com/1599080403000158/memoire-de-master/universite-abdelhamid-ibn-badis-mostaganem/extraction-de-caracteristiques-avec-les-ondelettes-de-gabor-pour-la-detection-faciale

N’hésitez pas à me poser des questions si vous avez besoin de plus d’informations.