Adaptive Module Composition

• Adaptive module composition is a strategy that dynamically assembles task-specific modules to support continual learning and efficient parameter management.
• The approach utilizes cosine similarity between input embeddings and task representation vectors to select, update, and prune modules, ensuring targeted learning and reduced redundancy.
• Empirical results show state-of-the-art performance with significant parameter reductions across diverse benchmarks, proving its efficacy in scalable machine learning.

Adaptive module composition is a foundational principle in contemporary machine learning and systems engineering, denoting the dynamic and task-dependent assembly of functional units ("modules") to achieve desirable properties such as continual learning, parameter efficiency, compositional generalization, privacy, and runtime adaptability. The field encompasses a wide range of algorithmic strategies for constructing, selecting, combining, and pruning modules so that models and systems retain the ability to learn incrementally, mitigate forgetting, transfer knowledge, and meet operational constraints.

1. Architectural Foundations of Adaptive Module Composition

The central architectural motif is a modular system—typically a fixed backbone (e.g., pretrained LLM or core neural architecture) augmented by a library of lightweight, task- or feature-specific modules. In continual learning scenarios, new modules are allocated for each incoming task, and the overall model dynamically composes previously learned and newly introduced modules to form task-specific solutions (Wang et al., 2024).

In MOCL-P, the module library consists of prefix-tuning modules $P_k$, each attached to a task representation vector $v_k \in \mathbb{R}^D$. New inputs are processed by assembling a composite prompt $\overline{P}(x)$, which is a weighted sum of relevant modules:

$$\overline{P}(x) = \sum_{k=0}^{m} \hat{\alpha}_k \cdot P_k$$

where coefficients $\hat{\alpha}_k$ are normalized cosine-similarities between the input embedding $h(x)$ and each module's $v_k$. Only the new module $P_m$, along with its associated $v_m$, are updated during training; older modules remain frozen.

This paradigm contrasts with monolithic architectures, enabling greater control over parameter growth, knowledge isolation, and targeted knowledge transfer.

2. Task Representation-Guided Composition and Training Dynamics

Adaptive composition is driven by automated matching of task representations to module features. For MOCL-P, for each training or inference sample, matching scores $\alpha_k = \text{cos}(h(x), v_k)$ are computed and normalized. This representation-guided weighting allows for efficient integration and reuse of earlier modules, while permitting the network to focus on novel aspects via a freshly allocated module.

The joint optimization objective on a newly arriving task $T_n$ is:

$$\min_{P_m, v_m} \left( -\sum_{(x,y)\in T_n} \log p(y|x;\overline{P}(x)) - \lambda \sum_{x\in T_n} \text{cos}(h(x), v_m) \right)$$

Here, the first term is standard cross-entropy for supervised learning; the second term regularizes the internal alignment between $v_m$ and the embeddings of its associated inputs, promoting module-feature specialization.

At inference, the system recomputes the module weights for each input, assembles the composite prefix, and forwards through the backbone in standard prefix-tuning fashion.

3. Adaptive Pruning for Parameter Efficiency

A key innovation of MOCL-P is the adaptive pruning strategy, which ensures parameter efficiency and prevents unnecessary proliferation of modules. After training on task $T_n$, the average matching coefficient $\alpha_m^\ast$ is calculated for the newly introduced module $P_m$:

$$\alpha_m^\ast = \frac{1}{|T_n|} \sum_{(x,y)\in T_n} \hat{\alpha}_m(x)$$

If $\alpha_m^\ast$ falls below a predefined threshold $\tau$, $P_m$ is deemed non-essential and is discarded; otherwise it is added (frozen) to the module library. This "learn it or leave it" rule enforces continual forward transfer and ruthless parameter pruning. The pruning threshold $\tau$ is empirically tuned per benchmark.

4. Algorithmic Workflow and Hyperparameter Choices

A typical pipeline for handling a new task is:

1. Allocate a new module $P_m$ and its vector $v_m$.
2. For several epochs:
   • For each minibatch, compute embeddings, module matching weights, form the composite prompt, evaluate losses, and backpropagate exclusively into $P_m$ and $v_m$.
3. Average the matching weights over the task.
4. Prune or keep $P_m$ based on whether its average weight exceeds $\tau$.

Key hyperparameters include module size (30–100 continuous vectors per task), feature vector dimension (equal to PLM embedding size), pruning threshold ($\tau$ varies by task set), representation loss weight ($\lambda$), and epochs to learn $v_m$ (4–6 typically suffice).

5. Empirical Performance and Comparative Analysis

MOCL-P achieves state-of-the-art results across diverse benchmarks:

Benchmark	Tasks	MOCL-P Score	Params	Prior Best	Params (Prior)	Parameter Reduction
AfriSenti	12	59.4 ± 0.1 F1	2.2M	59.3 F1	4.5M	2× fewer, equal accuracy
WikiAnn	176	73.9 ± 0.1 F1	8.0M	73.8 F1	24.9M	3× fewer, equal accuracy
MTL15	15	82.5 ± 0.9 %	15.6M	82.5 %	21.1M	~25% fewer, identical

These results attest to the efficacy of adaptive composition and pruning for achieving scalable continual learning with dramatic reductions in parameter overhead (Wang et al., 2024).

6. Limitations, Extensions, and Future Directions

MOCL-P and related frameworks are currently evaluated primarily on classification-style tasks. Applying adaptive module composition to generative NLP remains an open direction. The pruning criterion relies on a single fixed threshold $\tau$; more sophisticated schemes could involve module- or task-specific thresholds, or learnable criteria.

While simple vector-based task representations outperform richer methods (e.g., adapters, Gaussian embeddings), further research into graph-based task embeddings or other manifold representations could yield improved matching and modularity.

Task-agnostic continual learning (i.e., without available task IDs at inference) will require integrated mechanisms for automatic task detection and routing, potentially leveraging module composition and pruning to maintain a compact and effective module library.

7. Broader Context and Related Methodologies

Adaptive module composition is prevalent across multi-task learning, compositional instruction following, modular reinforcement learning, privacy-preserving analytics, and even runtime system reconfiguration. In compositional instruction-following frameworks, hard gating via CRF-based subgoal controllers routes control flow among specialized subgoal modules, yielding competitive gains in generalization to novel or unseen subgoal combinations (Corona et al., 2020).

In reinforcement learning, compositionality is realized by dynamically assembling policy modules for distinct subproblems; lifelong RL agents exploit accumulated modules for rapid adaptation and robust retention (Mendez et al., 2022). Modular composition principles are applied in continual learning methods (e.g., local module composition with layerwise gating (Ostapenko et al., 2021)), adaptive MLaaS in IoT using bandit-based module selection (Kanneganti et al., 22 May 2025), and even runtime module loading/unloading in emulation frameworks for ISA extensibility (Kourzanov et al., 22 May 2025).

The conceptual convergence across domains highlights adaptive module composition as a unifying strategy for scalable, efficient, and resilient learning systems.