| import unittest |
|
|
| from hdc.hypervec import hvc, sim |
| from hdc.memory_modes import ( |
| HolographicMemory, |
| HybridMemory, |
| PhotographicMemory, |
| capacity_report, |
| compare_modes, |
| ) |
|
|
| D = 2000 |
| SYMBOLS = [hvc("test/symbol/%d" % i, D) for i in range(8)] |
|
|
|
|
| class TestPhotographic(unittest.TestCase): |
| def test_recall_is_bit_exact(self): |
| mem = PhotographicMemory(d=D) |
| value = hvc("pixel/42", D) |
| mem.capture("frame/42", value) |
| got, score = mem.recall("frame/42") |
| self.assertEqual(got, value & ((1 << D) - 1)) |
| self.assertEqual(score, 1.0) |
|
|
| def test_miss_is_none(self): |
| mem = PhotographicMemory(d=D) |
| self.assertEqual(mem.recall("absent"), (None, 0.0)) |
|
|
| def test_capacity_evicts_oldest(self): |
| mem = PhotographicMemory(d=D, capacity=2) |
| for i in range(3): |
| mem.capture("k/%d" % i, SYMBOLS[i]) |
| self.assertEqual(len(mem), 2) |
| self.assertNotIn("k/0", mem) |
| self.assertIn("k/2", mem) |
| self.assertEqual(mem.stats()["evicted"], 1) |
|
|
| def test_overwrite_does_not_evict(self): |
| mem = PhotographicMemory(d=D, capacity=1) |
| mem.capture("k", SYMBOLS[0]) |
| mem.capture("k", SYMBOLS[1]) |
| self.assertEqual(mem.recall("k")[0], SYMBOLS[1]) |
| self.assertEqual(mem.stats()["evicted"], 0) |
|
|
|
|
| class TestHolographic(unittest.TestCase): |
| def test_majority_superposition_recalls_exactly_at_small_k(self): |
| mem = HolographicMemory(d=D, alphabet=SYMBOLS) |
| for i in range(4): |
| mem.record("slot/%d" % i, SYMBOLS[i]) |
| for i in range(4): |
| got, _ = mem.recall("slot/%d" % i) |
| self.assertEqual(got, SYMBOLS[i], msg="slot %d" % i) |
|
|
| def test_xor_accumulation_is_the_wrong_rule(self): |
| |
| |
| |
| from hdc.hypervec import bind |
|
|
| for k in (2, 4, 8): |
| trace = 0 |
| for i in range(k): |
| trace ^= bind(hvc("xor/%d" % i, D), SYMBOLS[i], D) |
| xor_hits = 0 |
| for i in range(k): |
| probe = bind(trace, hvc("xor/%d" % i, D), D) |
| best = max(SYMBOLS, key=lambda s: sim(probe, s, D)) |
| xor_hits += best == SYMBOLS[i] |
| self.assertLessEqual(xor_hits, k // 2, msg="k=%d" % k) |
|
|
| majority = HolographicMemory(d=D, alphabet=SYMBOLS) |
| for i in range(k): |
| majority.record("xor/%d" % i, SYMBOLS[i]) |
| self.assertEqual( |
| sum(1 for i in range(k) if majority.recall("xor/%d" % i)[0] == SYMBOLS[i]), |
| k, |
| msg="k=%d" % k, |
| ) |
|
|
| def test_confidence_falls_as_the_trace_fills(self): |
| mem = HolographicMemory(d=D, alphabet=SYMBOLS) |
| mem.record("slot/0", SYMBOLS[0]) |
| alone = mem.confidence("slot/0") |
| for i in range(1, 6): |
| mem.record("slot/%d" % i, SYMBOLS[i]) |
| crowded = mem.confidence("slot/0") |
| self.assertLess(crowded, alone) |
| self.assertGreater(alone, 0.9) |
|
|
| def test_empty_memory_returns_nothing(self): |
| mem = HolographicMemory(d=D, alphabet=SYMBOLS) |
| self.assertEqual(mem.recall("anything"), (None, 0.0)) |
| self.assertEqual(mem.confidence("anything"), 0.0) |
|
|
| def test_trace_is_bounded_by_dimension(self): |
| mem = HolographicMemory(d=D, alphabet=SYMBOLS) |
| for i in range(8): |
| mem.record("slot/%d" % i, SYMBOLS[i]) |
| self.assertLess(mem.trace.bit_length(), D + 1) |
| self.assertEqual(mem.stats()["items"], 8) |
|
|
| def test_capacity_report_is_monotone_in_similarity(self): |
| rows = capacity_report(D, sizes=(2, 8, 16), symbols=8) |
| self.assertEqual([r["items"] for r in rows], [2, 8, 16]) |
| for earlier, later in zip(rows, rows[1:]): |
| self.assertLessEqual(later["mean_similarity"], earlier["mean_similarity"]) |
|
|
|
|
| class TestHybrid(unittest.TestCase): |
| def test_exact_path_wins_when_present(self): |
| mem = HybridMemory(d=D, buckets=4, alphabet=SYMBOLS) |
| mem.capture("key/1", SYMBOLS[1]) |
| value, score, path = mem.recall("key/1") |
| self.assertEqual((value, score, path), (SYMBOLS[1], 1.0, "exact")) |
|
|
| def test_trace_path_answers_after_eviction(self): |
| mem = HybridMemory(d=D, buckets=1, per_bucket=1, alphabet=SYMBOLS) |
| mem.capture("first", SYMBOLS[0]) |
| mem.capture("second", SYMBOLS[1]) |
| self.assertNotIn("first", mem.exact[0]) |
| value, score, path = mem.recall("first") |
| self.assertEqual(path, "trace") |
| self.assertIsNotNone(value) |
|
|
| def test_buckets_are_disjoint(self): |
| mem = HybridMemory(d=D, buckets=8, alphabet=SYMBOLS) |
| mem.capture("key/1", SYMBOLS[1]) |
| filled = [i for i, cell in enumerate(mem.exact) if cell] |
| self.assertEqual(len(filled), 1) |
|
|
| def test_consolidate_matches_a_fresh_trace(self): |
| mem = HybridMemory(d=D, buckets=2, alphabet=SYMBOLS) |
| for i in range(4): |
| mem.capture("k/%d" % i, SYMBOLS[i]) |
| self.assertEqual(mem.consolidate(), 0) |
| for i in range(4): |
| self.assertEqual(mem.recall("k/%d" % i)[0], SYMBOLS[i]) |
|
|
| def test_compare_modes_photographic_is_perfect(self): |
| result = compare_modes(D, k=8, symbols=8) |
| self.assertEqual(result["photographic"], 1.0) |
| self.assertEqual(result["items"], 8) |
|
|
| def test_zero_buckets_rejected(self): |
| with self.assertRaises(ValueError): |
| HybridMemory(d=D, buckets=0) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
