MKCFup: Dual Filter Updates in Tracking & Kalman

• MKCFup is a dual-method approach that integrates multi-kernel correlation filtering for high-speed visual tracking with a robust update step in the Maximum Correntropy Kalman Filter for state estimation.
• The framework employs advanced kernel formulations and FFT-based alternating optimization, achieving superior performance metrics such as 83.5% precision and 64.1% AUC at 150 fps.
• Per-kernel temporal adaptation with Gaussian kernels reduces interference and enhances robustness, offering improved tracking precision and resilience to non-Gaussian noise.

MKCFup denotes two distinct but high-impact methods within the correlation filter and robust Kalman filtering literature: (1) the Multi-Kernel Correlation Filter update for high-speed visual object tracking (Tang et al., 2018), and (2) the “update” step in the Maximum Correntropy Kalman Filter, a robust state-estimation methodology (Chen et al., 2015). Both approaches exploit advanced kernel-based formulations and efficient alternating optimization. The following account details the MKCFup tracker for high-speed tracking and the Maximum Correntropy Kalman Filter update, including mathematical underpinnings, algorithmic schemes, evaluation, and performance insights.

1. Multi-Kernel Correlation Filter Frameworks

KCF and MKCF Formulations

The Kernelized Correlation Filter (KCF) learns a discriminative function in a reproducing-kernel Hilbert space (RKHS) by minimizing a Tikhonov-regularized empirical risk: $$\min_{f\in\mathcal{H}_k}\;\frac{1}{2}\sum_{i=0}^{l-1}\left(f(\mathbf{x}_i)-y_i\right)^2 + \frac{\lambda_0}{2}\|f\|_k^2,$$ where inputs are circulant shifts of a base patch, targets $y_i$ are Gaussian-shaped labels, and regularization parameter $\lambda_0>0$ penalizes RKHS norm $\|f\|_k$. By the Representer Theorem, $$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$. Letting $\mathbf{K}$ be the kernel matrix, the dual problem is quadratic with closed-form solution; in the circulant setting, FFT diagonalization yields element-wise updates for efficient computation (Tang et al., 2018).

The Multi-Kernel Correlation Filter (MKCF) extends KCF to convex combinations of $M$ base kernels: $$k(\mathbf{x}_i,\mathbf{x}_j) = \sum_{m=1}^{M} d_m\,k_m(\mathbf{x}_i,\mathbf{x}_j),\qquad d_m \ge 0,~\sum_{m=1}^M d_m = 1.$$ MKCF alternates between solving for the dual weights $\bm{\alpha}$ (fixed $\mathbf{d}$) and updating $y_i$0 (fixed $y_i$1) within a convex quadratic program, but exhibits increased computational complexity and only moderate improvements over KCF (Tang et al., 2018).

2. Upper-Bound Reformulation and Decoupled Optimization

MKCFup introduces an upper-bound surrogate to the MKCF objective, fundamentally decoupling kernel contributions and suppressing negative interference:

$y_i$2

with parameters $y_i$3, $y_i$4, and $y_i$5. This reformulation permits per-kernel loss evaluation, leading to more stable alternating block-coordinate optimization. Temporal adaptation and historical influence are controlled by per-kernel learning rates $y_i$6 and exponential weights $y_i$7:

$y_i$8

where $y_i$9 reflects the influence of frames 1 to $\lambda_0>0$0 according to (per-kernel) exponential forgetting.

3. Alternating Block-Coordinate Algorithm

MKCFup employs a highly efficient alternating optimization per frame, summarized as:

1. Initialize: $\lambda_0>0$1 for $\lambda_0>0$2.
2. Alternate $\lambda_0>0$3 times (typically $\lambda_0>0$4):
   • Fix $\lambda_0>0$5, solve for $\lambda_0>0$6 via FFT-based elementwise updates in the Fourier domain, exploiting running accumulators for numerator and denominator terms per kernel.
   • Fix $\lambda_0>0$7, update $\lambda_0>0$8 in closed-form using current responses and running historical averages.

Detection in the next frame utilizes the estimated weights and filter response: $\lambda_0>0$9 All operations remain in the Fourier domain, maintaining low computational overhead.

4. Feature Extraction, Kernels, and Historical Adaptation

MKCFup adopts two base kernel types:

• Color Name (CN) features: 13-D, projected to 4-D by PCA.
• HOG features: 9 orientation bins over $\|f\|_k$0 cells, PCA-reduced to 4-D.

Both use Gaussian base kernels

$\|f\|_k$1

with cross-validated kernel widths for color ($\|f\|_k$2, $\|f\|_k$3 for color images; reduced for grayscale). Per-kernel historical learning rates are $\|f\|_k$4, $\|f\|_k$5, and initial weights $\|f\|_k$6 adapt automatically thereafter (Tang et al., 2018).

5. Empirical Performance and Implementation Considerations

On OTB2013, MKCFup achieves 83.5% precision@20px and 64.1% AUC at 150 fps, outperforming both KCF (70.9% precision/50.7% AUC/297 fps) and classic MKCF (76.7%/57.0%/30 fps). The table below summarizes empirical metrics:

Tracker	Precision@20px	AUC	fps
KCF	70.9%	50.7%	297
MKCF	76.7%	57.0%	30
fMKCF	78.6%	58.0%	50
MKCFup	83.5%	64.1%	150

Key practical considerations:

• Search region: 2.5× object bounding-box (same as KCF)
• Hann window applied to suppress high-frequency FFT artifacts
• Gaussian response label matching feature patch shape
• Regularization: $\|f\|_k$7, $\|f\|_k$8
• Scale estimation: fDSST applied post-tracking

6. Theoretical and Practical Advantages

MKCFup’s upper-bound reformulation suppresses kernel mutual interference, enabling more discriminative per-feature optimization. Temporal weighting via $\|f\|_k$9 and per-kernel $$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$0 enables adaptive memory length per feature. All updates rely on FFT-based operations, facilitating real-time throughput ($$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$1150 fps).

The search region size is optimized for small inter-frame translations (offset ratio $$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$2), avoiding unnecessary background and increasing robustness in “small-move/high-speed” scenarios. Empirically, MKCFup consistently exhibits superior accuracy and computational efficiency over both linear kernel methods (KCF) and standard MKL-based correlation filters (MKCF) (Tang et al., 2018).

7. MKCFup in the Maximum Correntropy Kalman Filter

In robust state estimation, “MKCFup” also refers to the update step in the Maximum Correntropy Kalman Filter (MCKF) (Chen et al., 2015). Here, the MMSE criterion of classic Kalman filtering is replaced with the Maximum Correntropy Criterion (MCC), leading to a fixed-point update of the posterior mean: $$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$3 with modified covariances and gain reflecting data-driven residual weights: $$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$4 where $$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$5 and $$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$6 depend on the diagonal correntropy matrices $$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$7, $$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$8 induced by

$$f(\cdot) =\sum_{i=0}^{l-1}\alpha_i\,k(\mathbf{x}_i,\cdot)$$9

The fixed-point equations down-weight outliers via $\mathbf{K}$0, yielding robustness to heavy-tailed or impulsive noise. Convergence is guaranteed for sufficiently large $\mathbf{K}$1. For Gaussian noise, MCKF reduces to the classical Kalman update. This robustification incurs a marginal increase in computational complexity (a few fixed-point iterations per timestep), yielding superior empirical error distributions in non-Gaussian settings (Chen et al., 2015).