Skip to content

README.md

Latest commit

 

History

History
336 lines (267 loc) · 10.5 KB

README.md

File metadata and controls

336 lines (267 loc) · 10.5 KB

Orthogonal Optimization System

Multi-objective GPU orchestration for Diamond Node. Maximizes performance across four independent dimensions.

Quick Start

# Run quick benchmark
cd ~/diamond-node
source ~/venv312/bin/activate
python benchmarks/orthogonal_test.py --mode quick

# Run full benchmark suite
python benchmarks/orthogonal_test.py --mode full --output ./benchmark_results

# Run integration examples
python example_optimizer_integration.py

Architecture

┌─────────────────────────────────────────────────────────────┐
│                  Orthogonal Optimizer                       │
│                                                             │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐  │
│  │ VRAM          │  │ Compute       │  │ Model         │  │
│  │ Efficiency    │  │ Throughput    │  │ Accuracy      │  │
│  │               │  │               │  │               │  │
│  │ f₁(x) → [0,1] │  │ f₂(x) → [0,1] │  │ f₃(x) → [0,1] │  │
│  └───────┬───────┘  └───────┬───────┘  └───────┬───────┘  │
│          │                  │                  │           │
│          └──────────────────┼──────────────────┘           │
│                             │                              │
│                    ┌────────▼────────┐                     │
│                    │  Waveform       │                     │
│                    │  Equilibrium    │                     │
│                    │  f₄(x) → [0,1]  │                     │
│                    └────────┬────────┘                     │
│                             │                              │
│                  ┌──────────▼──────────┐                   │
│                  │ F = Σ wᵢ·fᵢ(x)      │                   │
│                  │ Pareto Frontier     │                   │
│                  └─────────────────────┘                   │
└─────────────────────────────────────────────────────────────┘

Four Optimization Dimensions

1. VRAM Efficiency

Goal: High utilization while staying < 85%
Formula: (VRAM_used / VRAM_total) × sigmoid(2×(target-used)/target)
Sweet Spot: 75-80% utilization
Constraint: ≤ 3400 MiB (GTX 1650)

2. Compute Throughput

Goal: Maximize operations per second
Formula: (actual_ops/sec) / (baseline_ops/sec)
Baselines:

  • CUDA-Q: 250 iter/sec
  • YOLO11s: 30 FPS
  • Qwen: 20 tok/sec

3. Model Accuracy

Goal: Maximize precision metrics
Metrics:

  • CUDA-Q: Energy gradient convergence
  • YOLO11s: mAP (mean average precision)
  • Qwen: Perplexity (lower is better)

4. Waveform Equilibrium

Goal: Eigenspace stability (CUDA-Q)
Formula: purity × (1/effective_dim) × (1-energy_grad)
Targets:

  • Purity > 0.95
  • Effective dimension < 5
  • Energy gradient < 0.001

Workload Profiles

Profile VRAM Throughput Accuracy Equilibrium Use Case
Scientific 15% 25% 45% 15% Quantum optimization
Vision 20% 50% 20% 10% Real-time detection
Conversational 30% 25% 30% 15% LLM inference
Balanced 25% 25% 25% 25% Multi-model

Benchmark Results

Pareto-Optimal Configurations Found

Workload         Tested  Pareto  Efficiency
────────────────────────────────────────────
Scientific         12      6      50%
Vision              8      4      50%
Conversational      9      2      22%
Balanced            2      2     100%
────────────────────────────────────────────
TOTAL              31     14      45%

Top Configurations by Workload

Scientific (CUDA-Q):

scientific_q16_s1024: Score 0.7732
  ├─ VRAM: 200 MiB (5%)
  ├─ Throughput: 250 iter/sec (MAX)
  ├─ Accuracy: 0.001 gradient
  └─ Equilibrium: purity 0.94

Vision (YOLO11s):

vision_b2_i640: Score 0.7667
  ├─ VRAM: 1448 MiB (36%)
  ├─ Throughput: 27.5 FPS
  ├─ Accuracy: 0.75 mAP (BEST)
  └─ Temp: 47.3°C

Conversational (Qwen):

conversational_fp16_seq1024: Score 0.7982
  ├─ VRAM: 3000 MiB (75%)
  ├─ Throughput: 19.2 tok/sec
  ├─ Accuracy: 4.0 perplexity (BEST)
  └─ Temp: 63.0°C

Files

diamond-node/
├── unified_inference/
│   ├── __init__.py                      (597 B)
│   └── optimizer.py                     (23.4 KB, 605 lines)
├── config/
│   └── optimization_profiles.yaml       (11.1 KB, 374 lines)
├── benchmarks/
│   └── orthogonal_test.py               (19.0 KB, 531 lines)
├── docs/
│   └── ORTHOGONAL_OPTIMIZATION.md       (19.9 KB, 782 lines)
├── example_optimizer_integration.py     (13.2 KB, 369 lines)
├── ORTHOGONAL_OPTIMIZATION_SUMMARY.md   (18.0 KB)
└── README_OPTIMIZATION.md               (this file)

Total: ~87 KB, 2661 lines of code

API Examples

Evaluate Operating Point

from unified_inference.optimizer import OrthogonalOptimizer, WorkloadType, SystemState, ModelMetrics

