Exemple #1
0
def relayer():
    Comp = brica1.PipeComponent()
    Comp.make_in_port("in", 3)
    Comp.make_out_port("out", 3)
    Comp.set_map("in", "out")

    Mod = brica1.Module()
    Mod.make_in_port("in", 3)
    Mod.make_out_port("out", 3)
    Mod.add_component("Comp", Comp)

    Scheduler = brica1.RealTimeSyncScheduler()
    Agent = brica1.Agent(Scheduler)
    Agent.make_in_port("in", 3)
    Agent.make_out_port("out", 3)
    Agent.add_submodule("Mod", Mod)

    brica1.alias_in_port((Agent, "in"), (Mod, "in"))
    brica1.alias_out_port((Agent, "out"), (Mod, "out"))
    brica1.alias_in_port((Mod, "in"), (Comp, "in"))
    brica1.alias_out_port((Mod, "out"), (Comp, "out"))

    def converter(msg):
        return np.array(list(msg.data), dtype=np.int16)

    Adapter = brica1.ros.ROSAdapter("relayer")
    Adapter.setup_subscriber("chatter0", Int16MultiArray, "out", 3, converter)
    Adapter.setup_publisher("chatter1", "in", 3)

    brica1.connect((Adapter, "out"), (Agent, "in"))
    brica1.connect((Agent, "out"), (Adapter, "in"))

    while not rospy.is_shutdown():
        Agent.step()
        print "Agent in port:  {}".format(Agent.get_in_port("in").buffer)
        print "Agent out port: {}".format(Agent.get_out_port("out").buffer)
Exemple #2
0
def relayer():
    Comp = brica1.PipeComponent()
    Comp.make_in_port("in", 3)
    Comp.make_out_port("out", 3)
    Comp.set_map("in", "out")

    Mod = brica1.Module()
    Mod.make_in_port("in", 3)
    Mod.make_out_port("out", 3)
    Mod.add_component("Comp", Comp)

    Scheduler = brica1.RealTimeSyncScheduler()
    Agent = brica1.Agent(Scheduler)
    Agent.make_in_port("in", 3)
    Agent.make_out_port("out", 3)
    Agent.add_submodule("Mod", Mod)

    brica1.alias_in_port((Agent, "in"), (Mod, "in"))
    brica1.alias_out_port((Agent, "out"), (Mod, "out"))
    brica1.alias_in_port((Mod, "in"), (Comp, "in"))
    brica1.alias_out_port((Mod, "out"), (Comp, "out"))

    def converter(msg):
        return np.array(list(msg.data), dtype=np.int16)

    Adapter = brica1.ros.ROSAdapter("relayer")
    Adapter.setup_subscriber("chatter0", Int16MultiArray, "out", 3, converter)
    Adapter.setup_publisher("chatter1", "in", 3)

    brica1.connect((Adapter, "out"), (Agent, "in"))
    brica1.connect((Agent, "out"), (Adapter, "in"))

    while not rospy.is_shutdown():
        Agent.step()
        print "Agent in port:  {}".format(Agent.get_in_port("in").buffer)
        print "Agent out port: {}".format(Agent.get_out_port("out").buffer)
    stacked_autoencoder.make_out_port("loss1", 1)
    stacked_autoencoder.make_out_port("loss2", 1)
    stacked_autoencoder.make_out_port("loss3", 1)
    stacked_autoencoder.make_out_port("loss4", 1)
    stacked_autoencoder.make_out_port("loss5", 1)
    stacked_autoencoder.make_out_port("loss6", 1)
    stacked_autoencoder.make_out_port("loss7", 1)
    stacked_autoencoder.make_out_port("loss8", 1)
    stacked_autoencoder.make_out_port("loss9", 1)
    stacked_autoencoder.make_out_port("loss10", 1)
    stacked_autoencoder.make_out_port("loss11", 1)
    stacked_autoencoder.make_in_port("target", 1)
    stacked_autoencoder.make_out_port("accuracy", 1)

    brica1.alias_in_port((stacked_autoencoder, "input"), (convolutional1, "input"))
    brica1.alias_out_port((stacked_autoencoder, "output"), (slp, "output"))
    brica1.alias_out_port((stacked_autoencoder, "loss1"), (convolutional1, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss2"), (convolutional2, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss3"), (convolutional3, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss4"), (convolutional4, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss5"), (convolutional5, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss6"), (convolutional6, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss7"), (convolutional7, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss8"), (convolutional8, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss9"), (autoencoder1, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss10"), (autoencoder2, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss11"), (slp, "loss"))
    brica1.alias_in_port((stacked_autoencoder, "target"), (slp, "target"))
    brica1.alias_out_port((stacked_autoencoder, "accuracy"), (slp, "accuracy"))

    scheduler = brica1.VirtualTimeSyncScheduler()
