Projet de système d'alarme de sécurité utilisant Ultralytics YOLOv8

Le projet de système d'alarme de sécurité utilisant Ultralytics YOLOv8 intègre des capacités avancées de vision par ordinateur pour améliorer les mesures de sécurité. YOLOv8 Le système de vision artificielle, développé par Ultralytics, permet de détecter les objets en temps réel, ce qui permet au système d'identifier les menaces potentielles à la sécurité et d'y répondre rapidement. Ce projet offre plusieurs avantages :

• Détection en temps réel : l'efficacité de YOLOv8's permet au système d'alarme de sécurité de détecter et de répondre aux incidents de sécurité en temps réel, minimisant ainsi le temps de réponse.
• Précision : YOLOv8 est connu pour sa précision dans la détection des objets, ce qui permet de réduire les faux positifs et d'améliorer la fiabilité du système d'alarme de sécurité.
• Capacités d'intégration : Le projet peut être intégré de façon transparente à l'infrastructure de sécurité existante, offrant ainsi une couche améliorée de surveillance intelligente.

Regarde : Projet de système d'alarme de sécurité avec Ultralytics YOLOv8 Détection d'objets

Code

Configure les paramètres du message

• Va sur App Password Generator, désigne un nom d'application tel que "security project", et obtiens un mot de passe à 16 chiffres. Copie ce mot de passe et colle-le dans le champ de mot de passe désigné comme indiqué.

password = ""
from_email = ""  # must match the email used to generate the password
to_email = ""  # receiver email

Création et authentification du serveur

import smtplib

server = smtplib.SMTP("smtp.gmail.com: 587")
server.starttls()
server.login(from_email, password)

Fonction d'envoi d'e-mail

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText


def send_email(to_email, from_email, object_detected=1):
    """Sends an email notification indicating the number of objects detected; defaults to 1 object."""
    message = MIMEMultipart()
    message["From"] = from_email
    message["To"] = to_email
    message["Subject"] = "Security Alert"
    # Add in the message body
    message_body = f"ALERT - {object_detected} objects has been detected!!"

    message.attach(MIMEText(message_body, "plain"))
    server.sendmail(from_email, to_email, message.as_string())

Détection d'objets et envoi d'alertes

from time import time

import cv2
import torch

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors


