administrator/frigate
1
0
Fork 0
mirror of https://github.com/blakeblackshear/frigate.git synced 2026-08-06 19:07:20 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Implement enchrichments events per second graph (#17436)

Browse Source 
* Cleanup existing naming

* Add face recognitions per second

* Add lpr fps

* Add all eps

* Clean up line graph

* Translations

* Change wording

* Fix incorrect access

* Don't require plates

* Add comment

* Fix
This commit is contained in:
Nicolas Mowen
2025-03-28 18:13:35 -05:00
committed by GitHub
parent b14abffea3
commit 9e8b85a957
11 changed files with 233 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files
frigate/data_processing/common/license_plate/mixin.py
+15 -6
View File
@@ -24,6 +24,7 @@ from frigate.comms.event_metadata_updater import (
from frigate.config.camera.camera import CameraTypeEnum
from frigate.const import CLIPS_DIR
from frigate.embeddings.onnx.lpr_embedding import LPR_EMBEDDING_SIZE
from frigate.util.builtin import EventsPerSecond
from frigate.util.image import area
logger = logging.getLogger(__name__)
@@ -34,11 +35,12 @@ WRITE_DEBUG_IMAGES = False
class LicensePlateProcessingMixin:
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.plates_rec_second = EventsPerSecond()
self.plates_rec_second.start()
self.plates_det_second = EventsPerSecond()
self.plates_det_second.start()
self.event_metadata_publisher = EventMetadataPublisher()
self.ctc_decoder = CTCDecoder()
self.batch_size = 6
# Detection specific parameters
@@ -947,15 +949,17 @@ class LicensePlateProcessingMixin:
"""
Update inference metrics.
"""
self.metrics.yolov9_lpr_fps.value = (
self.metrics.yolov9_lpr_fps.value * 9 + duration
self.metrics.yolov9_lpr_speed.value = (
self.metrics.yolov9_lpr_speed.value * 9 + duration
) / 10
def __update_lpr_metrics(self, duration: float) -> None:
"""
Update inference metrics.
"""
self.metrics.alpr_pps.value = (self.metrics.alpr_pps.value * 9 + duration) / 10
self.metrics.alpr_speed.value = (
self.metrics.alpr_speed.value * 9 + duration
) / 10
def _generate_plate_event(self, camera: str, plate: str, plate_score: float) -> str:
"""Generate a unique ID for a plate event based on camera and text."""
@@ -982,6 +986,8 @@ class LicensePlateProcessingMixin:
self, obj_data: dict[str, any], frame: np.ndarray, dedicated_lpr: bool = False
):
"""Look for license plates in image."""
self.metrics.alpr_pps.value = self.plates_rec_second.eps()
self.metrics.yolov9_lpr_pps.value = self.plates_det_second.eps()
camera = obj_data if dedicated_lpr else obj_data["camera"]
current_time = int(datetime.datetime.now().timestamp())
@@ -1011,6 +1017,7 @@ class LicensePlateProcessingMixin:
logger.debug(
f"{camera}: YOLOv9 LPD inference time: {(datetime.datetime.now().timestamp() - yolov9_start) * 1000:.2f} ms"
)
self.plates_det_second.update()
self.__update_yolov9_metrics(
datetime.datetime.now().timestamp() - yolov9_start
)
@@ -1093,6 +1100,7 @@ class LicensePlateProcessingMixin:
logger.debug(
f"{camera}: YOLOv9 LPD inference time: {(datetime.datetime.now().timestamp() - yolov9_start) * 1000:.2f} ms"
)
self.plates_det_second.update()
self.__update_yolov9_metrics(
datetime.datetime.now().timestamp() - yolov9_start
)
@@ -1197,6 +1205,7 @@ class LicensePlateProcessingMixin:
license_plates, confidences, areas = self._process_license_plate(
camera, id, license_plate_frame
)
self.plates_rec_second.update()
self.__update_lpr_metrics(datetime.datetime.now().timestamp() - start)
if license_plates:
frigate/data_processing/real_time/face.py
+8 -2
View File
@@ -24,6 +24,7 @@ from frigate.data_processing.common.face.model import (
FaceNetRecognizer,
FaceRecognizer,
)
from frigate.util.builtin import EventsPerSecond
from frigate.util.image import area
from ..types import DataProcessorMetrics
@@ -51,6 +52,7 @@ class FaceRealTimeProcessor(RealTimeProcessorApi):
self.requires_face_detection = "face" not in self.config.objects.all_objects
self.person_face_history: dict[str, list[tuple[str, float, int]]] = {}
self.recognizer: FaceRecognizer | None = None
self.faces_per_second = EventsPerSecond()
download_path = os.path.join(MODEL_CACHE_DIR, "facedet")
self.model_files = {
@@ -103,6 +105,7 @@ class FaceRealTimeProcessor(RealTimeProcessorApi):
score_threshold=0.5,
nms_threshold=0.3,
)
self.faces_per_second.start()
def __detect_face(
self, input: np.ndarray, threshold: float
@@ -146,12 +149,15 @@ class FaceRealTimeProcessor(RealTimeProcessorApi):
return face
def __update_metrics(self, duration: float) -> None:
self.metrics.face_rec_fps.value = (
self.metrics.face_rec_fps.value * 9 + duration
self.faces_per_second.update()
self.metrics.face_rec_speed.value = (
self.metrics.face_rec_speed.value * 9 + duration
) / 10
def process_frame(self, obj_data: dict[str, any], frame: np.ndarray):
"""Look for faces in image."""
self.metrics.face_rec_fps.value = self.faces_per_second.eps()
if not self.config.cameras[obj_data["camera"]].face_recognition.enabled:
return
frigate/data_processing/types.py
+16 -8
View File
@@ -6,18 +6,26 @@ from multiprocessing.sharedctypes import Synchronized
class DataProcessorMetrics:
image_embeddings_fps: Synchronized
text_embeddings_sps: Synchronized
image_embeddings_speed: Synchronized
text_embeddings_speed: Synchronized
face_rec_speed: Synchronized
face_rec_fps: Synchronized
alpr_speed: Synchronized
alpr_pps: Synchronized
yolov9_lpr_fps: Synchronized
yolov9_lpr_speed: Synchronized
yolov9_lpr_pps: Synchronized
def __init__(self):
self.image_embeddings_fps = mp.Value("d", 0.01)
self.text_embeddings_sps = mp.Value("d", 0.01)
self.face_rec_fps = mp.Value("d", 0.01)
self.alpr_pps = mp.Value("d", 0.01)
self.yolov9_lpr_fps = mp.Value("d", 0.01)
self.image_embeddings_speed = mp.Value("d", 0.01)
self.image_embeddings_eps = mp.Value("d", 0.0)
self.text_embeddings_speed = mp.Value("d", 0.01)
self.text_embeddings_eps = mp.Value("d", 0.0)
self.face_rec_speed = mp.Value("d", 0.01)
self.face_rec_fps = mp.Value("d", 0.0)
self.alpr_speed = mp.Value("d", 0.01)
self.alpr_pps = mp.Value("d", 0.0)
self.yolov9_lpr_speed = mp.Value("d", 0.01)
self.yolov9_lpr_pps = mp.Value("d", 0.0)
class DataProcessorModelRunner:
frigate/embeddings/embeddings.py
+22 -9
View File
@@ -21,7 +21,7 @@ from frigate.data_processing.types import DataProcessorMetrics
from frigate.db.sqlitevecq import SqliteVecQueueDatabase
from frigate.models import Event
from frigate.types import ModelStatusTypesEnum
from frigate.util.builtin import serialize
from frigate.util.builtin import EventsPerSecond, serialize
from frigate.util.path import get_event_thumbnail_bytes
from .onnx.jina_v1_embedding import JinaV1ImageEmbedding, JinaV1TextEmbedding
@@ -75,6 +75,11 @@ class Embeddings:
self.metrics = metrics
self.requestor = InterProcessRequestor()
self.image_eps = EventsPerSecond()
self.image_eps.start()
self.text_eps = EventsPerSecond()
self.text_eps.start()
self.reindex_lock = threading.Lock()
self.reindex_thread = None
self.reindex_running = False
@@ -120,6 +125,10 @@ class Embeddings:
device="GPU" if config.semantic_search.model_size == "large" else "CPU",
)
def update_stats(self) -> None:
self.metrics.image_embeddings_eps = self.image_eps.eps()
self.metrics.text_embeddings_eps = self.text_eps.eps()
def get_model_definitions(self):
# Version-specific models
if self.config.semantic_search.model == SemanticSearchModelEnum.jinav2:
@@ -175,9 +184,10 @@ class Embeddings:
)
duration = datetime.datetime.now().timestamp() - start
self.metrics.image_embeddings_fps.value = (
self.metrics.image_embeddings_fps.value * 9 + duration
self.metrics.image_embeddings_speed.value = (
self.metrics.image_embeddings_speed.value * 9 + duration
) / 10
self.image_eps.update()
return embedding
@@ -199,6 +209,7 @@ class Embeddings:
for i in range(len(ids)):
items.append(ids[i])
items.append(serialize(embeddings[i]))
self.image_eps.update()
self.db.execute_sql(
"""
@@ -209,8 +220,8 @@ class Embeddings:
)
duration = datetime.datetime.now().timestamp() - start
self.metrics.text_embeddings_sps.value = (
self.metrics.text_embeddings_sps.value * 9 + (duration / len(ids))
self.metrics.text_embeddings_speed.value = (
self.metrics.text_embeddings_speed.value * 9 + (duration / len(ids))
) / 10
return embeddings
@@ -231,9 +242,10 @@ class Embeddings:
)
duration = datetime.datetime.now().timestamp() - start
self.metrics.text_embeddings_sps.value = (
self.metrics.text_embeddings_sps.value * 9 + duration
self.metrics.text_embeddings_speed.value = (
self.metrics.text_embeddings_speed.value * 9 + duration
) / 10
self.text_eps.update()
return embedding
@@ -254,6 +266,7 @@ class Embeddings:
for i in range(len(ids)):
items.append(ids[i])
items.append(serialize(embeddings[i]))
self.text_eps.update()
self.db.execute_sql(
"""
@@ -264,8 +277,8 @@ class Embeddings:
)
duration = datetime.datetime.now().timestamp() - start
self.metrics.text_embeddings_sps.value = (
self.metrics.text_embeddings_sps.value * 9 + (duration / len(ids))
self.metrics.text_embeddings_speed.value = (
self.metrics.text_embeddings_speed.value * 9 + (duration / len(ids))
) / 10
return embeddings
frigate/embeddings/maintainer.py
+1
View File
@@ -236,6 +236,7 @@ class EmbeddingMaintainer(threading.Thread):
return
camera_config = self.config.cameras[camera]
self.embeddings.update_stats()
# no need to process updated objects if face recognition, lpr, genai are disabled
if not camera_config.genai.enabled and len(self.realtime_processors) == 0:
frigate/stats/util.py
+21 -6
View File
@@ -293,27 +293,42 @@ def stats_snapshot(
stats["embeddings"].update(
{
"image_embedding_speed": round(
embeddings_metrics.image_embeddings_fps.value * 1000, 2
embeddings_metrics.image_embeddings_speed.value * 1000, 2
),
"image_embedding": round(
embeddings_metrics.image_embeddings_eps.value, 2
),
"text_embedding_speed": round(
embeddings_metrics.text_embeddings_sps.value * 1000, 2
embeddings_metrics.text_embeddings_speed.value * 1000, 2
),
"text_embedding": round(
embeddings_metrics.text_embeddings_eps.value, 2
),
}
)
if config.face_recognition.enabled:
stats["embeddings"]["face_recognition_speed"] = round(
embeddings_metrics.face_rec_fps.value * 1000, 2
embeddings_metrics.face_rec_speed.value * 1000, 2
)
stats["embeddings"]["face_recognition"] = round(
embeddings_metrics.face_rec_fps.value, 2
)
if config.lpr.enabled:
stats["embeddings"]["plate_recognition_speed"] = round(
embeddings_metrics.alpr_pps.value * 1000, 2
embeddings_metrics.alpr_speed.value * 1000, 2
)
stats["embeddings"]["plate_recognition"] = round(
embeddings_metrics.alpr_pps.value, 2
)
if "license_plate" not in config.objects.all_objects:
if embeddings_metrics.yolov9_lpr_pps.value > 0.0:
stats["embeddings"]["yolov9_plate_detection_speed"] = round(
embeddings_metrics.yolov9_lpr_fps.value * 1000, 2
embeddings_metrics.yolov9_lpr_speed.value * 1000, 2
)
stats["embeddings"]["yolov9_plate_detection"] = round(
embeddings_metrics.yolov9_lpr_pps.value, 2
)
get_processing_stats(config, stats, hwaccel_errors)