Exemple #4
0
    stacked_autoencoder.make_out_port("loss2", 1)
    stacked_autoencoder.make_out_port("loss3", 1)
    stacked_autoencoder.make_out_port("loss4", 1)
    stacked_autoencoder.make_out_port("loss5", 1)
    stacked_autoencoder.make_out_port("loss6", 1)
    stacked_autoencoder.make_out_port("loss7", 1)
    stacked_autoencoder.make_out_port("loss8", 1)
    stacked_autoencoder.make_out_port("loss9", 1)
    stacked_autoencoder.make_out_port("loss10", 1)
    stacked_autoencoder.make_out_port("loss11", 1)
    stacked_autoencoder.make_in_port("target", 1)
    stacked_autoencoder.make_out_port("accuracy", 1)

    brica1.alias_in_port((stacked_autoencoder, "input"),
                         (convolutional1, "input"))
    brica1.alias_out_port((stacked_autoencoder, "output"), (slp, "output"))
    brica1.alias_out_port((stacked_autoencoder, "loss1"),
                          (convolutional1, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss2"),
                          (convolutional2, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss3"),
                          (convolutional3, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss4"),
                          (convolutional4, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss5"),
                          (convolutional5, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss6"),
                          (convolutional6, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss7"),
                          (convolutional7, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss8"),
Exemple #5
0
    def test_nested(self):
        s = brica1.VirtualTimeScheduler()
        agent = brica1.Agent(s)

        zero = numpy.zeros(3, dtype=numpy.short)
        v = numpy.array([1, 2, 3], dtype=numpy.short)

        CompA = brica1.ConstantComponent()
        CompB = brica1.PipeComponent()
        CompC = brica1.NullComponent()

        CompA.offset = 2.0
        CompB.offset = 0.0
        CompC.offset = 1.0

        CompA.interval = 5.0
        CompB.interval = 5.0
        CompC.interval = 5.0

        ModA = brica1.Module()
        ModB = brica1.Module()
        ModC = brica1.Module()

        SupA = brica1.Module()
        SupB = brica1.Module()
        SupC = brica1.Module()

        Top = brica1.Module()

        CompA.set_state("out", v)
        CompA.make_out_port("out", 3)
        CompB.make_in_port("in", 3)
        CompB.make_out_port("out", 3)
        CompB.set_map("in", "out")
        CompC.make_in_port("in", 3)

        ModA.make_out_port("out", 3)
        ModB.make_in_port("in", 3)
        ModB.make_out_port("out", 3)
        ModC.make_in_port("in", 3)

        SupA.make_out_port("out", 3)
        SupB.make_in_port("in", 3)
        SupB.make_out_port("out", 3)
        SupC.make_in_port("in", 3)

        SupA.add_submodule("ModA", ModA)
        SupB.add_submodule("ModB", ModB)
        SupC.add_submodule("ModC", ModC)

        ModA.add_component("CompA", CompA)
        ModB.add_component("CompB", CompB)
        ModC.add_component("CompC", CompC)

        # Port aliasing must start from outside-in
        brica1.alias_out_port((SupA, "out"), (ModA, "out"))
        brica1.alias_out_port((ModA, "out"), (CompA, "out"))

        brica1.alias_in_port((SupB, "in"), (ModB, "in"))
        brica1.alias_in_port((ModB, "in"), (CompB, "in"))

        brica1.alias_out_port((SupB, "out"), (ModB, "out"))
        brica1.alias_out_port((ModB, "out"), (CompB, "out"))

        brica1.alias_in_port((SupC, "in"), (ModC, "in"))
        brica1.alias_in_port((ModC, "in"), (CompC, "in"))

        brica1.connect((SupA, "out"), (SupB, "in"))
        brica1.connect((SupB, "out"), (SupC, "in"))

        Top.add_submodule("SupA", SupA)
        Top.add_submodule("SupB", SupB)
        Top.add_submodule("SupC", SupC)

        agent.add_submodule("Top", Top)

        self.assertTrue((CompA.get_state("out") == v).all())
        self.assertIsNot(CompA.get_state("out"), v)

        self.assertTrue((CompA.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())

        time = agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 5.0)

        time = agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 6.0)

        time = agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 7.0)

        time = agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v   ).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 10.0)

        time = agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v   ).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 11.0)

        time = agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v   ).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 12.0)

        time = agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v   ).all())
        self.assertTrue((CompB.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 15.0)

        time = agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v).all())
        self.assertTrue((CompB.get_out_port("out").buffer == v).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == v).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == v).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == v).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == v).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == v).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == v).all())
        self.assertEquals(time, 16.0)

        time = agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v).all())
        self.assertTrue((CompB.get_out_port("out").buffer == v).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == v).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == v).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == v).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == v).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == v).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == v).all())
        self.assertEquals(time, 17.0)
