--- title: Kernel-Perceptron Collision Detector url: https://www.emergentmind.com/topics/kernel-perceptron-collision-detector type: topic --- # Kernel-Perceptron Collision Detector Searching arXiv for the cited papers to ground the article in the latest indexed records. A kernel-perceptron collision detector is a family of collision-checking and occupancy-mapping methods in which occupied and free space are separated by the decision boundary of a sparse kernel classifier. In these methods, the boundary of obstacles in configuration space (C-space), or the boundary between occupied and free regions in an environment map, is represented by a small set of support vectors or related sparse basis elements. The resulting models support fast point classification, incremental updates from streaming data, and, in the occupancy-mapping setting, provable collision-checking conditions for continuous piecewise-linear and piecewise-polynomial trajectories without sampling [2002.01921]. Closely related developments include the Fastron proxy collision detector for manipulators [1709.02316], a sparse Bayesian generalization based on Relevance Vector Machines [2009.07207], a forward-kinematics kernel for manipulator collision checking [1910.06451], and configuration-space decomposition for scalable local models [2201.04314]. ## 1. Formal model and decision boundary The core object is a binary classifier over C-space. In the sparse kernel-based occupancy mapping formulation, if $S$ is the set of support vectors and each support vector $q_i\in\mathbb{R}^d$ has weight $\alpha_i\in\mathbb{R}$, the decision function is $$ f(q)=\sum_{i\in S}\alpha_i\,K(q,q_i), $$ with no explicit bias term, $b=0$, and labeling $$ \hat y(q)=\operatorname{sign}f(q), $$ where $+1$ denotes “occupied” and $-1$ denotes “free” [2002.01921]. The same representation can be written by splitting the support set into positive and negative parts, $S=\Lambda^+\cup\Lambda^-$, yielding $$ f(x)=\sum_{i=1}^{M^+}\alpha_i^+\,k(x_i^+,x)-\sum_{j=1}^{M^-}\alpha_j^-\,k(x_j^-,x). $$ The decision boundary $f(x)=0$ separates occupied from free C-space, and support vectors lie near this boundary and grow only when new boundary structure appears [2002.01921]. A closely related manipulator-collision formulation uses $$ f(x)=\sum_{i=1}^N \alpha_i\,K(x_i,x)+b $$ or, equivalently in label-weighted form, $$ f(q)=\sum_{i=1}^n \alpha_i y_i K(q_i,q)+b, $$ with $\operatorname{sign}f(\cdot)=+1$ interpreted as “in collision” and $\operatorname{sign}f(\cdot)=-1$ as “collision-free” [1709.02316][2201.04314]. This family resemblance is substantive: the same kernel-perceptron mechanism is used either as an online occupancy classifier or as a proxy for exact geometric collision detection. The most common kernel in these papers is the Gaussian or radial basis function kernel. In the occupancy-mapping model, $$ K(x,x')=\eta \exp(-\gamma\|x-x'\|^2), $$ with $\eta>0$ and $\gamma>0$ chosen offline, for example by ARD [2002.01921]. In manipulator applications, additional kernels have been studied. The forward-kinematics kernel places control points on the manipulator, computes their workspace positions $FK_m(x)$, and averages second-order rational quadratic kernel evaluations: $$ K_{\mathrm{FK}}(x,x')=\frac{1}{M}\sum_{m=1}^M K_{RQ}\bigl(FK_m(x),FK_m(x')\bigr),\qquad K_{RQ}(u,v)=\Bigl(1+\frac{\gamma}{2}\|u-v\|^2\Bigr)^{-2}. $$ Because it is a convex combination of positive-definite rational quadratic kernels, it is itself positive definite [1910.06451]. ## 2. Incremental learning, sparsification, and conservative biasing The detector is typically trained incrementally on locally observed or selectively relabeled data. In the autonomous navigation setting, the online training algorithm uses only local data $\mathcal D=\{(p_l,q_l)\}$ sampled from the latest depth scan, with $q_l\in\{\pm1\}$. An R*-tree over $\Lambda^+\cup\Lambda^-$ supports fast $k$-nearest-neighbor lookups of support vectors near each $p_l$. For each local point, the algorithm computes $$ F_l=\sum_{i=1}^{K^+}\alpha_i^+\,k(x_i^+,p_l)-\sum_{j=1}^{K^-}\alpha_j^-\,k(x_j^-,p_l), $$ then repeatedly selects the worst-classified point $m=\arg\min_l q_l F_l$, applies a one-step weight correction, updates an existing support vector or inserts a new one, updates all margins $F_l$, and removes redundant supports whose deletion keeps all remaining margins positive. With fixed $N_{\max}$ and small constant $K^+,K^-$, the overall cost is $O(|\mathcal D|)$ [2002.01921]. The same structural ideas appear in Fastron. Its kernel perceptron introduces one-step weight correction, $$ \Delta\alpha_i=r\,y_i-f(x_i), $$ with $r=r^+>1$ for collision points and $r=1$ for free points, margin-based prioritization via $$ i=\arg\min_j \{y_j f(x_j)\}, $$ and redundant-support-point removal after convergence for a fixed number of iterations [1709.02316]. Because $r^+>1$ is used whenever $y=+1$, the learned decision boundary is pushed farther into nominally safe regions, padding the learned $C_{\rm obs}$ in C-space. The stated effect is conservative collision status prediction: false negatives are reduced at the cost of some increase in false positives [1709.02316]. Dynamic environments introduce a relabeling problem. Fastron addresses this with a two-stage active learning strategy. Exploitation rechecks the current support set and nearby non-supports, while exploration uses random samples from the remaining dataset to detect obstacle incursions far from the old boundary. At each control cycle or planning iteration, the method snapshots current workspace obstacles, runs active learning to select a relabeling set $R$, performs kinematic-based collision detection on those points, and reruns the modified kernel perceptron update for up to $M$ iterations [1709.02316]. A plausible implication is that the learned proxy model is most effective when environmental change is localized enough that only a subset of stored configurations changes label between updates. Support-set pruning is central across the literature. In the occupancy-mapping algorithm, only misclassified or borderline points become new support vectors, and redundant support vectors are pruned if all remaining margins stay positive without them [2002.01921]. In D-Fastron and related manipulator variants, sparsification is explicitly treated as the main mechanism for reducing query cost because the online predictor evaluates only the support configurations retained after pruning [2201.04314]. ## 3. Deterministic collision certification for continuous trajectories A distinctive feature of the sparse kernel occupancy-mapping line is that collision checking is elevated from point classification to certification for continuous trajectories. The goal is to certify, for a continuous trajectory $q(t)$, that $f(q(t))<0$ for all $t$, which implies collision-free motion [2002.01921]. For pointwise certification, Proposition 1 derives an upper bound on the classifier score. For any $x$ and any negative support vector $(x_j^-,\alpha_j^-)\in\Lambda^-$, define $$ A=\sum_{i=1}^{M^+}\alpha_i^+,\qquad x_*^+=\arg\min_{x_i^+}\|x-x_i^+\|. $$ Then $$ f(x)\le U(x):=A\,k(x,x_*^+)-\alpha_j^-\,k(x,x_j^-). $$ If $U(x)<0$, then $f(x)<0$, hence $x$ is free [2002.01921]. This converts the full support-vector sum into a sufficient free-space test based on nearest positive and selected negative supports. For piecewise-linear trajectories, let $s(t)=s_0+t v$, $t\ge0$, and assume $U(s_0)<0$. Define $$ \beta=\frac{1}{\gamma}\bigl[\ln\alpha_j^- - \ln A\bigr], $$ and $$ \rho(s_0,x_i^+,x_j^-)= \begin{cases} +\infty,& v^T(x_i^+-x_j^-)\le0,\\[4pt] \dfrac{\beta-\|s_0-x_j^-\|^2+\|s_0-x_i^+\|^2}{2\,v^T(x_j^--x_i^+)},&\text{otherwise.} \end{cases} $$ Proposition 2 states that $s(t)$ is free as long as $$ t1$, the entire segment is free, otherwise the segment is reported in collision [2002.01921]. The naive complexity over all $M$ support vectors is $O(M^2)$, but restricting to $K^+,K^-$ nearest neighbors lowers this to $O(K^+K^-)$ or, with separate $\alpha_j^-$ selection, to $O(K^+)$ [2002.01921]. For piecewise-polynomial curves, the method repeatedly grows a certified free Euclidean ball around the current point. With $$ \bar\rho(s_0,x_i^+,x_j^-)=\frac{\beta-\|s_0-x_j^-\|^2+\|s_0-x_i^+\|^2}{2\|x_j^--x_i^+\|}, $$ one defines $$ r_u=\min_i \bar\rho(s_0,x_i^+,x_j^-),\qquad r_u^*=\min_i \max_j \bar\rho(s_0,x_i^+,x_j^-). $$ All points in the ball $B(s_0,r_u^*)$ are free. The algorithm initializes $t_0=0$, computes a certified radius $r_k$ at each current curve point $s(t_k)$, reports “collision” if $r_k<\epsilon$, solves $\|s(t)-s(t_k)\|=r_k$ for the smallest $t>t_k$, and either reports “free” when the solution reaches $t_f$ or continues iteratively [2002.01921]. The paper explicitly states that these conditions allow complete, without-sampling collision-checking for piecewise-linear and piecewise-polynomial robot trajectories [2002.01921]. The sparse Bayesian extension generalizes this idea to probabilistic occupancy classification. It replaces the hard-margin perceptron score with a probit RVM model, derives predictive probabilities in closed form, and obtains line and curve collision bounds through inflated-boundary constructions under RBF kernels. For line segments, this produces a quadratic $V(t)=a t^2+b t+c$ whose real roots determine whether the whole segment is free; for general curves, one marches along the trajectory through maximal free ellipsoid balls [2009.07207]. This suggests that deterministic certificate-style checking and uncertainty-aware occupancy modeling can coexist within the same sparse kernel framework. ## 4. Data structures, computational profile, and implementation The map representation is explicitly boundary-centric. In the occupancy-mapping formulation, the decision boundary $f(x)=0$ separates occupied from free C-space, support vectors lie near this boundary, and query-time occupancy evaluates the score only over nearest $K^+$ positive and $K^-$ negative support vectors [2002.01921]. An R*-tree stores $\Lambda^+\cup\Lambda^-$ and supports fast $K$-nearest-neighbor queries in $O(\log |\Lambda|)$ [2002.01921]. This is the main reason the representation scales with obstacle boundary complexity rather than map volume. The implementation reported for autonomous navigation uses kernel parameters $\eta=1$ and $\gamma=2.5$, training data sampled on a $0.25\,\mathrm{m}$ grid from each lidar scan, and an R*-tree over support vectors for $k$-NN lookups. The mapping update uses $K^++K^-=200$, while collision checking uses $K^+=K^-=10$ or $2$. The implementation was written in Python and run on an Intel i7-2.2 GHz with 16 GB RAM in simulation and on an Nvidia TX2 on the real car [2002.01921]. Memory use is correspondingly small. Each support vector stores a grid index as a 32 bit int plus a weight as a 32 bit float, for $8$ bytes per support vector. Typical counts are approximately $2{,}000$ support vectors, corresponding to approximately $16\,\mathrm{kB}$, with reported peaks up to approximately $2{,}700$ support vectors, or approximately $21.6\,\mathrm{kB}$. The same experimental summary compares this with OctoMap at approximately $12{,}372$ octree nodes times $2$ bytes, or approximately $24.7\,\mathrm{kB}$ [2002.01921]. The reported runtime is also explicitly quantified. Map update per lidar scan is approximately $0.11\,\mathrm{s}$. Linear-segment collision checking is approximately $15\,\mu\mathrm{s}$ per segment using score approximation on $M\approx10^3$ to $10^4$ support vectors, and polynomial-curve checking is approximately $40\,\mu\mathrm{s}$ per motion primitive in real experiments [2002.01921]. In warehouse simulation, the kernel map against ground truth achieved $98.5\%$ accuracy and $97.4\%$ recall for the inflated map, compared with an OctoMap baseline of $96.1\%$ accuracy and $96.8\%$ recall [2002.01921]. In manipulator settings, complexity statements are usually phrased relative to the support set. Fastron model queries take $O(|S|)$ kernel evaluations, and each model-update step is dominated by updating the margin vector through one column of the Gram matrix, which is $O(N)$. With capped update iterations $M$ and relabeling budget $A$, the total per-cycle cost is stated as $O(A\cdot \mathrm{cost}_{KCD}+M\cdot N)$ [1709.02316]. D-Fastron further reduces effective query cost by replacing one large model with several local ones; if there are $k$ clusters with roughly $N/k$ points each, the total training cost is $O(N^2/k)$ and the query cost becomes $O(3M+k+|S|/k)$ rather than $O(|S|)$ [2201.04314]. ## 5. Major variants and extensions The first major branch is Fastron, introduced as an online learning-based model and active learning strategy for proxy collision detection. It models C-space obstacles with a kernel perceptron, allows iterative updates in changing environments, and is explicitly designed as a proxy to kinematic-based collision detection rather than as an occupancy map [1709.02316]. Its emphasis is conservative prediction through obstacle padding, active learning under finite collision-checking budgets, and real-time CPU-only operation. A second branch is sparse kernel-based occupancy mapping for autonomous navigation in unknown environments. Here the kernel-perceptron detector is not merely a classifier over stored samples; it is the map itself. The environment boundary is encoded by the support vectors, and the same sparse representation supports both mapping and deterministic collision checking for continuous trajectories [2002.01921]. This is the formulation most directly associated with the phrase “Kernel-Perceptron Collision Detector” in onboard navigation. The sparse Bayesian extension generalizes the kernel perceptron model to a probabilistic map using a probit Relevance Vector Machine. Features are kernel evaluations against a sparse set of relevance vectors, the posterior over weights is Laplace-approximated, and the predictive output is $$ p(y|x)\approx \Phi\!\Bigl(\frac{\phi(x)^T\mu+b}{\sqrt{1+\phi(x)^T\Sigma\phi(x)}}\Bigr). $$ The paper states that this formulation allows robustness to measurement noise and probabilistic occupancy classification, while retaining efficient collision checking for general curves [2009.07207]. In the comparison included in that work, kernel-perceptron or RVM methods store only $O(\#\text{boundary points})$ support or relevance vectors, whereas voxel and octree representations discretize the entire space and grow with volume and resolution [2009.07207]. For manipulators, the forward-kinematics kernel modifies the similarity measure rather than the learning rule. By comparing workspace control-point positions rather than raw joint vectors, it improves proxy collision checking within the Fastron framework. The reported results on a $7$-DOF Baxter arm are a proxy-check time of $2.5\pm0.5\,\mu\mathrm{s}$ for Fastron FK versus $4.6\pm1.1\,\mu\mathrm{s}$ for Fastron RBF, model sizes of $302\pm110$ supports versus $2369\pm584$, update times of $55.8\pm4.8\,\mathrm{ms}$ versus $129.4\pm30.2\,\mathrm{ms}$, and classification accuracy of $96.4\%$ versus $74.5\%$ [1910.06451]. D-Fastron extends this line through configuration-space decomposition in forward-kinematics space. A feature map $\phi(q)=[fk_1(q);\dots;fk_M(q)]\in\mathbb{R}^{3M}$ is clustered with K-Means++, one Fastron model is trained per cluster, and each query is routed to the nearest centroid before local model evaluation [2201.04314]. The paper reports that D-Fastron support sets are $20\times$ to $30\times$ smaller than a global Fastron while maintaining $>95\%$ accuracy, and that on the $7$-DOF Baxter it produces on average $29\times$ faster collision checks and up to $9.8\times$ faster motion planning compared to state-of-the-art geometric collision checkers [2201.04314]. ## 6. Empirical profile, scope, and common sources of confusion Representative quantitative results across the literature are summarized below. | System | Representative result | Source | |---|---|---| | Sparse kernel occupancy map | $98.5\%$ accuracy, $97.4\%$ recall; linear collision check $\sim15\,\mu s$/segment | [2002.01921] | | Fastron | Proxy collision checks at least $2$ times faster than an efficient polyhedral collision checker and at least $8$ times faster than an efficient high-precision collision checker | [1709.02316] | | Fastron FK | $2.5\pm0.5\,\mu s$ proxy checks; about $8\times$ less memory; $96.4\%$ overall accuracy | [1910.06451] | | D-Fastron | On average $29\times$ faster collision checks and up to $9.8\times$ faster motion planning; overall accuracy $>95\%$ | [2201.04314] | Two recurring interpretive issues should be separated. First, conservative proxy collision detection is not the same as exact geometric collision detection. In Fastron, padding the learned obstacle region is explicitly intended to reduce false negatives while accepting more false positives [1709.02316]. In OMPL integrations with Fastron FK, this is handled by a “Verify & Repair” stage using FCL after planning with the proxy checker [1910.06451]. Second, not all kernel-perceptron collision detectors are probabilistic. The plain kernel perceptron has no explicit noise model; the sparse Bayesian variant adds posterior uncertainty and threshold control through the probit RVM formulation [2009.07207]. A separate terminological confusion arises from the word “collision” itself. In the paper “Are Neural Networks Collision Resistant?” the term refers to two distinct weight vectors that assign the same labels to all data, not to geometric contact or C-space occupancy. That work studies collision-finding for a square-wave perceptron, overlap-gap barriers, and candidate collision-resistant functions, and is conceptually distinct from robotic collision detection despite the shared perceptron vocabulary [2509.20262]. Taken together, the literature defines the kernel-perceptron collision detector as a sparse decision-boundary method for C-space classification whose principal strengths are incremental learning, small memory footprint, rapid query time, and, in the occupancy-mapping setting, certificate-style collision checking for continuous motions. Variants differ mainly in how similarity is defined, how uncertainty is modeled, and how sparsity is organized, but they share the same central premise: the geometry of collision-relevant boundaries can be captured by a compact kernel machine rather than by exhaustive geometric or volumetric enumeration [2002.01921]. Source: https://www.emergentmind.com/topics/kernel-perceptron-collision-detector