def test_input_specification_multiple_nested_compositions(self):
# level_0 composition --------------------------------- innermost composition
level_0 = Composition(name="level_0")
A0 = TransferMechanism(name="A0",
default_variable=[[0.], [0.]],
function=Linear(slope=1.))
B0 = TransferMechanism(name="B0", function=Linear(slope=2.))
level_0.add_node(A0)
level_0.add_node(B0)
level_0.add_projection(MappingProjection(), A0, B0)
level_0.add_projection(
MappingProjection(sender=A0.output_ports[1], receiver=B0), A0, B0)
# level_1 composition ---------------------------------
level_1 = Composition(name="level_1")
A1 = TransferMechanism(name="A1", function=Linear(slope=1.))
B1 = TransferMechanism(name="B1", function=Linear(slope=2.))
level_1.add_node(level_0)
level_1.add_node(A1)
level_1.add_node(B1)
level_1.add_projection(MappingProjection(), level_0, B1)
level_1.add_projection(MappingProjection(), A1, B1)
# level_2 composition --------------------------------- outermost composition
level_2 = Composition(name="level_2")
A2 = TransferMechanism(name="A2", size=2, function=Linear(slope=1.))
B2 = TransferMechanism(name="B2", function=Linear(slope=2.))
level_2.add_node(level_1)
level_2.add_node(A2)
level_2.add_node(B2)
level_2.add_projection(MappingProjection(), level_1, B2)
level_2.add_projection(MappingProjection(), A2, B2)
sched = Scheduler(composition=level_2)
# FIX: order of InputPorts in each inner composition (level_0 and level_1)
level_2.run(inputs={
A2: [[1.0, 2.0]],
level_1: {
A1: [[1.0]],
level_0: {
A0: [[1.0], [2.0]]
}
}
},
scheduler=sched)
# level_0 output = 2.0 * (1.0 + 2.0) = 6.0
assert np.allclose(level_0.get_output_values(level_2), [6.0])
# level_1 output = 2.0 * (1.0 + 6.0) = 14.0
assert np.allclose(level_1.get_output_values(level_2), [14.0])
# level_2 output = 2.0 * (1.0 + 2.0 + 14.0) = 34.0
assert np.allclose(level_2.get_output_values(level_2), [34.0])
def test_connect_compositions_with_complicated_states(self, mode):
inner_composition_1 = Composition(name="comp1")
A = TransferMechanism(name="A1",
default_variable=[[0.0], [0.0]],
function=Linear(slope=2.0))
B = TransferMechanism(name="B1",
default_variable=[[0.0], [0.0]],
function=Linear(slope=3.0))
inner_composition_1.add_node(A)
inner_composition_1.add_node(B)
inner_composition_1.add_projection(MappingProjection(sender=A, receiver=B), A, B)
inner_composition_1.add_projection(MappingProjection(sender=A.output_ports[1], receiver=B.input_ports[1]), A,
B)
inner_composition_2 = Composition(name="comp2")
A2 = TransferMechanism(name="A2",
default_variable=[[0.0], [0.0]],
function=Linear(slope=2.0))
B2 = TransferMechanism(name="B2",
default_variable=[[0.0], [0.0]],
function=Linear(slope=3.0))
inner_composition_2.add_node(A2)
inner_composition_2.add_node(B2)
inner_composition_2.add_projection(MappingProjection(sender=A2, receiver=B2), A2, B2)
inner_composition_2.add_projection(MappingProjection(sender=A2.output_ports[1], receiver=B2.input_ports[1]),
A2, B2)
outer_composition = Composition(name="outer_composition")
outer_composition.add_node(inner_composition_1)
outer_composition.add_node(inner_composition_2)
outer_composition.add_projection(projection=MappingProjection(), sender=inner_composition_1,
receiver=inner_composition_2)
outer_composition.add_projection(
projection=MappingProjection(sender=inner_composition_1.output_CIM.output_ports[1],
receiver=inner_composition_2.input_CIM.input_ports[1]),
sender=inner_composition_1, receiver=inner_composition_2)
sched = Scheduler(composition=outer_composition)
output = outer_composition.run(
inputs={inner_composition_1: [[[5.0], [50.0]]]},
scheduler=sched,
bin_execute=mode
)
assert np.allclose(output, [[[180.], [1800.]]])
if mode == 'Python':
assert np.allclose(inner_composition_1.get_output_values(outer_composition), [[30.], [300.]])
assert np.allclose(inner_composition_2.get_output_values(outer_composition), [[180.], [1800.]])
assert np.allclose(outer_composition.get_output_values(outer_composition), [[180.], [1800.]])
def test_compositions_as_origin_nodes(self, mode):
inner_composition_1 = Composition(name="inner_composition_1")
A = TransferMechanism(name="A", function=Linear(slope=0.5))
B = TransferMechanism(name="B", function=Linear(slope=2.0))
C = TransferMechanism(name="C", function=Linear(slope=3.0))
inner_composition_1.add_node(A)
inner_composition_1.add_node(B)
inner_composition_1.add_node(C)
inner_composition_1.add_projection(MappingProjection(), A, C)
inner_composition_1.add_projection(MappingProjection(), B, C)
inner_composition_1._analyze_graph()
inner_composition_2 = Composition(name="inner_composition_2")
A2 = TransferMechanism(name="A2", function=Linear(slope=0.25))
B2 = TransferMechanism(name="B2", function=Linear(slope=1.0))
inner_composition_2.add_node(A2)
inner_composition_2.add_node(B2)
inner_composition_2.add_projection(MappingProjection(), A2, B2)
inner_composition_2._analyze_graph()
mechanism_d = TransferMechanism(name="D", function=Linear(slope=3.0))
outer_composition = Composition(name="outer_composition")
outer_composition.add_node(inner_composition_1)
outer_composition.add_node(inner_composition_2)
outer_composition.add_node(mechanism_d)
outer_composition.add_projection(projection=MappingProjection(),
sender=inner_composition_1,
receiver=mechanism_d)
outer_composition.add_projection(projection=MappingProjection(),
sender=inner_composition_2,
receiver=mechanism_d)
sched = Scheduler(composition=outer_composition)
outer_composition._analyze_graph()
# FIX: order of InputStates on inner composition 1 is not stable
output = outer_composition.run(
inputs={
# inner_composition_1: [[2.0], [1.0]],
inner_composition_1: {
A: [2.0],
B: [1.0]
},
inner_composition_2: [[12.0]]
},
scheduler_processing=sched,
bin_execute=mode)
assert np.allclose(output, [[[36.]]])
if mode == 'Python':
assert np.allclose(A.get_output_values(outer_composition), [[1.0]])
assert np.allclose(B.get_output_values(outer_composition), [[2.0]])
assert np.allclose(C.get_output_values(outer_composition), [[9.0]])
assert np.allclose(A2.get_output_values(outer_composition),
[[3.0]])
assert np.allclose(B2.get_output_values(outer_composition),
[[3.0]])
assert np.allclose(
inner_composition_1.get_output_values(outer_composition),
[[9.0]])
assert np.allclose(
inner_composition_2.get_output_values(outer_composition),
[[3.0]])
assert np.allclose(
mechanism_d.get_output_values(outer_composition), [[36.0]])
assert np.allclose(
outer_composition.get_output_values(outer_composition),
[[36.0]])
