Hey there! 😊 It seems like Google's app password settings have indeed evolved, and I appreciate you reaching out for assistance on this. While the current documentation may reference older interfaces, the essence of setting up app passwords for projects like the Security Alarm System with Ultralytics YOLOv8 remains relevant.

If you're experiencing difficulties locating the specific options for app passwords on Google, you might consider looking into alternative email sending services that offer API support, such as SendGrid, Mailgun, or even using a local SMTP server setup, depending on your project's complexity and scale.

For a quick fix using smtplib with Gmail, ensure you've enabled two-factor authentication on your account, and then create an app password here: https://myaccount.google.com/apppasswords.

Here's a simplified version of how to use an app password:

import smtplib

EMAIL = "your_email@gmail.com"
APP_PASSWORD = "your_app_password"

with smtplib.SMTP("smtp.gmail.com", 587) as smtp:
    smtp.starttls()
    smtp.login(EMAIL, APP_PASSWORD)
    subject = "Security Alert"
    body = "Alert description"
    msg = f"Subject: {subject}\n\n{body}"
    smtp.sendmail(EMAIL, "receiver_email@gmail.com", msg)

Make sure to replace "your_email@gmail.com" and "your_app_password" with your actual Gmail email and the 16-digit app password you generate, respectively.

It's recommended to review the current Gmail documentation or seek updated guidance if Google's procedures have significantly changed since our last update. Hope this helps! If you have further questions or need more personalized assistance, feel free to ask.

thanks for replying, i fix it for the yolov8 as the same steps u explained, now i want to use it on yolov9 but i cant with these steps, because i am using the detect.py and i dont know how to deal with it , where to put each code, i dont have that much background in DL and python codes. the email part is working now

@e9l7a5f you can use YOLOv9 models the same way as you currently use YOLOv8 models; see https://docs.ultralytics.com/models/yolov9. For new projects we recommend YOLO26: https://docs.ultralytics.com/models/yolo26/.

@aaurelions Hi, thanks for sharing it. You will need to configure the parameters first by following the docs: https://docs.ultralytics.com/guides/security-alarm-system/

@Cheikh-Ahmedand thank you for your support! For Streamlit integration, you can collect user inputs like this:

import cv2
import streamlit as st
from ultralytics import solutions

# User inputs
from_email = st.text_input("Sender Email")
password = st.text_input("App Password", type="password")
to_email = st.text_input("Receiver Email")
capture_source = st.text_input("Camera Index/Video Path", "0")

# Initialize SecurityAlarm with user inputs
security = solutions.SecurityAlarm(show=True, model="yolo26n.pt", records=1)
security.authenticate(from_email, password, to_email)
cap = cv2.VideoCapture(int(capture_source) if capture_source.isdigit() else capture_source)

The SecurityAlarm implementation details remain as shown in our security alarm system guide. For email setup, ensure users follow the App Password Generator instructions.

Hello there, glenn-jocher!

Thanks for your nice Help!

I would like st.input_text for end users for from_emails /to_email and detector = ObjectDetection(capture_index=0) in the below code, not for the code you gave an example on:

Securiy Alarm System

password = " " from_email = "@gmail.com" # must match the email used to generate the password to_email = "@gmail.com" # receiver email

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

from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText from email.mime.image import MIMEImage

