Projeto de sistema de alarme de segurança utilizando Ultralytics YOLO11
O projeto de sistema de alarme de segurança que utiliza o Ultralytics YOLO11 integra capacidades avançadas de visão por computador para melhorar as medidas de segurança. YOLO11 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 YOLO11 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: YOLO11 é 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.
Ver: Projeto de sistema de alarme de segurança com Ultralytics YOLO11 Deteção de objectos
Código
Configurar os parâmetros da mensagem
Nota
É necessário gerar a palavra-passe da aplicação
- Navegue até ao Gerador de palavras-passe da aplicação, designe um nome de aplicação, como "projeto de segurança", e obtenha uma palavra-passe de 16 dígitos. Copie esta palavra-passe e cole-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 correio eletrónico
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 emissor 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("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()
Chamar a classe de deteção de objectos e executar a inferência
É isso mesmo! Quando executar o código, receberá uma única notificação no seu e-mail se for detectado algum objeto. A notificação é enviada imediatamente, não repetidamente. No entanto, sinta-se à vontade para personalizar o código de acordo com os requisitos do seu projeto.
Amostra de correio eletrónico recebido
FAQ
Como é que o Ultralytics YOLO11 melhora a precisão de um sistema de alarme de segurança?
Ultralytics YOLO11 melhora os sistemas de alarme de segurança, fornecendo uma deteção de objectos de elevada 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 YOLO11 na minha infraestrutura de segurança existente?
Sim, o Ultralytics YOLO11 pode ser perfeitamente integrado na sua infraestrutura de segurança existente. O sistema suporta vários modos e oferece flexibilidade para personalização, permitindo-lhe melhorar a sua configuração existente com capacidades avançadas de deteção de objectos. Para obter instruções detalhadas sobre a integração do YOLO11 nos seus projectos, visite a secção de integração.
Quais são os requisitos de armazenamento para executar Ultralytics YOLO11 ?
A execução de Ultralytics YOLO11 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 YOLO11 e quaisquer dependências adicionais. Para soluções baseadas na nuvem, o Ultralytics HUB oferece gestão eficiente de projectos e manuseamento 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 YOLO11 diferente de outros modelos de deteção de objectos como o Faster R-CNN ou o SSD?
Ultralytics YOLO11 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, pode explorar o nosso guia.
Como posso reduzir a frequência de falsos positivos no meu sistema de segurança utilizando Ultralytics YOLO11 ?
Para reduzir os falsos positivos, certifique-se de que o seu modelo Ultralytics YOLO11 é 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. As técnicas detalhadas de afinação de hiperparâmetros podem ser encontradas no nosso guia de afinação de hiperparâmetros.
