def test_validation():
graph = Topology('cpu')
class ValidationNodeStub(WorkerNodeBase):
def __init__(self, fails_validation):
super().__init__()
self.fails_validation = fails_validation
def _create_unit(self, creator: TensorCreator) -> Unit:
return RandomUnitStub(creator)
def _step(self):
pass
def validate(self):
if self.fails_validation:
raise NodeValidationException('Node failed to validate')
node = ValidationNodeStub(fails_validation=True)
graph.add_node(node)
with pytest.raises(NodeValidationException):
graph.prepare()
node.fails_validation = False
graph.prepare()
def test_expert_dimensions(self):
"""Tests multi-dimensional expert indexes."""
device = 'cpu'
parent_rf_size_x = parent_rf_size_y = 4
n_channels = 4
image_grid_size_x = image_grid_size_y = 16
input_dimensions = (image_grid_size_y, image_grid_size_x, n_channels)
parent_rf_dims = Size2D(parent_rf_size_x, parent_rf_size_y)
parent_grid_dimensions = (4, 4)
graph = Topology(device)
node = ReceptiveFieldNode(input_dimensions, parent_rf_dims)
graph.add_node(node)
memory_block = MemoryBlock()
memory_block.tensor = torch.zeros(image_grid_size_y,
image_grid_size_x,
n_channels,
device=device)
memory_block.tensor[0, parent_rf_size_x, 0] = 1
Connector.connect(memory_block, node.inputs.input)
graph.prepare()
graph.step()
node_output = node.outputs.output.tensor
assert node_output.shape == torch.Size(parent_grid_dimensions +
(parent_rf_size_y,
parent_rf_size_x, n_channels))
assert node_output[0, 1, 0, 0, 0] == 1
def test_is_initialized():
graph = Topology('cpu')
assert not graph.is_initialized()
graph.add_node(NodeStub())
assert not graph.is_initialized()
graph.prepare()
assert graph.is_initialized()
with raises(IllegalStateException):
graph.add_node(NodeStub())
def test_inverse_projection(self, device):
dtype = get_float(device)
params = ExpertParams()
params.flock_size = 2
params.n_cluster_centers = 4
params.spatial.input_size = 6
params.spatial.buffer_size = 7
params.spatial.batch_size = 3
params.temporal.n_frequent_seqs = 2
params.temporal.seq_length = 3
input_size = (3, 2)
graph = Topology(device)
node = ExpertFlockNode(params=params)
graph.add_node(node)
input_block = MemoryBlock()
input_block.tensor = torch.rand((params.flock_size, ) + input_size,
dtype=dtype,
device=device)
Connector.connect(input_block, node.inputs.sp.data_input)
graph.prepare()
node._unit.flock.sp_flock.cluster_centers = torch.tensor(
[[[1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 0.5, 0.5, 0, 0],
[0, 0, 0.5, 0, 0.5, 0]],
[[1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0]]],
dtype=dtype,
device=device)
# Just SP inverse projection
data = torch.tensor([[0, 0, 1, 0], [0.2, 0.3, 0.4, 0.1]],
dtype=dtype,
device=device)
packet = InversePassOutputPacket(data,
node.outputs.tp.projection_outputs)
projected = node.recursive_inverse_projection_from_output(packet)
# The result of the projection itself would be [[0, 0, 0.5, 0.5, 0, 0], ...], and it should be viewed as (2, 3, 2).
expected_projection = torch.tensor(
[[[0, 0], [0.5, 0.5], [0, 0]], [[0.2, 0.3], [0.4, 0.1], [0, 0]]],
dtype=dtype,
device=device)
assert same(expected_projection, projected[0].tensor)
def test_rf_node(self, device):
float_dtype = get_float(device)
parent_rf_size_x = parent_rf_size_y = 4
n_channels = 4
image_grid_size_x = image_grid_size_y = 16
dimensions = (image_grid_size_y, image_grid_size_x, n_channels)
parent_rf_dims = Size2D(parent_rf_size_y, parent_rf_size_x)
graph = Topology(device)
node = ReceptiveFieldNode(dimensions,
parent_rf_dims,
flatten_output_grid_dimensions=True)
graph.add_node(node)
memory_block = MemoryBlock()
memory_block.tensor = torch.zeros(image_grid_size_y,
image_grid_size_x,
n_channels,
dtype=float_dtype,
device=device)
memory_block.tensor[0, parent_rf_size_x, 0] = 1
Connector.connect(memory_block, node.inputs.input)
graph.prepare()
graph.step()
node_output = node.outputs.output.tensor
n_parent_rfs = (image_grid_size_y // parent_rf_size_y) * (
image_grid_size_x // parent_rf_size_x)
assert node_output.shape == torch.Size(
[n_parent_rfs, parent_rf_size_y, parent_rf_size_x, n_channels])
assert node_output[1, 0, 0, 0] == 1
back_projection = node.recursive_inverse_projection_from_output(
InversePassOutputPacket(node_output, node.outputs.output))
# assert back_projection.interpret_shape == input_image.shape
assert same(back_projection[0].tensor, memory_block.tensor)