event2vector 0.3.0__tar.gz → 0.3.1__tar.gz

event2vector-0.3.1/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+All notable changes to `event2vector` are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.1] - 2026-10-11
+
+### Fixed
+
+- `Event2Vec(geometry="rotation")` no longer crashes on Apple Silicon with
+  `NotImplementedError: The operator 'aten::linalg_matrix_exp' is not currently
+  implemented for the MPS device`. `RotationModel` now computes the matrix
+  exponential on the CPU when its input is on MPS and moves the result back, so
+  `device="mps"`, a bare `RotationModel` and a `ProductModel` with a rotation
+  factor all work.
+- The project links on PyPI pointed to `github.com/sulcantonin/event2vector`,
+  which does not exist; they now point to
+  [`github.com/sulcantonin/event2vec_public`](https://github.com/sulcantonin/event2vec_public).
+
+### Changed
+
+- When the device is chosen automatically and MPS would be picked, the
+  `rotation` geometry runs on the CPU instead and emits a `RuntimeWarning`. On
+  MPS every step round-trips through the CPU, which made training roughly 8–14×
+  slower than on the CPU alone for this model. Pass `device="mps"` to use MPS
+  anyway. CUDA and the other geometries are unaffected.
+
+### Added
+
+- Tests for the automatic device selection (`tests/test_device.py`).
+- This changelog, linked from the PyPI project page.
+
+## [0.3.0] - 2026-07-21
+
+Earlier releases are listed on [PyPI](https://pypi.org/project/event2vector/#history).
+
+[0.3.1]: https://pypi.org/project/event2vector/0.3.1/
+[0.3.0]: https://pypi.org/project/event2vector/0.3.0/

{event2vector-0.3.0 → event2vector-0.3.1}/MANIFEST.in

@@ -1,4 +1,5 @@
 include README.md
+include CHANGELOG.md
 exclude *.pkl
 exclude *.model
 exclude data/*

{event2vector-0.3.0 → event2vector-0.3.1}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: event2vector
-Version: 0.3.0
+Version: 0.3.1
 Summary: Scikit-learn-style geometric embeddings for event sequences.
 Author: Antonin Sulc
 License-Expression: MIT
-Project-URL: Homepage, https://github.com/sulcantonin/event2vector
-Project-URL: Repository, https://github.com/sulcantonin/event2vector
-Project-URL: Issues, https://github.com/sulcantonin/event2vector/issues
+Project-URL: Homepage, https://github.com/sulcantonin/event2vec_public
+Project-URL: Repository, https://github.com/sulcantonin/event2vec_public
+Project-URL: Issues, https://github.com/sulcantonin/event2vec_public/issues
+Project-URL: Changelog, https://github.com/sulcantonin/event2vec_public/blob/main/CHANGELOG.md
 Keywords: sequence-embedding,event-sequences,representation-learning,word2vec,scikit-learn,time-series
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
@@ -132,7 +133,7 @@ Key methods:
 - `most_similar`: gensim-style nearest-neighbor lookup over learned event embeddings using tokens or full sequences as queries.
 - `pad_sequences=True`: enables fully vectorized batches with masking for substantial throughput gains on large corpora.
 
-Device control: set `use_gpu=False` to force CPU even if CUDA/MPS is present, or pass an explicit `device` (e.g., `"cuda:0"` or `"cpu"`).
+Device control: set `use_gpu=False` to force CPU even if CUDA/MPS is present, or pass an explicit `device` (e.g., `"cuda:0"` or `"cpu"`). On Apple Silicon the `rotation` geometry defaults to the CPU, because MPS has no `matrix_exp` kernel and the CPU is faster for it; pass `device="mps"` to override.
 
 ## Geometries (v0.2)
 

{event2vector-0.3.0 → event2vector-0.3.1}/README.md

@@ -98,7 +98,7 @@ Key methods:
 - `most_similar`: gensim-style nearest-neighbor lookup over learned event embeddings using tokens or full sequences as queries.
 - `pad_sequences=True`: enables fully vectorized batches with masking for substantial throughput gains on large corpora.
 
-Device control: set `use_gpu=False` to force CPU even if CUDA/MPS is present, or pass an explicit `device` (e.g., `"cuda:0"` or `"cpu"`).
+Device control: set `use_gpu=False` to force CPU even if CUDA/MPS is present, or pass an explicit `device` (e.g., `"cuda:0"` or `"cpu"`). On Apple Silicon the `rotation` geometry defaults to the CPU, because MPS has no `matrix_exp` kernel and the CPU is faster for it; pass `device="mps"` to override.
 
 ## Geometries (v0.2)
 

{event2vector-0.3.0 → event2vector-0.3.1}/event2vector/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 
 from .models import EuclideanModel, HyperbolicModel, HyperbolicUtils, Event2Vec
 from .geometries import (

{event2vector-0.3.0 → event2vector-0.3.1}/event2vector/geometries.py

@@ -216,6 +216,10 @@ class RotationModel(nn.Module):
         a = torch.zeros(b, self.n, self.n, device=gen.device, dtype=gen.dtype)
         a[:, self.triu_i, self.triu_j] = gen
         a = a - a.transpose(1, 2)
+        if a.device.type == "mps":
+            # MPS has no matrix_exp kernel (pytorch/pytorch#141287); compute it on
+            # the CPU and move it back. Both transfers are differentiable.
+            return torch.matrix_exp(a.cpu()).to(a.device)
         return torch.matrix_exp(a)
 
     def zero_state(self, batch, device):

{event2vector-0.3.0 → event2vector-0.3.1}/event2vector/models.py

@@ -249,7 +249,18 @@ class Event2Vec:
             if use_gpu and torch.cuda.is_available():
                 device = torch.device("cuda")
             elif use_gpu and hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
-                device = torch.device("mps")
+                if self.geometry == "rotation":
+                    # MPS has no matrix_exp, so every rotation step would round-trip
+                    # through the CPU; for a model this small the CPU is much faster.
+                    warnings.warn(
+                        "geometry='rotation' needs torch.matrix_exp, which MPS does not "
+                        "implement; using device='cpu'. Pass device='mps' to run on MPS "
+                        "anyway (matrix_exp is then computed on the CPU).",
+                        RuntimeWarning,
+                    )
+                    device = torch.device("cpu")
+                else:
+                    device = torch.device("mps")
             else:
                 device = torch.device("cpu")
         else:

{event2vector-0.3.0 → event2vector-0.3.1}/event2vector.egg-info/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: event2vector
-Version: 0.3.0
+Version: 0.3.1
 Summary: Scikit-learn-style geometric embeddings for event sequences.
 Author: Antonin Sulc
 License-Expression: MIT
-Project-URL: Homepage, https://github.com/sulcantonin/event2vector
-Project-URL: Repository, https://github.com/sulcantonin/event2vector
-Project-URL: Issues, https://github.com/sulcantonin/event2vector/issues
+Project-URL: Homepage, https://github.com/sulcantonin/event2vec_public
+Project-URL: Repository, https://github.com/sulcantonin/event2vec_public
+Project-URL: Issues, https://github.com/sulcantonin/event2vec_public/issues
+Project-URL: Changelog, https://github.com/sulcantonin/event2vec_public/blob/main/CHANGELOG.md
 Keywords: sequence-embedding,event-sequences,representation-learning,word2vec,scikit-learn,time-series
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
@@ -132,7 +133,7 @@ Key methods:
 - `most_similar`: gensim-style nearest-neighbor lookup over learned event embeddings using tokens or full sequences as queries.
 - `pad_sequences=True`: enables fully vectorized batches with masking for substantial throughput gains on large corpora.
 
-Device control: set `use_gpu=False` to force CPU even if CUDA/MPS is present, or pass an explicit `device` (e.g., `"cuda:0"` or `"cpu"`).
+Device control: set `use_gpu=False` to force CPU even if CUDA/MPS is present, or pass an explicit `device` (e.g., `"cuda:0"` or `"cpu"`). On Apple Silicon the `rotation` geometry defaults to the CPU, because MPS has no `matrix_exp` kernel and the CPU is faster for it; pass `device="mps"` to override.
 
 ## Geometries (v0.2)
 

{event2vector-0.3.0 → event2vector-0.3.1}/event2vector.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+CHANGELOG.md
 MANIFEST.in
 README.md
 pyproject.toml
@@ -22,5 +23,4 @@ event2vector/datasets/realdata.py
 event2vector/eval/__init__.py
 event2vector/eval/figures.py
 event2vector/eval/harness.py
-tests/test_datasets.py
-tests/test_models.py
+tests/test_device.py

{event2vector-0.3.0 → event2vector-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "event2vector"
-version = "0.3.0"
+version = "0.3.1"
 description = "Scikit-learn-style geometric embeddings for event sequences."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -63,9 +63,10 @@ dev = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/sulcantonin/event2vector"
-Repository = "https://github.com/sulcantonin/event2vector"
-Issues = "https://github.com/sulcantonin/event2vector/issues"
+Homepage = "https://github.com/sulcantonin/event2vec_public"
+Repository = "https://github.com/sulcantonin/event2vec_public"
+Issues = "https://github.com/sulcantonin/event2vec_public/issues"
+Changelog = "https://github.com/sulcantonin/event2vec_public/blob/main/CHANGELOG.md"
 
 [tool.setuptools.packages.find]
 include = ["event2vector*"]

event2vector-0.3.1/tests/test_device.py

@@ -0,0 +1,75 @@
+"""Device-selection tests: the default constructor must work on every backend.
+
+The rest of the suite pins ``use_gpu=False``, so these are the tests that exercise
+the estimator's automatic CUDA / MPS / CPU choice. Run with `pytest tests/ -q`.
+"""
+import numpy as np
+import pytest
+import torch
+
+from event2vector import Event2Vec, ProductModel, RotationModel, StereographicModel
+
+MPS_AVAILABLE = hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+
+TINY_SEQS = [[0, 1, 2], [2, 1, 0, 1], [1, 2], [0, 2, 2, 1]]
+
+
+@pytest.mark.filterwarnings("ignore:geometry='rotation' needs torch.matrix_exp")
+def test_rotation_fits_with_default_device():
+    """Event2Vec(geometry="rotation") with no device arguments must fit on any machine
+    (it used to raise NotImplementedError for aten::linalg_matrix_exp on Apple Silicon)."""
+    est = Event2Vec(num_event_types=3, geometry="rotation", rotation_n=3,
+                    num_epochs=2, batch_size=2, random_state=0)
+    assert est.device.type != "mps"
+    est.fit(TINY_SEQS)
+
+    assert est.is_fitted_
+    assert np.isfinite(est.training_loss_).all()
+    emb = est.transform(TINY_SEQS)
+    assert emb.shape == (len(TINY_SEQS), 9)  # flattened 3x3 rotation
+    assert np.isfinite(emb).all()
+
+
+def test_auto_device_skips_mps_for_rotation(monkeypatch):
+    """When MPS would be auto-selected, rotation falls back to CPU with a warning.
+    Simulated so it runs on any platform; the model never touches MPS."""
+    monkeypatch.setattr(torch.cuda, "is_available", lambda: False)
+    monkeypatch.setattr(torch.backends.mps, "is_available", lambda: True)
+    with pytest.warns(RuntimeWarning, match="matrix_exp"):
+        est = Event2Vec(num_event_types=3, geometry="rotation")
+    assert est.device.type == "cpu"
+
+
+@pytest.mark.skipif(not MPS_AVAILABLE, reason="needs an MPS device")
+def test_rotation_runs_on_explicit_mps():
+    """device="mps" is honoured: matrix_exp runs on the CPU and the result (and its
+    gradient) matches a pure-CPU computation."""
+    torch.manual_seed(0)
+    gen = torch.randn(5, 3)
+    cpu_model = RotationModel(3, n=3)
+    mps_model = RotationModel(3, n=3).to("mps")
+
+    g_cpu = gen.clone().requires_grad_()
+    r_cpu = cpu_model._rot(g_cpu)
+    (r_cpu ** 3).sum().backward()
+    g_mps = gen.clone().to("mps").requires_grad_()
+    r_mps = mps_model._rot(g_mps)
+    (r_mps ** 3).sum().backward()
+
+    assert r_mps.device.type == "mps"
+    assert torch.allclose(r_cpu, r_mps.cpu(), atol=1e-5)
+    assert torch.allclose(g_cpu.grad, g_mps.grad.cpu(), atol=1e-5)
+
+    # a product manifold with a rotation factor goes through the same path
+    product = ProductModel([
+        RotationModel(3, n=3),
+        StereographicModel(3, embedding_dim=4, kappa=-1.0),
+    ]).to("mps")
+    logits, _, _ = product(torch.tensor([0, 1, 2], device="mps"))
+    assert torch.isfinite(logits).all()
+
+    est = Event2Vec(num_event_types=3, geometry="rotation", device="mps",
+                    num_epochs=2, batch_size=2, random_state=0)
+    est.fit(TINY_SEQS)
+    assert np.isfinite(est.training_loss_).all()
+

event2vector-0.3.0/tests/test_datasets.py

@@ -1,82 +0,0 @@
-"""Ground-truth tests for the centerpiece datasets.
-
-These lock the exact structure the paper's claims rely on: decay operators that
-sum to the known transmutation, and group abelianizations that match the known
-algebra. No model training required.
-"""
-import numpy as np
-
-from event2vector.datasets import make_decay, make_group
-from event2vector.datasets.decay import GROUND_TRUTH
-from event2vector.metrics import _multiset_ceiling
-
-
-# --------------------------------------------------------------------------- #
-# Physics: nuclear decay
-# --------------------------------------------------------------------------- #
-def test_decay_ground_truth_matches_physics():
-    d = make_decay(num_seq=200, seed=0)
-    gt = d["ground_truth"]
-    for mode_id, dzdn in gt.items():
-        name = d["inv_vocab"][mode_id]
-        assert tuple(dzdn) == GROUND_TRUTH[name]
-    # the canonical decays present must include alpha and beta_minus
-    assert "alpha" in d["vocab"] and "beta_minus" in d["vocab"]
-
-
-def test_canonical_series_sum_to_known_transmutation():
-    d = make_decay(num_seq=50, seed=0)
-    gt = d["ground_truth"]
-    expected = {"thorium_4n": (-8, -16), "uranium_4n+2": (-10, -22)}
-    for name, c in d["canonical"].items():
-        net = tuple(np.sum([gt[t] for t in c["tokens"]], axis=0))
-        assert net == c["net_dZdN"] == expected[name]
-
-
-def test_extended_decay_modes_present_and_exact():
-    d = make_decay(num_seq=6000, seed=0)
-    vocab = d["vocab"]
-    # the richer particle set is exercised by the generator
-    for m in ["electron_capture", "double_beta", "cluster_c14",
-              "proton_emission", "neutron_emission"]:
-        assert m in vocab, f"{m} not generated"
-    assert GROUND_TRUTH["cluster_c14"] == (-6, -8)
-    # electron capture and beta+ are physically distinct but share the operator
-    assert GROUND_TRUTH["electron_capture"] == GROUND_TRUTH["beta_plus"] == (-1, 1)
-
-
-# --------------------------------------------------------------------------- #
-# Math: group sequences
-# --------------------------------------------------------------------------- #
-def test_symmetric_group_abelianization_is_z2():
-    for name, n_el in [("s3", 6), ("s4", 24)]:
-        r = make_group(name, num_seq=300, max_len=8, seed=0)
-        assert r["is_abelian"] is False
-        assert r["n_elements"] == n_el
-        assert r["n_abelian"] == 2  # S_n abelianization = Z_2 (sign)
-
-
-def test_abelian_groups_element_equals_abelianization():
-    for name, n_el in [("z12", 12), ("z6xz4", 24)]:
-        r = make_group(name, num_seq=300, max_len=8, seed=0)
-        assert r["is_abelian"] is True
-        assert r["n_elements"] == n_el
-        assert r["n_abelian"] == n_el  # abelianization is the whole group
-
-
-def test_multiset_ceiling_abelian_vs_nonabelian():
-    n_gen = 3
-    # Abelian (Z6xZ4): the multiset determines the element exactly -> ceiling 1.0
-    z = make_group("z6xz4", num_seq=4000, max_len=10, seed=0)
-    seqs_z = z["processed_sequences"]
-    ng_z = len(z["vocab"])
-    assert _multiset_ceiling(seqs_z, z["sequence_labels_element"], ng_z) > 0.999
-    # Non-abelian (S4): abelianization is multiset-determined (1.0) but the full
-    # element is not (well below 1).
-    s = make_group("s4", num_seq=4000, max_len=10, seed=0)
-    seqs_s = s["processed_sequences"]
-    ng_s = len(s["vocab"])
-    abel_ceil = _multiset_ceiling(seqs_s, s["sequence_labels_abelian"], ng_s)
-    elem_ceil = _multiset_ceiling(seqs_s, s["sequence_labels_element"], ng_s)
-    assert abel_ceil > 0.999
-    assert elem_ceil < 0.8

event2vector-0.3.0/tests/test_models.py

@@ -1,360 +0,0 @@
-"""Journal-grade correctness tests for the Event2Vec estimator and models.
-
-Each test locks one property asserted by the paper or fixed during the TMLR
-revision. Run with `pytest tests/ -q`.
-"""
-import math
-
-import numpy as np
-import pytest
-import torch
-
-from event2vector import Event2Vec, EuclideanModel, HyperbolicModel, HyperbolicUtils
-from event2vector import (
-    HeisenbergModel,
-    ProductModel,
-    RotationModel,
-    StereographicModel,
-    StereographicUtils,
-)
-
-
-# --------------------------------------------------------------------------- #
-# Fixtures / helpers
-# --------------------------------------------------------------------------- #
-def structured_sequences():
-    """A small, strongly-patterned dataset (learnable, order-bearing)."""
-    base = [
-        [0, 1, 2, 3],
-        [0, 1, 2, 4],
-        [0, 2, 3, 4],
-        [0, 1, 3, 4],
-        [0, 2, 1, 4],
-    ]
-    return [torch.tensor(s, dtype=torch.long) for s in base for _ in range(8)]
-
-
-def euclid(**kw):
-    defaults = dict(
-        num_event_types=5,
-        embedding_dim=16,
-        dropout_p=0.0,
-        num_epochs=4,
-        batch_size=8,
-        random_state=0,
-        use_gpu=False,
-    )
-    defaults.update(kw)
-    return Event2Vec(**defaults)
-
-
-def hyper(**kw):
-    defaults = dict(
-        num_event_types=5,
-        embedding_dim=16,
-        geometry="hyperbolic",
-        curvature=1.0,
-        dropout_p=0.0,
-        num_epochs=4,
-        batch_size=8,
-        random_state=0,
-        use_gpu=False,
-    )
-    defaults.update(kw)
-    return Event2Vec(**defaults)
-
-
-# --------------------------------------------------------------------------- #
-# Shape / dtype / API
-# --------------------------------------------------------------------------- #
-def test_transform_shape_and_dtype():
-    m = euclid().fit(structured_sequences())
-    out = m.transform([[0, 1, 2], [0, 2, 3, 4]])
-    assert out.shape == (2, 16)
-    assert out.dtype == np.float32
-
-
-def test_accepts_list_and_tensor_inputs():
-    seqs_t = structured_sequences()
-    seqs_l = [s.tolist() for s in seqs_t]
-    euclid().fit(seqs_t)
-    euclid().fit(seqs_l)  # should not raise
-
-
-# --------------------------------------------------------------------------- #
-# Linear additive hypothesis
-# --------------------------------------------------------------------------- #
-def test_additivity_exact_when_clip_off():
-    """With clipping off and dropout off, the encoded state is *exactly* the
-    sum of constituent embeddings (the linear additive hypothesis, proved by
-    measurement)."""
-    m = euclid(max_norm=1e12).fit(structured_sequences())
-    emb = m.model.embedding.weight.detach()
-    seq = [0, 1, 2, 3]
-    h = m.transform([seq], as_numpy=False)[0]
-    ideal = emb[seq].sum(dim=0)
-    assert torch.allclose(h, ideal, atol=1e-5)
-    cos = torch.nn.functional.cosine_similarity(h[None], ideal[None]).item()
-    assert cos > 1 - 1e-5
-
-
-def test_additivity_is_order_invariant_euclidean():
-    """New Result 1: the ideal Euclidean endpoint is permutation invariant."""
-    m = euclid(max_norm=1e12).fit(structured_sequences())
-    a = m.transform([[0, 1, 2, 3]], as_numpy=False)[0]
-    b = m.transform([[3, 1, 0, 2]], as_numpy=False)[0]
-    assert torch.allclose(a, b, atol=1e-5)
-
-
-# --------------------------------------------------------------------------- #
-# Reconstruction loss reaches zero at the ideal update (both geometries)
-# --------------------------------------------------------------------------- #
-def _one_step_losses(m, h_old):
-    m.model.eval()  # disable dropout: increment == raw embedding
-    x = torch.tensor([1])
-    target = torch.tensor([2])
-    y1, h1, e1 = m.model(x, h_old)
-    _, h2, _ = m.model(x, h_old)
-    return m._compute_losses(y1, h1, e1, h_old, target, h2)
-
-
-def test_reconstruction_zero_at_ideal_euclidean():
-    m = euclid(max_norm=1e12)
-    _, recon, consist = _one_step_losses(m, torch.zeros(1, 16))
-    assert recon.item() < 1e-10
-    assert consist.item() < 1e-10  # eval mode => identical passes
-
-
-def test_reconstruction_zero_at_ideal_hyperbolic():
-    """The corrected left-cancellation target makes L_recon reach ~0 at the
-    ideal Möbius update (the old right-cancellation form could not)."""
-    m = hyper()
-    _, recon, _ = _one_step_losses(m, torch.zeros(1, 16))
-    assert recon.item() < 1e-6
-
-
-# --------------------------------------------------------------------------- #
-# Hyperbolic / Möbius algebra
-# --------------------------------------------------------------------------- #
-def test_mobius_identity():
-    x = torch.randn(4, 8) * 0.1
-    z = torch.zeros(4, 8)
-    assert torch.allclose(HyperbolicUtils.mobius_add(x, z, 1.0), x, atol=1e-5)
-
-
-def test_mobius_left_cancellation():
-    """(-x) ⊕ (x ⊕ y) == y  — the law the corrected recon loss relies on."""
-    x = torch.randn(4, 8) * 0.1
-    y = torch.randn(4, 8) * 0.1
-    lhs = HyperbolicUtils.mobius_add(-x, HyperbolicUtils.mobius_add(x, y, 1.0), 1.0)
-    assert torch.allclose(lhs, y, atol=1e-4)
-
-
-def test_project_to_ball_respects_radius():
-    c = 1.0
-    big = torch.randn(16, 8) * 100.0
-    proj = HyperbolicUtils.project_to_ball(big, c)
-    norms = proj.norm(dim=-1)
-    assert torch.all(norms < 1.0 / math.sqrt(c))
-
-
-# --------------------------------------------------------------------------- #
-# Hyperbolic init is NOT clobbered to std=0.02 (P0-1)
-# --------------------------------------------------------------------------- #
-def test_hyperbolic_init_near_origin():
-    model = HyperbolicModel(num_event_types=5, embedding_dim=64, dropout_p=0.0, c=1.0)
-    norms = model.embedding.weight.detach().norm(dim=-1)
-    # tiny uniform(-1e-3,1e-3) over d=64 => norm ~ 0.008, far below a std=0.02
-    # normal (~0.16) and well inside the ball.
-    assert norms.max().item() < 0.05
-
-
-def test_estimator_reset_keeps_hyperbolic_init_tiny():
-    m = hyper(embedding_dim=64)
-    m._reset_parameters()
-    norms = m.model.embedding.weight.detach().norm(dim=-1)
-    assert norms.max().item() < 0.05
-
-
-# --------------------------------------------------------------------------- #
-# Consistency loss is active iff dropout > 0 (P0-3)
-# --------------------------------------------------------------------------- #
-def test_consistency_loss_active_with_dropout():
-    m = euclid(dropout_p=0.3)
-    m.model.train()
-    x = torch.tensor([1])
-    h_old = torch.zeros(1, 16)
-    _, h1, _ = m.model(x, h_old)
-    _, h2, _ = m.model(x, h_old)
-    assert m.mse_loss(h1, h2).item() > 0.0
-
-
-def test_consistency_loss_zero_without_dropout():
-    m = euclid(dropout_p=0.0)
-    m.model.train()
-    x = torch.tensor([1])
-    h_old = torch.zeros(1, 16)
-    _, h1, _ = m.model(x, h_old)
-    _, h2, _ = m.model(x, h_old)
-    assert m.mse_loss(h1, h2).item() == 0.0
-
-
-# --------------------------------------------------------------------------- #
-# Training actually reduces the loss
-# --------------------------------------------------------------------------- #
-@pytest.mark.parametrize("geom", ["euclidean", "hyperbolic"])
-def test_fit_improves_loss(geom):
-    builder = euclid if geom == "euclidean" else hyper
-    m = builder(num_epochs=40, learning_rate=1e-2).fit(structured_sequences())
-    assert m.training_loss_[-1] < m.training_loss_[0]
-
-
-# --------------------------------------------------------------------------- #
-# Determinism given a seed (CPU)
-# --------------------------------------------------------------------------- #
-def test_determinism_given_seed_cpu():
-    seqs = structured_sequences()
-    a = euclid(dropout_p=0.2, num_epochs=6, random_state=123).fit(seqs)
-    b = euclid(dropout_p=0.2, num_epochs=6, random_state=123).fit(seqs)
-    assert np.allclose(a.training_loss_, b.training_loss_)
-    assert np.allclose(
-        a.model.embedding.weight.detach().numpy(),
-        b.model.embedding.weight.detach().numpy(),
-    )
-
-
-# --------------------------------------------------------------------------- #
-# padded vs unpadded must agree at inference (P2-8: only the loss differed)
-# --------------------------------------------------------------------------- #
-def test_padded_equals_unpadded_embeddings():
-    m = euclid(num_epochs=3).fit(structured_sequences())
-    seq = [0, 1, 2, 3, 4]
-    a = m.transform([seq], pad_sequences=True, as_numpy=False)[0]
-    b = m.transform([seq], pad_sequences=False, as_numpy=False)[0]
-    assert torch.allclose(a, b, atol=1e-5)
-
-
-# --------------------------------------------------------------------------- #
-# Curvature validation + optional Riemannian optimization
-# --------------------------------------------------------------------------- #
-def test_curvature_must_be_positive():
-    with pytest.raises(ValueError):
-        Event2Vec(num_event_types=5, geometry="hyperbolic", curvature=-1.0)
-    with pytest.raises(ValueError):
-        Event2Vec(num_event_types=5, geometry="hyperbolic", curvature=0.0)
-
-
-def test_riemannian_uses_manifold_parameter():
-    geoopt = pytest.importorskip("geoopt")
-    m = hyper(riemannian=True).fit(structured_sequences())
-    assert isinstance(m.model.embedding.weight, geoopt.ManifoldParameter)
-    norms = m.model.embedding.weight.detach().norm(dim=-1)
-    assert torch.all(norms < 1.0)  # stays inside the ball
-
-
-def test_most_similar_returns_topn():
-    m = euclid().fit(structured_sequences())
-    res = m.most_similar(positive=1, topn=3)
-    assert len(res) == 3
-    assert all(isinstance(i, int) and isinstance(v, float) for i, v in res)
-
-
-# --------------------------------------------------------------------------- #
-# v0.2 geometries: stereographic (kappa), rotation, Heisenberg, product
-# --------------------------------------------------------------------------- #
-def _geo(geometry, **kw):
-    defaults = dict(num_event_types=5, embedding_dim=8, dropout_p=0.0, num_epochs=4,
-                    batch_size=8, pad_sequences=True, random_state=0, use_gpu=False)
-    defaults.update(kw)
-    return Event2Vec(geometry=geometry, **defaults)
-
-
-ALL_NEW_GEOMS = [
-    dict(geometry="spherical", kappa=1.0),
-    dict(geometry="stereographic", kappa=-0.5),
-    dict(geometry="rotation", rotation_n=3),
-    dict(geometry="heisenberg", heisenberg_m=1),
-    dict(geometry="product", product_kappas=(-1.0, 1.0)),
-]
-
-
-@pytest.mark.parametrize("cfg", ALL_NEW_GEOMS)
-def test_new_geometry_fits_and_transforms(cfg):
-    m = _geo(**cfg).fit(structured_sequences())
-    emb = m.transform(structured_sequences())
-    assert emb.shape[1] == m.model.state_dim
-    assert np.isfinite(emb).all()
-
-
-@pytest.mark.parametrize("cfg", ALL_NEW_GEOMS)
-def test_new_geometry_fit_improves_loss(cfg):
-    # Curved-geometry optimization can overshoot at a high LR (the endpoint may
-    # bounce), so we lock the honest property: training reduces the loss.
-    m = _geo(num_epochs=40, learning_rate=5e-3, **cfg).fit(structured_sequences())
-    assert min(m.training_loss_) < m.training_loss_[0] * 0.98
-
-
-def test_stereographic_kappa0_is_euclidean_addition():
-    x, y = torch.randn(4, 6), torch.randn(4, 6)
-    assert torch.allclose(StereographicUtils.add(x, y, 0.0), x + y, atol=1e-6)
-
-
-def test_stereographic_negative_kappa_matches_mobius():
-    """kappa<0 stereographic addition equals Mobius addition with c=-kappa."""
-    x, y = torch.randn(4, 6) * 0.1, torch.randn(4, 6) * 0.1
-    kappa = -1.0
-    assert torch.allclose(
-        StereographicUtils.add(x, y, kappa),
-        HyperbolicUtils.mobius_add(x, y, -kappa),
-        atol=1e-5,
-    )
-
-
-@pytest.mark.parametrize("kappa", [-1.0, -0.3, 0.5, 2.0])
-def test_stereographic_left_cancellation(kappa):
-    """(-x) (+)_k (x (+)_k y) == y for every curvature (the recon-loss law)."""
-    x, y = torch.randn(4, 6) * 0.1, torch.randn(4, 6) * 0.1
-    add = StereographicUtils.add
-    assert torch.allclose(add(-x, add(x, y, kappa), kappa), y, atol=1e-4)
-
-
-def test_rotation_state_stays_orthogonal():
-    m = _geo("rotation", rotation_n=3, num_epochs=3).fit(structured_sequences())
-    h = m.transform([[0, 1, 2, 3, 4]], as_numpy=False)[0].reshape(3, 3)
-    assert torch.allclose(h @ h.t(), torch.eye(3), atol=1e-4)
-
-
-@pytest.mark.parametrize("cfg", ALL_NEW_GEOMS)
-def test_new_geometry_reconstruction_zero_at_ideal(cfg):
-    """Each geometry's left-cancellation makes L_recon ~ 0 at the ideal update."""
-    m = _geo(**cfg)
-    h0 = m.model.zero_state(1, torch.device("cpu"))
-    _, recon, _ = _one_step_losses(m, h0)
-    assert recon.item() < 1e-6
-
-
-def test_heisenberg_carries_order_information():
-    """The Heisenberg central coordinate distinguishes AB from BA; the additive
-    (Euclidean) endpoint does not."""
-    hm = HeisenbergModel(num_event_types=5, m=1)
-    hm.eval()
-    ab = hm.forward(torch.tensor([1]), hm.forward(torch.tensor([2]),
-                    hm.zero_state(1, torch.device("cpu")))[1])[1]
-    ba = hm.forward(torch.tensor([2]), hm.forward(torch.tensor([1]),
-                    hm.zero_state(1, torch.device("cpu")))[1])[1]
-    # same v (abelian part) but different central z (swept area) => order-sensitive
-    assert torch.allclose(ab[:, :2], ba[:, :2], atol=1e-5)
-    assert (ab[:, 2] - ba[:, 2]).abs().item() > 1e-4
-
-
-def test_stereographic_requires_kappa():
-    with pytest.raises(ValueError):
-        Event2Vec(num_event_types=5, geometry="stereographic")  # kappa missing
-    with pytest.raises(ValueError):
-        Event2Vec(num_event_types=5, geometry="spherical", kappa=-1.0)  # needs kappa>0
-
-
-def test_product_has_no_single_embedding():
-    m = _geo("product", product_kappas=(-1.0, 1.0)).fit(structured_sequences())
-    with pytest.raises(NotImplementedError):
-        m.most_similar(positive=1)