Instance-Level Task Parameters

• Instance-level task parameters are per-instance variables that enable granular, context-dependent adaptations in computation and processing.
• They incorporate learned weights, masks, and control settings to tailor operations for improved performance in multi-task learning, vision, robotics, and language tasks.
• These parameters improve efficiency and robustness by dynamically adjusting methods such as filtering, gating, and controller tuning based on individual data characteristics.

Instance-level task parameters are context-dependent, per-example or per-instance variables—or learned weights, maskings, filtering rules, or control settings—enabling granular, situationally adaptive operation in multi-task learning, communication, control, mapping, retrieval, and reasoning systems across vision, robotics, and language domains. Instance-level task parameterization fundamentally extends traditional task- or class-level processing by making computation, information transmission, or optimization contingent on features of individual data points or problem instances, typically for improved efficiency, generalization, interpretability, or robustness.

1. Definition and Core Principles

Instance-level task parameters are variables, sets, or configurations assigned, predicted, or learned for each data instance, rather than globally for tasks or classes. Their function is to enable selective, granular adaptation: filtering which objects to communicate in ICV scenes (Zhang et al., 27 Dec 2025), adjusting network block usage per input in MTL (Rahimian et al., 2023), selecting or weighting control gains for each trajectory segment in control (Cheng et al., 2024), tuning reasoning plans for each LLM prompt (Gunasekara et al., 4 Jul 2025), or enabling retrieval by individual object identity in composed queries (Psomas et al., 29 Oct 2025). Compared to traditional task-level parameterization, their salient property is per-instance specificity, precisely targeting heterogeneity among data points.

2. Instance-Level Task Parameter Types and Formalizations

The design and mathematical representation of instance-level parameters vary by domain:

• InsCom (ICVs): Utilizes two user-configurable sets:
  • $\mathcal{C}_T$: set of subject semantic class labels critical to the downstream task.
  • $\mathcal{IR}_T$: set of $(\text{relation}, \text{object-semantic})$ pairs, identifying critical context-specific relationships.
  • Filtering proceeds first at semantic-class level, then at relationship-instance level, yielding instance-specific masks on the input scene (Zhang et al., 27 Dec 2025).
• DynaShare (Multi-Task Learning): Employs binary gates per block:
  • $u^\ell_k$: task-level gate for block $\ell$ and task $k$ (fixed post-training).
  • $w^\ell(i)$: instance-specific gate for block $\ell$ and input $i$.
  • The merged gate $g^\ell_{k,i}=u^\ell_k \cdot w^\ell(i)$ determines per-instance execution paths through the network (Rahimian et al., 2023).
• Task-Parameter Nexus (TPN, Model-Based Control):
  • $\boldsymbol{\theta}_s$: optimal control parameters predicted per trajectory segment $T_s$ (instance), determined via offline auto-tuning across local trajectory perturbations and then learned via supervised mapping from trajectory features to $\boldsymbol{\theta}_s$ (Cheng et al., 2024).
• iSelf-Discover (LLM Reasoning):
  • At each problem instance $t_i$, a distinct reasoning plan and module subset $D_S, D_A$ and either a structured ($R_S$) or unstructured ($R_U$) plan is computed dynamically for each instance (Gunasekara et al., 4 Jul 2025).
• OpenMulti (Collaborative Mapping):
  • $C_{k,t,i}$: per-frame confidence for instance $i$ in agent $k$’s view.
  • Graph alignment thresholds ($\tau_{\text{IoU}}$, $d_\text{th}$) and codebook (CLIP, SBERT features) are used to uniquely align and fuse each object instance across agents for instance-consistent mapping and retrieval (Dou et al., 1 Sep 2025).
• Instance-Weighted MTL:
  • $w_{i,t}$: per-sample, per-task learnable weight that moderates each task’s loss for instance $i$; updated via gradient descent, automatically emphasizing uncorrupted or informative examples (Vasu et al., 2021).
• Instance-Level MIL Risk:
  • Defines and minimizes an unbiased estimator of instance-level risk in multiple-instance learning without instance labels, permitting optimization of instance-level classifiers under bag-level supervision (Peng et al., 2019).

3. Algorithmic Workflows and Optimization

InsCom: Instance Filtering for ICVs

1. Semantic Filtering: Prune scene graph triplets $\langle s_v, r_{v,w}, o_w \rangle$ where $\phi(s_v) \not\in \mathcal{C}_T$.
2. Instance Filtering: Retain only those for which $( r_{v,w}, \phi(o_w) ) \in \mathcal{IR}_T$.
3. Binary Masking: Inclusive masks $m_{\text{sem}}$, $m_{\text{ins}}$ are constructed per pixel. The intersection $m_T = m_{\text{sem}} \wedge m_{\text{ins}}$ selects only pixels comprising accepted, task-critical instances.
4. Transmission: The masked image $x_T = m_T \odot x$ is forwarded to ISE for downstream encoding (Zhang et al., 27 Dec 2025).

DynaShare: Dynamic Gating in MTL

• Training: Alternates between updating network weights given current gates and optimizing $\{\alpha_{\ell, k}\}$ for task-level gates; instance-gate relevance scores are trained to target a desired activation rate per block.
• Inference: For input $i$, and task $k$, instance relevance units determine $w^\ell(i)$, leading to skip/execution of each block for that example (Rahimian et al., 2023).

TPN: Per-Trajectory Gain Selection

• Offline (Batch-DiffTune): For each segment, perturb waypoints to build a batch $\mathcal{B}$; optimize controller parameters $\boldsymbol{\theta}^*(\mathcal{B})$ to minimize average tracking error via projected gradient descent.
• Online: Neural network maps trajectory features (flattened waypoints) to new $\boldsymbol{\theta}$ for unseen tasks (Cheng et al., 2024).

