Pengenalan ringkas kepada algoritma penjejakan SORT dan contoh pelaksanaan Pythonnya

SORT (Penjejakan Dalam Talian Mudah dan Masa Nyata) ialah algoritma penjejakan sasaran berdasarkan penapis Kalman, yang boleh menjejaki sasaran bergerak dengan mantap dalam adegan masa nyata. Algoritma SORT pada asalnya dicadangkan oleh Alex Bewley dan lain-lain pada tahun 2016. Ia telah digunakan secara meluas dalam pelbagai aplikasi dalam bidang penglihatan komputer, seperti pengawasan video, pemanduan autonomi, navigasi robot, dll.

Algoritma SORT terutamanya berdasarkan dua idea teras: penapisan Kalman dan algoritma Hungary. Penapis Kalman ialah algoritma untuk menganggar keadaan sistem Ia boleh menggunakan model dinamik sistem dan ukuran sensor untuk meramal dan mengemas kini keadaan sistem, dengan itu meningkatkan ketepatan anggaran keadaan. Algoritma Hungary ialah algoritma yang digunakan untuk menyelesaikan masalah padanan berat maksimum dalam graf dwipartit Ia boleh mencari padanan berat maksimum diberikan graf dwipartit.

Langkah utama algoritma SORT adalah seperti berikut:

Pengesanan sasaran: Gunakan algoritma pengesanan sasaran (seperti YOLO, SSD, dll.) untuk mengekstrak maklumat sasaran dalam bingkai semasa.

Nyatakan ramalan: Untuk setiap sasaran yang dijejaki, gunakan penapis Kalman untuk meramalkan keadaannya.

Perkaitan data: Berdasarkan status ramalan dan maklumat sasaran dalam bingkai semasa, gunakan algoritma Hungary untuk melakukan perkaitan data untuk mencari sasaran yang sepadan dengan setiap sasaran yang dijejaki dalam bingkai semasa.

Kemas kini status: Untuk setiap sasaran yang dijejaki, gunakan penapis Kalman untuk mengemas kini statusnya.

Output sasaran: Keluarkan maklumat status dan hasil penjejakan setiap sasaran yang dijejaki.

Dalam penglihatan komputer, algoritma SORT boleh digunakan pada pelbagai senario pengesanan sasaran. Sebagai contoh, dalam pengawasan video, algoritma SORT boleh menjejaki sasaran bergerak dalam masa nyata, dengan itu membolehkan pengesanan dan amaran awal kelakuan tidak normal di tempat kejadian. Dalam bidang pemanduan autonomi, algoritma SORT boleh menjejaki kenderaan lain, pejalan kaki dan peserta trafik lain untuk mencapai navigasi autonomi dan mengelak halangan kenderaan. Dalam navigasi robot, algoritma SORT boleh menjejaki sasaran bergerak untuk mencapai navigasi autonomi dan mengelakkan halangan robot.

Berikut ialah contoh kod mudah yang dilaksanakan dalam Python:

#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]

Kod di atas melaksanakan algoritma penjejakan SORT yang mudah, menggunakan penapis Kalman untuk meramal dan menganggar kedudukan dan halaju sasaran, dan kemudian menggunakan algoritma Hungary untuk melaksanakan menjejaki pada sasaran Persatuan, dan akhirnya menentukan sama ada sasaran itu mati berdasarkan bilangan kali berturut-turut yang tidak kelihatan sasaran dan mengeluarkan sasaran yang mati. Kod di atas melaksanakan algoritma penjejakan SORT yang mudah, menggunakan penapis Kalman untuk meramal dan menganggar kedudukan dan kelajuan sasaran, kemudian menggunakan algoritma Hungary untuk mengaitkan sasaran, dan akhirnya menilai sama ada sasaran telah mati dan mengalih keluar kematian berdasarkan nombor masa yang tidak kelihatan berturut-turut daripada sasaran.

Selain algoritma SORT, terdapat banyak algoritma penjejakan sasaran lain, seperti penapis Kalman, penapis zarah, penjejakan berbilang sasaran, dll. Setiap algoritma mempunyai senario, kelebihan dan keburukan yang berkenaan. Dalam aplikasi praktikal, adalah perlu untuk memilih algoritma yang sesuai untuk penjejakan sasaran berdasarkan senario dan keperluan tertentu.

Atas ialah kandungan terperinci Pengenalan ringkas kepada algoritma penjejakan SORT dan contoh pelaksanaan Pythonnya. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!