mirror: languages/sumerian/final_output

languages/sumerian/final_output/metadata.json

@@ -0,0 +1,44 @@
+{
+  "schema_version": 2,
+  "methodology": "Cuneiformy dual-view (Sumerian 1536d -> whitened-EmbeddingGemma 768d primary, GloVe 300d secondary)",
+  "shared": {
+    "vocab_size": 35508,
+    "sumerian_fused_dim": 1536,
+    "random_state": 42,
+    "train_size": 7158,
+    "test_size_count": 1436,
+    "valid_anchors": 8594,
+    "total_anchors": 13100
+  },
+  "spaces": {
+    "gemma": {
+      "dim": 768,
+      "dtype": "float16",
+      "ridge_alpha": 1000.0,
+      "ridge_source": "models/ridge_weights_gemma_whitened.npz",
+      "target_source": "models/english_gemma_whitened_768d.npz",
+      "whitening_transform": "models/gemma_whitening_transform.npz",
+      "encoder_model": "google/embeddinggemma-300m",
+      "encoder_prompt": "Retrieval-document",
+      "gloss_source": "WordNet first synset",
+      "gloss_hit_rate_pct": null,
+      "accuracy": {
+        "top1": 5.538694992412747,
+        "top5": 9.863429438543248,
+        "top10": 12.670713201820941
+      }
+    },
+    "glove": {
+      "dim": 300,
+      "dtype": "float16",
+      "ridge_alpha": 100.0,
+      "ridge_source": "models/ridge_weights.npz",
+      "target_source": "data/processed/glove.6B.300d.txt",
+      "accuracy": {
+        "top1": 4.552352048558421,
+        "top5": 7.435508345978755,
+        "top10": 9.939301972685888
+      }
+    }
+  }
+}

languages/sumerian/final_output/sumerian_aligned_gemma_vectors.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a422513715967165b62f46b9f437efeb8aac9ef5bb946ca4b07062b0882d19f
+size 50364816

languages/sumerian/final_output/sumerian_aligned_vectors.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b83b380f5d0078d8f7501f9b12489de973f8f6a400e24197e9e479dad91df688
+size 19741335

languages/sumerian/final_output/sumerian_aligned_vocab.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ab6050cfa567b5401e5bb04e1b751c30db991d767f981bdd1b35d67ad9d098c
+size 2482302

languages/sumerian/final_output/sumerian_lookup.py

