| import collections |
|
|
| import numpy as np |
| import pytest |
| from embodied.core import selectors |
|
|
|
|
| class TestSampleTree: |
|
|
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| def test_root_sum(self, branching): |
| tree = selectors.SampleTree(branching) |
| entries = range(50) |
| for index, uprob in enumerate(entries): |
| assert tree.root.uprob == sum(entries[:index]) |
| tree.insert(index, uprob) |
|
|
| @pytest.mark.parametrize('inserts', [1, 2, 10, 100]) |
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| def test_depth_inserts(self, inserts, branching): |
| tree = selectors.SampleTree(branching) |
| for index in range(inserts): |
| tree.insert(index, 1) |
| assert len(tree) == inserts |
| depths = self._find_leave_depths(tree) |
| target = max(1, int(np.ceil(np.log(inserts) / np.log(branching)))) |
| assert all(x == target for x in depths) |
|
|
| @pytest.mark.parametrize('inserts', [2, 10, 100]) |
| @pytest.mark.parametrize('remove_every', [2, 3, 4]) |
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| def test_depth_removals(self, inserts, remove_every, branching): |
| tree = selectors.SampleTree(branching) |
| for index in range(0, inserts, 1): |
| tree.insert(index, 1) |
| removals = list(range(0, inserts, remove_every)) |
| for index in removals: |
| tree.remove(index) |
| assert len(tree) == inserts - len(removals) |
| depths = self._find_leave_depths(tree) |
| target = max(1, int(np.ceil(np.log(inserts) / np.log(branching)))) |
| assert all(x == target for x in depths) |
|
|
| @pytest.mark.parametrize('inserts', [2, 10, 100]) |
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| def test_removal_num_nodes(self, inserts, branching): |
| tree = selectors.SampleTree(branching) |
| assert len(self._get_flat_nodes(tree)) == 1 |
| rng = np.random.default_rng(seed=0) |
| for key in rng.permutation(np.arange(inserts)): |
| tree.insert(key, 1) |
| num_nodes = len(self._get_flat_nodes(tree)) |
| for key in rng.permutation(np.arange(inserts)): |
| tree.remove(key) |
| assert len(self._get_flat_nodes(tree)) == 1 |
| for key in rng.permutation(np.arange(inserts)): |
| tree.insert(key, 1) |
| assert len(self._get_flat_nodes(tree)) == num_nodes |
|
|
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| def test_sample_single(self, branching): |
| tree = selectors.SampleTree(branching) |
| tree.insert(12, 1.0) |
| tree.insert(123, 1.0) |
| tree.insert(42, 1.0) |
| tree.remove(12) |
| tree.remove(42) |
| for _ in range(10): |
| assert tree.sample() == 123 |
|
|
| @pytest.mark.parametrize('inserts', [2, 10]) |
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| @pytest.mark.parametrize('uprob', [1e-5, 1.0, 1e5]) |
| def test_sample_uniform(self, inserts, branching, uprob): |
| tree = selectors.SampleTree(branching, seed=0) |
| keys = list(range(inserts)) |
| for key in keys: |
| tree.insert(key, 1.0) |
| for key in keys[::3]: |
| tree.remove(key) |
| keys.remove(key) |
| histogram = collections.defaultdict(int) |
| for _ in range(100 * len(keys)): |
| key = tree.sample() |
| histogram[key] += 1 |
| assert len(histogram) > 0 |
| assert len(histogram) == len(keys) |
| assert all(k in histogram for k in keys) |
| for key, count in histogram.items(): |
| prob = count / (100 * len(keys)) |
| assert prob > 0.5 * (1 / len(keys)) |
|
|
| @pytest.mark.parametrize('scale', [1e-5, 1, 1e5]) |
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| def test_sample_frequencies(self, scale, branching): |
| tree = selectors.SampleTree(branching, seed=0) |
| keys = [0, 1, 2, 3, 4, 5] |
| uprobs = [0, 3, 1, 1, 2, 2] |
| entries = dict(zip(keys, uprobs)) |
| for key, uprob in entries.items(): |
| tree.insert(key, scale * uprob) |
| histogram = collections.defaultdict(int) |
| for _ in range(100 * len(entries)): |
| key = tree.sample() |
| histogram[key] += 1 |
| assert len(histogram) > 0 |
| total = sum(entries.values()) |
| for key, uprob in entries.items(): |
| if uprob == 0: |
| assert key not in histogram |
| for key, count in histogram.items(): |
| prob = count / (100 * len(entries)) |
| target = entries[key] / total |
| assert 0.7 * target < prob < 1.3 * target |
|
|
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| def test_update_frequencies(self, branching): |
| tree = selectors.SampleTree(branching, seed=0) |
| keys = [0, 1, 2, 3, 4, 5] |
| uprobs = [0, 3, 1, 1, 2, 2] |
| entries = dict(zip(keys, uprobs)) |
| for key in entries.keys(): |
| tree.insert(key, 100) |
| for key, uprob in entries.items(): |
| tree.update(key, uprob) |
| histogram = collections.defaultdict(int) |
| for _ in range(100 * len(entries)): |
| key = tree.sample() |
| histogram[key] += 1 |
| assert len(histogram) > 0 |
| total = sum(entries.values()) |
| for key, uprob in entries.items(): |
| if uprob == 0: |
| assert key not in histogram |
| for key, count in histogram.items(): |
| prob = count / (100 * len(entries)) |
| target = entries[key] / total |
| assert 0.7 * target < prob < 1.3 * target |
|
|
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| def test_zero_probs_mixed(self, branching): |
| tree = selectors.SampleTree(branching, seed=0) |
| impossible = [] |
| for index in range(100): |
| if index % 3 == 0: |
| tree.insert(index, 1.0) |
| else: |
| tree.insert(index, 0.0) |
| impossible.append(index) |
| for _ in range(1000): |
| assert tree.sample() not in impossible |
|
|
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| def test_zero_probs_only(self, branching): |
| tree = selectors.SampleTree(branching, seed=0) |
| for index in range(100): |
| tree.insert(index, 0.0) |
| for _ in range(1000): |
| assert tree.sample() in range(100) |
|
|
| @pytest.mark.parametrize('branching', [2, 3, 5, 10]) |
| def test_infinity_probs(self, branching): |
| tree = selectors.SampleTree(branching, seed=0) |
| possible = [] |
| for index in range(100): |
| if index % 3 == 0: |
| tree.insert(index, np.inf) |
| possible.append(index) |
| else: |
| tree.insert(index, 1.0) |
| for _ in range(1000): |
| assert tree.sample() in possible |
|
|
| def _find_leave_depths(self, tree): |
| depths = [] |
| queue = [(tree.root, 0)] |
| while queue: |
| node, depth = queue.pop() |
| if hasattr(node, 'children'): |
| for child in node.children: |
| queue.append((child, depth + 1)) |
| else: |
| depths.append(depth) |
| assert len(depths) > 0 |
| return depths |
|
|
| def _get_flat_nodes(self, tree): |
| nodes = [] |
| queue = [tree.root] |
| while queue: |
| node = queue.pop() |
| nodes.append(node) |
| if hasattr(node, 'children'): |
| queue += node.children |
| return nodes |
|
|