Exemple #6
0
    def test_module(self):
        s = brica1.VirtualTimeSyncScheduler(1.0)
        agent = brica1.Agent(s)

        zero = numpy.zeros(3, dtype=numpy.short)
        v = numpy.array([1, 2, 3], dtype=numpy.short)

        CompA = brica1.ConstantComponent()
        CompB = brica1.PipeComponent()
        CompC = brica1.NullComponent()

        ModA = brica1.Module()
        ModB = brica1.Module()
        ModC = brica1.Module()
        ModD = brica1.Module()

        CompA.set_state("out", v)
        CompA.make_out_port("out", 3)
        CompB.make_in_port("in", 3)
        CompB.make_out_port("out", 3)
        CompB.set_map("in", "out")
        CompC.make_in_port("in", 3)

        ModA.make_out_port("out", 3)
        ModB.make_in_port("in", 3)
        ModB.make_out_port("out", 3)
        ModC.make_in_port("in", 3)

        ModA.add_component("CompA", CompA)
        ModB.add_component("CompB", CompB)
        ModC.add_component("CompC", CompC)

        brica1.alias_out_port((ModA, "out"), (CompA, "out"))
        brica1.alias_in_port((ModB, "in"), (CompB, "in"))
        brica1.alias_out_port((ModB, "out"), (CompB, "out"))
        brica1.alias_in_port((ModC, "in"), (CompC, "in"))

        brica1.connect((ModA, "out"), (ModB, "in"))
        brica1.connect((ModB, "out"), (ModC, "in"))

        ModD.add_submodule("ModA", ModA)
        ModD.add_submodule("ModB", ModB)
        ModD.add_submodule("ModC", ModC)

        agent.add_submodule("ModD", ModD)

        self.assertTrue((CompA.get_state("out") == v).all())
        self.assertIsNot(CompA.get_state("out"), v)

        self.assertTrue((CompA.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())

        agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())

        agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v   ).all())
        self.assertTrue((CompB.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())

        agent.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v).all())
        self.assertTrue((CompB.get_out_port("out").buffer == v).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == v).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == v).all())
