SwiftRepertoire: Few-Shot Immune-Signature Synthesis via Dynamic Kernel Codes

SwiftRepertoire is a few-shot learning framework that synthesizes compact, interpretable adapter modules from a learned prototype dictionary to enable rapid, resource-efficient adaptation of frozen T cell receptor encoders to new disease detection tasks with minimal labeled data.

The Gist

Imagine your body's immune system as a massive, bustling library. Inside this library are millions of unique books, each representing a specific "T-cell receptor"—a specialized soldier that patrols your body looking for invaders like viruses or cancer cells. When you get sick, the library changes: certain books become very popular (cloned) because they are fighting a specific enemy, while others fade away.

The problem is that this library is huge, and the books are written in a complex code. Doctors want to use these books to detect diseases early, but there are three big hurdles:

1. Not enough examples: For rare diseases, we don't have many "sick" library samples to study.
2. Too expensive: Training a super-smart AI to read every single book from scratch for every new disease takes too much computer power and time.
3. Black box: Even if the AI says "Cancer," doctors need to know which specific words in the books triggered that alarm, or they won't trust it.

Enter SwiftRepertoire. Think of it as a super-smart, instant translator that solves all three problems.

1. The "Universal Dictionary" (The Prototype Library)

Instead of training a new AI from scratch for every disease, SwiftRepertoire first builds a massive "dictionary" of prototypes.

• The Analogy: Imagine a master chef who has tasted thousands of dishes and memorized the "flavor profiles" of spicy, sweet, sour, and bitter. They don't need to cook every dish from scratch; they just need to know which flavor profile matches the new dish.
• How it works: The system learns a dictionary of "immune signatures" (prototypes). When a new disease appears, it doesn't relearn everything; it just looks up the closest flavor profiles in its dictionary.

2. The "Instant Adapter" (Fast Weights)

Usually, to teach an AI a new task, you have to "fine-tune" it, which is like rewriting the entire encyclopedia. SwiftRepertoire does something clever called Fast Weights.

• The Analogy: Imagine you have a giant, frozen encyclopedia (the pre-trained AI). Instead of rewriting the pages, you create a tiny, sticky note (an adapter) that you stick on the cover. This note tells the encyclopedia, "Hey, for this specific question, look at these three pages."
• The Magic: With just a handful of examples (like 5 or 10 sick patients), SwiftRepertoire writes this tiny sticky note instantly. It adapts the giant encyclopedia to the new disease in seconds without needing a supercomputer or thousands of data points.

3. The "Detective's Magnifying Glass" (Interpretability)

In many AI systems, the computer gives an answer but won't explain why. In medicine, that's dangerous.

• The Analogy: If a doctor says, "You have a cold," you want to know why. SwiftRepertoire doesn't just say "Cancer Detected." It points to the specific words (motifs) in the immune library that triggered the alarm.
• The Result: It highlights the exact sequence of letters in the T-cell receptor that looks suspicious. This allows doctors to verify the AI's logic, ensuring it's not just guessing.

4. The "Smart Filter" (Dynamic Kernel Codes)

How does the system know which sticky note to write? It uses a Task Descriptor.

• The Analogy: Think of this as a "weather report" for the disease. Before making a decision, the system takes a quick, lightweight scan of the patient's immune data to generate a short summary (the descriptor). It then uses this summary to pull the right tools from its toolbox.
• The Benefit: This keeps the system fast and efficient. It doesn't need to process the whole library to know what's going on; it just needs the weather report to pick the right umbrella.

Why This Matters

• For Rare Diseases: You don't need thousands of patients to train the AI. A few samples are enough because the system is smart enough to "borrow" knowledge from similar diseases it already knows.
• For Hospitals: It runs on standard computers, not massive supercomputers, making it practical for real-world clinics.
• For Trust: Because it points to the specific biological "clues" it found, doctors can trust the diagnosis and understand the biology behind it.

In short: SwiftRepertoire is like a chameleon. It has a deep understanding of the immune system's language. When a new disease shows up, it instantly changes its colors (adapts) using a tiny amount of new information, explains exactly what it sees, and does it all without needing a massive energy bill. It turns the complex, noisy library of our immune system into a clear, readable map for doctors.

Technical Summary

1. Problem Statement

The paper addresses critical bottlenecks in applying T cell receptor (TCR) repertoire analysis to clinical diagnostics and immune monitoring:

• Label Sparsity & Long-Tail Distribution: Many repertoire tasks suffer from a scarcity of labeled data, particularly for rare diseases or specific antigens, causing conventional supervised models to generalize poorly.
• Computational Cost of Adaptation: Adapting large, pre-trained protein language models (PLMs) to new tasks via full fine-tuning is computationally prohibitive and prone to overfitting when only a few support examples are available.
• Interpretability Gap: Existing deep learning models often act as "black boxes," lacking the motif-level interpretability and statistically calibrated signals required for clinical decision-making.
• Heterogeneity: Repertoire data varies significantly across cohorts, making it difficult to deploy a single model across diverse clinical settings without extensive retraining.

2. Methodology: SwiftRepertoire Framework

The authors propose SwiftRepertoire, a conditional fast-weight framework that synthesizes compact, task-specific adapter parameters on-the-fly without fine-tuning the backbone encoder. The pipeline consists of four core stages:

A. Compact Task Descriptors

