| |
| """ |
| app.py — Production Serving Harness & Playground for JMullings/Spectral_Embeddings |
| ================================================================================= |
| • Auto-downloads and unpacks EMBEDDINGS_CORE.npz from the Hugging Face Hub. |
| • Multiscale 16,384-D feature hashing with calibrated Riemannian metric decoding. |
| • Exposes Ollama-compatible REST endpoints (/api/embed, /api/tags, /api/metric). |
| • Binds to 0.0.0.0:7860 (Hugging Face Spaces default) or environment $PORT. |
| ================================================================================= |
| """ |
|
|
| import os |
| import sys |
| import json |
| import time |
| import math |
| import hashlib |
| import re |
| import threading |
| from pathlib import Path |
| from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer |
| from urllib.parse import urlparse |
|
|
| import numpy as np |
|
|
| |
| |
| |
|
|
| REPO_ID = "JMullings/Spectral_Embeddings" |
| FILENAME = "EMBEDDINGS_CORE.npz" |
| PORT = int(os.environ.get("PORT", 7860)) |
| HOST = "0.0.0.0" |
| BASE_DIR = Path(__file__).resolve().parent |
| LOCAL_WEIGHTS = BASE_DIR / FILENAME |
|
|
| if not LOCAL_WEIGHTS.exists(): |
| print(f"[*] Downloading {FILENAME} from huggingface.co/{REPO_ID}...") |
| try: |
| from huggingface_hub import hf_hub_download |
| downloaded = hf_hub_download( |
| repo_id=REPO_ID, |
| filename=FILENAME, |
| local_dir=str(BASE_DIR), |
| token=os.environ.get("HF_TOKEN") |
| ) |
| LOCAL_WEIGHTS = Path(downloaded) |
| print("[+] Download complete.") |
| except Exception as e: |
| print(f"[!] Warning: Could not download from Hub: {e}. Checking fallback.") |
|
|
| if not LOCAL_WEIGHTS.exists(): |
| raise FileNotFoundError(f"Missing model file {LOCAL_WEIGHTS}. Ensure {FILENAME} exists.") |
|
|
|
|
| |
| |
| |
|
|
| print(f"[*] Loading {LOCAL_WEIGHTS.name}...") |
| data = np.load(LOCAL_WEIGHTS, allow_pickle=True) |
| keys = list(data.files) |
| print(f"[+] Archive keys: {keys}") |
|
|
| |
| if "W_q" in keys: |
| W_raw = np.asarray(data["W_q"], dtype=np.float32) |
| if "col_idx" in keys and "H" in keys: |
| H = int(data["H"]) |
| k = int(data["k"]) if "k" in keys else W_raw.shape[0] |
| col_idx = np.asarray(data["col_idx"], dtype=np.int64) |
| W = np.zeros((k, H), dtype=np.float32) |
| if "W_scale" in keys: |
| W[:, col_idx] = W_raw * np.asarray(data["W_scale"], dtype=np.float32)[:, None] |
| else: |
| W[:, col_idx] = W_raw |
| else: |
| W = W_raw |
| elif "W" in keys: |
| W = np.asarray(data["W"], dtype=np.float32) |
| elif "W0" in keys: |
| W = np.asarray(data["W0"], dtype=np.float32) |
| else: |
| matrix_keys = [k for k in keys if len(data[k].shape) == 2] |
| W = np.asarray(data[matrix_keys[0]], dtype=np.float32) |
|
|
| b = np.asarray(data["b"] if "b" in keys else data.get("b0", np.zeros(W.shape[0], dtype=np.float32)), dtype=np.float32) |
|
|
| embed_dim, feature_dim = W.shape |
| hash_seed = int(data["hash_seed"]) if "hash_seed" in keys else 42 |
|
|
| print(f"[+] Projection Matrix: ({embed_dim} x {feature_dim}) = {W.size:,} parameters") |
| print(f"[+] Hash Seed: {hash_seed}") |
|
|
| |
| class TextEncoder: |
| def __init__(self, H: int = 16384, seed: int = 42): |
| self.H = H |
| self.seed = seed |
| self._cache = {} |
|
|
| def _hash_token(self, tok: str) -> int: |
| idx = self._cache.get(tok) |
| if idx is None: |
| h = hashlib.blake2b(f"{self.seed}:{tok}".encode("utf-8"), digest_size=8).digest() |
| idx = int.from_bytes(h, "little") % self.H |
| if len(self._cache) > 200_000: |
| self._cache.clear() |
| self._cache[tok] = idx |
| return idx |
|
|
| def transform(self, text: str) -> np.ndarray: |
| x = np.zeros(self.H, dtype=np.float32) |
| cleaned = text.lower().strip() |
| words = re.findall(r"[a-z0-9]+", cleaned) |
| for w in words: |
| x[self._hash_token(f"w:{w}")] += 2.0 |
| for j in range(len(words) - 1): |
| x[self._hash_token(f"bi:{words[j]}_{words[j+1]}")] += 3.0 |
| padded = f" {cleaned} " |
| L = len(padded) |
| for n in (3, 4): |
| for j in range(L - n + 1): |
| x[self._hash_token(f"ch:{padded[j:j+n]}")] += 1.0 |
| norm = float(np.linalg.norm(x)) |
| if norm > 1e-12: |
| x /= norm |
| return x |
|
|
| encoder = TextEncoder(H=feature_dim, seed=hash_seed) |
|
|
| |
| def build_unified_metric(dim: int) -> np.ndarray: |
| gamma = 1.50 |
| omega_star = 0.78 |
| raw_m = np.zeros(dim, dtype=np.float64) |
| for k in range(dim): |
| gamma_k = 0.5 + 0.35 * (k + 1) |
| center_k = 0.10 + 0.15 * k |
| sech2 = 1.0 - np.tanh(gamma_k * (omega_star - center_k)) ** 2 |
| raw_m[k] = gamma_k * sech2 |
| if raw_m.max() > 1e-12: |
| raw_m /= raw_m.max() |
| m_diag = (1.0 + gamma * raw_m) * (dim / max(float((1.0 + gamma * raw_m).sum()), 1e-12)) |
| return m_diag.astype(np.float32) |
|
|
| M_diag = build_unified_metric(embed_dim) |
|
|
| def embed(text: str) -> np.ndarray: |
| x = encoder.transform(text) |
| z = W @ x + b |
| norm = float(np.linalg.norm(z)) |
| return (z / max(norm, 1e-12)).astype(np.float32) |
|
|
| def unified_similarity(a: np.ndarray, b_vec: np.ndarray) -> float: |
| diff = a - b_vec |
| dist = np.sqrt(np.sum(M_diag * (diff ** 2))) |
| return float(np.exp(-dist)) |
|
|
|
|
| |
| |
| |
|
|
| print("\n--- Running Startup Verification Probe ---") |
| v1 = embed("How do I reset my password?") |
| v2 = embed("Steps to recover your account credentials.") |
| v3 = embed("The weather forecast calls for rain.") |
|
|
| raw_cos_p = float(np.dot(v1, v2)) |
| raw_cos_c = float(np.dot(v1, v3)) |
| cal_sim_p = unified_similarity(v1, v2) |
| cal_sim_c = unified_similarity(v1, v3) |
|
|
| print(f"• Raw Cosine : Paraphrase = {raw_cos_p:.4f} | Contradiction = {raw_cos_c:.4f} (Margin: {raw_cos_p - raw_cos_c:+.4f})") |
| print(f"• Calibrated Metric : Paraphrase = {cal_sim_p:.4f} | Contradiction = {cal_sim_c:.4f} (Margin: {cal_sim_p - cal_sim_c:+.4f})") |
| if cal_sim_p > cal_sim_c: |
| print(">>> [PASS] Semantic Discrimination Probe Verified.") |
| else: |
| print(">>> [WARN] Discrimination margin is zero or negative.") |
| print("------------------------------------------\n") |
|
|
|
|
| |
| |
| |
|
|
| class Handler(BaseHTTPRequestHandler): |
| def log_message(self, fmt, *args): |
| |
| if args and isinstance(args[0], str) and "/api/health" in args[0]: |
| return |
| sys.stderr.write(f"[{self.log_date_time_string()}] {self.address_string()} {fmt % args}\n") |
|
|
| def _send(self, code: int, body: bytes, ctype="application/json"): |
| self.send_response(code) |
| self.send_header("Content-Type", ctype) |
| self.send_header("Content-Length", str(len(body))) |
| self.send_header("Access-Control-Allow-Origin", "*") |
| self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS") |
| self.send_header("Access-Control-Allow-Headers", "*") |
| self.end_headers() |
| try: |
| self.wfile.write(body) |
| except (BrokenPipeError, ConnectionResetError): |
| pass |
|
|
| def do_OPTIONS(self): |
| self._send(204, b"") |
|
|
| def do_GET(self): |
| p = urlparse(self.path).path |
| if p in ("/", "/index.html"): |
| html_file = BASE_DIR / "index.html" |
| content = html_file.read_bytes() if html_file.exists() else b"<h1>Spectral Embeddings Server Active</h1>" |
| self._send(200, content, "text/html; charset=utf-8") |
| return |
|
|
| if p == "/api/health": |
| self._send(200, json.dumps({ |
| "status": "ok", |
| "model": REPO_ID, |
| "dim": embed_dim, |
| "feature_dim": feature_dim, |
| "parameters": int(W.size), |
| "metric": "unified_nn", |
| }).encode()) |
| return |
|
|
| if p == "/api/metric": |
| self._send(200, json.dumps({ |
| "name": "unified_nn", |
| "dim": embed_dim, |
| "M_diag": M_diag.tolist(), |
| "equation": "exp(-sqrt(sum_k M_kk (a_k-b_k)^2))" |
| }).encode()) |
| return |
|
|
| if p == "/api/tags": |
| self._send(200, json.dumps({ |
| "models": [{ |
| "name": "spectral-embed-v2-online", |
| "model": "spectral-embed-v2-online", |
| "size": int(W.size * 4), |
| "details": { |
| "family": "spectral", |
| "dimension": embed_dim, |
| "parameters": int(W.size) |
| } |
| }] |
| }).encode()) |
| return |
|
|
| self._send(404, b'{"error":"endpoint not found"}') |
|
|
| def do_POST(self): |
| p = urlparse(self.path).path |
| length = int(self.headers.get("Content-Length", 0)) |
| raw_body = self.rfile.read(length) if length > 0 else b"{}" |
|
|
| try: |
| body = json.loads(raw_body.decode("utf-8")) if raw_body else {} |
| except Exception: |
| self._send(400, b'{"error":"invalid json body"}') |
| return |
|
|
| if p in ("/api/embed", "/api/embeddings"): |
| inp = body.get("input", body.get("prompt", "")) |
| texts = [inp] if isinstance(inp, str) else [str(x) for x in inp] |
| |
| t0 = time.perf_counter() |
| embs = [embed(t).tolist() for t in texts] |
| ms = (time.perf_counter() - t0) * 1000.0 |
|
|
| self._send(200, json.dumps({ |
| "embeddings": embs, |
| "dim": embed_dim, |
| "model": "spectral-embed-v2-online", |
| "latency_ms": round(ms, 2), |
| "per_sentence_ms": round(ms / max(len(texts), 1), 3), |
| }).encode()) |
| return |
|
|
| self._send(404, b'{"error":"endpoint not found"}') |
|
|
|
|
| def main(): |
| print(f"[*] Starting Multi-Threaded Spectral Harness on http://{HOST}:{PORT}") |
| server = ThreadingHTTPServer((HOST, PORT), Handler) |
| try: |
| server.serve_forever() |
| except KeyboardInterrupt: |
| print("\n[!] Shutting down server gracefully...") |
| server.server_close() |
|
|
|
|
| if __name__ == "__main__": |
| main() |
