|
|
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 |
|
|
|
