eiporion 0.1.0__tar.gz

eiporion-0.1.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: eiporion
+Version: 0.1.0
+Summary: INT8 linear layers with DQT SR/MB-SR and bitsandbytes acceleration.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: bitsandbytes<0.46.0,>=0.45.0
+Requires-Dist: torch
+
+# Eiporion
+
+INT8 linear layers with DQT SR/MB-SR and bitsandbytes acceleration.
+
+## Install
+
+```bash
+pip install eiporion
+```
+
+## Quick use
+
+```python
+from eiporion import BitLinear
+```

eiporion-0.1.0/README.md

@@ -0,0 +1,15 @@
+# Eiporion
+
+INT8 linear layers with DQT SR/MB-SR and bitsandbytes acceleration.
+
+## Install
+
+```bash
+pip install eiporion
+```
+
+## Quick use
+
+```python
+from eiporion import BitLinear
+```

eiporion-0.1.0/eiporion/__init__.py

@@ -0,0 +1,11 @@
+from .eiporionkernels import quantize_fp_to_int8
+from .bitLinear import BitLinear, collect_bitlinear_modules
+from .eiporionoptim import EiporionOptim, EiporionOptimSR
+
+__all__ = [
+    "BitLinear",
+    "EiporionOptim",
+    "EiporionOptimSR",
+    "collect_bitlinear_modules",
+    "quantize_fp_to_int8",
+]

eiporion-0.1.0/eiporion/bitLinear.py

@@ -0,0 +1,108 @@
+import math
+
+import torch
+from torch import nn
+
+from .eiporionkernels import (
+    Int8LinearFn,
+    consume_bit_grad,
+    next_bit_handle,
+    register_bit_handle,
+    release_bit_handle,
+)
+
+
+def _init_int8_weight(out_features: int, in_features: int):
+    """Kaiming-uniform init, quantise to int8.
+
+    Matches bnb ``int8_vectorwise_quant``: per-row max_abs / 127 scale.
+    W_int8 = clip(round(W / scale), -128, 127)  with  scale = max_abs_per_row / 127.
+    W_eff  = int_weight * weight_scale  ≈  original kaiming weight.
+    """
+    weight = torch.empty((out_features, in_features), dtype=torch.float32)
+    nn.init.kaiming_uniform_(weight, a=math.sqrt(5))
+    w = weight.float()
+    scale_per_row = w.abs().amax(dim=1, keepdim=True).clamp_min(1e-8) / 127.0
+    q = torch.round(w / scale_per_row).clamp(-127, 127).to(torch.int8)
+    return q.contiguous(), scale_per_row.squeeze(1).contiguous()
+
+
+class BitLinear(nn.Module):
+    """INT8 linear layer matching bnb ``Int8Params`` + DQT paper.
+
+    * ``int_weight``    — int8 buffer ``[O, K]``, the quantised weight (bnb's CB).
+    * ``weight_scale``  — float buffer ``[O]``, per-row max_abs/127 (bnb's SCB/127).
+    * Forward: ``W_eff = int_weight * weight_scale``, then standard matmul.
+    * Gradients for ``int_weight`` are stashed in ``_BIT_GRAD_CACHE`` and consumed
+    by :class:`EiporionOptim` for DQT stochastic rounding.
+    """
+
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        bias: bool = False,
+    ) -> None:
+        super().__init__()
+        self.in_features = int(in_features)
+        self.out_features = int(out_features)
+
+        int_init, scale_init = _init_int8_weight(
+            out_features=self.out_features, in_features=self.in_features
+        )
+        self.register_buffer("int_weight", int_init, persistent=True)
+        self.register_buffer("weight_scale", scale_init, persistent=True)
+        self.register_buffer(
+            "_bit_handle",
+            torch.tensor(next_bit_handle(), dtype=torch.int64),
+            persistent=True,
+        )
+        self._registered_handle = int(self._bit_handle.item())
+        self.register_load_state_dict_post_hook(self._post_load_state_dict)
+
+        if bias:
+            self.bias = nn.Parameter(torch.zeros(out_features))
+        else:
+            self.register_parameter("bias", None)
+
+    @torch.no_grad()
+    def reset_int8_(self) -> None:
+        int_init, scale_init = _init_int8_weight(
+            out_features=self.out_features, in_features=self.in_features
+        )
+        self.int_weight.copy_(int_init.to(device=self.int_weight.device))
+        self.weight_scale.copy_(scale_init.to(device=self.weight_scale.device))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        if x.shape[-1] != self.in_features:
+            raise ValueError(
+                f"expected input last dim {self.in_features}, got {x.shape[-1]}"
+            )
+        if self.int_weight.device != x.device:
+            raise RuntimeError(
+                "BitLinear input and int_weight must be on same device. "
+                "Move module with model.to(device) before forward."
+            )
+        x2d = x.reshape(-1, self.in_features)
+        out2d = Int8LinearFn.apply(
+            x2d,
+            self.int_weight,
+            self.weight_scale,
+            self.bias,
+            int(self._bit_handle.item()),
+        )
+        return out2d.view(*x.shape[:-1], self.out_features)
+
+    def consume_weight_grad(self) -> torch.Tensor | None:
+        return consume_bit_grad(int(self._bit_handle.item()))
+
+    def _post_load_state_dict(self, module, incompatible_keys) -> None:
+        del module, incompatible_keys
+        new_handle = register_bit_handle(int(self._bit_handle.item()))
+        if new_handle != self._registered_handle:
+            release_bit_handle(self._registered_handle)
+            self._registered_handle = new_handle
+
+
+def collect_bitlinear_modules(module: nn.Module) -> list[BitLinear]:
+    return [m for m in module.modules() if isinstance(m, BitLinear)]