Exemple #7
0
    def test_module(self):
        s = brica1.VirtualTimeScheduler()
        ca = brica1.Agent(s)

        zero = numpy.zeros(3, dtype=numpy.short)
        v = numpy.array([1, 2, 3], dtype=numpy.short)

        CompA = brica1.ConstantComponent()
        CompB = brica1.PipeComponent()
        CompC = brica1.NullComponent()

        CompA.offset = 2.0
        CompB.offset = 0.0
        CompC.offset = 1.0

        CompA.interval = 5.0
        CompB.interval = 5.0
        CompC.interval = 5.0

        ModA = brica1.Module()
        ModB = brica1.Module()
        ModC = brica1.Module()
        ModD = brica1.Module()

        CompA.set_state("out", v)
        CompA.make_out_port("out", 3)
        CompB.make_in_port("in", 3)
        CompB.make_out_port("out", 3)
        CompB.set_map("in", "out")
        CompC.make_in_port("in", 3)

        ModA.make_out_port("out", 3)
        ModB.make_in_port("in", 3)
        ModB.make_out_port("out", 3)
        ModC.make_in_port("in", 3)

        ModA.add_component("CompA", CompA)
        ModB.add_component("CompB", CompB)
        ModC.add_component("CompC", CompC)

        brica1.alias_out_port((ModA, "out"), (CompA, "out"))
        brica1.alias_in_port((ModB, "in"), (CompB, "in"))
        brica1.alias_out_port((ModB, "out"), (CompB, "out"))
        brica1.alias_in_port((ModC, "in"), (CompC, "in"))

        brica1.connect((ModA, "out"), (ModB, "in"))
        brica1.connect((ModB, "out"), (ModC, "in"))

        ModD.add_submodule("ModA", ModA)
        ModD.add_submodule("ModB", ModB)
        ModD.add_submodule("ModC", ModC)

        ca.add_submodule("ModD", ModD)

        self.assertTrue((CompA.get_state("out") == v).all())
        self.assertIsNot(CompA.get_state("out"), v)

        self.assertTrue((CompA.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())

        time = ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 5.0)

        time = ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 6.0)

        time = ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 7.0)

        time = ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v   ).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 10.0)

        time = ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v   ).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 11.0)

        time = ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v   ).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 12.0)

        time = ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v   ).all())
        self.assertTrue((CompB.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertEquals(time, 15.0)

        time = ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v).all())
        self.assertTrue((CompB.get_out_port("out").buffer == v).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == v).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == v).all())
        self.assertEquals(time, 16.0)

        time = ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v).all())
        self.assertTrue((CompB.get_out_port("out").buffer == v).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == v).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == v).all())
        self.assertEquals(time, 17.0)
