Download nlrt.py from thelamapi/Next-Ask: direct link, hf CLI and curl.
- Browser
- Download file 8.04 kB
-
https://huggingface.co/thelamapi/Next-Ask/resolve/main/nlrt.py
- Command line
-
hf download hf://thelamapi/Next-Ask/nlrt.py
-
curl -L -o nlrt.py https://huggingface.co/thelamapi/Next-Ask/resolve/main/nlrt.py
8.04 kB
| """nlrt: tiny portable runtime shared by Next Lab models. | |
| The same layer list runs in NumPy (this file) and in the browser (nlrt.js). | |
| Weights are stored as base64 little-endian float32 inside model.json. | |
| Only NumPy is required to load and run a model. | |
| """ | |
| import base64 | |
| import json | |
| import math | |
| import numpy as np | |
| __all__ = ["b64e", "b64d", "forward", "load_model", "Mulberry32", "export_sequential"] | |
| def b64e(a): | |
| return base64.b64encode(np.ascontiguousarray(a, dtype="<f4").tobytes()).decode("ascii") | |
| def b64d(s, shape=None): | |
| a = np.frombuffer(base64.b64decode(s), dtype="<f4").astype(np.float64) | |
| return a.reshape(shape) if shape is not None else a | |
| def load_model(path): | |
| with open(path, "r", encoding="utf-8") as f: | |
| spec = json.load(f) | |
| for net in spec.get("nets", {}).values(): | |
| _decode(net) | |
| for k, v in list(spec.get("tensors", {}).items()): | |
| spec["tensors"][k] = b64d(v["data"], v["shape"]) | |
| return spec | |
| def _decode(layers): | |
| for L in layers: | |
| for key in ("w", "b"): | |
| if key in L and isinstance(L[key], str): | |
| L[key] = b64d(L[key], L.get(key + "_shape")) | |
| class Mulberry32: | |
| """Deterministic PRNG with an identical JavaScript twin in nlrt.js.""" | |
| def __init__(self, seed): | |
| self.a = seed & 0xFFFFFFFF | |
| def random(self): | |
| self.a = (self.a + 0x6D2B79F5) & 0xFFFFFFFF | |
| t = self.a | |
| t = ((t ^ (t >> 15)) * (t | 1)) & 0xFFFFFFFF | |
| t ^= (t + (((t ^ (t >> 7)) * (t | 61)) & 0xFFFFFFFF)) & 0xFFFFFFFF | |
| return ((t ^ (t >> 14)) & 0xFFFFFFFF) / 4294967296.0 | |
| def uniform(self, lo, hi): | |
| return lo + (hi - lo) * self.random() | |
| def randint(self, n): | |
| return int(math.floor(self.random() * n)) | |
| def normal(self): | |
| u = max(self.random(), 1e-12) | |
| v = self.random() | |
| return math.sqrt(-2.0 * math.log(u)) * math.cos(2.0 * math.pi * v) | |
| def _pair(v): | |
| return list(v) if isinstance(v, (list, tuple)) else [v, v] | |
| def _conv2d(x, w, b, stride, pad): | |
| n, c, h, wd = x.shape | |
| o, _, kh, kw = w.shape | |
| sh, sw = stride | |
| ph, pw = pad | |
| xp = np.pad(x, ((0, 0), (0, 0), (ph, ph), (pw, pw))) | |
| oh = (h + 2 * ph - kh) // sh + 1 | |
| ow = (wd + 2 * pw - kw) // sw + 1 | |
| cols = np.empty((n, c, kh, kw, oh, ow), dtype=x.dtype) | |
| for i in range(kh): | |
| for j in range(kw): | |
| cols[:, :, i, j] = xp[:, :, i:i + sh * oh:sh, j:j + sw * ow:sw] | |
| out = np.tensordot(cols, w, axes=([1, 2, 3], [1, 2, 3])) # n, oh, ow, o | |
| out = out.transpose(0, 3, 1, 2) | |
| if b is not None: | |
| out = out + b[None, :, None, None] | |
| return out | |
| def _maxpool(x, k): | |
| kh, kw = k | |
| n, c, h, w = x.shape | |
| oh, ow = h // kh, w // kw | |
| x = x[:, :, :oh * kh, :ow * kw].reshape(n, c, oh, kh, ow, kw) | |
| return x.max(axis=(3, 5)) | |
| def forward(layers, x): | |
| """Run a layer list on a batch. x: (N, D) or (N, C, H, W) or (N, C, L).""" | |
| x = np.asarray(x, dtype=np.float64) | |
| for L in layers: | |
| t = L["type"] | |
| if t == "linear": | |
| x = x @ L["w"].T + L["b"] | |
| elif t == "conv2d": | |
| squeeze = x.ndim == 3 | |
| if squeeze: | |
| x = x[:, :, None, :] | |
| x = _conv2d(x, L["w"], L["b"], _pair(L["stride"]), _pair(L["pad"])) | |
| if squeeze: | |
| x = x[:, :, 0, :] | |
| elif t == "relu": | |
| x = np.maximum(x, 0) | |
| elif t == "tanh": | |
| x = np.tanh(x) | |
| elif t == "sigmoid": | |
| x = 1 / (1 + np.exp(-x)) | |
| elif t == "maxpool": | |
| squeeze = x.ndim == 3 | |
| if squeeze: | |
| x = x[:, :, None, :] | |
| x = _maxpool(x, _pair(L["k"])) | |
| if squeeze: | |
| x = x[:, :, 0, :] | |
| elif t == "gap": | |
| x = x.reshape(x.shape[0], x.shape[1], -1).mean(axis=2) | |
| elif t == "flatten": | |
| x = x.reshape(x.shape[0], -1) | |
| elif t == "upsample": | |
| x = x.repeat(L["s"], axis=-1) | |
| if x.ndim == 4: | |
| x = x.repeat(L["s"], axis=-2) | |
| elif t == "l2norm": | |
| x = x / np.maximum(np.linalg.norm(x, axis=1, keepdims=True), 1e-12) | |
| elif t == "reshape": | |
| x = x.reshape([x.shape[0]] + list(L["shape"])) | |
| else: | |
| raise ValueError("unknown layer " + t) | |
| return x | |
| def export_sequential(seq): | |
| """Convert a torch nn.Sequential into a portable layer list (BatchNorm folded).""" | |
| import torch.nn as nn | |
| mods = list(seq.modules())[1:] if not isinstance(seq, (list, tuple)) else list(seq) | |
| mods = [m for m in mods if not isinstance(m, nn.Sequential)] | |
| layers = [] | |
| def tensor(t): | |
| return t.detach().cpu().double().numpy() | |
| for m in mods: | |
| if isinstance(m, nn.Linear): | |
| b = tensor(m.bias) if m.bias is not None else np.zeros(m.out_features) | |
| layers.append({"type": "linear", "w": tensor(m.weight), "b": b}) | |
| elif isinstance(m, (nn.Conv2d, nn.Conv1d)): | |
| w = tensor(m.weight) | |
| b = tensor(m.bias) if m.bias is not None else np.zeros(w.shape[0]) | |
| if isinstance(m, nn.Conv1d): | |
| w = w[:, :, None, :] | |
| stride, pad = [1, m.stride[0]], [0, m.padding[0]] | |
| else: | |
| stride, pad = list(m.stride), list(m.padding) | |
| layers.append({"type": "conv2d", "w": w, "b": b, "stride": stride, "pad": pad}) | |
| elif isinstance(m, (nn.BatchNorm1d, nn.BatchNorm2d)): | |
| prev = layers[-1] | |
| assert prev["type"] in ("conv2d", "linear"), "BatchNorm must follow conv/linear" | |
| scale = tensor(m.weight) / np.sqrt(tensor(m.running_var) + m.eps) | |
| shift = tensor(m.bias) - tensor(m.running_mean) * scale | |
| if prev["type"] == "conv2d": | |
| prev["w"] = prev["w"] * scale[:, None, None, None] | |
| else: | |
| prev["w"] = prev["w"] * scale[:, None] | |
| prev["b"] = prev["b"] * scale + shift | |
| elif isinstance(m, nn.ReLU): | |
| layers.append({"type": "relu"}) | |
| elif isinstance(m, nn.Tanh): | |
| layers.append({"type": "tanh"}) | |
| elif isinstance(m, nn.Sigmoid): | |
| layers.append({"type": "sigmoid"}) | |
| elif isinstance(m, nn.MaxPool2d): | |
| layers.append({"type": "maxpool", "k": _pair(m.kernel_size)}) | |
| elif isinstance(m, nn.MaxPool1d): | |
| k = m.kernel_size if isinstance(m, int) else m.kernel_size | |
| layers.append({"type": "maxpool", "k": [1, k if isinstance(k, int) else k[0]]}) | |
| elif isinstance(m, (nn.AdaptiveAvgPool2d, nn.AdaptiveAvgPool1d)): | |
| layers.append({"type": "gap"}) | |
| elif isinstance(m, nn.Flatten): | |
| layers.append({"type": "flatten"}) | |
| elif isinstance(m, nn.Upsample): | |
| layers.append({"type": "upsample", "s": int(m.scale_factor)}) | |
| elif isinstance(m, nn.Dropout): | |
| continue | |
| elif m.__class__.__name__ == "L2Norm": | |
| layers.append({"type": "l2norm"}) | |
| elif m.__class__.__name__ == "Reshape": | |
| layers.append({"type": "reshape", "shape": list(m.shape)}) | |
| else: | |
| raise ValueError("cannot export " + m.__class__.__name__) | |
| return layers | |
| def encode_layers(layers): | |
| out = [] | |
| for L in layers: | |
| L2 = dict(L) | |
| for key in ("w", "b"): | |
| if key in L2: | |
| arr = np.asarray(L2[key]) | |
| L2[key + "_shape"] = list(arr.shape) | |
| L2[key] = b64e(arr) | |
| out.append(L2) | |
| return out | |
| def save_model(path, nets=None, tensors=None, meta=None): | |
| spec = {"format": "nlrt-1", "meta": meta or {}, "nets": {}, "tensors": {}} | |
| for name, layers in (nets or {}).items(): | |
| spec["nets"][name] = encode_layers(layers) | |
| for name, arr in (tensors or {}).items(): | |
| arr = np.asarray(arr) | |
| spec["tensors"][name] = {"shape": list(arr.shape), "data": b64e(arr)} | |
| with open(path, "w", encoding="utf-8") as f: | |
| json.dump(spec, f, separators=(",", ":")) | |
| return spec | |