eiporion-0.1.0/eiporion/eiporionkernels.py

@@ -0,0 +1,227 @@
+import torch
+
+
+# ---------------------------------------------------------------------------
+# Handle registry
+# ---------------------------------------------------------------------------
+_NEXT_HANDLE = 1
+_REGISTERED_HANDLES: set[int] = set()
+_BIT_GRAD_CACHE: dict[int, torch.Tensor] = {}
+
+
+def next_bit_handle() -> int:
+    global _NEXT_HANDLE
+    while _NEXT_HANDLE in _REGISTERED_HANDLES:
+        _NEXT_HANDLE += 1
+    handle = _NEXT_HANDLE
+    _REGISTERED_HANDLES.add(handle)
+    _NEXT_HANDLE += 1
+    return handle
+
+
+def register_bit_handle(handle: int) -> int:
+    global _NEXT_HANDLE
+    handle = int(handle)
+    if handle <= 0:
+        raise ValueError(f"handle must be > 0, got {handle}")
+    _REGISTERED_HANDLES.add(handle)
+    _BIT_GRAD_CACHE.pop(handle, None)
+    if handle >= _NEXT_HANDLE:
+        _NEXT_HANDLE = handle + 1
+    return handle
+
+
+def release_bit_handle(handle: int) -> None:
+    handle = int(handle)
+    _REGISTERED_HANDLES.discard(handle)
+    _BIT_GRAD_CACHE.pop(handle, None)
+
+
+def consume_bit_grad(handle: int) -> torch.Tensor | None:
+    return _BIT_GRAD_CACHE.pop(int(handle), None)
+
+
+# ---------------------------------------------------------------------------
+# bitsandbytes backend
+# ---------------------------------------------------------------------------
+_BNB_F = None
+_BNB_FMT = "col_ampere"
+
+try:
+    import bitsandbytes.functional as _BNB_F
+
+    if torch.cuda.is_available():
+        cc = torch.cuda.get_device_capability()
+        if cc[0] >= 8:
+            _BNB_FMT = "col_ampere"
+        elif cc[0] == 7 and cc[1] >= 5:
+            _BNB_FMT = "col_turing"
+        else:
+            _BNB_FMT = "col32"
+except ImportError:
+    pass
+
+# Weight-transform cache  (handle → (CxB, SB, version))
+_BNB_WCACHE: dict[int, tuple] = {}
+_BNB_WVERSION: dict[int, int] = {}
+
+
+def _cached_weight_transform(
+    handle: int, int_weight: torch.Tensor, weight_scale: torch.Tensor
+):
+    """Return (CxB, SB) for the current weight; re-transform only if stale."""
+    cur_ver = _BNB_WVERSION.get(handle, 0)
+    entry = _BNB_WCACHE.get(handle)
+    if entry is not None:
+        CxB, SB, cached_ver = entry
+        if cached_ver == cur_ver:
+            return CxB, SB
+
+    # bitsandbytes expects fp16 input for int8_vectorwise_quant
+    w_fp16 = int_weight.to(torch.float16) * weight_scale.to(torch.float16).unsqueeze(1)
+    w_q, _w_s, _ = _BNB_F.int8_vectorwise_quant(w_fp16)
+    CxB, SB = _BNB_F.transform(w_q, _BNB_FMT)
+    _BNB_WCACHE[handle] = (CxB, SB, cur_ver)
+    return CxB, SB
+
+
+def _invalidate_weight_cache(handle: int):
+    """Call after int_weight is modified by stochastic rounding."""
+    _BNB_WVERSION[handle] = _BNB_WVERSION.get(handle, 0) + 1
+
+
+# ---------------------------------------------------------------------------
+# Weight quantisation  (static, used at init / reset)
+# ---------------------------------------------------------------------------
+
+
+def quantize_fp_to_int8(weight: torch.Tensor, eps: float = 1e-8):
+    if weight.ndim != 2:
+        raise ValueError(
+            f"weight must be 2D [out_features, in_features], got {tuple(weight.shape)}"
+        )
+    w = weight.float()
+    scale = w.abs().amax(dim=1, keepdim=True).clamp_min(float(eps)) / 127.0
+    q = torch.round(w / scale).clamp(-127, 127).to(torch.int8)
+    return q.contiguous(), scale.squeeze(1).contiguous()
+
+
+# ---------------------------------------------------------------------------
+# Int8LinearFn
+# ---------------------------------------------------------------------------
+
+
+class Int8LinearFn(torch.autograd.Function):
+    @staticmethod
+    def forward(
+        ctx,
+        x2d: torch.Tensor,  # [N, K]  (autocast doesn't cover custom Fns)
+        int_weight: torch.Tensor,  # [O, K]  int8
+        weight_scale: torch.Tensor,  # [O]     float  (trainable Parameter)
+        bias: torch.Tensor | None,  # [O]     float
+        handle: int,
+    ):
+        return _forward_bf16(ctx, x2d, int_weight, weight_scale, bias, handle)
+
+    @staticmethod
+    def backward(ctx, grad_out: torch.Tensor):
+        return _backward_impl(ctx, grad_out)
+
+
+# ---------------------------------------------------------------------------
+# Path A: bitsandbytes cuBLASLt INT8 Tensor Cores
+# ---------------------------------------------------------------------------
+
+
+def _forward_bnb(ctx, x2d, int_weight, weight_scale, bias, handle):
+    # 1. Quantise activation — bitsandbytes works in fp16
+    x_fp16 = x2d.half()
+    CA, SCA, _ = _BNB_F.int8_vectorwise_quant(x_fp16)
+
+    # 2. Transform activation to col32 layout
+    C32A, SA = _BNB_F.transform(CA, "col32")
+
+    # 3. Get cached weight transform
+    CxB, SB = _cached_weight_transform(handle, int_weight, weight_scale)
+
+    # 4. INT8 matmul via cuBLASLt
+    out_i32, _ = _BNB_F.igemmlt(C32A, CxB, SA, SB)
+
+    # 5. Dequantise — output must match activation scale × weight scale
+    out = _BNB_F.mm_dequant(out_i32, SCA, weight_scale.half().unsqueeze(1))
+
+    if bias is not None:
+        out.add_(bias.half())
+
+    ctx.save_for_backward(x2d.to(torch.bfloat16), int_weight, weight_scale)
+    ctx.handle = int(handle)
+    ctx.has_bias = bias is not None
+    ctx.input_dtype = x2d.dtype
+    return out.to(dtype=x2d.dtype)
+
+
+# ---------------------------------------------------------------------------
+# Path B: BF16 fallback  (torch.matmul on BF16 Tensor Cores, works everywhere)
+# ---------------------------------------------------------------------------
+
+
+def _forward_bf16(ctx, x2d, int_weight, weight_scale, bias, handle):
+    x2d_bf16 = x2d.to(torch.bfloat16)
+    w_bf16 = int_weight.to(torch.bfloat16) * weight_scale.to(torch.bfloat16).unsqueeze(
+        1
+    )
+    out = torch.matmul(x2d_bf16, w_bf16.t())
+    if bias is not None:
+        out.add_(bias)
+    ctx.save_for_backward(x2d_bf16, int_weight, weight_scale)
+    ctx.handle = int(handle)
+    ctx.has_bias = bias is not None
+    ctx.input_dtype = x2d.dtype
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Common backward (BF16 matmul — correct for both forward paths)
+# ---------------------------------------------------------------------------
+
+
+def _backward_impl(ctx, grad_out):
+    x2d_bf16, int_weight, weight_scale = ctx.saved_tensors
+    go_bf16 = grad_out.to(torch.bfloat16)
+    ws_bf16 = weight_scale.to(torch.bfloat16)
+
+    w_bf16 = int_weight.to(torch.bfloat16) * ws_bf16.unsqueeze(1)
+
+    grad_in = torch.matmul(go_bf16, w_bf16)
+
+    grad_w = torch.matmul(go_bf16.t(), x2d_bf16)
+    cached = _BIT_GRAD_CACHE.get(ctx.handle)
+    if cached is None:
+        _BIT_GRAD_CACHE[ctx.handle] = grad_w.to(dtype=torch.bfloat16)
+    else:
+        cached.add_(grad_w.to(dtype=torch.bfloat16))
+
+    grad_bias = go_bf16.sum(dim=0).to(dtype=grad_out.dtype) if ctx.has_bias else None
+
+    # int_weight and weight_scale are fixed buffers — no gradient flows to them.
+    # int_weight is updated via DQT in EiporionOptim; weight_scale stays fixed.
+    return (
+        grad_in.to(dtype=grad_out.dtype),
+        None,  # int_weight
+        None,  # weight_scale
+        grad_bias,
+        None,  # handle
+    )
+
+
+# ---------------------------------------------------------------------------
+# INT8 weight update
+# ---------------------------------------------------------------------------
+
+
+@torch.no_grad()
+def update_int8_weight_(int_weight: torch.Tensor, delta_q: torch.Tensor) -> None:
+    """In-place int8 weight update:  W += delta_q, clamped to [-127, 127]."""
+    result = int_weight.to(torch.int16) + delta_q.to(torch.int16)
+    result.clamp_(-127, 127)
+    int_weight.copy_(result.to(torch.int8))