class ObjectDetection:
    def __init__(self, capture_index):
        """Initializes an ObjectDetection instance with a given camera index."""
        self.capture_index = capture_index
        self.email_sent = False

        # model information
        self.model = YOLO("yolov8n.pt")

        # visual information
        self.annotator = None
        self.start_time = 0
        self.end_time = 0

        # device information
        self.device = "cuda" if torch.cuda.is_available() else "cpu"

    def predict(self, im0):
        """Run prediction using a YOLO model for the input image `im0`."""
        results = self.model(im0)
        return results

    def display_fps(self, im0):
        """Displays the FPS on an image `im0` by calculating and overlaying as white text on a black rectangle."""
        self.end_time = time()
        fps = 1 / round(self.end_time - self.start_time, 2)
        text = f"FPS: {int(fps)}"
        text_size = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 1.0, 2)[0]
        gap = 10
        cv2.rectangle(
            im0,
            (20 - gap, 70 - text_size[1] - gap),
            (20 + text_size[0] + gap, 70 + gap),
            (255, 255, 255),
            -1,
        )
        cv2.putText(im0, text, (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2)

    def plot_bboxes(self, results, im0):
        """Plots bounding boxes on an image given detection results; returns annotated image and class IDs."""
        class_ids = []
        self.annotator = Annotator(im0, 3, results[0].names)
        boxes = results[0].boxes.xyxy.cpu()
        clss = results[0].boxes.cls.cpu().tolist()
        names = results[0].names
        for box, cls in zip(boxes, clss):
            class_ids.append(cls)
            self.annotator.box_label(box, label=names[int(cls)], color=colors(int(cls), True))
        return im0, class_ids

    def __call__(self):
        """Run object detection on video frames from a camera stream, plotting and showing the results."""
        cap = cv2.VideoCapture(self.capture_index)
        assert cap.isOpened()
        cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
        cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
        frame_count = 0
        while True:
            self.start_time = time()
            ret, im0 = cap.read()
            assert ret
            results = self.predict(im0)
            im0, class_ids = self.plot_bboxes(results, im0)

            if len(class_ids) > 0:  # Only send email If not sent before
                if not self.email_sent:
                    send_email(to_email, from_email, len(class_ids))
                    self.email_sent = True
            else:
                self.email_sent = False

            self.display_fps(im0)
            cv2.imshow("YOLOv8 Detection", im0)
            frame_count += 1
            if cv2.waitKey(5) & 0xFF == 27:
                break
        cap.release()
        cv2.destroyAllWindows()
        server.quit()

Appelle la classe de détection d'objets et exécute l'inférence

detector = ObjectDetection(capture_index=0)
detector()

C'est tout ! Lorsque tu exécuteras le code, tu recevras une seule notification sur ton email si un objet est détecté. La notification est envoyée immédiatement, et non de façon répétée. Cependant, n'hésite pas à personnaliser le code en fonction des exigences de ton projet.

Exemple de courriel reçu

FAQ

Comment Ultralytics YOLOv8 améliore-t-il la précision d'un système d'alarme de sécurité ?

Ultralytics YOLOv8 améliore les systèmes d'alarme de sécurité en offrant une détection d'objets en temps réel et de haute précision. Ses algorithmes avancés réduisent considérablement les faux positifs, garantissant ainsi que le système ne réagit qu'aux menaces réelles. Cette fiabilité accrue peut être intégrée de façon transparente à l'infrastructure de sécurité existante, améliorant ainsi la qualité globale de la surveillance.

Puis-je intégrer Ultralytics YOLOv8 à mon infrastructure de sécurité existante ?

Oui, Ultralytics YOLOv8 peut être intégré de façon transparente à ton infrastructure de sécurité existante. Le système prend en charge différents modes et offre une grande souplesse de personnalisation, ce qui te permet d'améliorer ta configuration existante avec des capacités avancées de détection d'objets. Pour obtenir des instructions détaillées sur l'intégration de YOLOv8 dans tes projets, visite la section intégration.

Quelles sont les exigences en matière de stockage pour l'exécution de Ultralytics YOLOv8 ?

L'exécution de Ultralytics YOLOv8 sur une installation standard nécessite généralement environ 5 Go d'espace disque libre. Cela comprend l'espace nécessaire au stockage du modèle YOLOv8 et de toutes les dépendances supplémentaires. Pour les solutions basées sur le cloud, Ultralytics HUB offre une gestion efficace des projets et des ensembles de données, ce qui peut optimiser les besoins en stockage. En savoir plus sur le plan Pro pour des fonctionnalités améliorées, notamment un espace de stockage étendu.

Qu'est-ce qui différencie Ultralytics YOLOv8 d'autres modèles de détection d'objets comme Faster R-CNN ou SSD ?

Ultralytics YOLOv8 offre une longueur d'avance sur les modèles tels que Faster R-CNN ou SSD grâce à ses capacités de détection en temps réel et à sa plus grande précision. Son architecture unique lui permet de traiter les images beaucoup plus rapidement sans compromettre la précision, ce qui le rend idéal pour les applications sensibles au temps comme les systèmes d'alarme de sécurité. Pour une comparaison complète des modèles de détection d'objets, tu peux explorer notre guide.

Comment puis-je réduire la fréquence des faux positifs dans mon système de sécurité en utilisant Ultralytics YOLOv8 ?

Pour réduire le nombre de faux positifs, assure-toi que ton modèle Ultralytics YOLOv8 est correctement entraîné avec un ensemble de données diversifié et bien annoté. Un réglage précis des hyperparamètres et une mise à jour régulière du modèle avec de nouvelles données peuvent améliorer de façon significative la précision de la détection. Tu trouveras des techniques détaillées de réglage des hyperparamètres dans notre guide de réglage des hyperparamètres.

Commentaires