def send_email(to_email, from_email, image_path, object_detected=1): """Sends an email with an image attachment.""" message = MIMEMultipart() message["From"] = from_email message["To"] = to_email message["Subject"] = "Security Alert" message_body = f"ALERT - {object_detected} objects have been detected!" message.attach(MIMEText(message_body, "plain")) with open(image_path, 'rb') as img_file: img = MIMEImage(img_file.read()) message.attach(img) server.sendmail(from_email, to_email, message.as_string())

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, classes=[0])
    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:
           image_path = f"detected_frame_{frame_count}.jpg"
           cv2.imwrite(image_path, im0)
           if not self.email_sent:
            send_email(to_email, from_email, image_path, 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()

detector = ObjectDetection(capture_index=0) detector()

would you please give an example of st. input_text for end users letting them write their emails and capture_index on the above code?

Sincerely Yours!

Thank you for your question! For Streamlit integration with user inputs in your security system, here's how to modify your code:

import streamlit as st

# User inputs
from_email = st.text_input("Sender Email")
to_email = st.text_input("Receiver Email")
password = st.text_input("App Password", type="password")
capture_index = st.text_input("Camera Index/Video Path", "0")

# Initialize detector with user inputs
detector = ObjectDetection(capture_index=int(capture_index) if capture_index.isdigit() else capture_index)

This allows users to specify their email credentials and camera source through Streamlit's interactive interface. The Security Alarm System guide shows how these inputs integrate with YOLO11's detection capabilities. For email setup requirements, please ensure users follow the App Password Generator instructions from our security alarm documentation.

Hey glenn-jocher!

As you know, ML models need frequent check so as their data remain undriffed and their distribution remain unchanged.

To frequently monitor deployed ml models by streamlit in case it is deployed to aws ec2, Google Cloud, or streamlit community cloud or in local server, what should I do ?

Please give an example!

Thanks!

@boukosho for monitoring deployed YOLO11 models across cloud platforms, consider implementing a heartbeat system with performance metrics logging. Our Security Alarm System guide shows email alert integration that could be adapted for drift detection notifications. For production deployments, Ultralytics Platform provides monitoring for deployed endpoints; see the Platform monitoring documentation. A minimal implementation might track inference statistics and trigger alerts via our solutions.SecurityAlarm class when thresholds are exceeded.

@Cheikh-Ahmedand to adjust the confidence threshold in your security alarm system, set the conf argument when initializing the solution. For example:

security = solutions.SecurityAlarm(model="yolo26n.pt", conf=0.5)  # only detections above 0.5 confidence

This ensures notifications only trigger for detections exceeding your specified confidence level. For more details, refer to the Security Alarm System guide.

hey!

Thanks glenn-jocher for your respectful response.

security = solutions.SecurityAlarm(model="yolo11n.pt", conf=0.5) # Set confidence threshold >0.3 security.model.conf = 0.5 # Alternative direct method

N.B, I would like to add conf=0.5 for the below function (self.model = YOLO("yolo11n.pt"), not for the above one

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"

How to do so with examples, please!

Sincerely Yours!

@Cheikh-Ahmedand in your own ObjectDetection class, pass conf when you run inference rather than when loading the model:

self.model = YOLO("yolo26n.pt")
results = self.model.predict(im0, conf=0.5)

For more details on model arguments, see the Predict mode documentation.

Hey glenn- jocher!

Thanks lots for your respectful response.

self.model = YOLO("yolo11n.pt", task="detect").set({"conf": 0.5})

When i run the above code, an error has been occured:

(AttributeError: 'DetectionModel' object has no attribute 'set')

What should i do instead? With examples, Please.

Best Regards!

To set the confidence threshold in your custom ObjectDetection class, modify your predict method like this:

def predict(self, im0):
    results = self.model.predict(im0, classes=[0], conf=0.5)  # Add conf here
    return results

The conf parameter should be passed during inference rather than model initialization. For more details on prediction arguments, see the Predict mode documentation.

To use your webcam or camera stream with OpenCV's VideoCapture, replace the file path with:

• 0 for default laptop camera (e.g., cap = cv2.VideoCapture(0))
• RTSP URL for network cameras (e.g., cap = cv2.VideoCapture("rtsp://username:password@camera_ip:port/stream"))

For DVR/NVR cameras, use your camera's RTSP stream URL. See OpenCV VideoCapture docs for more input formats.

@boukosho hi! We're happy to help with YOLO security alarm system questions. Our comprehensive Security Alarm System guide at https://docs.ultralytics.com/guides/security-alarm-system/ provides complete implementation code and documentation. For specific issues, feel free to open a GitHub Discussion with details about your implementation and we'll assist there. 😊

Hello there! What do you mean by the below function?

cap = cv2.VideoCapture("Path/to/video/file.mp4") assert cap.isOpened(), "Error reading video file"

Namely, I have a Webcam or the laptop camera or dvr/nvr cameras and I want to attach them to the above function. How to do so? With examples, please!! . Sincerely Yours!

To use your webcam, laptop camera, or DVR/NVR cameras with cv2.VideoCapture, modify the source argument:

1. Webcam/Laptop Camera:
   cap = cv2.VideoCapture(0) (0 for default camera, 1 for secondary, etc.)

2. IP/DVR/NVR Cameras:
   Use RTSP/HTTP stream URLs like:
   cap = cv2.VideoCapture("rtsp://username:password@camera_ip:port/stream")

The rest of the security alarm code remains unchanged. Ensure your camera feed is accessible and credentials are correctly formatted in URLs. For more details on video sources, see our Object Detection and Tracking guide.

For webcam/laptop camera use cap = cv2.VideoCapture(0) (0=default camera index). For IP cameras, use an RTSP URL like cap = cv2.VideoCapture("rtsp://username:password@camera_ip:port/path"). The assert checks if the video source opens successfully. You can find specific camera URL formats in your DVR/NVR documentation.

sorry I sovle that problem if I want to use my laptob cam what do I have to do?

@andrewjang2234 to use your laptop's camera, set the capture_index parameter in the ObjectDetection class to 0 (e.g., ObjectDetection(capture_index=0)). This should automatically access your default webcam. If issues persist, ensure your camera is not being used by another application.

@andrewjang2234 the to_email refers to the recipient's email address where the alert or notification will be sent. If you have further questions about this setup, feel free to ask!