Eine kurze Einführung in den SORT-Tracking-Algorithmus und sein Python-Implementierungsbeispiel

SORT (Simple Online and Realtime Tracking) ist ein auf dem Kalman-Filter basierender Zielverfolgungsalgorithmus, der sich bewegende Ziele in Echtzeitszenen zuverlässig verfolgen kann. Der SORT-Algorithmus wurde ursprünglich 2016 von Alex Bewley und anderen vorgeschlagen. Er wird häufig in verschiedenen Anwendungen im Bereich Computer Vision eingesetzt, wie z. B. Videoüberwachung, autonomes Fahren, Roboternavigation usw. Der

SORT-Algorithmus basiert hauptsächlich auf zwei Kernideen: der Kalman-Filterung und dem ungarischen Algorithmus. Der Kalman-Filter ist ein Algorithmus zur Schätzung des Systemzustands. Er kann das dynamische Modell des Systems und Sensormessungen verwenden, um den Systemzustand vorherzusagen und zu aktualisieren und so die Genauigkeit der Zustandsschätzung zu verbessern. Der ungarische Algorithmus ist ein Algorithmus zur Lösung des Problems der maximalen Gewichtsanpassung bei zweiteiligen Diagrammen. Er kann die maximale Gewichtsanpassung bei gegebenen zweiteiligen Diagrammen ermitteln.

Die Hauptschritte des SORT-Algorithmus sind wie folgt:

Zielerkennung: Verwenden Sie Zielerkennungsalgorithmen (wie YOLO, SSD usw.), um Zielinformationen im aktuellen Frame zu extrahieren.

Zustandsvorhersage: Verwenden Sie für jedes verfolgte Ziel den Kalman-Filter, um seinen Zustand vorherzusagen.

Datenzuordnung: Basierend auf dem Vorhersagestatus und den Zielinformationen im aktuellen Frame verwenden Sie den ungarischen Algorithmus, um eine Datenzuordnung durchzuführen und das Ziel zu finden, das jedem verfolgten Ziel im aktuellen Frame entspricht.

Statusaktualisierung: Verwenden Sie für jedes verfolgte Ziel den Kalman-Filter, um seinen Status zu aktualisieren.

Zielausgabe: Geben Sie die Statusinformationen und Tracking-Ergebnisse jedes verfolgten Ziels aus.

In der Computer Vision kann der SORT-Algorithmus auf verschiedene Zielverfolgungsszenarien angewendet werden. Bei der Videoüberwachung kann der SORT-Algorithmus beispielsweise sich bewegende Ziele in Echtzeit verfolgen und so ungewöhnliches Verhalten am Tatort erkennen und frühzeitig warnen. Im Bereich des autonomen Fahrens kann der SORT-Algorithmus andere Fahrzeuge, Fußgänger und andere Verkehrsteilnehmer verfolgen, um eine autonome Navigation und Hindernisvermeidung von Fahrzeugen zu erreichen. Bei der Roboternavigation kann der SORT-Algorithmus sich bewegende Ziele verfolgen, um eine autonome Navigation und Hindernisvermeidung des Roboters zu erreichen.

Das Folgende ist ein einfacher Beispielcode, der in Python implementiert ist:

#python
import numpy as np
from filterpy.kalman import KalmanFilter
from scipy.optimize import linear_sum_assignment

class Track:

def init(self,prediction,track_id,track_lifetime):
    self.prediction=np.atleast_2d(prediction)
    self.track_id=track_id
    self.track_lifetime=track_lifetime
    self.age=0
    self.total_visible_count=1
    self.consecutive_invisible_count=0

def predict(self, kf):
    self.prediction = kf.predict()
    self.age += 1

def update(self, detection, kf):
    self.prediction = kf.update(detection)
    self.total_visible_count += 1
    self.consecutive_invisible_count = 0

def mark_missed(self):
    self.consecutive_invisible_count += 1