Instance Risk for MIL

• Uses an unbiased estimator of instance-level risk, given only bag labels, with a formula involving an average over all instances (for $y=1$) plus a $\pi_0$-weighted correction for negative-bag instances (difference in loss for $y=0$ vs $y=1$).
• Slack variables enforce bag-level constraints (Peng et al., 2019).

4. User Configuration and Hyperparameter Selection Strategies

Instance-level task parameters may be user-specified (e.g. $\mathcal{C}_T$, $\mathcal{IR}_T$ in InsCom) or learned from data (e.g. weights $w_{i,t}$ in instance-weighted MTL). Typical selection strategies include:

• Semantic and relation filters (InsCom): Set at deployment per downstream task; choosing smaller $\mathcal{C}_T$ / stricter $\mathcal{IR}_T$ reduces bandwidth and redundancy but must capture all safety-critical contexts. Empirically, restricting to hazardous pedestrian classes and crossings produces $>7.8\times$ data reduction and substantial PSNR improvements (Zhang et al., 27 Dec 2025).
• Regularization and masks (DynaShare, MTL): Regularizer weights $\lambda_{\text{sparsity}}$, $\lambda_{\text{sharing}}$, and target rates $t$ determine the granularity and computation cost of adaptivity. Ablation demonstrates that full task+instance gating gives the highest accuracy/computation tradeoff (Rahimian et al., 2023, Vasu et al., 2021).
• Thresholds and alignment (OpenMulti): IoU/Iob/distance thresholds govern when two instances are merged across agents. Default values ($\tau_{\text{IoU}}=0.3$, $d_\text{th}=0.01$ m) are robust; raising $\tau_{\text{IoU}}$ decreases false merges but may hurt recall (Dou et al., 1 Sep 2025).
• Hyperparameters (MIL): The constraint weight $C$ is selected by cross-validation, bounded, Bayes-consistent losses (MSE) prevent overfitting; instance-negative prior $\pi_0$ is estimated empirically (Peng et al., 2019).

5. Quantitative Impact and Empirical Evidence

Instance-level parameterization consistently yields measurable gains in efficiency and/or task performance:

• InsCom: In collision-warning configuration,
  • $>7.8\times$ reduction in data volume compared to NTSCC,
  • Task-Critical PSNR boost of $1.75$–$14.03$ dB,
  • $>7.8\times$ reduced bit usage over BPG+LDPC (Zhang et al., 27 Dec 2025).
• DynaShare:
  • On NYU-v2, DynaShare($t=0.55$) yields $+14.4\%$ over AdaShare, with $-42\%$ FLOPs;
  • On Cityscapes, $+5.0\%$ lift, $-13\%$ FLOPs;
  • On MIMIC-III, $+15.5\%$ improvement vs. single-task (Rahimian et al., 2023).
• OpenMulti: Instance-level alignment and semantic graph fusion yield fine-grained geometric accuracy (Acc $2.5$ cm, F-mIoU $46\%$) and enable instance-level retrieval with codebook-backed semantic features (Dou et al., 1 Sep 2025).
• Instance-weighted MTL: Up to $60\%$ reduction in surface error under heavy label corruption (SURREAL), robust performance on CityScapes segmentation and robust label-noise detection (Vasu et al., 2021).

6. Limitations and Considerations

While instance-level parameters enable powerful adaptivity, their practical deployment entails:

• Memory overhead: Explicit storage of per-instance parameters scales with dataset size (e.g. $400$k in SURREAL is $\sim1\%$ of total parameters) but is manageable with sparse updates (Vasu et al., 2021).
• Sensitivity to configuration: In communication and mapping, over-pruning can miss critical information; under-pruning defeats the purpose.
• Statistical efficiency: Estimators like the unbiased risk for MIL require accurate empirical priors and robust loss functions to avoid overfitting (Peng et al., 2019).
• Transferability: QAOA studies show parameters optimized on small prototypical instances of the same class can transfer effectively, but across-divergent instance classes must be handled carefully (Katial et al., 2024).
• Computational cost: Offline tuning (e.g. TPN’s Batch-DiffTune) can be expensive; for online systems, efficient inference (e.g. MLPs, sparse network activation) is essential (Cheng et al., 2024).

7. Domain-Specific Applications and Extensions

Instance-level task parameterization is increasingly central in diverse fields:

• Vehicular communication (ICVs): Real-time masking and transmission of only context-critical objects and relations (Zhang et al., 27 Dec 2025).
• MTL & Computer Vision: Adaptive computation and loss weighting per input; instance-level parsing, composition, fine-grained retrieval, or mask refinement (Rahimian et al., 2023, Zhang et al., 2022, Psomas et al., 29 Oct 2025).
• Robotics and Control: Rapid instance-specific controller tuning for task-varying motion requirements, as well as skill learning across varying task geometries (Cheng et al., 2024, Huang et al., 2017).
• Instance-level Retrieval & Mapping: Uniquely identifying, aligning, and retrieving fine-grained entities across large databases or map representations (Psomas et al., 29 Oct 2025, Dou et al., 1 Sep 2025).
• Learning under weak supervision (MIL): Direct optimization of instance-level performance, even with only bag-level or group-level supervision (Peng et al., 2019).
• LLM Compound Systems: Tuning reasoning and planning at the per-instance level, adapting logic or tool invocation dynamically (Gunasekara et al., 4 Jul 2025).

These advances continue to demonstrate that instance-level task parameters are essential primitives for scalable, adaptive, and robust systems in multi-modal, multi-agent, and multi-task scenarios.