Progetto di sistema di allarme di sicurezza con l'utilizzo di Ultralytics YOLOv8

Il progetto del sistema di allarme di sicurezza che utilizza Ultralytics YOLOv8 integra funzionalità avanzate di visione artificiale per migliorare le misure di sicurezza. YOLOv8 Il sistema di visione artificiale, sviluppato da Ultralytics, consente di rilevare gli oggetti in tempo reale, permettendo al sistema di identificare e rispondere tempestivamente alle potenziali minacce alla sicurezza. Questo progetto offre diversi vantaggi:

• Rilevamento in tempo reale: l'efficienza di YOLOv8 permette al sistema di allarme di rilevare e rispondere agli incidenti di sicurezza in tempo reale, riducendo al minimo i tempi di risposta.
• Precisione: YOLOv8 è noto per la sua precisione nel rilevamento degli oggetti, riducendo i falsi positivi e migliorando l'affidabilità del sistema di allarme di sicurezza.
• Capacità di integrazione: Il progetto può essere perfettamente integrato con l'infrastruttura di sicurezza esistente, fornendo un livello superiore di sorveglianza intelligente.

Guarda: Progetto di sistema di allarme di sicurezza con Ultralytics YOLOv8 rilevamento di oggetti

Codice

Imposta i parametri del messaggio

• Vai su App Password Generator, indica il nome di un'applicazione, ad esempio "progetto di sicurezza", e ottieni una password di 16 cifre. Copia questa password e incollala nel campo della password designata come indicato.

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

Creazione e autenticazione del server

import smtplib

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

Funzione di invio 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())

Rilevamento degli oggetti e invio di avvisi

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

Richiamare la classe Object Detection ed eseguire l'inferenza

detector = ObjectDetection(capture_index=0)
detector()

Tutto qui! Quando eseguirai il codice, riceverai una singola notifica sulla tua email se viene rilevato un oggetto. La notifica viene inviata immediatamente, non ripetutamente. Tuttavia, sentiti libero di personalizzare il codice in base alle esigenze del tuo progetto.

Campione di e-mail ricevute

DOMANDE FREQUENTI

In che modo Ultralytics YOLOv8 migliora la precisione di un sistema di allarme di sicurezza?

Ultralytics YOLOv8 migliora i sistemi di allarme di sicurezza offrendo un'elevata precisione e un rilevamento degli oggetti in tempo reale. I suoi algoritmi avanzati riducono significativamente i falsi positivi, garantendo che il sistema risponda solo alle minacce reali. Questa maggiore affidabilità può essere integrata senza problemi nell'infrastruttura di sicurezza esistente, migliorando la qualità complessiva della sorveglianza.

Posso integrare Ultralytics YOLOv8 con la mia infrastruttura di sicurezza esistente?

Sì, Ultralytics YOLOv8 può essere perfettamente integrato con l'infrastruttura di sicurezza esistente. Il sistema supporta diverse modalità e offre flessibilità di personalizzazione, consentendoti di migliorare la tua configurazione esistente con funzionalità avanzate di rilevamento degli oggetti. Per istruzioni dettagliate sull'integrazione di YOLOv8 nei tuoi progetti, visita la sezione dedicata all'integrazione.

Quali sono i requisiti di archiviazione per l'esecuzione di Ultralytics YOLOv8 ?

L'esecuzione di Ultralytics YOLOv8 su una configurazione standard richiede in genere circa 5GB di spazio libero su disco. Questo include lo spazio per memorizzare il modello YOLOv8 e tutte le dipendenze aggiuntive. Per le soluzioni basate sul cloud, Ultralytics HUB offre una gestione efficiente dei progetti e dei set di dati, che può ottimizzare le esigenze di archiviazione. Per saperne di più sul piano Pro, che offre funzioni avanzate, tra cui uno spazio di archiviazione più ampio.

Cosa rende Ultralytics YOLOv8 diverso da altri modelli di rilevamento degli oggetti come Faster R-CNN o SSD?

Ultralytics YOLOv8 offre un vantaggio rispetto a modelli come Faster R-CNN o SSD grazie alle sue capacità di rilevamento in tempo reale e alla sua maggiore precisione. La sua architettura unica gli permette di elaborare le immagini molto più velocemente senza compromettere la precisione, rendendolo ideale per applicazioni sensibili al tempo come i sistemi di allarme di sicurezza. Per un confronto completo dei modelli di rilevamento degli oggetti, puoi consultare la nostra guida.

Come posso ridurre la frequenza dei falsi positivi nel mio sistema di sicurezza utilizzando Ultralytics YOLOv8 ?

Per ridurre i falsi positivi, assicurati che il tuo modello Ultralytics YOLOv8 sia adeguatamente addestrato con un set di dati diversificato e ben annotato. La messa a punto degli iperparametri e l'aggiornamento regolare del modello con nuovi dati possono migliorare significativamente l'accuratezza del rilevamento. Le tecniche dettagliate di regolazione degli iperparametri sono disponibili nella nostra guida alla regolazione degli iperparametri.

Commenti