Samba: Synchronized Set-of-Sequences Modeling for Multiple Object Tracking

## Abstract

Abstract Multiple object tracking in complex scenarios - such as coordinated dance performances, team sports, or dynamic animal groups - presents unique challenges. In these settings, objects frequently move in coordinated patterns, occlude each other, and exhibit long-term dependencies in their trajectories. However, it remains a key open research question on how to model long-range dependencies within tracklets, interdependencies among tracklets, and the associated temporal occlusions. To this end, we introduce Samba, a novel linear-time set-of-sequences model designed to jointly process multiple tracklets by synchronizing the multiple selective state-spaces used to model each tracklet. Samba autoregressively predicts the future track query for each sequence while maintaining synchronized long-term memory representations across tracklets. By integrating Samba into a tracking-by-propagation framework, we propose SambaMOTR, the first tracker effectively addressing the aforementioned issues, including long-range dependencies, tracklet interdependencies, and temporal occlusions. Additionally, we introduce an effective technique for dealing with uncertain observations (MaskObs) and an efficient training recipe to scale SambaMOTR to longer sequences. By modeling long-range dependencies and interactions among tracked objects, SambaMOTR implicitly learns to track objects accurately through occlusions without any hand-crafted heuristics. Our approach significantly surpasses prior state-of-the-art on the DanceTrack, BFT, and SportsMOT datasets.

## 1 Introduction

mot involves detecting multiple objects while keeping track of individual instances throughout a video stream. It is critical for multiple downstream tasks such as sports analysis, autonomous navigation,
and media production (Luo et al., ).
Traditionally, \Acmot methods are validated on relatively simple settings such as surveillance datasets (Milan et al., ), where pedestrians exhibit largely linear motion and diverse appearance, and rarely interact with each other in complex ways.
However, in dynamic environments like team sports, dance performances, or animal groups, objects frequently move in coordinated patterns, occlude each other, and exhibit non-linear motion with long-term dependencies in their trajectories (Fig. 1).
Modeling the long-term interdependencies between objects in these settings, where their movements are often synchronized or influenced by one another, remains an open problem that current methods fail to address.

Current tracking-by-detection methods (Bewley et al., ; Wojke et al., ; Zhang et al., ; Cao et al., ) often rely on heuristics-based models like the Kalman filter to independently model the trajectory of objects and predict their future location. However, these methods struggle with the non-linear nature of object dynamics such as motion, appearance, and pose changes.
Tracking-by-propagation (Sun et al., ; Meinhardt et al., ; Zeng et al., ) offers an alternative by modeling tracking as an end-to-end autoregressive object detection problem, leveraging detection transformers (Carion et al., ; Zhu et al., ) to propagate track queries over time.
Their flexible design fostered promising performance in settings with complex motion, pose, and appearance patterns, such as dance (Sun et al., ), sports (Cui et al., ), and bird (Zheng et al., ) tracking datasets.
However, such methods only propagate the temporal information across adjacent frames, failing to account for long-range dependencies.
MeMOTR (Gao & Wang, ) attempts a preliminary solution to this problem by storing temporal information through an external heuristics-based memory. However, its use of an \acema to compress past history results in a suboptimal temporal memory representation, as it discards fine-grained long-range dependencies that are crucial for accurate tracking over time.
Moreover, by processing each tracklet independently and overlooking tracklets interaction, current methods cannot accurately model objects’ behavior through occlusions, resorting to naive heuristics to handle such cases:
some (Zhang et al., ; Gao & Wang, ) freeze the track queries during occlusions and only rely on their last observed state during prolonged occlusions;
others (Zeng et al., ) delegate occlusion management to the propagation module, which fails to estimate accurate track trajectories as it only propagates information across adjacent frames and does not account for historical information.
We argue that effective long-term memory and interaction modeling allow for more accurate inference of occluded objects’ behavior in complex environments, such as team sports or dance performances, by leveraging past information and understanding joint motion patterns.

Figure: (a) DanceTrack (Sun et al., )

To address these shortcomings, we propose Samba
(^1^11Samba is named for its foundation on the Synchronization of Mamba’s selective state-spaces (Gu & Dao, ). Its name reflects the coordinated motion of tracklets (Fig. 1), much like the synchronized movements in the samba dance. By synchronizing the hidden states across sequences, our approach is disentangled from Mamba’s selective \acpssm and can, in principle, be applied to any sequence model that includes an intermediate memory representation, such as other \acpssm or recurrent neural networks.)
, a novel linear-time set-of-sequences model that processes a set of sequences (*e.g*. multiple tracklets) simultaneously and compresses their histories into synchronized long-term memory representations, capturing interdependencies within the set.
Samba adopts selective \acpssm from Mamba (Gu & Dao, ) to independently model all tracklets, compressing their long-range histories into hidden states.
We then propose to synchronize these memory representations across tracklets at each time step to account for interdependencies (*e.g*. interactions among tracklets).
We implement synchronization via a self-attention mechanism (Vaswani et al., ) across the hidden states of all sequences, allowing tracklets to exchange information. This approach proves beneficial in datasets where objects move in coordinated patterns (Tabs. 1, 2 and 3).
The resulting set-of-sequences model, Samba, retains the linear-time complexity of \acpssm while modeling the joint dynamics of the set of tracklets.

By integrating Samba into a
tracking-by-propagation framework (Zeng et al., ), we present SambaMOTR, an end-to-end multiple object tracker that models long-range dependencies and interactions between tracklets to handle complex motion patterns and occlusions in a principled manner.
SambaMOTR complements a transformer-based object detector with a novel set-of-queries propagation module based on Samba, which accounts for both individual tracklet histories and their interactions when autoregressively predicting the next track queries.

Additionally, some queries result in uncertain detections due to occlusions or challenging scenarios (see Fig. 2, Occlusion). To prevent these detections from compromising the memory representation and accumulating errors during query propagation with Samba, we propose MaskObs. MaskObs blocks unreliable observations from entering the set-of-queries propagation module while updating the corresponding hidden states and track queries using only the long-term memory of their tracklets and interactions with confidently tracked objects. Unlike previous methods that freeze track queries during occlusions, MaskObs leverages both temporal and spatial context - *i.e*. past behavior and interdependencies with other tracklets - to more accurately predict an object’s future state. Consequently, SambaMOTR tracks objects through occlusions more effectively (Tab. 4, line d).

Finally, we introduce an efficient training recipe to scale SambaMOTR to longer sequences by sampling arbitrarily long sequences, computing tracking results, and applying gradients only on the last five frames. This simple strategy enables us to learn longer-range dependencies for query propagation, improving the tracking performance while maintaining the same GPU memory requirements as previous methods (Zeng et al., ; Gao & Wang, ).

We validate SambaMOTR on the challenging DanceTrack (Sun et al., ), SportsMOT (Cui et al., ), and BFT (Zheng et al., ) datasets. Owing to our contributions, we establish a new state of the art on all datasets. We summarize them as follows:
(a) we introduce Samba, our novel linear-time set-of-sequences model based on synchronized \acpssm;
(b) we introduce SambaMOTR, the first tracking-by-propagation method that leverages past tracklet history in a principled manner to learn long-range dependencies, tracklets interaction, and occlusion handling;
(c) we introduce MaskObs, a simple technique for dealing with uncertain observations in \acpssm and an efficient training recipe that enables learning stronger sequence models with limited compute.

Figure: Figure 2: Overview of SambaMOTR. SambaMOTR combines a transformer-based object detector with a set-of-sequences Samba model. The object detector’s encoder extracts image features from each frame, which are fed into its decoder together with detect and track queries to detect newborn objects or re-detect tracked ones. The Samba set-of-sequences model is composed of multiple synchronized Samba units that simultaneously process the past memory and currently observed output queries for all tracklets to predict the next track queries and update the track memory. The hidden states of newborn objects are initialized from zero values (barred squares). In case of occlusions or uncertain detections, the corresponding query is masked (red cross) during the Samba update.
Refer to caption: x4.png

## 2 Related Work

##### Tracking-by-detection.

