fix(coins): wrap experiment.prepare() with shm and dim-expansion patches

Two research-code behaviours break inference inside the deployment
container; both are silenced by monkey-patching for the duration of
each experiment.prepare() call (and restored in a finally).

- torch.nn.Module.share_memory: research code calls
embedder.share_memory() to share weights across multi-process
training workers. The website is single-process and the call is
gratuitous; on Linux containers with a small /dev/shm (Docker
default 64 MB, free HF Spaces tmpfs similar) it raises Bus error
mid-prepare. No-op replacement keeps prepare() happy.

- torch.load: prepare() loads transe_model.tar to seed the embedder's
entity_embeddings_initial buffers, then KBGAT's __init__ assigns
weight.data = init, silently re-shaping the YAML-declared embedding
layer to the init's shape. For wordnet KBGAT this is fatal: the
trained checkpoint is 200d but the wordnet TransE init is 100d, so
the embedder ends up at 100d and load_state_dict fails on the
trained weights. The patch detects TransE state dicts and repeats
them along the embedding axis (e.g. 100d -> 200d via cat([init,
init])) when the YAML's embedding_dim is an integer multiple of the
init's dim — same trick _adapt_kbgat_state_dict already uses for
the GATConv multi-head expansion.

Also switches the HF_CHECKPOINTS_REPO default to the correctly-cased
Bani57/checkpoints (the HF Hub namespace check is case-sensitive).

src/backend/api/services/registry.py

@@ -64,7 +64,7 @@ def _safe_load_lightning_checkpoint(cls, ckpt_path):
 # on-disk layout under settings.CHECKPOINTS_ROOT (RESEARCH_ROOT by default), so
 # snapshot_download() drops every file into its final location and the scan
 # routines below find them unchanged.
-HF_CHECKPOINTS_REPO = os.environ.get("HF_CHECKPOINTS_REPO", "bani57/checkpoints")
+HF_CHECKPOINTS_REPO = os.environ.get("HF_CHECKPOINTS_REPO", "Bani57/checkpoints")
 
 # Per-area checkpoint subdirectories (relative to CHECKPOINTS_ROOT).  Used to
 # detect a fully-populated tree so we can skip the network round-trip on warm
@@ -827,6 +827,10 @@ class ModelRegistry:
             "test": False,
             "results_dir": str(Path(settings.COINS_COMPLETION_DIR) / "results"),
         }
+        # YAML's embedding_dim is the trained model's dim.  Used below to
+        # expand the TransE init when its dim is smaller (e.g. wordnet kbgat
+        # was trained at 200d but wordnet's transe_model.tar is 100d).
+        target_embedding_dim = int(yaml_config.get("embedder_hpars", {}).get("embedding_dim", 100))
 
         original_cwd = os.getcwd()
         try:
@@ -850,30 +854,98 @@ class ModelRegistry:
             # Each load_graph() reloads the full graph from disk and recomputes community
             # structures; reusing a cached Loader avoids this for e.g. all four
             # transe/distmult/complex/rotate variants that share the same seed on every dataset.
