quantization/hsaq/assignment.py

"""
Sovereign Hive — Bit-width assignment for HSAQ quantization.

Given per-layer drift measurements at each (bits, quantizer) combination,
selects a (bits, quantizer) assignment per layer that minimizes total drift
subject to a global VRAM-weights budget.

Pure logic — no I/O. Input data comes from sensitivity_profile rows fetched
by the caller via the Vault module (which sits behind PermissionGate).

Algorithm: greedy by drift-savings-per-byte-cost.
    1. Start: every layer assigned its cheapest option.
    2. While budget allows: globally pick the (layer, upgrade) pair that
       buys the most drift reduction per additional byte; apply it.
    3. Stop: when no upgrade fits the remaining budget, or no upgrade
       reduces drift further.

Provably within a small constant factor of the ILP optimum for this shape of
problem; runs in O(L * B^2) per pass and converges in at most L*(B-1) passes,
where L = number of layer/components and B = bit-width options. Milliseconds
for any realistic model. The pattern is standard in SqueezeLLM and OWQ.

For multi-config output (a Pareto frontier per candidate), call pareto_frontier
with a list of budgets.
"""

from __future__ import annotations

from dataclasses import dataclass
from typing import Literal

Quantizer = Literal["hqq", "awq", "gptq"]
BitWidth = Literal[2, 3, 4]


# ── Inputs / outputs ───────────────────────────────────────────────────────


@dataclass(frozen=True)
class LayerOption:
    """One (bits, quantizer) candidate for a layer/component.

    bytes_per_param should already include quantizer-specific overhead
    (HQQ group-quant scales/zeros, AWQ/GPTQ metadata, etc.); the profiler
    is responsible for measuring it accurately.
    """

    bits: BitWidth
    quantizer: Quantizer
    drift: float  # measured KL divergence vs fp16
    bytes_per_param: float  # bits/8 + quantizer overhead


@dataclass
class LayerCandidate:
    """All measured options for a single layer/component."""

    layer_idx: int
    component: str  # 'attn' | 'mlp' | 'attn.q' | 'attn.k' | ...
    param_count: int  # in this layer/component
    options: list[LayerOption]

    def cheapest(self) -> LayerOption:
        """Option with the smallest bytes_per_param."""
        return min(self.options, key=lambda o: o.bytes_per_param)


@dataclass
class Assignment:
    layer_idx: int
    component: str
    chosen: LayerOption
    bytes_used: float


@dataclass
class AssignmentResult:
    assignments: list[Assignment]
    total_drift: float
    total_weights_gb: float
    budget_gb: float
    headroom_gb: float
    saturated: bool  # True if budget filled before all upgrades exhausted

    @property
    def by_layer(self) -> dict[tuple[int, str], Assignment]:
        return {(a.layer_idx, a.component): a for a in self.assignments}


class BudgetInfeasibleError(Exception):
    def __init__(self, current_gb: float, budget_gb: float):
        super().__init__(
            f"Even the cheapest assignment ({current_gb:.2f} GB) exceeds the "
            f"weight budget ({budget_gb:.2f} GB). Reduce model size, increase "
            f"KV quantization aggressiveness, or shrink context length."
        )
        self.current_gb = current_gb
        self.budget_gb = budget_gb


# ── Core algorithm ─────────────────────────────────────────────────────────