Tracking-by-detection is a popular paradigm in \acmot, consisting of an object detection stage followed by data association to yield object trajectories throughout a video.
Motion and appearance cues are typically utilized to match detections to tracklets through hand-crafted heuristics.
The motion-based tracker SORT (Bewley et al., ) relies on \aciou to assign the tracklet locations predicted with a Kalman filter to object detections.
ByteTrack (Zhang et al., ) introduces a two-stage matching scheme to associate low-confidence detections.
OC-SORT (Cao et al., ) models non-linear motion by taking care of noise accumulation under occlusion.
Alternatively, appearance descriptors can be used alone (Pang et al., ; Li et al., ; ) or in combination with motion (Wojke et al., ; Wang et al., ; Zhang et al., ; Segu et al., ; Li et al., ) to
match detections to tracklets according to a similarity metric.
Due to the disentangled nature of the two stages, tracking-by-detection methods historically leveraged state-of-the-art object detectors to top the MOT challenge (Dendorfer et al., ).
However, by relying on hand-crafted heuristics, such methods struggle with non-linear motion and appearance patterns (Sun et al., ; Cui et al., ; Zheng et al., ; Li et al., ), and require domain-specific hyperparameters (Segu et al., ; Liu et al., ).
Recent transformer-based methods have eased the burden of heuristics.
TransTrack (Sun et al., ) decodes track and detect queries with siamese transformer decoders and associates them with simple \aciou matching.
MeMOT (Cai et al., ) fuses a large memory bank into a tracklet descriptor with a transformer-based memory aggregator. However, it requires storing and processing with quadratic complexity the historical information from up to 27 past frames.
GTR (Zhou et al., ) matches static trajectory queries to detections to generate tracklets, but fails to model object motion and tracklet interaction.
In contrast, SambaMOTR implicitly learns motion, appearance, and tracklet interaction models by autoregressively predicting the future track queries with our set-of-sequences model Samba.

##### Tracking-by-propagation.

Recent work (Meinhardt et al., ; Zeng et al., ) introduced a more flexible and end-to-end trainable *tracking-by-propagation* design that treats \acmot as an autoregressive problem where object detection and query propagation are tightly coupled.
Leveraging the transformer-based Deformable DETR (Zhu et al., ) object detector, TrackFormer (Meinhardt et al., ) and MOTR (Zeng et al., ) autoregressively propagate the detection queries through time to re-detect (track) the same object in subsequent frames.
MOTRv2 (Zhang et al., ) leverages a pre-trained YOLOX object detector to provide anchors for Deformable DETR and boost its detection performance.
However, these approaches only propagate queries across adjacent frames, failing to fully leverage the historical information.
MeMOTR (Gao & Wang, ) first attempts to utilize the temporal information in tracking-by-propagation by aggregating long- (\acema of a tracklet’s queries through time) and short-term memory (fusion of the output detect queries across the last two observed frames) in a temporal interaction module.
By collapsing the tracklet history with an \acema and by freezing the last observed state of track queries and memory under occlusions, MeMOTR cannot accurately estimate track query trajectories through occlusions.
Finally, by modeling query propagation independently for each tracklet, it does not model tracklet interaction.
In contrast, our proposed Samba set-of-sequences model relies on individual \acpssm to independently model each tracklet as a sequence and it synchronizes the memory representations across the set of tracklets to enable tracklet interaction. Equipped with Samba, SambaMOTR autoregressively predicts future queries aware of long-range dynamics and of other tracklets’ motion and appearance.

## 3 Preliminaries

Before introducing SambaMOTR (Sec. 4), we present the necessary background and notation on selective state-space models (Sec. 3.1) and tracking-by-propagation (Sec. 3.2).

### 3.1 Selective State-Space Models

Inspired by classical state-space models (SSMs) (Kalman, ), structured SSMs (S4) (Gu et al., ) introduce a sequence model whose computational complexity scales linearly, rather than quadratically, with the sequence length. This makes S4 a principled and efficient alternative to transformers (Vaswani et al., ).
By further introducing a selection mechanism - *i.e*. rendering the \acssm parameters input-dependent - Mamba (Gu & Dao, ) can model time-variant systems, bridging the performance gap with transformers (Vaswani et al., ).

We here formally define selective \acpssm (S6) (Gu & Dao, ).
Let $x(t)$ be the input signal at time $t$, $h(t)$ the hidden state, and $y(t)$ the output signal.
Given the system $\mathbf{A}$, control $\mathbf{B}$, and output $\mathbf{C}$ matrices, we define the continuous linear time-variant \acssm in Eq. 1.
The discrete-time equivalent system (Eq. 2) of the defined \acssm is obtained through a discretization rule.
The chosen discretization rule is typically the zero-order hold (ZOH) model: $\mathbf{\bar{A}}(t)=\exp(\mathbf{\Delta}(t)\mathbf{A}(t))$,  $\mathbf{\bar{B}}(t)=(\mathbf{\Delta}(t)\mathbf{A}(t))^{-1}(\exp(\mathbf{\Delta
}(t)\mathbf{A}(t))-\mathbf{I})\cdot\mathbf{\Delta}(t)\mathbf{B}(t)$:
$\displaystyle h^{\prime}(t)$
$\displaystyle=\mathbf{A}(t)h(t)+\mathbf{B}(t)x(t)$
(1)
$\displaystyle y(t)$
$\displaystyle=\mathbf{C}(t)h(t)$
$\displaystyle h_{t}$
$\displaystyle=\mathbf{\bar{A}}(t)h_{t-1}+\mathbf{\bar{B}}(t)x_{t}$
(2)
$\displaystyle y_{t}$
$\displaystyle=\mathbf{C}(t)h_{t}$

$x_{t}$, $h_{t}$, $y_{t}$ are the observations sampled at time $t$ of the input signal $x(t)$, hidden state $h(t)$, and output signal $y(t)$.
While S4 learns a linear time-invariant (LTI) system with $\mathbf{\Delta}(t)\!=\!\mathbf{\Delta}$, $\mathbf{A}(t)\!=\!\mathbf{A}$, $\mathbf{B}(t)\!=\!\mathbf{B}$ and $\mathbf{C}(t)\!=\!\mathbf{C}$, S6 introduces selectivity to learn a time-variant system by making $\mathbf{\Delta}(t)$, $\mathbf{B}(t)$ and $\mathbf{C}(t)$ dependent on the input $x(t)$, *i.e*. $\mathbf{\Delta}(t)=\tau_{\Delta}(\mathbf{\Delta}+s_{\Delta}(x(t)))$, $\mathbf{B}(t)=s_{B}(x(t))$, $\mathbf{C}(t)=s_{C}(x(t))$, where $\tau_{\Delta}=\texttt{softplus}$, and $s_{\Delta}$, $s_{B}$, $s_{C}$ are learnable linear mappings.

In this paper, we propose to treat tracking-by-propagation as a sequence modeling problem. Given the discrete sequence of historical track queries for a certain tracklet, our query propagation module Samba (Sec. 4.2) leverages \acpssm to account for the historical tracklet information in a principled manner. By recursively compressing all tracklet history into a long-term memory, Samba’s complexity scales linearly with the number of frames, enabling efficient training on long sequences while processing indefinitely long tracklets at inference time.

### 3.2 Tracking-by-propagation

Tracking-by-propagation methods alternate between a detection stage and a propagation stage,
relying on a DETR-like (Carion et al., ) transformer object detector and a query propagation module.
At a time step $t$, the backbone and transformer encoder extract image features for a frame $I_{t}$.
The detection stage involves feeding both a fixed-length set of learnable detect queries $Q^{det}_{t}$ to the transformer decoder to detect newborn objects and a variable-length set of propagated track queries $Q^{tck}_{t}$ to re-detect tracked ones.
At time $t=0$, the set of track queries is empty, *i.e*. $Q^{tck}_{0}=E^{tck}_{0}=\emptyset$.
Detect and track queries $[Q^{det}_{t},Q^{tck}_{t}]$ interact in the decoder with image features to generate the corresponding output embeddings $[E^{det}_{t},E^{tck}_{t}]$ and bounding box predictions $[D^{det}_{t},D^{tck}_{t}]$.
We denote the set of embeddings corresponding to newborn objects as $\hat{E}^{det}_{t}$, and $\hat{E}^{tck}_{t}=[\hat{E}^{det}_{t},E^{tck}_{t}]$ as the set of embeddings corresponding to the tracklets $\mathcal{S}_{t}$ active at time $t$.
During the propagation stage, a query propagation module $\Theta(\cdot)$ typically takes as input the set of embeddings $\hat{E}^{tck}_{t}$ and outputs refined tracked queries $Q^{tck}_{t+1}=\Theta(\hat{E}^{tck}_{t})$ to re-detect the corresponding objects in the next frame.

