mirror of
https://github.com/hanzoai/papers.git
synced 2026-11-03 02:27:30 +00:00
108 lines
3.6 KiB
TeX
108 lines
3.6 KiB
TeX
\section{HLLM: Physics-Inspired LLM Routing}
|
|
|
|
|
|
The Hamiltonian Hidden-Markov LLM (HLLM) framework introduces a novel approach to model selection by treating inference routing as a physical system with conserved quantities and regime transitions.
|
|
|
|
\subsection{Theoretical Foundation}
|
|
|
|
\subsubsection{Regime Detection via HMM}
|
|
|
|
The system models user interaction patterns as a Hidden Markov Model with four primary regimes:
|
|
|
|
\begin{equation}
|
|
\mathcal{R} = \{\text{Exploration}, \text{Exploitation}, \text{Crisis}, \text{Transition}\}
|
|
\end{equation}
|
|
|
|
State transitions follow the Markov property:
|
|
|
|
\begin{equation}
|
|
P(r_{t+1} = j | r_t = i, r_{t-1}, \ldots) = P(r_{t+1} = j | r_t = i) = A_{ij}
|
|
\end{equation}
|
|
|
|
where $A$ is the transition matrix learned from historical observations.
|
|
|
|
\subsubsection{Hamiltonian Dynamics}
|
|
|
|
Price dynamics for model selection follow Hamiltonian mechanics:
|
|
|
|
\begin{equation}
|
|
H(q, p, t) = T(p) + V(q, t)
|
|
\end{equation}
|
|
|
|
where:
|
|
\begin{itemize}
|
|
\item $q$: Model configuration space (quality, latency)
|
|
\item $p$: Momentum (pricing pressure)
|
|
\item $T(p) = \frac{p^2}{2m}$: Kinetic energy (market dynamics)
|
|
\item $V(q,t)$: Potential energy (intrinsic model costs)
|
|
\end{itemize}
|
|
|
|
Hamilton's equations govern system evolution:
|
|
|
|
\begin{align}
|
|
\frac{dq}{dt} &= \frac{\partial H}{\partial p} \\
|
|
\frac{dp}{dt} &= -\frac{\partial H}{\partial q}
|
|
\end{align}
|
|
|
|
This formulation ensures energy conservation and prevents pricing instabilities.
|
|
|
|
\subsubsection{Expected Free Energy Minimization}
|
|
|
|
Model selection minimizes Expected Free Energy (EFE) from active inference:
|
|
|
|
\begin{equation}
|
|
\mathcal{G}(\pi) = \mathbb{E}_{Q(\tilde{o}, \tilde{s}|\pi)} \left[ \log Q(\tilde{s}|\pi) - \log P(\tilde{o}, \tilde{s}) \right]
|
|
\end{equation}
|
|
|
|
where:
|
|
\begin{itemize}
|
|
\item $\pi$: Routing policy
|
|
\item $\tilde{o}$: Future observations
|
|
\item $\tilde{s}$: Future states
|
|
\item $Q(\tilde{s}|\pi)$: Belief distribution under policy $\pi$
|
|
\item $P(\tilde{o}, \tilde{s})$: Generative model
|
|
\end{itemize}
|
|
|
|
Decomposing EFE into epistemic and pragmatic values:
|
|
|
|
\begin{equation}
|
|
\mathcal{G}(\pi) = \underbrace{\mathbb{E}_{Q(\tilde{o}|\pi)}[D_{KL}[Q(\tilde{s}|\tilde{o}, \pi)||Q(\tilde{s}|\pi)]]}_{\text{Epistemic value (information gain)}} - \underbrace{\mathbb{E}_{Q(\tilde{o}|\pi)}[\log P(\tilde{o})]}_{\text{Pragmatic value (preference)}}\end{equation}
|
|
|
|
\subsection{BitDelta Quantization}
|
|
|
|
User-specific adapters use 1-bit quantization inspired by BitDelta \cite{bitdelta}:
|
|
|
|
\begin{equation}
|
|
\Delta W = \text{sign}(W_{\text{full}} - W_{\text{base}}) \cdot \alpha
|
|
\end{equation}
|
|
|
|
where $\alpha$ is a learned scaling factor. This achieves $32\times$ compression with minimal quality loss.
|
|
|
|
\subsection{Implementation}
|
|
|
|
The HLLM system (\texttt{crates/hanzo-hllm/}) implements:
|
|
|
|
\begin{algorithm}
|
|
\caption{HLLM Routing Decision}
|
|
\begin{algorithmic}[1]
|
|
\REQUIRE User ID, Request, Observations
|
|
\ENSURE Routing Decision
|
|
\STATE Detect regime $r \leftarrow$ HMM.detect(observations)
|
|
\STATE Get user adapter $A_u \leftarrow$ AdapterManager.get(user\_id)
|
|
\STATE Compute phase space $\Phi \leftarrow$ Hamiltonian(regime, adapter)
|
|
\STATE Calculate EFE $\mathcal{G} \leftarrow$ FreeEnergy($r$, $A_u$, request)
|
|
\STATE Select model $m^* \leftarrow \arg\min_{m} \mathcal{G}(\pi_m)$
|
|
\STATE Update adapter $A_u \leftarrow$ BitDelta.update($A_u$, decision)
|
|
\RETURN RoutingDecision($m^*$, regime, EFE)
|
|
\end{algorithmic}
|
|
\end{algorithm}
|
|
|
|
Key features:
|
|
\begin{itemize}
|
|
\item Sled database backend for persistent storage
|
|
\item Vector index for semantic search (768-dim embeddings)
|
|
\item LRU cache for hot adapters (default: 100 entries)
|
|
\item Async Rust implementation with Tokio runtime
|
|
\end{itemize}
|
|
|