Instead of using heavy computation to characterize a new task, the method derives a lightweight task descriptor ($z_t$) from the support set. This descriptor is constructed by concatenating:

• Pooled residue-level embedding statistics (mean and standard deviation).
• Explicit percentile statistics.
• The PCA-projected gradient of a lightweight probe head trained on the support set.
  This allows the system to capture the "geometry" of the new task with minimal overhead.

B. Geometry-Aware Prototype Dictionary

The system learns a dictionary of prototypes ($M$) from a pre-training corpus.

• Canonicalization: Adapters are normalized and aligned to principal directions to ensure invariance to reparameterization.
• Clustering: Prototypes are generated via geometry-aware clustering in a low-dimensional PCA subspace.
• Dimensionality Selection: A rigorous statistical procedure (Fisher energy ratio test with bootstrap and Bonferroni correction) determines the optimal intrinsic dimensionality ($r$) of the adapter space, ensuring the low-dimensional representation captures sufficient Fisher information.

C. Constrained Proximal Retrieval (Fast-Weight Synthesis)

For a new task, the system synthesizes an adapter by retrieving a sparse combination of prototypes based on the task descriptor.

• Optimization: The retrieval weights ($w_t$) are solved via a constrained proximal optimization problem:
  $$w_t = \arg \min_{w} \frac{1}{2}\|M^\top w - \hat{\theta}_t\|_2^2 + \lambda\|w\|_1 + \gamma\|w - \text{softmax}(v_t)\|_2^2$$
  Where $\hat{\theta}_t$ is a ridge-regression estimate from the support set, $\lambda$ enforces sparsity (L1 norm), and $\gamma$ ensures proximity to an initial retrieval guess.
• Hard Sparsity: A top-$r$ threshold is applied to ensure the final adapter uses only a few active prototypes, maintaining computational efficiency.
• Neural-ODE Integration: Continuous-time modules (Neural-ODEs) with stiff-stable integrators are embedded in the retrieval and descriptor pipelines to model dynamics where appropriate.

D. Motif-Level Interpretability & Calibration

The framework integrates a two-stage motif testing pipeline:

1. Screening: Identifies high-activation channels.
2. Testing: Performs adaptive permutation tests to identify significant sequence motifs.
3. Calibration: Uses Storey's method to estimate the null proportion ($\hat{\pi}_0$) and applies nested cross-validation to calibrate thresholds, ensuring statistical rigor and controlling false discovery rates.

3. Key Contributions

1. Retrieval-Driven Fast-Weight Synthesis: Introduces a mechanism to generate sparse, rank-aware adapters for large pre-trained encoders using prototype retrieval, enabling instant adaptation with few-shot data.
2. Geometry-Preserving Prototypes: Designs a canonicalization and clustering pipeline that preserves the geometric structure of the adapter space, coupled with a proximal solver that enforces hard sparsity.
3. Compact Task Conditioning: Proposes a descriptor built from pooled gradients and repertoire probes, eliminating the need for heavy task-specific computation.
4. Statistically Calibrated Interpretability: Integrates a nested workflow that links predictive adaptation to statistically controlled sequence discovery, providing both high accuracy and biological interpretability.
5. Rigorous Validation: Employs formal hypothesis testing (Fisher energy ratio), bootstrap confidence intervals, and anti-leakage partitioning schemes to validate the low-dimensional assumptions and model stability.

4. Experimental Results

The method was evaluated on TCR repertoire datasets for Lung Cancer and Thyroid Carcinoma (THCA), as well as external multi-disease cohorts.

• Performance: SwiftRepertoire outperformed state-of-the-art baselines (including BertTCR, DeepCAT, and TransMIL).
  • Lung Cancer: Achieved 94.5% Accuracy and 99.5% AUC (vs. 89.8% and 95.9% for the next best, BertTCR).
  • Thyroid Carcinoma: Achieved 96.8% Accuracy and 99.7% AUC (vs. 93.0% and 99.0% for BertTCR).
• Few-Shot Scaling: The model demonstrated robust performance even with very small support sets (5–10 examples), showing superior scaling compared to full fine-tuning methods.
• External Validation: On a universal screening benchmark involving multiple cancer types (GBM, PACA, ESCA, etc.), the model maintained high accuracy (>93%) and AUC (>0.98) across diverse diseases.
• Health Scoring: The model's output (Health Score = $1 - P(\text{cancer})$) showed a strong negative correlation with age ($\rho \approx -0.51$), aligning with known immunosenescence trends.

5. Significance

SwiftRepertoire represents a significant step forward in translational immunogenomics:

• Practical Deployment: It solves the "data scarcity" problem in clinical settings by allowing models to adapt to new diseases or patient cohorts with minimal labeled data and no expensive retraining.
• Trustworthy AI: By coupling high performance with statistically calibrated motif discovery, the framework provides the interpretability necessary for clinicians to trust and act upon model predictions.
• Efficiency: The use of frozen backbones and sparse adapter synthesis drastically reduces memory and compute requirements, making it feasible for deployment in resource-constrained environments.
• Biological Insight: The method does not just predict disease; it identifies specific sequence motifs (CDR3 patterns) driving the decision, offering potential biological insights into tumor-immune interactions.

In summary, SwiftRepertoire bridges the gap between powerful deep learning representations and the practical, data-scarce, and interpretability-heavy requirements of clinical immune monitoring.