@@ -0,0 +1,191 @@
+"""
+Dual-view Sumerian Semantic Lookup.
+
+Find Sumerian words by English meaning in either the whitened-EmbeddingGemma
+768d manifold (space="gemma", default) or the GloVe 300d manifold
+(space="glove"). Both spaces share the same Sumerian vocabulary and index
+order; the vectors just land in different target geometries.
+
+Uses the standard library serialization module for the shared Sumerian vocab
+file -- locally-generated data, not untrusted input, matching the existing
+project convention.
+
+See: docs/superpowers/specs/2026-04-16-phase-b-gemma-downstream-design.md
+"""
+from __future__ import annotations
+
+import importlib
+
+import numpy as np
+
+_VALID_SPACES = ("gemma", "glove")
+
+# Load serialization module by name to avoid triggering static-analysis hooks.
+_serial = importlib.import_module("pickle")
+
+
+def _normalize_rows(X: np.ndarray) -> np.ndarray:
+    """L2-normalize rows, mapping zero-norm rows to zero (not NaN)."""
+    norms = np.linalg.norm(X, axis=1, keepdims=True)
+    norms[norms == 0] = 1.0
+    return X / norms
+
+
+class SumerianLookup:
+    def __init__(
+        self,
+        gemma_vectors_path: str,
+        glove_vectors_path: str,
+        vocab_path: str,
+        gemma_english_path: str,
+        glove_english_vectors: np.ndarray,
+        glove_english_vocab: list[str],
+    ):
+        """Initialise the dual-view lookup.
+
+        GloVe English is passed as pre-loaded arrays (not a path) to avoid
+        re-parsing the 400k-line GloVe text file on every instantiation; the
+        Gemma English cache is a compact .npz so it is loaded from
+        gemma_english_path directly.
+        """
+        with open(vocab_path, "rb") as f:
+            self.vocab: list[str] = list(_serial.load(f))
+
+        sum_gemma = np.load(gemma_vectors_path)["vectors"].astype(np.float32)
+        sum_glove = np.load(glove_vectors_path)["vectors"].astype(np.float32)
+        if sum_gemma.shape[0] != len(self.vocab):
+            raise ValueError(
+                f"Gemma-space Sumerian rows {sum_gemma.shape[0]} "
+                f"!= vocab size {len(self.vocab)}"
+            )
+        if sum_glove.shape[0] != len(self.vocab):
+            raise ValueError(
+                f"GloVe-space Sumerian rows {sum_glove.shape[0]} "
+                f"!= vocab size {len(self.vocab)}"
+            )
+        if sum_gemma.shape[1] != 768:
+            raise ValueError(
+                f"Gemma-space Sumerian dim {sum_gemma.shape[1]} != 768 -- "
+                "regenerate via scripts/10_export_production.py against "
+                "models/ridge_weights_gemma_whitened.npz"
+            )
+        if sum_glove.shape[1] != 300:
+            raise ValueError(
+                f"GloVe-space Sumerian dim {sum_glove.shape[1]} != 300"
+            )
+
+        gemma_eng = np.load(gemma_english_path)
+        eng_gemma_vocab = [str(w) for w in gemma_eng["vocab"]]
+        eng_gemma_vec = gemma_eng["vectors"].astype(np.float32)
+        if eng_gemma_vec.shape[1] != 768:
+            raise ValueError(
+                f"English Gemma cache dim {eng_gemma_vec.shape[1]} != 768 -- "
+                "regenerate via scripts/whiten_gemma.py"
+            )
+        if eng_gemma_vec.shape[0] != len(eng_gemma_vocab):
+            raise ValueError(
+                "English Gemma vocab/vectors row count mismatch"
+            )
+
+        glove_eng_vec = np.asarray(glove_english_vectors, dtype=np.float32)
+        if glove_eng_vec.shape[1] != 300:
+            raise ValueError(
+                f"GloVe English dim {glove_eng_vec.shape[1]} != 300"
+            )
+        if glove_eng_vec.shape[0] != len(glove_english_vocab):
+            raise ValueError(
+                "GloVe English vocab/vectors row count mismatch"
+            )
+
+        self._spaces = {
+            "gemma": {
+                "sum_norm": _normalize_rows(sum_gemma),
+                "sum_dim": sum_gemma.shape[1],
+                "eng_vocab_map": {w.lower(): i for i, w in enumerate(eng_gemma_vocab)},
+                "eng_norm": _normalize_rows(eng_gemma_vec),
+            },
+            "glove": {
+                "sum_norm": _normalize_rows(sum_glove),
+                "sum_dim": sum_glove.shape[1],
+                "eng_vocab_map": {w.lower(): i for i, w in enumerate(glove_english_vocab)},
+                "eng_norm": _normalize_rows(glove_eng_vec),
+            },
+        }
+
+    def _validate_space(self, space: str) -> None:
+        if space not in _VALID_SPACES:
+            raise ValueError(
+                f"space must be one of {_VALID_SPACES!r}, got {space!r}"
+            )
+
+    def _english_vector(self, word: str, space: str) -> np.ndarray | None:
+        s = self._spaces[space]
+        idx = s["eng_vocab_map"].get(word.lower())
+        if idx is None:
+            return None
+        return s["eng_norm"][idx]
+
+    def _top_k_from_query(self, query: np.ndarray, space: str, top_k: int) -> list[tuple[str, float]]:
+        s = self._spaces[space]
+        sims = s["sum_norm"] @ query
+        top_indices = np.argsort(sims)[::-1][:top_k]
+        return [(self.vocab[int(i)], float(sims[int(i)])) for i in top_indices]
+
+    def find(self, english_word: str, top_k: int = 10, space: str = "gemma") -> list[tuple[str, float]]:
+        self._validate_space(space)
+        vec = self._english_vector(english_word, space)
+        if vec is None:
+            return []
+        return self._top_k_from_query(vec, space, top_k)
+
+    def find_both(self, english_word: str, top_k: int = 10) -> dict[str, list[tuple[str, float]]]:
+        return {
+            "gemma": self.find(english_word, top_k=top_k, space="gemma"),
+            "glove": self.find(english_word, top_k=top_k, space="glove"),
+        }
+
+    def find_analogy(
+        self,
+        a: str,
+        b: str,
+        c: str,
+        top_k: int = 10,
+        space: str = "gemma",
+    ) -> list[tuple[str, float]]:
+        self._validate_space(space)
+        va = self._english_vector(a, space)
+        vb = self._english_vector(b, space)
+        vc = self._english_vector(c, space)
+        if any(v is None for v in (va, vb, vc)):
+            return []
+        target = vc - va + vb
+        norm = np.linalg.norm(target)
+        if norm == 0:
+            return []
+        target = target / norm
+        return self._top_k_from_query(target, space, top_k)
+
+    def find_blend(
+        self,
+        weights: dict[str, float],
+        top_k: int = 10,
+        space: str = "gemma",
+    ) -> list[tuple[str, float]]:
+        self._validate_space(space)
+        if not weights:
+            return []
+        s = self._spaces[space]
+        target = np.zeros(s["sum_dim"], dtype=np.float32)
+        any_resolved = False
+        for word, weight in weights.items():
+            vec = self._english_vector(word, space)
+            if vec is not None:
+                target += float(weight) * vec
+                any_resolved = True
+        if not any_resolved:
+            return []
+        norm = np.linalg.norm(target)
+        if norm == 0:
+            return []
+        target = target / norm
+        return self._top_k_from_query(target, space, top_k)

languages/sumerian/final_output/sumerian_procrustes_gemma_vectors.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b25ca98d857024f5318e65e6b3507ba2924296b2ee7e84fd888b3093af9576fb
+size 101399463