def assign_bit_widths(
    candidates: list[LayerCandidate],
    weight_budget_gb: float,
    min_bits_floor: dict[str, int] | None = None,
) -> AssignmentResult:
    """Greedy assignment of (bits, quantizer) per layer/component.

    Parameters
    ----------
    candidates : list[LayerCandidate]
        One entry per layer/component, each carrying its measured options
        from the sensitivity_profile Vault table.
    weight_budget_gb : float
        Maximum total weight VRAM in GB. Caller computes this by subtracting
        KV cache, activations, LoRA, and driver headroom from VRAM_BUDGET_GB.
    min_bits_floor : dict[str, int] | None
        Optional per-component lower bound on bit width. Maps component name
        (LayerCandidate.component) -> minimum bits. Layers in this dict will
        start at the cheapest option meeting the floor, which sidesteps HQQ's
        non-monotonic-drift filter on outlier-heavy layers (those where
        4-bit drift can exceed 3-bit drift due to group-quant breaking on
        outlier channels). The greedy loop never downgrades, so the floor
        is preserved through to the final assignment.

    Raises
    ------
    BudgetInfeasibleError
        If even the cheapest assignment (respecting the floor) exceeds budget.
    ValueError
        If a floor specifies a layer with no option meeting it.
    """
    if not candidates:
        raise ValueError("No candidates provided")
    if weight_budget_gb <= 0:
        raise ValueError(f"Non-positive weight budget: {weight_budget_gb}")

    floor = min_bits_floor or {}

    def _cheapest_meeting_floor(c: LayerCandidate) -> LayerOption:
        min_bits = floor.get(c.component)
        if min_bits is None:
            return c.cheapest()
        eligible = [o for o in c.options if o.bits >= min_bits]
        if not eligible:
            raise ValueError(
                f"No option for layer '{c.component}' meets floor {min_bits}-bit "
                f"(available: {sorted({o.bits for o in c.options})})"
            )
        return min(eligible, key=lambda o: o.bytes_per_param)

    # Initialize at the cheapest option per layer (respecting floor).
    current: dict[tuple[int, str], LayerOption] = {}
    bytes_used: dict[tuple[int, str], float] = {}
    cand_by_key: dict[tuple[int, str], LayerCandidate] = {}

    for c in candidates:
        key = (c.layer_idx, c.component)
        opt = _cheapest_meeting_floor(c)
        current[key] = opt
        bytes_used[key] = opt.bytes_per_param * c.param_count
        cand_by_key[key] = c

    total_bytes = sum(bytes_used.values())
    budget_bytes = weight_budget_gb * 1e9

    if total_bytes > budget_bytes:
        raise BudgetInfeasibleError(
            current_gb=total_bytes / 1e9,
            budget_gb=weight_budget_gb,
        )

    def best_upgrade(key: tuple[int, str]) -> tuple[float, LayerOption, float] | None:
        """Return (drift_savings_per_byte, target_option, extra_bytes) for the
        best upgrade of this layer, or None if no upgrade is available."""
        cand = cand_by_key[key]
        cur = current[key]
        best: tuple[float, LayerOption, float] | None = None
        for opt in cand.options:
            if opt.bytes_per_param <= cur.bytes_per_param:
                continue
            if opt.drift >= cur.drift:
                continue  # not actually an upgrade
            drift_reduction = cur.drift - opt.drift
            extra_bytes = (opt.bytes_per_param - cur.bytes_per_param) * cand.param_count
            if extra_bytes <= 0:
                continue
            ratio = drift_reduction / extra_bytes
            if best is None or ratio > best[0]:
                best = (ratio, opt, extra_bytes)
        return best

    saturated = False
    while True:
        winner_key: tuple[int, str] | None = None
        winner_ratio = -1.0
        winner_opt: LayerOption | None = None
        winner_extra = 0.0
        any_upgrade_available = False

        for key in current:
            up = best_upgrade(key)
            if up is None:
                continue
            any_upgrade_available = True
            _ratio, target, extra = up
            if total_bytes + extra > budget_bytes:
                continue
            if _ratio > winner_ratio:
                winner_ratio = _ratio
                winner_key = key
                winner_opt = target
                winner_extra = extra

        if winner_key is None:
            saturated = any_upgrade_available
            break

        # Apply winning upgrade.
        assert winner_opt is not None
        bytes_used[winner_key] += winner_extra
        total_bytes += winner_extra
        current[winner_key] = winner_opt

    assignments = [
        Assignment(
            layer_idx=key[0],
            component=key[1],
            chosen=current[key],
            bytes_used=bytes_used[key],
        )
        for key in current
    ]
    assignments.sort(key=lambda a: (a.layer_idx, a.component))

    total_drift = sum(a.chosen.drift for a in assignments)
    total_weights_gb = total_bytes / 1e9
    return AssignmentResult(
        assignments=assignments,
        total_drift=total_drift,
        total_weights_gb=total_weights_gb,
        budget_gb=weight_budget_gb,
        headroom_gb=weight_budget_gb - total_weights_gb,
        saturated=saturated,
    )


# ── Pareto frontier exploration ────────────────────────────────────────────


def pareto_frontier(
    candidates: list[LayerCandidate],
    budgets_gb: list[float],
) -> list[AssignmentResult]:
    """Run assign_bit_widths at multiple budgets to produce a Pareto frontier
    (budget vs total_drift). Caller picks the knee point or surfaces the
    trade-off to a human reviewer.

    Infeasible budgets are skipped (not raised) so a partial frontier is still
    useful when the lower budgets are too tight.
    """
    results: list[AssignmentResult] = []
    for b in budgets_gb:
        try:
            results.append(assign_bit_widths(candidates, b))
        except BudgetInfeasibleError:
            continue
    return results