Projeto de sistema de alarme de segurança utilizando Ultralytics YOLOv8

O projeto de sistema de alarme de segurança que utiliza Ultralytics YOLOv8 integra capacidades avançadas de visão por computador para melhorar as medidas de segurança. YOLOv8 O sistema de visão por computador, desenvolvido pela Ultralytics, permite a deteção de objectos em tempo real, permitindo que o sistema identifique e responda prontamente a potenciais ameaças à segurança. Este projeto oferece várias vantagens:

• Deteção em tempo real: a eficiência do YOLOv8 permite que o sistema de alarme de segurança detecte e responda a incidentes de segurança em tempo real, minimizando o tempo de resposta.
• Precisão: YOLOv8 é conhecido pela sua precisão na deteção de objectos, reduzindo os falsos positivos e aumentando a fiabilidade do sistema de alarme de segurança.
• Capacidades de integração: O projeto pode ser perfeitamente integrado na infraestrutura de segurança existente, proporcionando uma camada melhorada de vigilância inteligente.

Observa: Projeto de sistema de alarme de segurança com Ultralytics YOLOv8 Deteção de objectos

Código

Configura os parâmetros da mensagem

• Navega até ao Gerador de palavras-passe da aplicação, designa um nome de aplicação, como "projeto de segurança", e obtém uma palavra-passe de 16 dígitos. Copia esta palavra-passe e cola-a no campo de palavra-passe designado, conforme as instruções.

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

Criação e autenticação de servidores

import smtplib

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

Função de envio de 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())

Deteção de objectos e envio de alertas

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

Chama a classe Object Detection e executa a inferência

detector = ObjectDetection(capture_index=0)
detector()

E pronto! Quando executares o código, receberás uma única notificação no teu e-mail se for detectado algum objeto. A notificação é enviada imediatamente, não repetidamente. No entanto, estás à vontade para personalizar o código de acordo com os requisitos do teu projeto.

Exemplo de e-mail recebido

FAQ

Como é que o Ultralytics YOLOv8 melhora a precisão de um sistema de alarme de segurança?

Ultralytics YOLOv8 melhora os sistemas de alarme de segurança, fornecendo uma deteção de objectos de alta precisão e em tempo real. Os seus algoritmos avançados reduzem significativamente os falsos positivos, assegurando que o sistema apenas responde a ameaças genuínas. Esta maior fiabilidade pode ser perfeitamente integrada na infraestrutura de segurança existente, melhorando a qualidade geral da vigilância.

Posso integrar o Ultralytics YOLOv8 na minha infraestrutura de segurança existente?

Sim, o Ultralytics YOLOv8 pode ser perfeitamente integrado na tua infraestrutura de segurança existente. O sistema suporta vários modos e oferece flexibilidade para personalização, permitindo-te melhorar a tua configuração existente com capacidades avançadas de deteção de objectos. Para obter instruções detalhadas sobre a integração do YOLOv8 nos teus projectos, visita a secção de integração.

Quais são os requisitos de armazenamento para executar Ultralytics YOLOv8 ?

Executar Ultralytics YOLOv8 numa configuração padrão requer normalmente cerca de 5 GB de espaço livre em disco. Isso inclui espaço para armazenar o modelo YOLOv8 e quaisquer dependências adicionais. Para soluções baseadas na nuvem, o Ultralytics HUB oferece gerenciamento eficiente de projetos e manuseio de conjuntos de dados, o que pode otimizar as necessidades de armazenamento. Saiba mais sobre o Plano Pro para obter recursos aprimorados, incluindo armazenamento estendido.

O que torna o Ultralytics YOLOv8 diferente de outros modelos de deteção de objectos como o Faster R-CNN ou o SSD?

Ultralytics YOLOv8 oferece uma vantagem sobre modelos como o Faster R-CNN ou SSD com as suas capacidades de deteção em tempo real e maior precisão. A sua arquitetura única permite-lhe processar imagens muito mais rapidamente sem comprometer a precisão, tornando-o ideal para aplicações sensíveis ao tempo, como sistemas de alarme de segurança. Para uma comparação abrangente dos modelos de deteção de objectos, podes explorar o nosso guia.

Como posso reduzir a frequência de falsos positivos no meu sistema de segurança utilizando Ultralytics YOLOv8 ?

Para reduzir os falsos positivos, certifica-te de que o teu modelo Ultralytics YOLOv8 é adequadamente treinado com um conjunto de dados diversificado e bem anotado. O ajuste fino dos hiperparâmetros e a atualização regular do modelo com novos dados podem melhorar significativamente a precisão da deteção. Podes encontrar técnicas detalhadas de afinação de hiperparâmetros no nosso guia de afinação de hiperparâmetros.

Comentários