🤖 Adaptive Multi-Adapter LLM System

Novel approach to LLM fine-tuning using specialized LoRA adapters with learned routing

🎯 Overview

Traditional fine-tuning creates a single model good at one task. This project implements a multi-adapter architecture where:

• 🎓 Multiple specialized adapters handle different types of queries (reasoning, code, creative, analysis)
• 🧠 Learned router network dynamically selects optimal adapters using BERT-based classification
• 📊 Self-evaluation system monitors quality with multi-metric assessment and uncertainty quantification
• 🔄 Continuous improvement through targeted synthetic data generation

🏗️ Architecture

                    ┌─────────────────┐
                    │   User Query    │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │  Router Network │ ← BERT-based classifier
                    │  (Complexity +  │   with Gumbel-Softmax
                    │   Task Type)    │
                    └────────┬────────┘
                             │
         ┌───────────┬───────┴───────┬───────────┐
         ▼           ▼               ▼           ▼
    ┌─────────┐ ┌─────────┐   ┌─────────┐ ┌─────────┐
    │Reasoning│ │  Code   │   │Creative │ │Analysis │
    │ Adapter │ │ Adapter │   │ Adapter │ │ Adapter │
    └────┬────┘ └────┬────┘   └────┬────┘ └────┬────┘
         │           │             │           │
         └───────────┴──────┬──────┴───────────┘
                            ▼
                    ┌───────────────┐
                    │  Generation   │
                    └───────┬───────┘
                            │
                    ┌───────▼───────┐
                    │ Self-Evaluator│ ← Multi-metric scoring
                    │ + Uncertainty │   MC Dropout, calibration
                    └───────────────┘

📊 Results

🚀 Quick Start

Installation

git clone https://github.com/isuruigi/adaptive-lora-framework.git
cd adaptive-lora-framework
pip install -r requirements.txt

Run Demo

# Set API key (get free from https://console.groq.com)
export GROQ_API_KEY="your-key"

# Start Gradio server
python scripts/run_gradio_server.py

Train an Adapter (Colab Pro recommended)

# Generate training data
python scripts/prepare_data.py --adapter reasoning --samples 1000

# Train adapter
python -m src.adapters.lora_trainer \
    --adapter_config configs/adapters/reasoning_adapter.yaml \
    --output_dir models/reasoning

Train Router

python experiments/train_router.py \
    --config configs/router_config.yaml \
    --output_dir models/router

📁 Project Structure

adaptive-lora-framework/
├── src/
│   ├── adapters/          # LoRA adapter training & management
│   │   ├── lora_trainer.py
│   │   └── adapter_manager.py
│   ├── router/            # Intelligent routing system
│   │   ├── router_model.py    # BERT-based router with Gumbel-Softmax
│   │   ├── router_trainer.py  # Multi-objective training
│   │   └── reinforcement.py   # RL-based improvement
│   ├── evaluation/        # Quality assessment
│   │   ├── self_evaluator.py  # Multi-metric evaluation
│   │   ├── uncertainty.py     # MC Dropout, calibration
│   │   └── llm_judge.py       # GPT-4/Claude evaluation
│   ├── data/              # Data processing
│   │   └── synthetic_generator.py
│   ├── serving/           # Production API
│   │   ├── api.py         # FastAPI endpoints
│   │   └── inference_engine.py
│   └── monitoring/        # Observability
│       ├── metrics.py
│       └── alerting.py
├── configs/               # YAML configurations
├── experiments/           # Training scripts
├── tests/                 # Unit, integration, load tests
├── k8s/                   # Kubernetes manifests
├── deploy/                # Deployment configs
└── notebooks/             # Jupyter notebooks

🔬 Key Innovations

1. Learned Router Network

Unlike rule-based routing, uses a trainable network that learns from actual performance data:

from src.router import AdapterRouter

router = AdapterRouter(
    encoder_name="sentence-transformers/all-MiniLM-L6-v2",
    num_adapters=4,
    hidden_dim=256,
    use_gumbel=True  # Differentiable selection
)

# Predict best adapter
adapter_probs, complexity = router(query_embedding)

2. Multi-Metric Self-Evaluation

Goes beyond accuracy with relevance, coherence, factuality, and safety scoring:

from src.evaluation import SelfEvaluator

evaluator = SelfEvaluator()
metrics = evaluator.evaluate(
    query="Explain quantum computing",
    response="Quantum computing uses qubits...",
    adapter_used="reasoning"
)
# Returns: {relevance: 0.9, coherence: 0.85, completeness: 0.8}

3. Uncertainty Quantification

MC Dropout and ensemble methods for confidence estimation:

from src.evaluation import UncertaintyQuantifier

quantifier = UncertaintyQuantifier(model, n_samples=10)
mean, uncertainty = quantifier.predict_with_uncertainty(input_ids)

💻 Technical Stack

🧪 Testing

# Run all tests
pytest tests/ -v

# Unit tests only
pytest tests/unit/ -v

# Integration tests
pytest tests/integration/ -v

# Load tests
pytest tests/load/ -v

📈 Training Details

Adapter Training:

• Rank: 16-32 (varies by adapter)
• Learning rate: 2e-4 with cosine schedule
• Batch size: 32 (gradient accumulation)
• Training time: ~2 hours per adapter (A100)

Router Training:

• Encoder: all-MiniLM-L6-v2
• Dataset: 5000 synthetic examples
• Loss: Cross-entropy + complexity regularization
• Training time: 15 minutes

🚀 Deployment Options

📝 Citation

@misc{adaptive-lora-2024,
  author = {Your Name},
  title = {Adaptive Multi-Adapter LLM System},
  year = {2024},
  url = {https://github.com/isuruigi/adaptive-lora-framework}
}

📄 License

MIT License - see LICENSE for details.

---

Built with ❤️ as a portfolio project demonstrating modern MLOps practices