const { useState, useEffect, useRef } = React; const { SectionHeader, useReveal } = window; /* ── Abstract ── */ function AbstractSection() { const keywords = ['LoRA','adapter merging','static code analysis','vulnerability detection','multi-task learning','large language models','linear combination','task interference','PrimeVul']; const contributions = [ { n: '01', text: 'Empirical study of LoRA adapter merging for code analysis — 19 lambda configurations across two structurally dissimilar tasks (SCA and VD).' }, { n: '02', text: 'Dense 4×4 interference characterisation showing merged adapters retain up to 98% of solo VD and 91% of solo SCA performance.' }, { n: '03', text: 'Three-tier SCA evaluation with Hungarian algorithm assignment providing partial credit for near-miss detections.' }, { n: '04', text: 'Evidence that switching from BigVul to PrimeVul (F1: +0.249) outperforms model scaling from Qwen-3B to Llama-8B (F1: +0.078).' }, ]; const r1 = useReveal(), r2 = useReveal(); return (
{/* Abstract prose */}

We investigate whether task-specific LoRA adapters — each fine-tuned independently on{' '} Meta-Llama-3.1-8B-Instruct{' '} — can be merged via weighted linear combination into a single adapter that preserves performance on both tasks.

We evaluate 19 configurations: a 4×4 lambda grid{' '} (λSCA, λVD ∈ {'{0.3, 0.5, 0.7, 1.0}'}) plus three baselines, on synthetic SCA data (3,463 samples) and PrimeVul vulnerability data (9,858 expert-verified C/C++ samples).

The best merged configuration retains{' '} 98% of solo VD performance while gaining SCA capability, and 91% of solo SCA performance while gaining VD capability. Interference is asymmetric: VD is more sensitive to SCA adapter weight than vice versa.

KEYWORDS

{keywords.join(' · ')}

{/* Contributions */}

KEY CONTRIBUTIONS

{contributions.map(c => (
{c.n}

{c.text}

))}
); } /* ── Problem ── */ function ProblemSection() { const problems = [ { n: '1', title: 'Memory Overhead', desc: 'Separate specialised models for each task multiply VRAM requirements. A 8B model at 4-bit precision consumes 5–8 GB per task.' }, { n: '2', title: 'Latency Multiplication', desc: 'Running independent inference passes per task adds unacceptable latency when simultaneous SCA and VD are required in production.' }, { n: '3', title: 'Unknown Task Interference', desc: 'Adapter merging for code has never been studied. SCA (JSON arrays) and VD (binary labels) have fundamentally different output structures — interference dynamics are unknown.' }, ]; const gapItems = [ { label: 'NLP adapter merging', status: 'Prior work', dim: true }, { label: 'Code LLM fine-tuning', status: 'Prior work', dim: true }, { label: 'Code adapter merging', status: 'This paper', dim: false }, { label: 'Heterogeneous-output merging',status: 'This paper', dim: false }, { label: 'Per-layer adaptive merge', status: 'Future work', dim: true }, ]; const r1 = useReveal(), r2 = useReveal(); return (
{problems.map(p => (
CHALLENGE {p.n}

{p.title}

{p.desc}

))}

RESEARCH LANDSCAPE

{gapItems.map(g => (
{g.label} {g.status}
))}
); } /* ── Methodology ── */ function MethodologySection() { const formula = window.katex ? window.katex.renderToString( '\\Delta W_{\\text{merged}} = \\lambda_{\\text{SCA}} \\cdot \\Delta W_{\\text{SCA}} \\;+\\; \\lambda_{\\text{VD}} \\cdot \\Delta W_{\\text{VD}}', { displayMode: true, throwOnError: false } ) : 'ΔW_merged = λ_SCA·ΔW_SCA + λ_VD·ΔW_VD'; const loraFormula = window.katex ? window.katex.renderToString( 'W = W_0 + B \\cdot A \\qquad B \\in \\mathbb{R}^{d \\times r},\\; A \\in \\mathbb{R}^{r \\times d},\\; r=16', { displayMode: true, throwOnError: false } ) : 'W = W₀ + BA'; const steps = [ { n: '1', title: 'Independent Fine-tuning', desc: 'Train SCA and VD adapters separately on Meta-Llama-3.1-8B-Instruct. Identical LoRA config: r=16, α=16, 7 modules/layer, 42M trainable params.', accent: 'var(--blue)' }, { n: '2', title: 'Post-hoc Merging', desc: 'Combine weight deltas via PEFT\'s add_weighted_adapter (combination_type="linear"). Weights are not normalised — deliberate design choice.', accent: 'var(--accent)' }, { n: '3', title: 'Grid Search', desc: 'Evaluate 16 merged configs (4×4 lambda grid) plus 3 baselines = 19 total. Full test-set inference on both SCA and VD per config.', accent: 'var(--green)' }, { n: '4', title: 'Pareto Analysis', desc: 'Identify Pareto-optimal configs spanning the VD–SCA performance trade-off for practical deployment guidance.', accent: 'var(--purple)' }, ]; const rArch = useReveal(), rData = useReveal(), rForm = useReveal(); return (
{/* Steps */}
{steps.map((s, i) => (
{s.n}
{s.title}

{s.desc}

))}
{/* Architecture diagram */}

ADAPTER ARCHITECTURE

{/* Base model */}
FROZEN BASE MODEL
Meta-Llama-3.1-8B-Instruct   W₀
32 layers · 4096 dims · ~8B frozen parameters · 4-bit NF4
+
{/* Two adapters */}
{[ { tag: 'SCA ADAPTER', accent: 'var(--blue)', task: 'Static Code Analysis', params: 'A_SCA · B_SCA', io: 'Python → JSON array of issues', f1: 'F1 = 0.994', note: '~1.6h · 800 steps · r=16' }, { tag: 'VD ADAPTER', accent: 'var(--purple)', task: 'Vulnerability Detection', params: 'A_VD · B_VD', io: 'C/C++ → "vulnerable" | "safe"', f1: 'F1 = 0.732', note: '~3.9h · 1100 steps · r=16' }, ].map((a, i) => (
{a.tag}
{a.task}
{a.params}  (42M trainable params)
{a.io}
{a.f1} {a.note}
))}
↓   WEIGHTED LINEAR COMBINATION   ↓
{/* Merged */}
MERGED MULTI-TASK ADAPTER
λ ∈ {'{0.3, 0.5, 0.7, 1.0}'}  ·  16 merged configurations  +  3 baselines = 19 total
{/* Data pipeline + hyperparams */}

DATASETS

{[ { label: 'SCA', accent: 'var(--blue)', steps: ['35 Python templates', '→ AST-validated generation', '→ xxhash deduplication', '→ 3,463 unique samples'], note: '11 categories · stratified train/val/test splits' }, { label: 'VD', accent: 'var(--purple)', steps: ['PrimeVul (expert-verified labels)', '→ Filter 3–200 line functions', '→ 50/50 undersampling', '→ 9,858 samples'], note: 'C/C++ · pre-defined splits · MAX_SEQ=512 tokens' }, ].map(d => (
{d.label} Dataset
{d.steps.map((s, i) => (
{s}
))}
{d.note}
))}

LORA FORMULATION

SHARED HYPERPARAMETERS

{[ ['LoRA rank r','16'],['LoRA alpha α','16'],['Target modules','7/layer'], ['Learning rate','2×10⁻⁴'],['LR schedule','Cosine'],['Optimizer','AdamW 8-bit'], ['Max seq length','512 tokens'],['Precision','BF16'], ].map(([k,v]) => (
{k} {v}
))}
Hardware: NVIDIA RTX 3060 Ti (8 GB VRAM) · 32 GB RAM · Windows 11 · Single GPU
); } Object.assign(window, { AbstractSection, ProblemSection, MethodologySection });