Sicherheitsalarmsystem Projekt mit Ultralytics YOLO11
Das Projekt für ein Sicherheitsalarmsystem, das Ultralytics YOLO11 nutzt, integriert fortschrittliche Computer-Vision-Funktionen zur Verbesserung der Sicherheitsmaßnahmen. YOLO11 Das von Ultralytics entwickelte System zur Erkennung von Objekten in Echtzeit ermöglicht es dem System, potenzielle Sicherheitsbedrohungen sofort zu erkennen und darauf zu reagieren. Dieses Projekt bietet mehrere Vorteile:
- Erkennung in Echtzeit: Die Effizienz von YOLO11 ermöglicht es dem Sicherheitsalarmsystem, Sicherheitsvorfälle in Echtzeit zu erkennen und darauf zu reagieren, wodurch die Reaktionszeit minimiert wird.
- Genauigkeit: YOLO11 ist bekannt für seine Genauigkeit bei der Objekterkennung, wodurch Fehlalarme reduziert und die Zuverlässigkeit des Sicherheitssystems erhöht werden.
- Integrationsfähigkeiten: Das Projekt kann nahtlos in die bestehende Sicherheitsinfrastruktur integriert werden und bietet eine zusätzliche intelligente Überwachungsebene.
Beobachten: Sicherheitsalarmsystem Projekt mit Ultralytics YOLO11 Objekt-Erkennung
Code
Einstellen der Parameter der Nachricht
Hinweis
App Passwortgenerierung ist notwendig
- Navigieren Sie zum App-Passwort-Generator, geben Sie einen App-Namen ein, z. B. "Sicherheitsprojekt", und erhalten Sie ein 16-stelliges Passwort. Kopieren Sie dieses Passwort und fügen Sie es wie angewiesen in das vorgesehene Passwortfeld ein.
password = ""
from_email = "" # must match the email used to generate the password
to_email = "" # receiver email
Erstellung und Authentifizierung von Servern
import smtplib
server = smtplib.SMTP("smtp.gmail.com: 587")
server.starttls()
server.login(from_email, password)
E-Mail-Sendefunktion
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())
Objekterkennung und Alarmsender
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()
Aufrufen der Klasse Object Detection und Ausführen der Inferenz
Das war's! Wenn Sie den Code ausführen, erhalten Sie eine einzige Benachrichtigung per E-Mail, wenn ein Objekt entdeckt wird. Die Benachrichtigung wird sofort und nicht wiederholt gesendet. Es steht Ihnen jedoch frei, den Code an die Anforderungen Ihres Projekts anzupassen.
Empfangene E-Mail Probe
FAQ
Wie verbessert Ultralytics YOLO11 die Genauigkeit eines Sicherheitsalarmsystems?
Ultralytics YOLO11 verbessert Sicherheitsalarmsysteme durch eine hochpräzise Objekterkennung in Echtzeit. Seine fortschrittlichen Algorithmen reduzieren Fehlalarme erheblich und stellen sicher, dass das System nur auf echte Bedrohungen reagiert. Diese erhöhte Zuverlässigkeit lässt sich nahtlos in die bestehende Sicherheitsinfrastruktur integrieren und verbessert die allgemeine Überwachungsqualität.
Kann ich Ultralytics YOLO11 in meine bestehende Sicherheitsinfrastruktur integrieren?
Ja, Ultralytics YOLO11 kann nahtlos in Ihre bestehende Sicherheitsinfrastruktur integriert werden. Das System unterstützt verschiedene Modi und bietet Flexibilität bei der Anpassung, so dass Sie Ihr bestehendes System mit erweiterten Objekterkennungsfunktionen erweitern können. Detaillierte Anweisungen zur Integration von YOLO11 in Ihre Projekte finden Sie im Abschnitt Integration.
Wie hoch sind die Speicheranforderungen für die Ausführung von Ultralytics YOLO11 ?
Für die Ausführung von Ultralytics YOLO11 auf einer Standardinstallation werden in der Regel etwa 5 GB freier Speicherplatz benötigt. Dies schließt den Speicherplatz für das Modell YOLO11 und alle zusätzlichen Abhängigkeiten ein. Für Cloud-basierte Lösungen bietet Ultralytics HUB effizientes Projektmanagement und Datensatzverwaltung, wodurch der Speicherbedarf optimiert werden kann. Erfahren Sie mehr über den Pro Plan, der erweiterte Funktionen und mehr Speicherplatz bietet.
Wodurch unterscheidet sich Ultralytics YOLO11 von anderen Objekterkennungsmodellen wie Faster R-CNN oder SSD?
Ultralytics YOLO11 bietet mit seinen Echtzeit-Erkennungsfunktionen und seiner höheren Genauigkeit einen Vorteil gegenüber Modellen wie Faster R-CNN oder SSD. Dank seiner einzigartigen Architektur kann es Bilder viel schneller verarbeiten, ohne Kompromisse bei der Präzision einzugehen, was es ideal für zeitkritische Anwendungen wie Sicherheitsalarmsysteme macht. Einen umfassenden Vergleich von Objekterkennungsmodellen können Sie in unserem Leitfaden nachlesen.
Wie kann ich die Häufigkeit von Fehlalarmen in meinem Sicherheitssystem mit Ultralytics YOLO11 reduzieren?
Um Fehlalarme zu vermeiden, sollten Sie sicherstellen, dass Ihr Ultralytics YOLO11 Modell mit einem vielfältigen und gut kommentierten Datensatz angemessen trainiert ist. Die Feinabstimmung von Hyperparametern und die regelmäßige Aktualisierung des Modells mit neuen Daten können die Erkennungsgenauigkeit erheblich verbessern. Detaillierte Techniken zur Abstimmung von Hyperparametern finden Sie in unserer Anleitung zur Abstimmung von Hyperparametern.
