Unified Prediction and Planning via Conflict-Aware Disjoint Parameter Training

AI summary

Overview

• Research area: Robotics — unified motion prediction and motion planning for social robot navigation in crowded environments, addressed through a model-merging framework.
• Technical level: Advanced (assumes familiarity with multi-task learning, task vectors, model merging, and trajectory prediction/planning metrics).
• Scope: The paper identifies a parameter-level "Skill Conflict" inside the shared encoder of compact prediction-and-planning models and proposes Disjoint Parameter Training (DPT) plus Sparse Merging to resolve it, evaluated on the JRDB and JTA crowd navigation benchmarks.

What This Paper Is About

Unified robot navigation models typically run prediction (forecasting how nearby people will move) and planning (choosing the robot's own safe trajectory) through one shared encoder. Because these two tasks want different kinds of features, and because compact edge-deployable models have little spare capacity, the two tasks end up competing for the same weights and degrade each other. The paper names this phenomenon Skill Conflict, measures it directly, and proposes a training-and-merging scheme that gives each task its own non-overlapping parameter region before the two are combined into a single model.

Key Contributions

1. Definition and empirical analysis of Skill Conflict. The authors define Skill Conflict as overlapping parameter assignments that force distinct tasks to compete for the same weights, and quantify it in a shared-encoder prediction–planning model, showing measured overlaps of 8.35% at a 10% mask ratio rising to 39.25% at a 50% mask ratio.
2. Disjoint Parameter Training (DPT). A fine-tuning strategy that alternates between prediction and planning, permanently allocating the top-K unassigned parameters with the largest absolute gradients to each task via binary masks, growing those masks during the first half of training and freezing them in the second half. This produces task-specialized "material" models whose core encoder regions are mutually exclusive by construction.
3. Sparse Merging. A merging operation that combines only a restrictive, high-magnitude fraction of each task vector (mask ratio K = 1% in the main experiments) rather than the full masked coordinates, on the argument that adjacent or nearby parameters still couple features even when their primary supports are disjoint.
4. Broad applicability evidence. Experiments showing DPT improves Task Arithmetic, Ties Merging, and Sparse Merging on both JRDB and JTA, and that adding a joint-reasoning fine-tuning stage on the parameters left inactive after DPT and Sparse Merging yields further gains.

Main Findings

• Single-task performance improves steadily with parameter utilization; joint performance saturates early. Sweeping the mask ratio K over [10%, 90%] and reporting 1/ADE (higher is better), single-task merges (Plan Merged, Pred Merged) keep improving and plateau high, while the two-task merge (Both Merged, with the non-target task fixed at 40% utilization) gains only marginally before saturating at a substantially lower ceiling.
• The overlap metric explains the saturation. At K = 10%, the planning and prediction activation masks overlap by 8.35%; at K = 50%, overlap surges to 39.25%, meaning the shared encoder becomes increasingly entangled as each task claims more parameters.
• DPT improves every merging method tested. Table 1 reports that applying DPT before merging improves Task Arithmetic, Ties Merging, and Sparse Merging across planning and prediction metrics on both JRDB and JTA, and that Plan Finetune and Pred Finetune performance remains largely unchanged with DPT, indicating the method does not degrade inherent single-task capability.
• Smaller DPT allocation budgets favor the corresponding task. On JRDB with Sparse Merging at K = 1%, increasing a task's DPT allocation ratio lowers its own performance (e.g., a 90/10 Plan/Pred split gives planning ADE 0.4899 and prediction ADE 0.5777, while 10/90 gives planning ADE 0.3898 and prediction ADE 0.6046; the 50/50 split gives 0.4044 and 0.5952). The authors interpret this as evidence that larger learnable regions spread a skill across more parameters.
• Sparse is better than dense. With a 50:50 DPT allocation on JRDB, K = 2 gives the best overall performance across all metrics (planning ADE 0.4041, collision rate 0.0096, FDE 0.7320, miss rate 0.3697; prediction ADE 0.5753, FDE 1.0174), with gradual degradation as K increases to 5, 10, 20, and 40.
• DPT maintains performance where the baseline saturates. Repeating the mask-ratio experiments with DPT applied shows both tasks retaining high performance even with large parameter allocations, and reaching high single-task performance quickly with small allocations.
• DPT + Sparse Merging beats unified and merging baselines on JRDB. All at K = 1% for Sparse Merging: DPT + SM records planning ADE 0.4044, collision rate 0.0091, FDE 0.7458, miss rate 0.3706 and prediction ADE 0.5952, FDE 1.0352, compared with DIPP (0.8048, 0.0167, 1.3542, 0.6940, 0.8834, 1.6406), DTPP (0.6232, 0.0145, 1.1338, 0.6931, 0.7686, 1.4253), Ensemble (0.5807, 0.0146, 0.9000, 0.4786, 1.1313, 1.5258), Task Arithmetic (0.9387, 0.0189, 1.1798, 0.8887, 0.9904, 1.3870), Ties Merging (0.8759, 0.0167, 1.1503, 0.9019, 0.9463, 1.3412), Localize-and-Stitch (0.8838, 0.0176, 1.1393, 0.9487, 0.8104, 1.2670), and T-Switch (0.8047, 0.0199, 1.1009, 0.8784, 0.8091, 1.2112).
• Adding joint reasoning helps further. DPT + SM + JR improves over DPT + SM alone, reaching planning ADE 0.3640, collision rate 0.0074, FDE 0.7105, miss rate 0.3589 and prediction ADE 0.5097, FDE 0.9396.
• The Ensemble baseline outperforming other merging baselines suggests the conflict is parameter-level. Since averaging fine-tuned models at inference (which leaves parameters untouched) beats parameter-merging baselines, the authors argue the planning–prediction conflict is primarily parameter-level rather than output-level.
• Qualitative results show the same pattern. In dense JRDB scenes, DIPP and DTPP show poor prediction and planning for nearby agents, and Localize-and-Stitch (which merges only 1% of a sparse subset into the pretrained weights) retains the pretrained model's aggressive-prediction/safe-planning behavior, while DPT + Sparse Merging produces accurate prediction and safer plans.

Methodology in Plain English

The authors start from a pretrained Social-Transmotion backbone, extended with a planning decoder, and pretrain it with a game-theoretic loss. They then set up the standard model-merging recipe: fine-tune a separate copy of the model for each task (these copies are called "material" models), subtract the pretrained weights to get a "task vector" per task, and combine the vectors back into one model.

Their diagnostic tool is a binary mask that keeps only the top-K percent of task-vector coordinates by magnitude. Sweeping K shows that when each task tries to claim more of the model, the two tasks' masks overlap more and joint performance stops improving. To fix this, DPT alternates between the two tasks during fine-tuning. At each step it computes gradients over the whole model but updates only the highest-gradient parameters that neither task has claimed yet, permanently assigning them to the current task through a mask. Masks grow through the first half of training and are frozen in the second half so each task can consolidate its region. Finally, Sparse Merging combines only a very small fraction (K = 1% in the main results) of each task's vector, on the reasoning that nearby parameters can still interfere functionally even without direct coordinate overlap. An optional joint-reasoning fine-tuning stage then uses the leftover, inactive parameters to recover cross-task reasoning.

Why This Matters

The paper argues that model merging research has been developed almost entirely for massive language models, where parameter capacity is abundant and each task can occupy a sparse, largely distinct subspace. Compact robots have no such luxury, so the interference problem is qualitatively different and more severe. Framing the failure as a measurable, quantifiable overlap and showing that it can be eliminated during training rather than patched at merge time is the paper's distinctive move.

Real-world applications:

• Mobile service robots in crowded spaces — indoor/outdoor pedestrian environments like those in the JRDB dataset, where the robot must both anticipate pedestrian motion and plan safe paths on limited onboard compute.
• Edge-deployed autonomous systems — any platform where inference latency and memory budgets rule out keeping multiple task-specific models or expert branches at runtime.
• Assistive and delivery robots — navigation around people where collision avoidance (safety) and goal completion matter simultaneously.
• Autonomous driving — the paper reports an extension to end-to-end autonomous driving with closed-loop and open-loop evaluation in the vehicle domain in its supplementary material.

Industry relevance: the framework is designed to be applied in parallel with whatever merging method an engineering team already uses, so it can improve existing compact multi-task deployment pipelines without replacing the underlying architecture. The paper also notes it examines training cost and inference efficiency in supplementary material, which matters for whether the approach fits production budgets.

Future Directions

• Scaling the conflict analysis to other backbones and capacities. The paper already repeats the Skill Conflict study on DTPP and reports additional studies across architectures, model capacities, DPT settings, random seeds, controlled overlap, sub-task decomposition, mask evolution, and layer-wise conflict analysis in supplementary material; extending this systematically would clarify how general the phenomenon is.
• Better accounting for functional, non-coordinate interference. Sparse Merging exists precisely because disjoint masks are not sufficient; characterizing which nearby parameters couple and why remains open.
• Automating the allocation and mask-ratio choices. Both the DPT allocation ratio and the Sparse Merging mask ratio K measurably change performance, and the paper reports no procedure for selecting them ahead of time.
• Extending to full autonomous driving. The paper reports a supplementary extension to end-to-end driving with closed-loop and open-loop evaluation, which points toward validating the framework outside crowd navigation.

Target Audience

Researchers and engineers working on multi-task learning, model merging, and efficient robot navigation — particularly those deploying joint prediction-and-planning models on resource-constrained edge hardware, and those studying task interference in shared encoders. Readers should be comfortable with task vectors, fine-tuning, and trajectory prediction/planning metrics such as ADE, FDE, collision rate, and miss rate.

Authors’ abstract

Accurate motion prediction of surrounding agents and safe motion planning are two closely coupled key tasks for social robot navigation in crowded environments. Deploying these systems on resource-constrained edge devices necessitates compact, unified models that can perform both tasks simultaneously. However, within these compact shared encoders, recent unified models often overlook severe representational conflicts that arise from the distinct objectives of predicting neighbor behaviors versus ego-centric safety planning. To address this issue, we first identify the Skill Conflict$\unicode{x2014}$a phenomenon where overlapping parameter assignments cause distinct tasks to compete for the same weights, preventing the model from fully specializing in individual skills. To resolve this, we propose a novel model-merging-based framework, Disjoint Parameter Training (DPT). DPT mitigates performance degradation caused by Skill Conflict through distributed parameter learning, which separates the key parameter regions of each task while preserving their core capabilities prior to merging. In addition, we observe that sparse merging, which selectively integrates only the most influential parameters for each task rather than combining all task-specific parameters, yields optimal performance by preventing interference among adjacent features and concentrating representational capacity. DPT can be applied in parallel with a variety of merging methods. Evaluated on standard crowd navigation benchmarks (JRDB and JTA), our framework demonstrates superior performance, validating its versatility and effectiveness for safe, resource-efficient robot navigation.