def is_dead(self):
    return self.consecutive_invisible_count >= self.track_lifetime

class Tracker:

def init(self,track_lifetime,detection_variance,process_variance):
    self.next_track_id=0
    self.tracks=[]
    self.track_lifetime=track_lifetime
    self.detection_variance=detection_variance
    self.process_variance=process_variance
    self.kf=KalmanFilter(dim_x=4,dim_z=2)
    self.kf.F=np.array([[1,0,1,0],
                    [0,1,0,1],
                    [0,0,1,0],
                    [0,0,0,1]])
    self.kf.H=np.array([[1,0,0,0],
                    [0,1,0,0]])
    self.kf.R=np.array([[self.detection_variance,0],
                    [0,self.detection_variance]])
    self.kf.Q=np.array([[self.process_variance,0,0,0],
                    [0,self.process_variance,0,0],
                    [0,0,self.process_variance,0],
                    [0,0,0,self.process_variance]])

def update(self, detections):
    # predict track positions using Kalman filter
    for track in self.tracks:
        track.predict(self.kf)

    # associate detections with tracks using Hungarian algorithm
    if len(detections) > 0:
        num_tracks = len(self.tracks)
        num_detections = len(detections)
        cost_matrix = np.zeros((num_tracks, num_detections))
        for i, track in enumerate(self.tracks):
            for j, detection in enumerate(detections):
                diff = track.prediction - detection
                distance = np.sqrt(diff[0,0]**2 + diff[0,1]**2)
                cost_matrix[i,j] = distance
        row_indices, col_indices = linear_sum_assignment(cost_matrix)
        unassigned_tracks = set(range(num_tracks)) - set(row_indices)
        unassigned_detections = set(range(num_detections)) - set(col_indices)
        for i, j in zip(row_indices, col_indices):
            self.tracks[i].update(detections[j], self.kf)
        for i in unassigned_tracks:
            self.tracks[i].mark_missed()
        for j in unassigned_detections:
            new_track = Track(detections[j], self.next_track_id, self.track_lifetime)
            self.tracks.append(new_track)
            self.next_track_id += 1

    # remove dead tracks
    self.tracks = [track for track in self.tracks if not track.is_dead()]

    # return list of track positions
    return [track.prediction.tolist()[0] for track in self.tracks]

Der obige Code implementiert einen einfachen SORT-Tracking-Algorithmus, der den Kalman-Filter verwendet, um die Zielposition und -geschwindigkeit vorherzusagen und zu schätzen, und dann den ungarischen Algorithmus zur Ausführung verwendet Verfolgung des Ziels und schließlich Bestimmung, ob das Ziel tot ist, basierend auf der Anzahl der aufeinanderfolgenden Unsichtbarkeiten des Ziels, und Entfernung des toten Ziels. Der obige Code implementiert einen einfachen SORT-Verfolgungsalgorithmus, der den Kalman-Filter verwendet, um die Position und Geschwindigkeit des Ziels vorherzusagen und zu schätzen, dann den ungarischen Algorithmus zum Zuordnen des Ziels zu verwenden und schließlich zu beurteilen, ob das Ziel tot ist, und den Tod anhand der Zahl zu entfernen von aufeinanderfolgenden unsichtbaren Zeiten des Ziels.

Neben dem SORT-Algorithmus gibt es viele weitere Zielverfolgungsalgorithmen, wie z. B. Kalman-Filter, Partikelfilter, Multizielverfolgung usw. Jeder Algorithmus hat seine anwendbaren Szenarien, Vor- und Nachteile. In praktischen Anwendungen ist es notwendig, basierend auf spezifischen Szenarien und Anforderungen einen geeigneten Algorithmus zur Zielverfolgung auszuwählen.

Das obige ist der detaillierte Inhalt vonEine kurze Einführung in den SORT-Tracking-Algorithmus und sein Python-Implementierungsbeispiel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!