Although prior work failed to properly model long-range history and tracklet interactions (Zeng et al., ; Gao & Wang, ; Meinhardt et al., ), and given that multiple objects often move synchronously (Fig. 1), we argue that the future state of objects in a scene can be better predicted by (i) considering both their historical positions and appearances, and (ii) estimating their interactions.
In this work, we cast query propagation as a set-of-sequences modeling problem.
Given a set of multiple tracklets, we encode the history of each tracklet in a memory representation using a state-space model and propose memory synchronization to account for their joint dynamics.

## 4 Method

In this section, we introduce SambaMOTR, an end-to-end multiple object tracker that combines transformer-based object detection with our set-of-sequences model Samba to jointly model the long-range history of each tracklet and the interaction across tracklets to propagate queries.
First, in Sec. 3.2 we provide background on the tracking-by-propagation framework and motivate the need for better modeling of both temporal information and tracklets interaction.
Then, we describe the SambaMOTR architecture (Sec. 4.1) and introduce Samba (Sec. 4.2), our novel set-of-sequences model based on synchronized state spaces that jointly models the temporal dynamics of a set of sequences and their interdependencies.
Finally, in Sec. 4.3 we describe SambaMOTR’s query propagation strategy based on Samba, our effective technique MaskObs to deal with occlusions in \acpssm, a recipe to learn long-range sequence models with limited compute, and our simple inference pipeline.

### 4.1 Architecture

Similar to other tracking-by-propagation methods (Meinhardt et al., ; Zeng et al., ; Gao & Wang, ), the proposed SambaMOTR architecture (Fig. 2) is composed of a DETR-like (Carion et al., ) object detector and a query propagation module.
As object detector, we use Deformable-DETR (Zhu et al., ) with a ResNet-50 (He et al., ) backbone followed by a transformer encoder to extract image features and a transformer decoder to detect bounding boxes from a set of detect and track queries.
As query propagation module, we use our set-of-sequences model Samba. Each sequence is processed by a Samba unit synchronized with all others. A Samba unit consists of two Samba blocks (Sec. 4.2) interleaved with LayerNorm (Ba et al., ) and a residual connection.

### 4.2 Samba: Synchronized State-Space Models for Set-of-sequences Modeling

Figure: Figure 3: Synchronized State-Space Models. We illustrate a set of $k$ synchronized \acpssm. A Long-Term Memory Update block updates each hidden state $\tilde{h}_{t-1}^{i}$ based on the current observation $x_{t}^{i}$, resulting in the updated memory $h_{t}^{i}$. The Memory Synchronization block then derives the synchronized hidden state $\tilde{h}_{t}^{i}$, which is fed into the Output Update module to predict the output $y_{t}^{i}$.
Refer to caption: x5.png

Set-of-sequences modeling involves simultaneously modeling a set of temporal sequences and the interdependencies among them. In \acmot, set-of-sequences models can capture long-range temporal relationships within each tracklet as well as complex interactions across tracklets.
To this end, we introduce Samba, a linear-time set-of-sequences model based on the synchronization of multiple state-space models.
In this paper, we leverage Samba as a set-of-queries propagation network to jointly model multiple tracklets and their interactions in a tracking-by-propagation framework.

Synchronized Selective State-Space Models. Let $x_{t}^{i}$ be the discrete observation at time $t$ of the $i$-th input sequence from a set of sequences $\mathcal{S}$. We choose selective \acpssm (Gu & Dao, ) to model each sequence through a hidden state $h_{t}^{i}$ (Eq. 3a) encoding long-term memory, but our approach applies to any other \acssm.
Given the memory $\tilde{h}_{t-1}^{i}$, we define a long-term memory update (LTMU) function that updates $\tilde{h}_{t-1}^{i}$ based on the current observation $x_{t}^{i}$, resulting in the updated memory $h_{t}^{i}$.
We propose a memory synchronization (MS) function $\Gamma_{i\in\mathcal{S}}(\cdot)$ that produces a set of synchronized hidden states $\tilde{h}_{t}^{i}$ $\forall i\in\mathcal{S}$, modeling interactions across the set of sequences $\mathcal{S}$ (Eq. 3b).
Finally, we derive the output $y_{t}^{i}$ for each sequence through the output update (OU) function (Eq. 3c).

$$ $\displaystyle\text{LTMU}\!:\qquad h_{t}^{i}$ $\displaystyle=\mathbf{\bar{A}}^{i}(t)h_{t-1}^{i}+\mathbf{\bar{B}}^{i}(t)x_{t}^ {i}$ (3a) $\displaystyle\text{MS}\!:\qquad\tilde{h}_{t}^{i}$ $\displaystyle=\Gamma_{i\in\mathcal{S}}\left(h_{t}^{i}\right)$ (3b) $\displaystyle\text{OU}\!:\qquad y^{i}_{t}$ $\displaystyle=\mathbf{C}(t)\tilde{h}^{i}_{t}$ (3c) $$

An ideal memory synchronization function should be flexible regarding the number of its inputs (hidden states) and equivariant to their order.
Thus, we propose to define the memory synchronization function $\Gamma(\cdot)=[FFN(MHSA(\cdot))]_{\times N_{sync}}$ as a set of $N_{sync}$ stacked blocks with multi-head self-attention (MHSA) (Vaswani et al., ) followed by a feed-forward network (FFN).
A schematic illustration of the proposed synchronized state-space model layer is in Fig. 3.

Set-of-sequences Model. Refer to Sec. B.1 for a detailed description of how our synchronized SSM is used in the Samba units that model each sequence in the set-of-sequences Samba model.

### 4.3 SambaMOTR: End-to-end Tracking-by-propagation with Samba

Query Propagation with Samba.
As described in Sec. 3.2, the query propagation module $\Theta(\cdot)$ takes as input the decoder output embeddings $\hat{E}^{tck}_{t}$ and outputs refined track queries $Q^{tck}_{t+1}=\Theta(\hat{E}^{tck}_{t})$.
SambaMOTR extends this paradigm by accounting for the temporal information and tracklets interaction.
In particular, we use our Samba module $\Phi(\cdot)$ to compress the history of each tracklet into a hidden state $h^{i}_{t}$ and synchronize it across tracklets to derive the synchronized memory $\tilde{h}^{i}_{t}$.
Notice that $\tilde{h}^{i}_{t}=\mathbf{0}$ for a newborn object $i$.
At time $t$, we first enrich the detector output embeddings $\hat{E}^{tck}_{t}$ with position information by summing to them sine-cosine positional encodings $PE(\cdot)$ of the corresponding bounding boxes coordinates $\hat{D}^{tck}_{t}$ to implicitly model object motion and appearance, obtaining the set of input observations $X^{tck}_{t}=\hat{E}^{tck}_{t}+PE(\hat{D}^{tck}_{t})$.
Given the set of input observations $X^{tck}_{t}$ and past synchronized hidden states $\tilde{H}_{t-1}$ for all tracklets in the set $\mathcal{S}_{t}$ of tracklets at time $t$, we feed them into Samba $(Y_{t},\tilde{H}_{t})=\Phi(X^{tck}_{t},\tilde{H}_{t-1})$ to obtain the output embeddings $Y_{t}$ and updated synchronized hidden states $\tilde{H}_{t}$.
Finally, we use the output embeddings $Y_{t}$ and a learnable mapping $s_{y}$ to predict a residual $\Delta Q^{tck}_{t}=s_{y}(Y_{t})$ to the past track queries $Q^{tck}_{t}$ and generate the new ones, *i.e*. $Q^{tck}_{t+1}=Q^{tck}_{t}+\Delta Q^{tck}_{t}$.
By recursively unfolding this process over time, SambaMOTR can track multiple objects while compressing indefinitely long tracklet histories into their long-term memory representations, effectively modeling object motion and appearance changes, and tracklets interactions.

