Sicherheitsalarmsystem Projekt mit Ultralytics YOLOv8
Das Projekt "Security Alarm System", das Ultralytics YOLOv8 nutzt, integriert fortschrittliche Computer Vision FĂ€higkeiten, um die SicherheitsmaĂnahmen zu verbessern. YOLOv8 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 YOLOv8 ermöglicht es dem Sicherheitsalarmsystem, SicherheitsvorfÀlle in Echtzeit zu erkennen und darauf zu reagieren, wodurch die Reaktionszeit minimiert wird.
- Genauigkeit: YOLOv8 ist fĂŒr seine Genauigkeit bei der Objekterkennung bekannt, die Fehlalarme reduziert und die ZuverlĂ€ssigkeit des Sicherheitssystems erhöht.
- IntegrationsfĂ€higkeiten: Das Projekt kann nahtlos in die bestehende Sicherheitsinfrastruktur integriert werden und bietet eine zusĂ€tzliche intelligente Ăberwachungsebene.
Pass auf: Sicherheitsalarmsystem-Projekt mit Ultralytics YOLOv8 Objekterkennung
Code
Richte die Parameter der Nachricht ein
Hinweis
App Passwortgenerierung ist notwendig
- Navigiere zum App-Passwort-Generator, gib einen App-Namen ein, z. B. "Sicherheitsprojekt", und erhalte ein 16-stelliges Passwort. Kopiere dieses Passwort und fĂŒge es wie angegeben in das vorgesehene Passwortfeld ein.
password = ""
from_email = "" # must match the email used to generate the password
to_email = "" # receiver email
Server erstellen und authentifizieren
import smtplib
server = smtplib.SMTP("smtp.gmail.com: 587")
server.starttls()
server.login(from_email, password)
E-Mail senden Funktion
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 Warnsender
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()
Rufe die Klasse Object Detection auf und fĂŒhre die Inferenz aus
Das war's! Wenn du den Code ausfĂŒhrst, erhĂ€ltst du eine einzige Benachrichtigung per E-Mail, wenn ein Objekt entdeckt wird. Die Benachrichtigung wird sofort und nicht wiederholt gesendet. Du kannst den Code jedoch gerne an die Anforderungen deines Projekts anpassen.
Empfangene E-Mail Probe
FAQ
Wie kann Ultralytics YOLOv8 die Genauigkeit eines Sicherheitssystems verbessern?
Ultralytics YOLOv8 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 YOLOv8 in meine bestehende Sicherheitsinfrastruktur integrieren?
Ja, Ultralytics YOLOv8 kann nahtlos in deine bestehende Sicherheitsinfrastruktur integriert werden. Das System unterstĂŒtzt verschiedene Modi und bietet FlexibilitĂ€t bei der Anpassung, so dass du dein bestehendes System mit fortschrittlichen Objekterkennungsfunktionen erweitern kannst. Detaillierte Anweisungen zur Integration von YOLOv8 in deine Projekte findest du im Bereich Integration.
Wie hoch sind die Speicheranforderungen fĂŒr die AusfĂŒhrung von Ultralytics YOLOv8 ?
FĂŒr die AusfĂŒhrung von Ultralytics YOLOv8 auf einer Standardinstallation werden normalerweise etwa 5 GB freier Speicherplatz benötigt. Darin enthalten ist der Speicherplatz fĂŒr das Modell YOLOv8 und alle zusĂ€tzlichen AbhĂ€ngigkeiten. FĂŒr Cloud-basierte Lösungen bietet Ultralytics HUB ein effizientes Projektmanagement und die Verwaltung von DatensĂ€tzen, wodurch der Speicherbedarf optimiert werden kann. Erfahre mehr ĂŒber den Pro Plan mit erweiterten Funktionen und mehr Speicherplatz.
Wodurch unterscheidet sich Ultralytics YOLOv8 von anderen Objekterkennungsmodellen wie Faster R-CNN oder SSD?
Ultralytics YOLOv8 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 findest du in unserem Leitfaden.
Wie kann ich die HĂ€ufigkeit von Fehlalarmen in meinem Sicherheitssystem mit Ultralytics YOLOv8 reduzieren?
Um Fehlalarme zu vermeiden, solltest du sicherstellen, dass dein Ultralytics YOLOv8 Modell mit einem vielfĂ€ltigen und gut kommentierten Datensatz ausreichend trainiert ist. Die Feinabstimmung der Hyperparameter und die regelmĂ€Ăige Aktualisierung des Modells mit neuen Daten können die Erkennungsgenauigkeit erheblich verbessern. Detaillierte Techniken zur Abstimmung der Hyperparameter findest du in unserem Leitfaden zur Abstimmung von Hyperparametern.
