Projet de système d'alarme de sécurité Utilisation Ultralytics YOLO11
Le projet de système d'alarme de sécurité utilisant Ultralytics YOLO11 intègre des capacités avancées de vision par ordinateur pour améliorer les mesures de sécurité. YOLO11 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 pour la sécurité et d'y répondre rapidement. Ce projet présente plusieurs avantages :
- Détection en temps réel : l'efficacité de YOLO11'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: YOLO11 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 manière transparente à l'infrastructure de sécurité existante, offrant ainsi une couche supplémentaire de surveillance intelligente.
Regarder : Projet de système d'alarme de sécurité avec Ultralytics YOLO11 Détection d'objets
Code
Définir les paramètres du message
Note
La génération d'un mot de passe pour l'application est nécessaire
- Naviguez vers App Password Generator, désignez un nom d'application tel que "security project", et obtenez un mot de passe à 16 chiffres. Copiez ce mot de passe et collez-le dans le champ prévu à cet effet, 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 de courrier Ă©lectronique
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("yolo11n.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("YOLO11 Detection", im0)
frame_count += 1
if cv2.waitKey(5) & 0xFF == 27:
break
cap.release()
cv2.destroyAllWindows()
server.quit()
Appeler la classe de détection d'objets et exécuter l'inférence
Le tour est joué ! Lorsque vous exécutez le code, vous recevez une notification unique sur votre courrier électronique si un objet est détecté. La notification est envoyée immédiatement, et non de manière répétée. Cependant, n'hésitez pas à personnaliser le code pour l'adapter aux exigences de votre projet.
Exemple de courriel reçu
FAQ
Comment Ultralytics YOLO11 améliore-t-il la précision d'un système d'alarme de sécurité ?
Ultralytics YOLO11 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 que le système ne réagit qu'aux menaces réelles. Cette fiabilité accrue peut être intégrée de manière transparente à l'infrastructure de sécurité existante, améliorant ainsi la qualité globale de la surveillance.
Puis-je intégrer Ultralytics YOLO11 à mon infrastructure de sécurité existante ?
Oui, Ultralytics YOLO11 peut être intégré de manière transparente à votre infrastructure de sécurité existante. Le système prend en charge différents modes et offre une grande souplesse de personnalisation, ce qui vous permet d'améliorer votre installation existante grâce à des capacités avancées de détection d'objets. Pour obtenir des instructions détaillées sur l'intégration de YOLO11 dans vos projets, consultez la section sur l'intégration.
Quelles sont les exigences en matière de stockage pour l'exécution de Ultralytics YOLO11 ?
L'exécution de Ultralytics YOLO11 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 YOLO11 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 de stockage. En savoir plus sur le Plan Pro pour des fonctionnalités améliorées, y compris un espace de stockage plus important.
Qu'est-ce qui différencie Ultralytics YOLO11 d'autres modèles de détection d'objets tels que Faster R-CNN ou SSD ?
Ultralytics YOLO11 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, vous pouvez consulter notre guide.
Comment puis-je réduire la fréquence des faux positifs dans mon système de sécurité en utilisant Ultralytics YOLO11 ?
Pour réduire le nombre de faux positifs, veillez à ce que votre modèle Ultralytics YOLO11 soit correctement entraîné à l'aide d'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 manière significative la précision de la détection. Vous trouverez des techniques détaillées de réglage des hyperparamètres dans notre guide de réglage des hyperparamètres.
