Frigate ist ein Open-Source Network Video Recorder (NVR) mit KI-gestützter Objekterkennung. Anders als klassische Überwachungssysteme nutzt Frigate moderne Machine-Learning-Modelle wie YOLOv9, um Personen, Fahrzeuge und andere Objekte in Echtzeit zu erkennen. Mit einem KI-Beschleuniger wie einer handelsüblichen GPU läuft die Objekterkennung besonders performant.
In diesem Artikel zeige ich, wie ich Frigate auf einem Ubuntu-System mit NVIDIA-GPU eingerichtet habe.
Zuerst prüfen wir, welche Treiber für deine GPU verfügbar sind:
1
sudo ubuntu-drivers devices
Standardmäßig wird der offene Nouveau Treiber genutzt. Wir benötigen aber den propritären Treiber von Nvidia.
Installiere den empfohlenen Treiber automatisch:
1
sudo ubuntu-drivers autoinstall
Nach der Installation kannst du das nvidia-smi Komamndo nutzen. Es sollte dir deine GPU anzeigen und den Status deiner Grafikkarte (Temperatur, Leistungsaufnahme, GPU-Prozesse, etc)
Frigate wird in einem Docker Container ausgeführt. Damit Docker die GPU nutzen kann und sie dem Container zur Verfügung stellen kann, benötigen wir das Nvidia Container Toolkit.
Erstelle die benötigten Verzeichnisse für Frigate:
1
2
3
4
5
6
7
8
9
10
11
# Hier packe ich die docker-compose.yml rein.sudo mkdir -p /mnt/data/frigate
# Hier wird das Konfigurationsverzeichnis von Frigate in den Container gemappt.sudo mkdir -p /mnt/data/frigate/config
# Hier werden Objekterkennungs-Modelle abgelegt. Beispielsweise YoloV9.sudo mkdir -p /mnt/data/frigate/config/model_cache
# Hier werden Videodaten und Snapshots abgespeichert. Hier sollte viel Speicherplatz verfügbar sein.sudo mkdir -p /mnt/cctv/frigate-storage
Tip
Tipp: Verwende für /mnt/cctv/frigate-storage idealerweise eine separate Festplatte, um die System-SSD zu schonen.
Erstelle die Docker Compose-Datei für Frigate. Ich nutze das Image ghcr.io/blakeblackshear/frigate:0.17.0-beta1-tensorrt. Achte auf das -tensorrt Suffix, denn dieses Image unterstützt die Nvidia GPU.
Ob eine neuere Version von Frigate existiert, kannst du hier nachsehen. Passe entsprechend die Version im Image-Tag an.
sudo tee /mnt/data/frigate/docker-compose.yml << 'EOF'
services:
frigate:
container_name: frigate
image: ghcr.io/blakeblackshear/frigate:0.17.0-beta1-tensorrt
restart: unless-stopped
stop_grace_period: 30s
# Wenn du sehr viele Kameras nutzt, musst du diesen Wert ggf. ein wenig höher stellen.
# In der Web-Oberfläche von Frigate siehst du, wie viel /dev/shm ausgelastet ist und
# kannst den Wert hier dann anpassen.
shm_size: "1024mb"
# Die GPU dem Container zur Verfügung stellen.
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: 1 # Oder 'all' für alle GPUs
capabilities: [gpu]
volumes:
- /etc/localtime:/etc/localtime:ro
- /mnt/data/frigate/config:/config
- /mnt/cctv/frigate-storage:/media/frigate
- type: tmpfs # Reduziert SSD-Verschleiß
target: /tmp/cache
tmpfs:
# 1 GB
size: 1000000000
ports:
- "8971:8971" # Hauptwebinterface
- "5000:5000" # Ungeschützte API- und Weboberfläche
- "8554:8554" # RTSP-Feeds
- "8555:8555/tcp" # WebRTC über TCP
- "8555:8555/udp" # WebRTC über UDP
environment:
FRIGATE_RTSP_PASSWORD: "DEIN_SICHERES_PASSWORT"
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
EOF
Du kannst jetzt schonmal den Container mit docker compose up -d starten. Wir müssen allerdings noch ein Objekterkennungsmodell laden und die Konfiguration erstellen.
Frigate benötigt ein KI-Modell für die Objekterkennung. Wir nutzen YOLOv9, das wir für unsere GPU optimieren. Nvidia GPUs arbeiten am besten mit einem Modell im ONNX Format. Beachte, dass nicht jedes Modell mit jedem Format kompatibel ist.
Wir können das YOLOv9 Modell mit Docker herunterladen und konvertieren:
t (tiny) - Sehr schnell, dafür aber etwas geringerere Genauigkeit
s (small) - Gute Balance für Echtzeit
m (medium) - Genaue Erkennung, dafür aber etwas langsamer
c, e - Sehr genau, aber zu langsam für Echtzeit
IMG_SIZE:
320 - Sehr schnell, gut um große Objekte zu erkennen
640 - Ausgewogen, gut um auch kleinere oder weiter entferntere Objekte erkennen zu können
1024/1280 - Erkennt noch kleinere Objekte, benötigt allerdings mehr Leistung
Info
Faustregel: Größere Modelle und Bildgrößen verbessern die Erkennungsgenauigkeit, erhöhen aber oft die Inferenzzeit. Also die Objekterkennungszeit.
Für Echtzeit-Überwachung ist m mit 640px das größte, was man sinnvollerweise einsetzen sollte. Wenn man viele oder sehr hochauflösende Kameras hat, muss man gegebenenfalls ein wenig balancieren und vielleicht ein kleineres Modell nutzen oder die Imagesize reduzieren.
Kopiere die generierten Modelle ins Frigate Konfigurationsverzeichnis:
Das OpenVino Format benötigen wir nicht wirklich. OpenVino funktioniert in der Regel besser, wenn man es ohne GPU, also nur auf der CPU ausführen möchte.
sudo tee /mnt/data/frigate/config/config.yaml << 'EOF'
# MQTT für Home Assistant Integration
mqtt:
enabled: true
host: 192.168.178.205
port: 1883
topic_prefix: frigate
client_id: frigate
user: frigate
password: DEIN_MQTT_PASSWORT
# GPU-Detektoren konfigurieren
# Ich nutze 3 parallele Detektoren, die alle auf der GPU laufen.
detectors:
onnx0:
type: onnx
device: GPU
onnx1:
type: onnx
device: GPU
onnx2:
type: onnx
device: GPU
# OpenVino kannst du wie folgt nutzen:
# type: openvino
# device: CPU
# YOLOv9-Modell konfigurieren
model:
model_type: yolo-generic
width: 640 # Muss mit IMG_SIZE übereinstimmen
height: 640
input_tensor: nchw
input_dtype: float
path: /config/model_cache/yolo.onnx
labelmap_path: /labelmap/coco-80.txt
# FFmpeg Hardware-Beschleunigung (für Video Dekodierung mit GPU)
ffmpeg:
retry_interval: 10
hwaccel_args: preset-nvidia
# Objekterkennung aktivieren
detect:
enabled: true
# wie oft pro Sekunde die Bilderkennung durchgeführt wird (häufigere Inteferenzen belasten GPU mehr)
fps: 10
# Zu trackende Objekte. Vorsicht: Nicht jedes Modell ist für alle Objekte trainiert.
# Hier sind die Klassen, die Yolo trainiert: https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml
objects:
track:
- person
- car
- bicycle
- motorcycle
- cat
- dog
# Komischer Videostream, der immer aktuelle Ereignisse von anderen Kameras darstellt.
# Siehe Frigate Doku, wenn du das nutzen möchtest: https://docs.frigate.video/configuration/birdseye
birdseye:
enabled: false
# Review-System für Ereignisse
review:
alerts:
enabled: true
labels:
- person
- car
- bicycle
- motorcycle
- cat
- dog
detections:
enabled: true
# Aufnahme-Einstellungen
record:
enabled: true
# Anzahl der Minuten zwischen Aufräum-Intervallen.
expire_interval: 5
retain:
days: 3
mode: all
alerts:
pre_capture: 10
post_capture: 10
retain:
# Alle Alarme für 30 Tage aufzeichnen
days: 30
mode: all
detections:
pre_capture: 10
post_capture: 10
retain:
# Alle erkannten Objekte für 30 Tage aufzeichnen
days: 30
mode: all
# Neu in Frigate 17?
continuous:
days: 30
motion:
days: 30
# Mit go2rtc kannst du Videostreams in rtsp Streams rekodieren. Frigate kann nur rtsp Streams verarbeiten.
# Die meisten Kameras stellen bereits einen rtsp Stream bereit, manchmal aber auch nur mjpg. In dem Fall
# Kannst du ein rtsp Stream aus dem mjpg Stream erzeugen:
go2rtc:
streams:
# erzeuge den rtsp Stream: rtsp://127.0.0.1:8554/achim-carport-alt
achim-carport-alt:
ffmpeg:http://user:pass@192.168.0.23/mjpg/video.mjpg#video=h264#hardware
# Kameras konfigurieren
cameras:
oyten-eingang:
enabled: true
ffmpeg:
inputs:
- path: rtsp://user:pass@192.168.178.233:88/videoMain
roles:
- detect
- record
oyten-treppe:
enabled: true
ffmpeg:
inputs:
- path: rtsp://user:pass@192.168.178.230:88/videoMain
roles:
- detect
- record
oyten-remise:
enabled: true
ffmpeg:
inputs:
- path: rtsp://user:pass@192.168.178.231:88/videoMain
roles:
- detect
- record
oyten-parkplatz:
enabled: true
ffmpeg:
inputs:
- path: rtsp://user:pass@192.168.178.237:88/videoMain
roles:
- detect
- record
achim-haupteingang:
enabled: true
ffmpeg:
inputs:
- path: rtsp://user:pass@192.168.0.21:88/videoMain
roles:
- detect
- record
# Kamerastream, der zuvor mit go2rtc konvertiert wurde
achim-carport:
enabled: true
ffmpeg:
inputs:
- path: rtsp://127.0.0.1:8554/achim-carport-alt
roles:
- detect
- record
# Hühnerkamera Stream wird in separatem Docker-Container erstellt.
# Hier braucht auch keine Objektinferenz stattfinden.
chickens:
enabled: true
ffmpeg:
inputs:
- path: rtsp://chickencam:8554/live
roles: []
# Kamera Oyten-Halle ist derzeit deaktiviert:
oyten-halle:
enabled: false
ffmpeg:
inputs:
- path: rtsp://user:pass@192.168.178.154:88/videoMain
roles:
- detect
# TLS (HTTPS) Deaktivieren
tls:
enabled: false
# Für welche Frigate Version wurde die Konfiguration erstellt?
version: 0.17-0
EOF
Tip
Kamera hinzufügen: Passe den cameras-Bereich an deine eigenen Kameras an. Du kannst beliebig viele Kameras hinzufügen, indem du den Block kopierst und anpasst.
Seit Frigate 17 kann man Kameras auch direkt in der Weboberfläche hinzufügen. In dem Fall braucht man hier
in der Konfigurationsdatei die gar nicht hinzufügen.
Detektoren skalieren: Erhöhe die Anzahl der Detektoren (onnx0, onnx1, …), wenn du viele Kameras hast
Optimiere Bewegungserkennung: Frigate lässt die Objekterkennung immer nur dann laufen, wenn Bewegung erkannt wird. Daher ist eine funktionierende Bewegungserfassung wichtig. Passe Bewegungsschwellwerte in der Oberfläche an.
Zones nutzen: Definiere Zonen in Kameras, um nur relevante Bereiche zu überwachen. Nutze insbesondere Bewegungsmasken um sich im Wind bewegende Bäume/Büsche auszumaskieren. Nutze Objektmasken um Objekte auszumaskieren, die dich nicht interessieren, beispielsweise Fahrzeuge auf öffentlichen Straßen.
Detect FPS reduzieren: Reduziere detect.fps: 5, wenn du viele Kameras hast, auf denen gleichzeitig Bewegung erkannt wird und daher die GPU (oder CPU) zu stark belastet wird. Du kannst auch ein kleineres Modell ausprobieren.
Ungeschützter Port: Der Port 5000 ist ungeschützt. Richte einen Benutzer mit Passwort ein und nutze zukünftig den geschützten Port 8971. Vergiss nicht den Port 5000 aus der docker-compose.yml zu entfernen.
Mit Frigate und GPU-Beschleunigung hast du nun ein leistungsstarkes, KI-gestütztes Überwachungssystem. Die Objekterkennung läuft in Echtzeit und du kannst beliebig viele Kameras anbinden.
Die Integration mit Home Assistant über MQTT ermöglicht zudem smarte Automationen basierend auf erkannten Objekten.