Exemple #8
0
    def test_nested(self):
        s = brica1.VirtualTimeSyncScheduler(1.0)
        ca = brica1.Agent(s)

        zero = numpy.zeros(3, dtype=numpy.short)
        v = numpy.array([1, 2, 3], dtype=numpy.short)

        CompA = brica1.ConstantComponent()
        CompB = brica1.PipeComponent()
        CompC = brica1.NullComponent()

        ModA = brica1.Module()
        ModB = brica1.Module()
        ModC = brica1.Module()

        SupA = brica1.Module()
        SupB = brica1.Module()
        SupC = brica1.Module()

        Top = brica1.Module()

        CompA.set_state("out", v)
        CompA.make_out_port("out", 3)
        CompB.make_in_port("in", 3)
        CompB.make_out_port("out", 3)
        CompB.set_map("in", "out")
        CompC.make_in_port("in", 3)

        ModA.make_out_port("out", 3)
        ModB.make_in_port("in", 3)
        ModB.make_out_port("out", 3)
        ModC.make_in_port("in", 3)

        SupA.make_out_port("out", 3)
        SupB.make_in_port("in", 3)
        SupB.make_out_port("out", 3)
        SupC.make_in_port("in", 3)

        SupA.add_submodule("ModA", ModA)
        SupB.add_submodule("ModB", ModB)
        SupC.add_submodule("ModC", ModC)

        ModA.add_component("CompA", CompA)
        ModB.add_component("CompB", CompB)
        ModC.add_component("CompC", CompC)

        # Out ports must be aliased inside-out
        brica1.alias_out_port((ModA, "out"), (CompA, "out"))
        brica1.alias_out_port((SupA, "out"), (ModA, "out"))

        # In ports must be aliased outside-in
        brica1.alias_in_port((SupB, "in"), (ModB, "in"))
        brica1.alias_in_port((ModB, "in"), (CompB, "in"))

        # Out ports must be aliased inside-out
        brica1.alias_out_port((ModB, "out"), (CompB, "out"))
        brica1.alias_out_port((SupB, "out"), (ModB, "out"))

        # In ports must be aliased outside-in
        brica1.alias_in_port((SupC, "in"), (ModC, "in"))
        brica1.alias_in_port((ModC, "in"), (CompC, "in"))

        brica1.connect((SupA, "out"), (SupB, "in"))
        brica1.connect((SupB, "out"), (SupC, "in"))

        Top.add_submodule("SupA", SupA)
        Top.add_submodule("SupB", SupB)
        Top.add_submodule("SupC", SupC)

        ca.add_submodule("Top", Top)

        self.assertTrue((CompA.get_state("out") == v).all())
        self.assertIsNot(CompA.get_state("out"), v)

        self.assertTrue((CompA.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())

        ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == zero).all())
        self.assertTrue((CompB.get_out_port("out").buffer == zero).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == zero).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())

        ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v   ).all())
        self.assertTrue((CompB.get_out_port("out").buffer == v   ).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == zero).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == zero).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == v   ).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == v   ).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == zero).all())

        ca.step()

        self.assertTrue((CompA.get_out_port("out").buffer == v).all())
        self.assertTrue((CompB.get_in_port("in").buffer   == v).all())
        self.assertTrue((CompB.get_out_port("out").buffer == v).all())
        self.assertTrue((CompC.get_in_port("in").buffer   == v).all())
        self.assertTrue((ModA.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModB.get_in_port("in").buffer    == v).all())
        self.assertTrue((ModB.get_out_port("out").buffer  == v).all())
        self.assertTrue((ModC.get_in_port("in").buffer    == v).all())
        self.assertTrue((SupA.get_out_port("out").buffer  == v).all())
        self.assertTrue((SupB.get_in_port("in").buffer    == v).all())
        self.assertTrue((SupB.get_out_port("out").buffer  == v).all())
        self.assertTrue((SupC.get_in_port("in").buffer    == v).all())
