Overslaan naar inhoud

Beveiligingsalarmsysteem project met Ultralytics YOLOv8

Beveiligingsalarmsysteem

Het project Beveiligingsalarmsysteem met Ultralytics YOLOv8 integreert geavanceerde computervisiemogelijkheden om de beveiligingsmaatregelen te verbeteren. YOLOv8 ontwikkeld door Ultralytics, biedt realtime objectdetectie, waardoor het systeem snel potentiƫle veiligheidsbedreigingen kan identificeren en erop kan reageren. Dit project biedt verschillende voordelen:

  • Real-time Detectie: YOLOv8's efficiĆ«ntie stelt het Security Alarm System in staat om beveiligingsincidenten in real-time te detecteren en erop te reageren, waardoor de responstijd tot een minimum wordt beperkt.
  • Nauwkeurigheid: YOLOv8 staat bekend om zijn nauwkeurigheid bij het detecteren van objecten, het verminderen van vals-positieven en het vergroten van de betrouwbaarheid van het beveiligingsalarmsysteem.
  • Integratiemogelijkheden: Het project kan naadloos worden geĆÆntegreerd met bestaande beveiligingsinfrastructuur, waardoor een verbeterde laag van intelligente bewaking ontstaat.



Kijken: Project voor beveiligingsalarmsysteem met Ultralytics YOLOv8 Objectdetectie

Code

De parameters van het bericht instellen

Opmerking

App wachtwoordgeneratie is noodzakelijk

  • Navigeer naar App Password Generator, wijs een app-naam aan zoals "beveiligingsproject" en vraag een 16-cijferig wachtwoord op. Kopieer dit wachtwoord en plak het volgens de instructies in het aangewezen wachtwoordveld.
password = ""
from_email = ""  # must match the email used to generate the password
to_email = ""  # receiver email

Server aanmaken en verifiƫren

import smtplib

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

Functie voor verzenden per 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())

Objectdetectie en waarschuwingszender

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()

De klasse Objectdetectie aanroepen en de conclusie uitvoeren

detector = ObjectDetection(capture_index=0)
detector()

Dat is het! Als je de code uitvoert, ontvang je een enkele melding op je e-mail als er een object wordt gedetecteerd. De melding wordt onmiddellijk verzonden, niet herhaaldelijk. Voel je echter vrij om de code aan te passen aan de vereisten van jouw project.

Voorbeeld ontvangen e-mail

Voorbeeld ontvangen e-mail

FAQ

Hoe verbetert Ultralytics YOLOv8 de nauwkeurigheid van een beveiligingsalarmsysteem?

Ultralytics YOLOv8 verbetert beveiligingsalarmsystemen door zeer nauwkeurige detectie van objecten in realtime. De geavanceerde algoritmes verminderen het aantal valse meldingen aanzienlijk, zodat het systeem alleen reageert op echte bedreigingen. Deze verhoogde betrouwbaarheid kan naadloos worden geĆÆntegreerd in bestaande beveiligingsinfrastructuur, waardoor de algehele bewakingskwaliteit wordt verbeterd.

Kan ik Ultralytics YOLOv8 integreren met mijn bestaande beveiligingsinfrastructuur?

Ja, Ultralytics YOLOv8 kan naadloos worden geĆÆntegreerd met je bestaande beveiligingsinfrastructuur. Het systeem ondersteunt verschillende modi en biedt flexibiliteit voor aanpassingen, zodat je je bestaande installatie kunt uitbreiden met geavanceerde objectdetectiemogelijkheden. Ga voor gedetailleerde instructies over het integreren van YOLOv8 in je projecten naar de integratiesectie.

Wat zijn de opslagvereisten voor het uitvoeren van Ultralytics YOLOv8 ?

Voor het uitvoeren van Ultralytics YOLOv8 op een standaardinstallatie is meestal ongeveer 5 GB vrije schijfruimte nodig. Dit is inclusief ruimte voor het opslaan van het YOLOv8 model en eventuele aanvullende afhankelijkheden. Voor cloudgebaseerde oplossingen biedt Ultralytics HUB efficiƫnt projectbeheer en datasetverwerking, waardoor de opslagbehoeften kunnen worden geoptimaliseerd. Kom meer te weten over het Pro Plan voor verbeterde functies, waaronder meer opslagruimte.

Wat maakt Ultralytics YOLOv8 anders dan andere objectdetectiemodellen zoals Faster R-CNN of SSD?

Ultralytics YOLOv8 biedt een voorsprong op modellen als Faster R-CNN of SSD met zijn realtime detectiemogelijkheden en hogere nauwkeurigheid. Dankzij de unieke architectuur kunnen beelden veel sneller worden verwerkt zonder dat dit ten koste gaat van de nauwkeurigheid, waardoor het ideaal is voor tijdgevoelige toepassingen zoals beveiligingsalarmsystemen. Voor een uitgebreide vergelijking van objectdetectiemodellen kun je onze gids raadplegen.

Hoe kan ik de frequentie van valse positieven in mijn beveiligingssysteem verlagen met Ultralytics YOLOv8 ?

Om fout-positieven te verminderen, moet je ervoor zorgen dat je Ultralytics YOLOv8 model voldoende getraind is met een diverse en goed geannoteerde dataset. Het fijn afstellen van hyperparameters en het regelmatig bijwerken van het model met nieuwe gegevens kan de detectienauwkeurigheid aanzienlijk verbeteren. Gedetailleerde hyperparameter tuning technieken zijn te vinden in onze hyperparameter tuning gids.



Aangemaakt 2023-12-02, Bijgewerkt 2024-07-05
Auteurs: glenn-jocher (7), ambitious-octopus (1), IvorZhu331 (1), RizwanMunawar (1)

Reacties