eiporion-0.1.0/eiporion/eiporionoptim.py

@@ -0,0 +1,258 @@
+import torch
+from bitsandbytes.optim import AdamW8bit
+
+from .bitLinear import BitLinear
+from .eiporionkernels import update_int8_weight_, _invalidate_weight_cache
+
+
+# ---- 8-bit blockwise helpers with mu-law companding ----
+_MU = 255.0
+_1_OVER_LN1P_MU = 1.0 / 5.545177444479562  # 1 / ln(1 + 255)
+
+
+def _pad_to_block_multiple(t: torch.Tensor, blocksize: int, num_blocks: int):
+    padded_size = num_blocks * blocksize
+    if padded_size > t.numel():
+        return torch.cat(
+            [t, torch.zeros(padded_size - t.numel(), device=t.device, dtype=t.dtype)]
+        )
+    return t
+
+
+def _quantize_blockwise_signed(x: torch.Tensor, blocksize: int):
+    x_flat = x.float().contiguous().view(-1)
+    numel = x_flat.numel()
+    num_blocks = (numel + blocksize - 1) // blocksize
+    x_padded = _pad_to_block_multiple(x_flat, blocksize, num_blocks)
+    x_blocks = x_padded.view(num_blocks, blocksize)
+    absmax = x_blocks.abs().amax(dim=1).clamp_min(1e-12)
+
+    # mu-law companding: normalise → compress → quantise
+    x_norm = (x_blocks / absmax.unsqueeze(1)).clamp(-1.0, 1.0)
+    x_comp = torch.sign(x_norm) * torch.log1p(_MU * x_norm.abs()) * _1_OVER_LN1P_MU
+
+    q_blocks = torch.round(x_comp * 127.0).clamp(-127, 127).to(torch.int16)
+    q_flat = (q_blocks.view(-1)[:numel] + 128).to(torch.uint8)
+    return q_flat.view_as(x), absmax
+
+
+def _dequantize_blockwise_signed(q, absmax, blocksize, shape):
+    q_flat = q.contiguous().view(-1)
+    numel = q_flat.numel()
+    num_blocks = absmax.numel()
+    q_padded = _pad_to_block_multiple(q_flat, blocksize, num_blocks)
+    q_blocks = q_padded.view(num_blocks, blocksize).float()
+
+    # inverse mu-law
+    y = ((q_blocks - 128.0) / 127.0).clamp(-1.0, 1.0)
+    x_norm = torch.sign(y) * (torch.exp(y.abs() / _1_OVER_LN1P_MU) - 1.0) / _MU
+    out_blocks = x_norm * absmax.unsqueeze(1)
+    return out_blocks.view(-1)[:numel].view(shape)
+
+
+def _quantize_blockwise_unsigned(x: torch.Tensor, blocksize: int):
+    x_flat = x.float().contiguous().view(-1)
+    numel = x_flat.numel()
+    num_blocks = (numel + blocksize - 1) // blocksize
+    x_padded = _pad_to_block_multiple(x_flat, blocksize, num_blocks)
+    x_blocks = x_padded.view(num_blocks, blocksize)
+    absmax = x_blocks.amax(dim=1).clamp_min(1e-12)
+
+    # mu-law companding (unsigned: [0, 1] range)
+    x_norm = (x_blocks / absmax.unsqueeze(1)).clamp(0.0, 1.0)
+    x_comp = torch.log1p(_MU * x_norm) * _1_OVER_LN1P_MU
+
+    q_blocks = torch.round(x_comp * 255.0).clamp(0, 255)
+    q_flat = q_blocks.view(-1)[:numel].to(torch.uint8)
+    return q_flat.view_as(x), absmax
+
+
+def _dequantize_blockwise_unsigned(q, absmax, blocksize, shape):
+    q_flat = q.contiguous().view(-1)
+    numel = q_flat.numel()
+    num_blocks = absmax.numel()
+    q_padded = _pad_to_block_multiple(q_flat, blocksize, num_blocks)
+    q_blocks = q_padded.view(num_blocks, blocksize).float()
+
+    y = (q_blocks / 255.0).clamp(0.0, 1.0)
+    x_norm = (torch.exp(y / _1_OVER_LN1P_MU) - 1.0) / _MU
+    out_blocks = x_norm * absmax.unsqueeze(1)
+    return out_blocks.view(-1)[:numel].view(shape)
+
+
+class EiporionOptim(AdamW8bit):
+    """bnb AdamW8bit for dense params + 8-bit AdamW + DQT-SR for INT8 weights."""
+
+    def __init__(
+        self,
+        params,
+        lr=1e-3,
+        betas=(0.9, 0.999),
+        eps=1e-8,
+        weight_decay=0.1,
+        bit_modules=None,
+        block_size=256,
+        sr_bias_scale=0.15,
+    ):
+        super().__init__(
+            params,
+            lr=lr,
+            betas=betas,
+            eps=eps,
+            weight_decay=weight_decay,
+        )
+        self.bit_modules = list(bit_modules) if bit_modules is not None else []
+        self._bit_handles = (
+            [int(m._bit_handle.item()) for m in self.bit_modules]
+            if bit_modules is not None
+            else []
+        )
+        self._bit_state: dict[int, dict[str, torch.Tensor | int]] = {}
+        self.block_size = int(block_size)
+        self.sr_bias_scale = float(sr_bias_scale)
+
+    def add_bit_modules(self, modules) -> None:
+        for module in modules:
+            if not isinstance(module, BitLinear):
+                raise TypeError(f"expected BitLinear, got {type(module).__name__}")
+            if module not in self.bit_modules:
+                self.bit_modules.append(module)
+                self._bit_handles.append(int(module._bit_handle.item()))
+
+    @torch.no_grad()
+    def step(self, closure=None):
+        loss = super().step(closure)
+
+        if not self.bit_modules:
+            return loss
+
+        group = self.param_groups[0]
+        lr = float(group["lr"])
+        beta1, beta2 = group["betas"]
+        eps = float(group["eps"])
+        wd = float(group["weight_decay"])
+        bs = self.block_size
+
+        for module, handle in zip(self.bit_modules, self._bit_handles):
+            g = module.consume_weight_grad()
+            if g is None:
+                continue
+            g = g.float().contiguous()
+
+            state = self._bit_state.setdefault(handle, {})
+            if "step" not in state:
+                state["step"] = 0
+                # 8-bit m, v (matching AdamW8bit scheme)
+                m_q, m_absmax = _quantize_blockwise_signed(
+                    torch.zeros_like(g, dtype=torch.float32), bs
+                )
+                v_q, v_absmax = _quantize_blockwise_unsigned(
+                    torch.zeros_like(g, dtype=torch.float32), bs
+                )
+                state["m_q"] = m_q
+                state["m_absmax"] = m_absmax
+                state["v_q"] = v_q
+                state["v_absmax"] = v_absmax
+                # residual also 8-bit blockwise, same scheme as m
+                r_q, r_absmax = _quantize_blockwise_signed(
+                    torch.zeros_like(g, dtype=torch.float32), bs
+                )
+                state["r_q"] = r_q
+                state["r_absmax"] = r_absmax
+
+            m = _dequantize_blockwise_signed(
+                state["m_q"], state["m_absmax"], bs, g.shape
+            )
+            v = _dequantize_blockwise_unsigned(
+                state["v_q"], state["v_absmax"], bs, g.shape
+            )
+            residual = _dequantize_blockwise_signed(
+                state["r_q"], state["r_absmax"], bs, g.shape
+            )
+            state["step"] += 1
+            t = state["step"]
+
+            m.mul_(beta1).add_(g, alpha=1.0 - beta1)
+            v.mul_(beta2).addcmul_(g, g, value=1.0 - beta2)
+            m_hat = m / (1.0 - beta1**t)
+            v_hat = v / (1.0 - beta2**t)
+
+            ws = module.weight_scale.float().unsqueeze(1).clamp_min(eps)
+            iw = module.int_weight.float()
+            adam_term = m_hat / (v_hat.sqrt() + eps)
+            delta_w_eff = -lr * (adam_term + wd * iw * ws)
+            residual = residual + delta_w_eff / ws
+
+            abs_res = residual.abs()
+            base = torch.floor(abs_res)
+            frac = abs_res - base
+            # Momentum-biased SR
+            bias = torch.tanh(adam_term) * self.sr_bias_scale * torch.sign(residual)
+            frac_biased = (frac + bias).clamp(0.0, 1.0)
+            extra = (torch.rand_like(frac) < frac_biased).float()
+            delta_q = (torch.sign(residual) * (base + extra)).to(torch.int32)
+
+            if torch.any(delta_q != 0):
+                update_int8_weight_(module.int_weight, delta_q)
+                residual = residual - delta_q.float()
+                _invalidate_weight_cache(handle)
+
+            r_q, r_absmax = _quantize_blockwise_signed(residual, bs)
+            state["r_q"] = r_q
+            state["r_absmax"] = r_absmax
+
+            m_q, m_absmax = _quantize_blockwise_signed(m, bs)
+            v_q, v_absmax = _quantize_blockwise_unsigned(v, bs)
+            state["m_q"] = m_q
+            state["m_absmax"] = m_absmax
+            state["v_q"] = v_q
+            state["v_absmax"] = v_absmax
+
+        return loss
+
+    def state_dict(self):
+        state = super().state_dict()
+        state["bit_state"] = {
+            int(handle): {
+                key: value.detach().cpu() if torch.is_tensor(value) else value
+                for key, value in per_handle.items()
+            }
+            for handle, per_handle in self._bit_state.items()
+        }
+        return state
+
+    def load_state_dict(self, state_dict):
+        state_dict = dict(state_dict)
+        bit_state = state_dict.pop("bit_state", {})
+        super().load_state_dict(state_dict)
+        self._bit_state = {}
+        for handle, per_handle in bit_state.items():
+            self._bit_state[int(handle)] = {
+                key: value.clone() if torch.is_tensor(value) else value
+                for key, value in per_handle.items()
+            }
+
+
+class EiporionOptimSR(EiporionOptim):
+    """EiporionOptim with unbiased stochastic rounding (no momentum bias)."""
+
+    def __init__(
+        self,
+        params,
+        lr=1e-3,
+        betas=(0.9, 0.999),
+        eps=1e-8,
+        weight_decay=0.1,
+        bit_modules=None,
+        block_size=256,
+    ):
+        super().__init__(
+            params,
+            lr=lr,
+            betas=betas,
+            eps=eps,
+            weight_decay=weight_decay,
+            bit_modules=bit_modules,
+            block_size=block_size,
+            sr_bias_scale=0.0,
+        )