Exemple #9
0
    stacked_autoencoder.make_in_port("input", 117)
    stacked_autoencoder.make_in_port("target", 1)
    stacked_autoencoder.make_in_port("state_c1", lstm_n_units)
    stacked_autoencoder.make_in_port("state_h1", lstm_n_units)
    stacked_autoencoder.make_in_port("state_c2", lstm_n_units)
    stacked_autoencoder.make_in_port("state_h2", lstm_n_units)
    stacked_autoencoder.make_out_port("output", 10)
    stacked_autoencoder.make_out_port("loss1", 1)
    stacked_autoencoder.make_out_port("loss2", 1)
    stacked_autoencoder.make_out_port("loss3", 1)
    stacked_autoencoder.make_out_port("loss4", 1)
    stacked_autoencoder.make_out_port("accuracy", 1)

    brica1.alias_in_port((stacked_autoencoder, "input"), (component1, "input"))
    brica1.alias_out_port((stacked_autoencoder, "output"),
                          (LSTMcomponent, "output"))
    brica1.alias_out_port((stacked_autoencoder, "loss1"), (component1, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss2"), (component2, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss3"), (component3, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss4"),
                          (LSTMcomponent, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "accuracy"),
                          (LSTMcomponent, "accuracy"))
    brica1.alias_in_port((stacked_autoencoder, "target"),
                         (LSTMcomponent, "target"))

    time = 0.0

    if use_gpu:
        stacked_autoencoder.to_gpu(stacked_autoencoder)
Exemple #10
0
    stacked_autoencoder.add_component("autoencoder1", autoencoder1, 1)
    stacked_autoencoder.add_component("autoencoder2", autoencoder2, 2)
    stacked_autoencoder.add_component("autoencoder3", autoencoder3, 3)
    stacked_autoencoder.add_component("slp", slp, 4)

    stacked_autoencoder.make_in_port("input", 28**2)
    stacked_autoencoder.make_in_port("target", 1)
    stacked_autoencoder.make_out_port("output", 1000)
    stacked_autoencoder.make_out_port("loss1", 1)
    stacked_autoencoder.make_out_port("loss2", 1)
    stacked_autoencoder.make_out_port("loss3", 1)
    stacked_autoencoder.make_out_port("loss4", 1)
    stacked_autoencoder.make_out_port("accuracy", 1)

    brica1.alias_in_port((stacked_autoencoder, "input"), (autoencoder1, "input"))
    brica1.alias_out_port((stacked_autoencoder, "output"), (slp, "output"))
    brica1.alias_out_port((stacked_autoencoder, "loss1"), (autoencoder1, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss2"), (autoencoder2, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss3"), (autoencoder3, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss4"), (slp, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "accuracy"), (slp, "accuracy"))
    brica1.alias_in_port((stacked_autoencoder, "target"), (slp, "target"))

    scheduler = brica1.VirtualTimeSyncScheduler()
    agent = brica1.Agent(scheduler)
    module = brica1.Module()
    module.add_component("stacked_autoencoder", stacked_autoencoder)
    agent.add_submodule("module", module)

    time = 0.0
Exemple #11
0
    sda.make_out_port("out", 1)

    brica1.connect((sensor, "x_train"), (da1, "in"))
    brica1.connect((da1, "out"), (da2, "in"))
    brica1.connect((da2, "out"), (da3, "in"))
    brica1.connect((da3, "out"), (perceptron, "x_in"))
    brica1.connect((sensor, "y_train"), (perceptron, "y_in"))

    sda = brica1.ComponentSet()
    sda.make_out_port("out", 1)
    sda.add_component("sensor", sensor, 0)
    sda.add_component("da1", da1, 1)
    sda.add_component("da2", da2, 2)
    sda.add_component("da3", da3, 3)
    sda.add_component("perceptron", perceptron, 4)
    brica1.alias_out_port((sda, "out"), (perceptron, "out"))

    mod = brica1.Module()
    mod.make_out_port("out", 1)
    mod.add_component("sda", sda)
    brica1.alias_out_port((mod, "out"), (sda, "out"))

    ca.add_submodule("mod", mod)

    epoch = 0
    while perceptron.train:
        da1_sum = 0
        da2_sum = 0
        da3_sum = 0
        acc_sum = 0
        for i in xrange(600):
Exemple #12
0
    stacked_autoencoder.add_component("autoencoder2", autoencoder2, 2)
    stacked_autoencoder.add_component("autoencoder3", autoencoder3, 3)
    stacked_autoencoder.add_component("slp", slp, 4)

    stacked_autoencoder.make_in_port("input", 28**2)
    stacked_autoencoder.make_in_port("target", 1)
    stacked_autoencoder.make_out_port("output", 1000)
    stacked_autoencoder.make_out_port("loss1", 1)
    stacked_autoencoder.make_out_port("loss2", 1)
    stacked_autoencoder.make_out_port("loss3", 1)
    stacked_autoencoder.make_out_port("loss4", 1)
    stacked_autoencoder.make_out_port("accuracy", 1)

    brica1.alias_in_port((stacked_autoencoder, "input"),
                         (autoencoder1, "input"))
    brica1.alias_out_port((stacked_autoencoder, "output"), (slp, "output"))
    brica1.alias_out_port((stacked_autoencoder, "loss1"),
                          (autoencoder1, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss2"),
                          (autoencoder2, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss3"),
                          (autoencoder3, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "loss4"), (slp, "loss"))
    brica1.alias_out_port((stacked_autoencoder, "accuracy"), (slp, "accuracy"))
    brica1.alias_in_port((stacked_autoencoder, "target"), (slp, "target"))

    scheduler = brica1.VirtualTimeSyncScheduler()
    agent = brica1.Agent(scheduler)
    module = brica1.Module()
    module.add_component("stacked_autoencoder", stacked_autoencoder)
    agent.add_submodule("module", module)