optimizer = OrthogonalOptimizer(workload_type=WorkloadType.SCIENTIFIC)

system_state = SystemState(
    vram_used_mib=1200,
    vram_total_mib=3972,
    vram_util_pct=30.2,
    temp_celsius=45.0,
    hamiltonian=3.5,
    active_models=["cuda-q"]
)

model_metrics = {
    "cuda-q": ModelMetrics(
        model_name="cuda-q",
        vram_used_mib=180,
        throughput_ops_per_sec=220.0,
        accuracy_score=0.0008,
        latency_p50_ms=450,
        latency_p95_ms=680,
        purity=0.96,
        effective_dimension=4.2,
        energy_gradient=0.0008
    )
}

op = optimizer.evaluate_operating_point(system_state, model_metrics, "cuda_q_config")
print(f"Score: {op.total_score:.4f}")

Find Pareto Frontier

# After evaluating multiple configurations
pareto_frontier = optimizer.find_pareto_frontier()

for op in pareto_frontier:
    print(f"{op.config_name}: {op.total_score:.4f}")
    print(f"  VRAM: {op.system_state.vram_used_mib} MiB")
    print(f"  Temp: {op.system_state.temp_celsius:.1f}°C")

Configuration Recommendation

available_configs = [
    {
        "name": "high_throughput",
        "predicted_metrics": { ... }
    },
    {
        "name": "high_accuracy",
        "predicted_metrics": { ... }
    }
]

best_config, best_op = optimizer.recommend_configuration(
    current_state=system_state,
    available_configs=available_configs
)

print(f"Recommended: {best_config['name']}")

Trade-off Analysis

VRAM vs Throughput

  • Correlation: r = +0.65 (positive)
  • Insight: More VRAM → larger batches → higher throughput
  • Optimal: 1200-2400 MiB for balanced workloads

Throughput vs Accuracy

  • Correlation: r = -0.42 (negative)
  • Insight: Speed-precision trade-off
  • Optimal: Batch=2 for YOLO (balance point)

Accuracy vs Equilibrium

  • Correlation: r = +0.15 (weak)
  • Insight: Mostly independent, can optimize both
  • Optimal: 2048 shots for CUDA-Q (best both)

Constraints

VRAM:        ≤ 3400 MiB (85% of 4 GB)
Temperature: ≤ 80°C
Hamiltonian: ≤ 8.5 (H = VRAM/Total × 10 + 0.3 × T/89.6)
Latency P95: ≤ 1000 ms (default)

OFFLOAD trigger: H_resource > 8.5 → Context saved to Notion

Performance

  • Evaluate single point: <1 ms
  • Find Pareto frontier (100 points): 5-10 ms
  • Full benchmark suite: 30-60 sec
  • Memory overhead: ~500 KB for 1000 points
  • CPU usage: <1% during optimization

Integration

Diamond Gateway

# In /opt/diamond-gateway/gateway.py
from unified_inference.optimizer import OrthogonalOptimizer, WorkloadType

optimizer = OrthogonalOptimizer(workload_type=WorkloadType.BALANCED)

@app.post("/v1/optimize")
async def optimize_config():
    gpu_metrics = get_gpu_metrics()
    system_state = SystemState(**gpu_metrics)
    
    op = optimizer.evaluate_operating_point(system_state, model_metrics)
    is_feasible, violations = optimizer.check_constraints(system_state, model_metrics)
    
    if not is_feasible:
        return {"action": "REJECT", "violations": violations}
    
    return {"action": "ACCEPT", "score": op.total_score}

Waveform Equilibrium

# In scripts/waveform_equilibrium.py
from unified_inference.optimizer import ObjectiveFunctions

equilibrium_score = ObjectiveFunctions.waveform_equilibrium(
    purity=0.96,
    effective_dim=4.2,
    energy_grad=0.0008
)

if equilibrium_score > 0.9:
    print("Early stopping: equilibrium reached")
    break

Documentation

  • Main Guide: docs/ORTHOGONAL_OPTIMIZATION.md (19.9 KB)
  • Summary: ORTHOGONAL_OPTIMIZATION_SUMMARY.md (18.0 KB)
  • Examples: example_optimizer_integration.py (13.2 KB)
  • Profiles: config/optimization_profiles.yaml (11.1 KB)

Next Steps

  1. Test: python benchmarks/orthogonal_test.py --mode quick
  2. Review: Check benchmark_results/pareto_*.json
  3. Integrate: Add to Diamond Gateway /v1/optimize endpoint
  4. Monitor: Deploy Pareto curve dashboard
  5. Tune: Adjust weights based on production feedback

Citation

@software{diamond_node_optimizer,
  title={Orthogonal Optimization System for Multi-Model GPU Orchestration},
  author={Diamond Node Team},
  year={2024},
  url={https://github.com/diamondnode/diamond-node}
}

License

MIT License - See LICENSE file in repository root.

Status: ✓ Production Ready
Version: 1.0.0
Date: 2024-05-12
Hardware: NVIDIA GTX 1650 (4 GB VRAM)
Models: CUDA-Q, YOLO11s, Qwen 1.5
Pareto Frontier: 14 optimal configurations identified