eiporion-0.1.0/eiporion.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: eiporion
+Version: 0.1.0
+Summary: INT8 linear layers with DQT SR/MB-SR and bitsandbytes acceleration.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: bitsandbytes<0.46.0,>=0.45.0
+Requires-Dist: torch
+
+# Eiporion
+
+INT8 linear layers with DQT SR/MB-SR and bitsandbytes acceleration.
+
+## Install
+
+```bash
+pip install eiporion
+```
+
+## Quick use
+
+```python
+from eiporion import BitLinear
+```

eiporion-0.1.0/eiporion.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+eiporion/__init__.py
+eiporion/bitLinear.py
+eiporion/eiporionkernels.py
+eiporion/eiporionoptim.py
+eiporion.egg-info/PKG-INFO
+eiporion.egg-info/SOURCES.txt
+eiporion.egg-info/dependency_links.txt
+eiporion.egg-info/requires.txt
+eiporion.egg-info/top_level.txt

eiporion-0.1.0/eiporion.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

eiporion-0.1.0/eiporion.egg-info/requires.txt

@@ -0,0 +1,2 @@
+bitsandbytes<0.46.0,>=0.45.0
+torch

eiporion-0.1.0/eiporion.egg-info/top_level.txt

@@ -0,0 +1 @@
+eiporion

eiporion-0.1.0/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "eiporion"
+version = "0.1.0"
+description = "INT8 linear layers with DQT SR/MB-SR and bitsandbytes acceleration."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = ["bitsandbytes>=0.45.0,<0.46.0", "torch"]
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["eiporion"]

eiporion-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+