MaskObs: Dealing with Uncertain Observations.
Tracking-by-propagation may occasionally deal with occluded objects or uncertain detections.
Given a function $conf(\cdot)$ to estimate the predictive confidence of an input observation $x^{i}_{t}$, we propose MaskObs, a strategy to handle uncertain observations.
MaskObs masks uncertain observations from the state update (Eq. 4), thus defining the system dynamics solely based on its history and the interdependencies with other sequences:

$$ $\displaystyle\vspace{-30pt}h_{t}^{i}$ $\displaystyle=\mathbf{\bar{A}^{i}}(t)h^{i}_{t-1}+\mathbf{\bar{B}^{i}}(t)x^{i}_ {t}\cdot\mathds{1}[conf(x^{i}_{t})>\tau_{mask}]\vspace{-25pt}$ (4) $$

$\mathds{1}[\cdot]$ is the indicator function, and $\tau_{mask}$ is the confidence threshold, *e.g*. $\tau_{mask}=0.5$.
We implement $conf(x^{i}_{t})$ as the predictive confidence $conf(d^{i}_{t})$ of the corresponding bounding box $d^{i}_{t}$.
In our work, this design choice allows us to better model query propagation through occlusions (Tab. 4, line b).

Efficiently Learning Long-range Sequence models.
Previous MOTR-like approaches are trained end-to-end on a sequence of $5$ consecutive frames sampled at random intervals.
While SambaMOTR’s set-of-sequences model Samba already shows impressive generalization performance to long sequences at inference time (Tab. 4, line c), we propose to train on longer sequences (*i.e*. $10$ frames) and only apply gradients to the last $5$ frames (Tab. 4, line d).
We hypothesize that this strategy allows us to learn better history compression for late observations in a sequence, resulting in even better tracking performance while being trained with similar GPU memory requirements.
A schematic illustration of our training scheme proposal is in Fig. B.

Inference Pipeline.
At a given time step $t$, we jointly input the learnable detect queries $Q_{det}$ and track queries $Q_{t}^{tck}$ ($Q_{0}^{tck}=\emptyset$) into the transformer decoder to produce detection embeddings $E^{det}_{t}$ and tracking embeddings $E_{t}^{tck}$ and the corresponding bounding boxes.
Each detection bounding box with a confidence score higher than a threshold $\tau_{det}$ will initialize a newborn track $\hat{E}^{det}$.
We then propagate the embeddings of newborn $\hat{E}^{det}$ and tracked $E_{t}^{tck}$ objects together with the track memory $\tilde{H}_{t-1}$ to generate the updated track queries $Q^{t+1}_{track}$ and synchronized memory $\tilde{H}_{t+1}$.
To deal with occlusions and lost objects, we consider an individual track query $q_{t}^{i,track}$ inactive if its corresponding bounding box confidence $conf(d^{i}_{t})$ at time $t$ is lower than $\tau_{track}$. If a track query is inactive for more than $N_{miss}$ frames, it is deemed lost and dropped.

Unlike MeMOTR (Gao & Wang, ), which does not update the track embedding and long-term memory for an object with low detection confidence at a time step $t$, our approach employs a principled query propagation scheme that can hallucinate likely track query trajectories under occlusions by relying on its past history or attending to other trajectories.
Thus, we always update the memory and track query for any tracklet - even when occluded - as long as it is not deemed lost.

## 5 Experiments