-            loader_key = (dataset_id, seed, leiden_resolution)
-            if loader_key in self._coins_loaders:
-                cached_loader = self._coins_loaders[loader_key]
-                # Defensive: ensure machines length matches current num_communities.
-                # _load_all_loaders already does this, but any future code path that
-                # populates _coins_loaders directly could skip it.
-                import numpy as np
-                expected_len = cached_loader.num_communities + 2
-                if len(cached_loader.machines) != expected_len:
-                    cached_loader.machines = np.zeros(expected_len, dtype=int)
-                experiment.loader = cached_loader
-                # Temporarily replace load_graph with a no-op: prepare() will find all
-                # required attributes (num_nodes, communities, graph_indexes, …) already set.
-                _orig_load_graph = cached_loader.load_graph
-                cached_loader.load_graph = lambda *args, **kwargs: None
-                try:
+            #
+            # share_memory monkey-patch: experiment.prepare() constructs the embedder
+            # and immediately calls embedder.share_memory() to share weights across
+            # multi-process training workers.  We run single-process inference so the
+            # call is gratuitous, and on Linux containers with a small /dev/shm
+            # (Docker default 64 MB, free HF Spaces tmpfs similar) it raises a Bus
+            # error mid-prepare.  No-op the Module.share_memory class method for the
+            # duration of prepare() and restore it after.
+            #
+            # torch.load monkey-patch: experiment.prepare() loads transe_model.tar to
+            # initialise the embedder's entity_embeddings_initial buffers.  The KBGAT
+            # __init__ then assigns weight.data = init, which silently re-shapes the
+            # 200d embedding layer (built from YAML embedding_dim) to the 100d transe
+            # init's shape — and the trained checkpoint's load_state_dict afterwards
+            # blows up on the dim mismatch.  Expand the transe init from 100d to
+            # target_embedding_dim by repeating along the embedding axis (same trick
+            # _adapt_kbgat_state_dict uses for GATConv multi-head expansion).
+            import torch as _pt
+            import torch.nn as _nn
+            _orig_share_memory = _nn.Module.share_memory
+            _nn.Module.share_memory = lambda self: self
+            _orig_torch_load = _pt.load
+
+            def _expand_transe_load(*args, **kwargs):
+                state_dict = _orig_torch_load(*args, **kwargs)
+                if not isinstance(state_dict, dict):
+                    return state_dict
+                if not any(k.endswith("entity_embeddings.weight") for k in state_dict):
+                    return state_dict
+                # Detect transe init dim and bail if it already matches.
+                sample = next(v for k, v in state_dict.items()
+                              if k.endswith("entity_embeddings.weight") and hasattr(v, "shape"))
+                src_dim = int(sample.shape[-1])
+                if src_dim == target_embedding_dim or src_dim == 0:
+                    return state_dict
+                if target_embedding_dim % src_dim != 0:
+                    logger.warning(
+                        "TransE init dim %d not a divisor of YAML embedding_dim %d; "
+                        "leaving init unchanged (load_state_dict may fail).",
+                        src_dim, target_embedding_dim,
+                    )
+                    return state_dict
+                n_repeats = target_embedding_dim // src_dim
+                expanded = {}
+                for key, value in state_dict.items():
+                    if not hasattr(value, "shape") or value.ndim < 1:
+                        expanded[key] = value
+                        continue
+                    # entity_embeddings(_initial).weight: [num_entities, dim] -> repeat dim
+                    # r_embeddings_initial.weight:       [num_relations, dim] -> repeat dim
+                    # r_embeddings.weight:               [dim, num_relations] -> repeat dim 0
+                    if key.endswith(("entity_embeddings.weight",
+                                     "entity_embeddings_initial.weight",
+                                     "r_embeddings_initial.weight")) and value.shape[-1] == src_dim:
+                        expanded[key] = value.repeat(*([1] * (value.ndim - 1)), n_repeats)
+                    elif key.endswith("r_embeddings.weight") and value.shape[0] == src_dim:
+                        expanded[key] = value.repeat(n_repeats, *([1] * (value.ndim - 1)))
+                    else:
+                        expanded[key] = value
+                logger.info("Expanded transe init from %dd to %dd (x%d repeat) for %s/%s",
+                            src_dim, target_embedding_dim, n_repeats, dataset_id, algorithm)
+                return expanded
+
+            _pt.load = _expand_transe_load
+            try:
+                loader_key = (dataset_id, seed, leiden_resolution)
+                if loader_key in self._coins_loaders:
+                    cached_loader = self._coins_loaders[loader_key]
+                    # Defensive: ensure machines length matches current num_communities.
+                    # _load_all_loaders already does this, but any future code path that
+                    # populates _coins_loaders directly could skip it.
+                    import numpy as np
+                    expected_len = cached_loader.num_communities + 2
+                    if len(cached_loader.machines) != expected_len:
+                        cached_loader.machines = np.zeros(expected_len, dtype=int)
+                    experiment.loader = cached_loader
+                    # Temporarily replace load_graph with a no-op: prepare() will find all
+                    # required attributes (num_nodes, communities, graph_indexes, …) already set.
+                    _orig_load_graph = cached_loader.load_graph
+                    cached_loader.load_graph = lambda *args, **kwargs: None
+                    try:
+                        experiment.prepare()
+                    finally:
+                        cached_loader.load_graph = _orig_load_graph
+                    logger.info("Reused shared Loader for %s seed=%d", dataset_id, seed)
+                else:
                     experiment.prepare()
-                finally:
-                    cached_loader.load_graph = _orig_load_graph
-                logger.info("Reused shared Loader for %s seed=%d", dataset_id, seed)
-            else:
-                experiment.prepare()
-                self._coins_loaders[loader_key] = experiment.loader
-                logger.info("Cached new Loader for %s seed=%d", dataset_id, seed)
+                    self._coins_loaders[loader_key] = experiment.loader
+                    logger.info("Cached new Loader for %s seed=%d", dataset_id, seed)
+            finally:
+                _nn.Module.share_memory = _orig_share_memory
+                _pt.load = _orig_torch_load
 
             ckpt_path = (Path(settings.COINS_COMPLETION_DIR) / "checkpoints"
                          / f"{dataset_id}_{algorithm}.tar")