Task Vectors

A task vector is fundamentally a directional delta in weight space, calculated as ΔW = W_finetuned - W_pretrained. This vector can be added to the base model's weights to impart the new task's capability. This linearity enables arithmetic operations like task vector addition (Task A + Task B) or negation (-Task A) to combine or remove behaviors, forming the basis for model arithmetic and task composition.

While the vector itself is the same size as the model, it is a static artifact representing the outcome of fine-tuning. Its primary efficiency comes from enabling selective application. Engineers can store many compact task vectors (just the delta weights) and apply them dynamically to a single frozen base model, avoiding the cost of storing or serving many fully independent fine-tuned models. This is a form of memory-efficient multi-task serving.

The linear representation allows for intuitive manipulation:

• Task Addition: W_new = W_base + ΔW_task1 + ΔW_task2 to create a multi-task model.
• Task Negation: W_new = W_base - ΔW_biased to reduce an unwanted behavior.
• Interpolation: W_new = W_base + α * ΔW_task to control the strength of a capability. This facilitates model editing and the creation of custom model blends without retraining, though effectiveness depends on linearity assumptions in the loss landscape.

Empirical studies show task vectors are often sparse; significant changes are concentrated in specific layers (often middle layers) and neurons. This sparsity suggests the model's knowledge is modularly organized. Furthermore, vectors for different tasks can be decomposed into shared, reusable components and task-specific components. This insight drives more efficient methods like training on vector subspaces or applying updates to only a critical subset of parameters.

A core challenge is task interference. Simply adding multiple task vectors can lead to performance degradation on individual tasks, as the parameter changes are not perfectly orthogonal. This is a manifestation of catastrophic forgetting in a static, additive paradigm. Mitigation strategies include:

• Orthogonalization of vectors before addition.
• Sequential application with lightweight regularization.
• Using sparse masks to apply each vector to non-overlapping parameter subsets.

Task vectors are the fundamental unit in model merging techniques like Task Arithmetic and TIES-Merging. These methods use vectors from multiple fine-tuned models to create a unified model that performs well across all source tasks. The process involves:

1. Trimming: Removing redundant or contradictory parameter changes within each vector.
2. Electing Sign: Resolving sign conflicts for each parameter across vectors.
3. Disjoint Merging: Combining the elected changes. This allows the creation of generalist models from specialist ones.

Adapter layers are small, bottleneck feed-forward networks inserted sequentially after the attention and feed-forward modules within a frozen transformer block. They project activations to a lower dimension, apply a non-linearity, and project back up. Like task vectors, they represent a parameterized adaptation, but are integrated as discrete modules rather than a global arithmetic delta applied to the base weights.

Prompt tuning learns a small set of continuous embedding vectors (soft prompts) that are prepended to the input sequence. This conditions the frozen pre-trained model for a specific task. It is distinct from task vectors, as it operates purely in the input embedding space rather than modifying the model's internal weights. The learned prompts act as a task-specific context signal.

Delta tuning is the overarching family of methods that update only a small subset of parameters (the 'delta') while keeping the base model frozen. Task vectors, LoRA, and adapters are all specific instantiations of delta tuning. The core principle is that effective adaptation can be achieved by learning a sparse or structured modification (Δθ) to the original parameters (θ₀).

Model merging is the practice of arithmetically combining the weights of multiple fine-tuned models (e.g., via task vector addition) to create a single model that blends their capabilities. This relies on the linear mode connectivity hypothesis—that different fine-tuned models reside in the same low-error basin. Task vectors are the fundamental unit of operation in weight-space merging techniques.

BitFit is a simple PEFT method where only the bias terms within a transformer model are updated during fine-tuning, while all other weights remain frozen. This creates an extremely sparse delta (often <1% of parameters). The resulting bias delta can be conceptualized as a highly constrained, sparse task vector, demonstrating that even minimal updates in specific locations can enable effective adaptation.