In this section, we present experimental results to validate SambaMOTR.
We describe our evaluation protocol (Sec. 5.1) and report implementation details (Sec. 5.2).
We then compare SambaMOTR to the previous state-of-the-art methods (Sec. 5.3) and conduct an ablation study (Sec. 5.4) on the method components.
We provide more ablations in the appendix.
Qualitative results can be found in Fig. 1 and at the anonymous project page [https://anonymous-samba.github.io/](https://anonymous-samba.github.io/).

### 5.1 Evaluation Protocol

##### Datasets.

To evaluate SambaMOTR, we select a variety of challenging datasets exhibiting highly non-linear motion in crowded scenarios, with frequent occlusions and uniform appearances.
All datasets present scenes with objects moving synchronously. Thus, they represent a suitable benchmark for assessing the importance of modeling tracklet interaction.
DanceTrack (Sun et al., ) is a multi-human tracking dataset composed of 100 group dancing videos.
The Bird Flock Tracking (BFT) (Zheng et al., ) dataset includes 106 clips from the BBC documentary series Earthflight (Downer & Tennant, ).
SportsMOT (Cui et al., ) consists of 240 video sequences from basketball, volleyball, and soccer scenes.
Due to the highly linear motion in MOT17 (Milan et al., ), its small size (only 7 videos), and the subsequent need for training on additional detection datasets, end-to-end tracking methods do not provide additional advantages over more naive Kalman-filter-based methods. We report its results in the Appendix.

##### Metrics.

Following prior work, we measure the overall tracking performance with the HOTA (Luiten et al., ) metric and disentangle detection accuracy (DetA) and association accuracy (AssA).
We report the MOTA (Bernardin & Stiefelhagen, ) and IDF1 (Ristani et al., ) metrics for completeness.
Since our objective is improving association performance and the overall tracking quality, HOTA and AssA are the most representative metrics.

### 5.2 Implementation Details

Following prior works (Gao & Wang, ; Zhang et al., ), we apply random resize, random crop, and photometric augmentations as data augmentation.
The shorter side of the input image is resized to 800 preserving the aspect ratio, and the maximum size is restricted to 1536.
For a fair comparison with prior work (Sun et al., ; Zeng et al., ; Gao & Wang, ), we use the Deformable-DETR (Zhu et al., ) object detector with ResNet-50 (He et al., ) and initialize it from COCO (Lin et al., ) pre-trained weights.
Similar to MeMOTR (Gao & Wang, ), we inject track queries after one decoder layer.
We run our experiments on 8 NVIDIA RTX 4090 GPUs, with batch size 1 per GPU.
Each batch element contains a video clip with 10 frames, and we compute and backpropagate the gradients only over the last 5.
We sample uniformly spaced frames at random intervals from 1 to 10 within each clip.
We utilize the AdamW optimizer (Loshchilov & Hutter, ) with initial learning rate of $2.0\times 10^{-4}$.
For simplicity, $\tau_{det}\!=\!\tau_{track}\!=\!\tau_{mask}\!=\!0.5$. $N_{miss}$ is $35$, $20$, and $50$ on DanceTrack, BFT, and SportsMOT, respectively, due to different dataset dynamics.
On DanceTrack (Sun et al., ), we train SambaMOTR for 15 epochs on the training set and drop the learning rate by a factor of $10$ at the $10^{th}$ epoch.
On BFT (Sun et al., ), we train for 20 epochs and drop the learning rate after 10 epochs.
On SportsMOT (Cui et al., ), we train for 18 epochs and drop the learning rate after 8 and 12 epochs.
SambaMOTR’s inference runs at 16 FPS on a single NVIDIA RTX 4090 GPUs.

### 5.3 Comparison with the State of the Art

We compare SambaMOTR with multiple tracking-by-detection and tracking-by-propagation approaches on the DanceTrack (Tab. 1), BFT (Tab. 2) and SportsMOT (Tab. 3) datasets.
All methods are trained without using additional datasets.
Since trackers use various object detectors with different baseline performance, we report the detector used for each method.
For fair comparison, we report the performance of tracking-by-propagation methods with Deformable DETR (Zhu et al., ), marking the best in bold. We underle the overall best result. Tracking-by-detection methods often use the stronger YOLOX-X (Ge et al., ), but tracking-by-propagation consistently outperforms them, with SambaMOTR achieving the highest HOTA and AssA across all datasets.

**Table 1: State-of-the-art comparison on DanceTrack (Sun et al., ) without additional training data. Best tracking-by-propagation method in bold; best overall underlined.**
| Methods | Detector | HOTA | AssA | DetA | IDF1 | MOTA |
| --- | --- | --- | --- | --- | --- | --- |
| Tracking-by-detection: |  |  |  |  |  |  |
| FairMOT (Zhang et al., ) | CenterNet (Duan et al., ) | 39.7 | 23.8 | 66.7 | 40.8 | 82.2 |
| CenterTrack (Zhou et al., ) | 41.8 | 22.6 | 78.1 | 35.7 | 86.8 |  |
| TraDeS (Wu et al., ) | 43.3 | 25.4 | 74.5 | 41.2 | 86.2 |  |
| TransTrack (Sun et al., ) | Deformable DETR (Zhu et al., ) | 45.5 | 27.5 | 75.9 | 45.2 | 88.4 |
| GTR (Zhou et al., ) | CenterNet2 (Zhou et al., ) | 48.0 | 31.9 | 72.5 | 50.3 | 84.7 |
| ByteTrack (Zhang et al., ) | YOLOX-X (Ge et al., ) | 47.7 | 32.1 | 71.0 | 53.9 | 89.6 |
| QDTrack (Pang et al., ) | 54.2 | 36.8 | 80.1 | 50.4 | 87.7 |  |
| OC-SORT (Cao et al., ) | 55.1 | 38.3 | 80.3 | 54.6 | 92.0 |  |
| C-BIoU (Yang et al., ) | 60.6 | 45.4 | 81.3 | 61.6 | 91.6 |  |
| Tracking-by-propagation: |  |  |  |  |  |  |
| MOTR (Zeng et al., ) | Deformable DETR (Zhu et al., ) | 54.2 | 40.2 | 73.5 | 51.5 | 79.7 |
| MeMOTR (Gao & Wang, ) | 63.4 | 52.3 | 77.0 | 65.5 | 85.4 |  |
| SambaMOTR (ours) | 67.2 | 57.5 | 78.8 | 70.5 | 88.1 |  |

**Table 2: State-of-the-art comparison on BFT (Zheng et al., ) without additional training data. Best tracking-by-propagation method in bold; best overall underlined.**
| Method | Detector | HOTA | AssA | DetA | IDF1 | MOTA |
| --- | --- | --- | --- | --- | --- | --- |
| Tracking-by-detection: |  |  |  |  |  |  |
| FairMOT (Zhang et al., ) | CenterNet (Duan et al., ) | 40.2 | 28.2 | 53.3 | 41.8 | 56.0 |
| CenterTrack (Zhou et al., ) | 65.0 | 54.0 | 58.5 | 61.0 | 60.2 |  |
| SORT (Wojke et al., ) | YOLOX-X (Ge et al., ) | 61.2 | 62.3 | 60.6 | 77.2 | 75.5 |
| ByteTrack (Zhang et al., ) | 62.5 | 64.1 | 61.2 | 82.3 | 77.2 |  |
| OC-SORT (Cao et al., ) | 66.8 | 68.7 | 65.4 | 79.3 | 77.1 |  |
| TransCenter (Xu et al., ) | Deformable DETR (Zhu et al., ) | 60.0 | 61.1 | 66.0 | 72.4 | 74.1 |
| TransTrack (Sun et al., ) | 62.1 | 60.3 | 64.2 | 71.4 | 71.4 |  |
| Tracking-by-propagation: |  |  |  |  |  |  |
| TrackFormer (Meinhardt et al., ) | Deformable DETR (Zhu et al., ) | 63.3 | 61.1 | 66.0 | 72.4 | 74.1 |
| SambaMOTR (ours) | 69.6 | 73.6 | 66.0 | 81.9 | 72.0 |  |

##### DanceTrack.

The combination of highly irregular motion and crowded scenes with frequent occlusions and uniform appearance historically made DanceTrack challenging for tracking-by-detection methods. Despite their higher DetA when using the strong object detector YOLOX-X (Ge et al., ), tracking-by-propagation significantly outperforms them (see MeMOTR (Gao & Wang, ) and SambaMOTR).
SambaMOTR sets a new state of the art, with $+3.8$ HOTA and $+5.2$ AssA on the strongest competitor MeMOTR.
Our method owes this performance improvement to its better modeling of the historical information, our effective strategy to learn accurate sequence models through occlusions, and our modeling of tracklets interaction (group dancers move synchronously).

##### BFT.

Bird flocks present similar appearance and non-linear motion. For this reason, OC-SORT works best among tracking-by-detection methods. Nevertheless, bird flocks move synchronously, and interaction among tracklets is an essential cue for modeling joint object motion. Thanks to our proposed sequence models synchronization, SambaMOTR achieves $+2.8$ HOTA and $+4.9$ AssA over the best competitor overall (OC-SORT), and an impressive $+6.3$ HOTA and $+12.5$ improvement over the previous best tracking-by-propagation method TrackFormer (Meinhardt et al., ).

##### SportsMOT.

Sports scenes typically present non-linear motion patterns that the Kalman filter struggles to model, hence the underwhelming performance of ByteTrack (Zhang et al., ).
For this reason, trackers that model non-linear motion either explicitly (OC-SORT (Cao et al., )) or implicitly (TransTrack (Sun et al., )) perform well.
Notably, our tracking-by-propagation SambaMOTR enables implicit joint modeling of motion, appearance, and tracklet interaction, obtaining the best HOTA overall ($69.8$) despite the lower DetA of our Deformable-DETR detector compared to OC-SORT’s YOLOX-X.
Moreover, SambaMOTR exhibits a significant $+1.6$ AssA over the best tracking-by-propagation method and an impressive $+4.6$ AssA over OC-SORT.

**Table 3: State-of-the-art comparison on SportsMOT (Cui et al., ) without additional training data. Best tracking-by-propagation method in bold; best overall underlined.**
| Methods | Detector | HOTA | AssA | DetA | IDF1 | MOTA |
| --- | --- | --- | --- | --- | --- | --- |
| Tracking-by-detection: |  |  |  |  |  |  |
| FairMOT (Zhang et al., ) | CenterNet (Duan et al., ) | 49.3 | 34.7 | 70.2 | 53.5 | 86.4 |
| QDTrack (Pang et al., ) | YOLOX-X (Ge et al., ) | 60.4 | 47.2 | 77.5 | 62.3 | 90.1 |
| ByteTrack (Zhang et al., ) | 62.1 | 50.5 | 76.5 | 69.1 | 93.4 |  |
| OC-SORT (Cao et al., ) | 68.1 | 54.8 | 84.8 | 68.0 | 93.4 |  |
| TransTrack (Sun et al., ) | Deformable DETR (Zhu et al., ) | 68.9 | 57.5 | 82.7 | 71.5 | 92.6 |
| Tracking-by-propagation: |  |  |  |  |  |  |
| MeMOTR (Gao & Wang, ) | Deformable DETR (Zhu et al., ) | 68.8 | 57.8 | 82.0 | 69.9 | 90.2 |
| SambaMOTR (ours) | 69.8 | 59.4 | 82.2 | 71.9 | 90.3 |  |

**Table 4: Ablation on method components on the DanceTrack test set. Compared to prior work (in gray), we introduce a long-range query propagation module based on state-space models (SSM), we mask uncertain queries during the state update (MaskObs), we synchronize memory representations across tracklets (Sync), and we learn from longer sequences (Longer).**
| Method |  | SSM | MaskObs | Sync | Longer | HOTA | AssA | DetA | IDF1 | MOTA |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| SambaMOTR (Ours) | (a) | ✓ | - | - | - | 63.5 | 53.8 | 75.1 | 67.0 | 81.7 |
| (b) | ✓ | ✓ | - | - | 64.8 | 54.3 | 77.7 | 68.1 | 85.7 |  |
| (c) | ✓ | ✓ | ✓ | - | 65.9 | 55.6 | 78.4 | 68.7 | 87.4 |  |
| (d) | ✓ | ✓ | ✓ | ✓ | 67.2 | 57.5 | 78.8 | 70.5 | 88.1 |  |
| MOTR (Zeng et al., ) | (e) | - | - | - | - | 54.2 | 40.2 | 73.5 | 51.5 | 79.7 |
| MeMOTR (Gao & Wang, ) | (f) | - | - | - | - | 63.4 | 52.3 | 77.0 | 65.5 | 85.4 |

### 5.4 Ablation Studies

We ablate the effect of each component of our method in Tab. 4, as detailed in Sec. 4 and illustrated in Fig. B. Additional ablation studies are presented in Sec. C.2.

SSM. Line (a) shows the benefits of a sequential representation for tracking. We use a vanilla sequence model, such as Mamba, as the baseline for query propagation, establishing a robust foundation that outperforms MeMOTR’s EMA-based history and temporal attention module.

MaskObs. Handling track queries during occlusions (line b) with MaskObs - which masks uncertain observations from the state update and relies on long-term memory and interactions with visible tracklets - leads to significant overall improvements ($+1.3$ HOTA), highlighting the effectiveness of managing occluded objects.

Sync. Making tracklets aware of each other through our synchronization mechanism (line c) results in over 1% improvement across all metrics, demonstrating how modeling interactions between tracklets enhances tracking accuracy by capturing joint dynamics and coordinated movements.

Long-sequence training. Efficiently incorporating longer sequences during training (line d) helps the model to properly utilize its long-term memory, enabling generalization to indefinitely long sequences and leading to a notable $+1.9$ improvement in AssA.

Our final query propagation method (line d) improves MeMOTR’s association accuracy by $+5.2$ (line f), and MOTR’s by an impressive $+17.3$ (line e).

## 6 Limitations

Following the tracking-by-propagation paradigm, our model drops tracklets that are inactive for more than $N_{miss}$ frames to decrease the risk of ID switches. However, in some datasets like SportsMOT (Cui et al., ) football players may disappear from the camera view for multiple seconds, outliving the $N_{miss}$ threshold.
We argue that future work should complement tracking-by-propagation with long-term re-identification to tackle this issue.
Furthermore, in this paper, we introduced Samba, a set-of-sequences model. Our ablation study (Tab. 4) shows that Samba significantly outperforms the already strong \acssm baseline. However, this comes with the trade-off of increased computational complexity. In particular, \acpssm have linear complexity in time and linear complexity in the number of sequences (tracklets) independently modeled. Samba retains linear-time complexity, which enables it to track for indefinitely long-time horizons, but quadratic complexity in the number of sequences due to the use of self-attention in memory synchronization. Our ablations show that this trade-off is worth the performance improvement.

## 7 Conclusion

The proposed SambaMOTR fully leverages the sequential nature of the tracking task by using our set-of-sequences model, Samba, as a query propagation module to jointly model the temporal history of each tracklet and their interactions.
The resulting tracker runs with linear-time complexity and can track objects across indefinitely long sequences.
SambaMOTR surpasses the state-of-the-art on all benchmarks, reporting significant improvements in association accuracy compared to prior work.

#### Acknowledgments

This work was supported in part by the Max Plank ETH Center for Learning Systems.

## Appendix

In this appendix, we report additional discussions and experiments.
First, we provide background on sequence models in App. A.
Then, we report additional implementation details for SambaMOTR in App. B.
We show a schematic illustration of the Samba block in Fig. A and our method components in Fig. B.
Finally, we provide additional results App. C,
conducting several ablation studies on specific design choices that contributed to SambaMOTR’s performance.

## Appendix A Background on Sequence Models.

##### Sequence Models.

Sequence models are a class of machine learning models dealing with sequential data, *i.e*. where the order of elements is important.
Applications of sequence models are widespread across different fields, such as natural language processing (Vaswani et al., ; Gu & Dao, ), time series forecasting (Wen et al., ) and video analysis (Venugopalan et al., ).
Several architectures have been proposed to process sequences, each with its own strengths and limitations.
\Acprnn handles sequential data by maintaining a hidden state that updates as the network processes each element in a sequence. However, RNNs often struggle with long sequences due to issues like vanishing or exploding gradients (Pascanu et al., ).
\Aclstm networks (Hochreiter & Schmidhuber, ) introduce gating units to mitigate \acrnn’s vanishing gradient problem.
Transformers (Vaswani et al., ) rely on self-attention mechanisms to weigh the importance of different parts of the input data. Unlike \acprnn and \acplstm, transformers process entire sequences simultaneously, making them efficient at modeling long-range dependencies at the cost of quadratic computational complexity wrt. sequence length.
Building on the idea of modeling temporal dynamics like \acprnn and \acplstm, structured state-space models (Gu et al., ) introduce a principled approach to state management inspired by classical \acpssm (Kalman, ). Despite excelling at modeling long-range dependencies in continuous signals, structured \acpssm lag behind transformers on discrete modalities such as text. Recently, selective state-space models (Mamba) (Gu & Dao, ) improved over prior work by making the \acssm parameters input-dependent, achieving the modeling power of Transformers while scaling linearly with sequence length.

##### Set-of-sequences Models.

Only few approaches (Yang et al., ; Amiridi et al., ; Wu et al., ) explore the task of set-of-sequences modeling, which we define as the task of simultaneously modeling multiple temporal sequences and their interdependencies to capture complex relationships and interactions across different data streams.
Set-of-sequences modeling has applications in multivariate time series analysis (Amiridi et al., ), dynamic graph modeling (Wu et al., ), and sensor data fusion (Yang et al., ).
However, existing techniques involve complex and expensive designs.
We here introduce Samba, a linear-time set-of-sequences model based on the synchronization of multiple selective state-space models to account for the interaction across sequences.

## Appendix B SambaMOTR - Additional Details

Figure: Figure A: Illustration of our Set-of-sequences Model block. Our set-of-sequences model Samba simultaneously processes an arbitrary number $M$ of input sequences. Each sequence is processed by a Samba unit, synchronized with the others thanks to our synchronized state-space model. All Samba units share weights and are composed of a stack of $N$ Samba blocks. A Samba block has the same architecture as a Mamba block, but it adopts our synchronized SSM to synchronize long-term memory representations across the individual state-space models.
Refer to caption: x6.png

Figure: Figure B: Schematic illustration of our contributions (as ablated in Tab. 4). State-space model (SSM) blocks at timesteps with gradient applied are in green, and blocks without gradient are in grey.
Refer to caption: x7.png

SambaMOTR builds on Samba to introduce linear-time sequence modeling in tracking-by-propagation, treating each tracklet as a sequence of queries and autoregressively predicting the future track query.
By inducing synchronization on the SSMs’ memories across an arbitrary number of sequences, Samba elegantly models tracklet interaction and query propagation under occlusions.

### B.1 Samba

We illustrate a Samba set-of-sequences model in Fig. A.
A Samba model (Fig. A) is composed of a set of siamese Samba units (one for each sequence being modeled) with shared weights.
Each Samba unit is synchronized with others through our synchronized \acssm layer.
In particular, a Samba unit is composed of $N$ non-linear Samba blocks.
To obtain a non-linear Samba unitblock that can be embedded into a neural network, we wrap the synchronized \acssm layer following the Mamba (Gu & Dao, ) architecture.
A linear projection expands the input dimension $D$ by an expansion factor $E$, followed by a causal convolution and a SiLU (Hendrycks & Gimpel, ) activation before being fed to the sync \acssm layer. The output of a residual connection is passed to a SiLU before being multiplied by the output of the synchronized SSM and passed to an output linear projection.
Moreover, we replace Mamba’s RMSNorm (Zhang & Sennrich, ) with LayerNorm (Ba et al., ) for consistency with the detector.
Finally, we repeat $N$ such Samba blocks, interleaved with standard normalization and residual connections, to form a Samba unit.
The resulting set-of-sequences model is linear-time, supports a variable number of sequences that start and end at different time steps, and models long-range relationships and interdependencies across multiple sequences.

### B.2 Schematic Illustration of Our Contributions

We provide a schematic illustration of our contributions towards building Samba in Fig. B, disentangling them from one another to make the functioning of each component clear.

Mamba is the underlying sequence model, shown in the first row (Mamba).
The second row depicts our strategy to deal with uncertain observations by ignoring them in the state update (Occlusion Masking).
Synchronization across multiple sequence models using our synchronization module to let their hidden states communicate to model sequence interaction is shown in the third row (Sync).
The last row illustrates our efficient training strategy to learn long-range dynamics from longer sequences at a comparable computational expense for backpropagation (Longer).

Each of these components is ablated in Tab. 4 by incrementally adding them within our framework, showing the effectiveness of each towards the impressive final performance of SambaMOTR.

## Appendix C Additional Results

**Table A: State-of-the-art comparison on MOT17 (Milan et al., ). Best tracking-by-propagation method in bold; best overall underlined. For a fair comparison with the only MeMOTR’s published result, we also adopt DAB-Deformable-DETR.**
| Methods | Detector | HOTA | AssA | DetA | IDF1 | MOTA |
| --- | --- | --- | --- | --- | --- | --- |
| Tracking-by-detection: |  |  |  |  |  |  |
| CenterTrack (Zhou et al., ) | CenterNet (Duan et al., ) | 52.2 | 51.0 | 53.8 | 64.7 | 67.8 |
| FairMOT (Zhang et al., ) | 59.3 | 58.0 | 60.9 | 72.3 | 73.7 |  |
| TransTrack (Sun et al., ) | Deformable DETR (Zhu et al., ) | 54.1 | 47.9 | 61.6 | 63.9 | 74.5 |
| TransCenter (Xu et al., ) | 54.5 | 49.7 | 60.1 | 62.2 | 73.2 |  |
| MeMOT (Cai et al., ) | 56.9 | 55.2 | - | 69.0 | 72.5 |  |
| GTR (Zhou et al., ) | CenterNet2 (Zhou et al., ) | 59.1 | 57.0 | 61.6 | 71.5 | 75.3 |
| DeepSORT (Wojke et al., ) | YOLOX-X (Ge et al., ) | 61.2 | 59.7 | 63.1 | 74.5 | 78.0 |
| SORT (Bewley et al., ) | 63.0 | 62.2 | 64.2 | 78.2 | 80.1 |  |
| ByteTrack (Zhang et al., ) | 63.1 | 62.0 | 64.5 | 77.3 | 80.3 |  |
| OC-SORT (Cao et al., ) | 63.2 | 63.4 | 63.2 | 77.5 | 78.0 |  |
| QDTrack (Pang et al., ) | 63.5 | 62.6 | 64.5 | 77.5 | 78.7 |  |
| C-BIoU (Yang et al., ) | 64.1 | 63.7 | 64.8 | 79.7 | 81.1 |  |
| MotionTrack (Qin et al., ) | 65.1 | 65.1 | 65.4 | 80.1 | 81.1 |  |
| Tracking-by-propagation: |  |  |  |  |  |  |
| TrackFormer (Meinhardt et al., ) | Deformable DETR (Zhu et al., ) | - | - | - | 68.0 | 74.1 |
| MOTR (Zeng et al., ) | 57.2 | 55.8 | 58.9 | 68.4 | 71.9 |  |
| MeMOTR (Gao & Wang, ) | DAB-Deformable DETR (Liu et al., ) | 58.8 | 58.4 | 59.6 | 71.5 | 72.8 |
| SambaMOTR (ours) | 58.8 | 58.2 | 59.7 | 71.0 | 72.9 |  |

We report additional results on the popular MOT17 pedestrian tracking benchmark in Sec. C.1.
We extend our ablation study in Sec. C.2, investigating the effectiveness of synchronization, the use of positional embeddings and the effectiveness of residual prediction.

### C.1 MOT17

While MOT17 served as a benchmark of paramount importance to advance the state of current multiple object tracking algorithms, its very small size is reducing its significance as a training dataset. Since MOT17 only counts 7 training videos, modern tracking solutions complement its training with additional detection datasets and increasingly stronger detectors to improve the overall tracking performance and top the leaderboard. However, such expedients are deviating from the study of fundamental tracking solutions and focusing more on engineering tricks. Moreover, due to its highly linear motion, its small size (only 7 videos), and the subsequent need for training on additional detection datasets, end-to-end tracking methods do not provide additional advantages over more naive Kalman-filter-based methods. For this reason, we preferred to it other more modern and meaningful datasets in the main paper, *i.e*. DanceTrack (Sun et al., ), SportsMOT (Cui et al., ) and BFT (Zheng et al., ), which allows us to study the importance of modeling tracklets interaction and of implicitly learning motion and appearance models to cope with the underlying non-linear motion, appearance and pose changes of the objects.
Nevertheless, we here compare with the state-of-the-art for completeness and show comparable performance to previous tracking-by-propagation methods.

### C.2 Ablation Studies

We here complement the ablation study in Sec. 5.4 with additional experiments on specific SambaMOTR’s design choices. All ablations are based on the final version of our method, including all contributions as in Tab. 4 line d.

##### Ablation on different formulations of synchronization.

In Tab. C, we ablate on different formulations of state synchronization and report the corresponding state update equation for each option. In particular, the first row (Sync: -) does not apply state synchronization and is equivalent to using Mamba as a query propagation module together with our occlusion masking and efficient longer training strategy as explained in Sec. 4.3. Since this option does not model tracklet interaction, it reports the lowest performance.
We then compare synchronizing the hidden state before (prior) or after (posterior) and find that synchronizing the posterior is more effective. We attribute this to the opportunity to compensate for occluded observations in the current frame with the dynamics from other unoccluded tracklets to better model track query propagation through occlusions.

##### Ablation on the effect of synchronization on hard DanceTrack sequences.

In Tab. B, we report the performance on hard sequences of the DanceTrack test set for two SambaMOTR with and without synchronization. We select the top-6 hardest sequences for the version without synchronization and show that utilizing synchronization greatly improves the overall metrics.

##### Ablation on the use of query positional embeddings in Samba.

In Tab. D, we ablate on the addition of positional embeddings to the track embeddings before feeding them to Samba. We find that positional embeddings are very beneficial to Samba, arguably because they enable to implicitly learn non-linear motion models.

##### Ablation on the prediction of residual vs. full queries with Samba.

In Tab. E, we ablate on the output format of our Samba-based query propagation module. We compare two versions: one that directly outputs the final track queries with Samba, and one that predicts a residual over the track queries used to detect in the current frame. We find that learning a residual is significantly more effective than directly predicting the final track query.

##### Ablation on the query propagation strategy through occlusions.

We compare two query propagation strategies for occluded track queries in Tab. F. First, we evaluate our model with MeMOTR’s (Gao & Wang, ) query propagation strategy (Freeze), which freezes the last observed state - *i.e*. the last track query that generated a confident detection - and memory until the tracklet is detected again in a new frame.
Next, we compare this with actively propagating occluded track queries and their memory through occlusions using our MaskObs strategy (Sec. 4.3).
We find that MaskObs outperforms Freeze: by inferring a tracklet’s future state during occlusions using only its past memory and interactions with other observed objects, it keeps tracklets alive longer.

**Table B: Ablation on the effect of synchronization on difficult sequences on DanceTrack test.**
| Sequence | Synchronization |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| ✗ | ✓ |  |  |  |  |  |
| HOTA | DetA | AssA | HOTA | DetA | AssA |  |
| dancetrack0046 | 34.5 | 54.0 | 22.1 | 39.8 | 60.7 | 26.2 |
| dancetrack0085 | 39.6 | 60.9 | 25.9 | 40.3 | 63.9 | 25.5 |
| dancetrack0050 | 41.9 | 66.4 | 26.5 | 42.4 | 69.8 | 25.8 |
| dancetrack0036 | 42.9 | 74.7 | 24.7 | 48.4 | 77.5 | 30.3 |
| dancetrack0028 | 43.1 | 71.9 | 25.8 | 47.8 | 73.6 | 31.1 |
| dancetrack0009 | 43.4 | 73.6 | 25.7 | 48.0 | 75.2 | 30.7 |
| average | 40.9 | 66.9 | 25.1 | 44.5 | 70.1 | 28.3 |

**Table C: Ablation on memory synchronization positioning. We report the state equation and performance on the DanceTrack test set for: (i) the baseline without synchronization (-); (ii) synchronization on the updated state prior to input contribution (Prior); (iii) synchronization on the fully-updated state (Posterior).**
| Sync | State Equation | HOTA | AssA | DetA | IDF1 | MOTA |
| --- | --- | --- | --- | --- | --- | --- |
| - | $h_{t}^{i}=\mathbf{\bar{A}^{i}}(t)h^{i}_{t-1}+\mathbf{\bar{B}^{i}}(t)x^{i}_{t}$ | 66.0 | 56.4 | 77.5 | 69.5 | 86.7 |
| Prior | $h_{t}^{i}=\Gamma_{i\in\mathcal{T}}\left(\mathbf{\bar{A}^{i}}(t)h^{i}_{t-1}<br>\right)+\mathbf{\bar{B}^{i}}(t)x^{i}_{t}$ | 66.1 | 56.7 | 77.3 | 70.0 | 86.4 |
| Posterior | $h_{t}^{i}=\Gamma_{i\in\mathcal{T}}\left(\mathbf{\bar{A}^{i}}(t)h^{i}_{t-1}+<br>\mathbf{\bar{B}^{i}}(t)x^{i}_{t}\right)$ | 67.2 | 57.5 | 78.8 | 70.5 | 88.1 |

**Table D: Ablation on the use of positional embeddings. We ablate on the addition of positional embeddings to the observed queries fed as input to the Samba module.**
| Query Position | HOTA | AssA | DetA | IDF1 | MOTA |
| --- | --- | --- | --- | --- | --- |
| - | 65.6 | 56.2 | 76.7 | 69.3 | 85.4 |
| ✓ | 67.2 | 57.5 | 78.8 | 70.5 | 88.1 |

**Table E: Ablation on the use of residual prediction. We evaluate two formats for the output of SambaMOTR’s Samba module, *i.e*. direct query prediction (-) and prediction of a residual wrt. the track query from the previous frame (✓).**
| Residual | HOTA | AssA | DetA | IDF1 | MOTA |
| --- | --- | --- | --- | --- | --- |
| - | 64.2 | 54.0 | 76.7 | 67.0 | 84.5 |
| ✓ | 67.2 | 57.5 | 78.8 | 70.5 | 88.1 |

**Table F: Ablation on strategies for tracking through occlusions. We evaluate two strategies for tracking objects through occlusions: freezing the last observed track state (Freeze) as in MeMOTR, and propagating queries through occlusions using our MaskObs strategy.**
| Strategy | HOTA | AssA | DetA | IDF1 | MOTA |
| --- | --- | --- | --- | --- | --- |
| Freeze | 65.9 | 56.6 | 76.8 | 69.7 | 86.3 |
| MaskObs | 67.2 | 57.5 | 78.8 | 70.5 | 88.1 |

## Peer Reviews

confidence: 5
contribution: 3
initial_rating: 5
presentation: 2
questions: - Just to confirm, does the state space model operate on the coordinate domain (bounding boxes) or the visual domain (pixel values)? If it does operate on the coordinate domain, how can the auto-regressed output boxes be refined to fit the subjects without looking at visual features?
soundness: 2
strengths: - Overall, the experiments are extensive with different alterations in modeling provided in the main paper and appendix.
summary: The paper introduces SambaMOTR for multiple object tracking in videos. This method aims to improve tracking by utilizing temporal information about object movements to model historical object data, and occlusions, thereby modeling long-range dependencies, implicit motion, and appearance between tracklets.
weaknesses: - Visual comparisons show that the Samba autoregressive model performs better than memory/motion models should be provided to substantiate the claims.
- The interpretations of system $\mathbf{A}$ and control $\mathbf{B}$ matrices in the context of object tracking are unclear. Providing clearer definitions of notations would be helpful.
- I understand the intention to separate two paradigms tracking-by-detection (TBD) and tracking-by-propagation (TBP), but the difference is subtle as the TBP still needs bounding boxes to initiate the states, and needs a detector to recognize newly appearing objects. Then, propagation alone is simply not practical in this problem of multiple object tracking.
- Then it should be fair to compare with TBD methods, and the performance still falls short behind classic motion models as reported in Table A.
- While I value the effort in development, the innovation in the method appears to be limited, as it essentially represents a straightforward combination of MOTR and Mamba and the motivation is not really compelling.

---

confidence: 3
contribution: 2
initial_rating: 8
presentation: 3
questions: (1) Would it be possible to include a comparison of SambaMOTR on top of YOLOX-X to have an apple-to-apples comparison with prior tracking-by-detections works?
soundness: 3
strengths: (1) The presented method achieves strong performance.

(2) the reason to integrate SSMs into a tracking-by-propagation framework is well motivated.

(3) The ablation studies conducted verified the introduced modifications.

(4) The paper is well written; the provided illustrative examples showcase strong results.
summary: The paper introduces the novel SAMBA model architecture for multi-object tracking. It takes a unique approach to tracking in a tracking-by-propagation framework, building on top of selective state-space models captured by Mamba models. Additional self-attention is used to model dependency between tracks. The method is evaluated on three tracking datasets, and it demonstrates a new state-of-the-art performance.
weaknesses: (1) There is a lack of qualitative comparison between prior works and the proposed method. It is helpful to see qualitative differences between methods' outputs to highlight what improvements in the models' output are contributing to the improvement in the performance. 

(2) On L137, it is stated that  SambaMOTR has "the same GPU memory requirements". However, the paper lacks any measurements to back up this claim. Overall, there is emphasis placed on efficiency in the paper, so it would be good to include some measurements and comparisons to show these points. For example, including peak memory requirements and FLOPS would illustrate this point. 

(3) While the method shows strong results, chiefly due to architectural modifications, it is worth asking whether efficiency gains enable larger (higher capacity) models, which lead to improvements or whether the SSMs formulation provides better biases for the tracking problem. While it might be difficult to disentangle such factors, the paper could help guide future research in this area by reporting some (albeit not great) proxies, such as learnable parameter counts, etc.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 4
questions: see Weaknesses.
soundness: 4
strengths: 1. SambaMOTR introduces the novel linear-time set-of-sequences model designed to jointly process multiple tracklets by synchronizing the multiple selective state-spaces used to model each tracklet.
2. SambaMOTR achieves good tracking results on DanceTrack, BFT, and SportsMOT datasets.
summary: The paper introduces a tracking-by-propagation framework, SambaMOTR, which wanna tackles the question of how to model long-range dependencies within tracklets, interdependencies among tracklets, and the associated temporal occlusions. The core function of the  SambaMOTR is the Samba module, a novel linear-time set-of-sequences model designed to jointly process multiple tracklets by synchronizing the multiple selective state-spaces used to model each tracklet.  SambaMOTR is evaluated on DanceTrack, BFT, and SportsMOT datasets and achieves the state-of-the-art performance.
weaknesses: 1. The authors are advised to analyze the computational complexity.
2. The authors are advised to analyze why Samba is suitable for trajectory modeling and compare it with xLSTM, other SSMs, and RRNs.
3. The authors are advised to provide some tracking cases of SambaMOTR to demonstrate its superiority in trajectory modeling.

Meta-review: Summary  
This paper proposes SambaMOTR based on a linear-time set-of-sequences model for multiple object tracking. It processes multiple tracklets simultaneously by synchronizing multiple selective state spaces. The method leverages temporal information about object movements to model historical data and handle occlusions, enabling the modeling of long-range dependencies, implicit motion, and appearance relationships between tracklets. SambaMOTR achieves state-of-the-art performance on the DanceTrack, BFT, and SportsMOT datasets.

Strengths & weaknesses  
All reviewers recognized the strengths of the paper are strong experimental results and innovative ideas, and the weaknesses are lacking some technique details and more experimental results (visual comparisons, efficiency evaluations). After rebuttal, the weaknesses are well addressed by the authors. The final ratings are 8,8,6 and all reviewers recommend accepting this paper.

The AC concurs with the reviewers and recommends accepting this paper. In addition, the authors are encouraged to incorporate the suggested technical details and efficiency evaluations to further enhance the work.

Decision: Accept (Spotlight)