def test_component(self):
s = brica1.VirtualTimeSyncScheduler(1.0)
ca = brica1.CognitiveArchitecture(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()
ModA.add_component("CompA", CompA)
ModA.add_component("CompB", CompB)
ModA.add_component("CompC", CompC)
CompA.set_state("out", v)
CompA.make_out_port("out", 3)
CompB.make_in_port("in", 3)
CompB.connect(CompA, "out", "in")
CompB.make_out_port("out", 3)
CompB.set_map("in", "out")
CompC.make_in_port("in", 3)
CompC.connect(CompB, "out", "in")
ca.add_submodule("ModA", ModA)
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())
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())
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())
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())
def _(bm):
s = brica1.VirtualTimeSyncScheduler(1.0)
agent = brica1.Agent(s)
compA = brica1.ConstantComponent()
compB = brica1.NullComponent()
mod = brica1.Module();
mod.add_component('compA', compA)
mod.add_component('compB', compB)
compA.make_out_port('out', 256*256*3)
compB.make_in_port('in', 256*256*3)
brica1.connect((compA, 'out'), (compB, 'in'))
agent.add_submodule('mod', mod)
for _ in bm:
agent.step()
mnist = data.load_mnist_data()
mnist['data'] = mnist['data'].astype(np.float32)
mnist['data'] /= 255
mnist['target'] = mnist['target'].astype(np.int32)
N_train = 60000
x_train, x_test = np.split(mnist['data'], [N_train])
y_train, y_test = np.split(mnist['target'], [N_train])
N_test = y_test.size
f = open('sda.pkl', 'rb')
stacked_autoencoder = pickle.load(f)
f.close()
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
sum_loss1 = 0
sum_loss2 = 0
sum_loss3 = 0
sum_loss4 = 0
sum_accuracy = 0
for batchnum in xrange(0, N_test, batchsize):
x_batch = x_test[batchnum:batchnum + batchsize]
def test_nested(self):
s = brica1.VirtualTimeSyncScheduler(1.0)
ca = brica1.CognitiveArchitecture(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
CompA.alias_out_port(ModA, "out", "out")
ModA.alias_out_port(SupA, "out", "out")
# In ports must be aliased outside-in
ModB.alias_in_port(SupB, "in", "in")
CompB.alias_in_port(ModB, "in", "in")
# Out ports must be aliased inside-out
CompB.alias_out_port(ModB, "out", "out")
ModB.alias_out_port(SupB, "out", "out")
# In ports must be aliased outside-in
ModC.alias_in_port(SupC, "in", "in")
CompC.alias_in_port(ModC, "in", "in")
SupB.connect(SupA, "out", "in")
SupC.connect(SupB, "out", "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())
def main():
parser = argparse.ArgumentParser(
description='BriCA Minimal Cognitive Architecture with Gym')
parser.add_argument('mode',
help='1:random act, 2: reinforcement learning',
choices=['1', '2'])
parser.add_argument('--dump', help='dump file path')
parser.add_argument('--episode_count',
type=int,
default=1,
metavar='N',
help='Number of training episodes (default: 1)')
parser.add_argument('--max_steps',
type=int,
default=20,
metavar='N',
help='Max steps in an episode (default: 20)')
parser.add_argument('--config',
type=str,
default='minimal_CA.json',
metavar='N',
help='Model configuration (default: minimal_CA.json')
parser.add_argument('--model',
type=str,
metavar='N',
help='Saved model for visual path')
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='disables CUDA training')
parser.add_argument('--brical',
type=str,
default='minimalCA.brical.json',
metavar='N',
help='a BriCAL json file')
args = parser.parse_args()
with open(args.config) as config_file:
config = json.load(config_file)
nb = brical.NetworkBuilder()
f = open(args.brical)
nb.load_file(f)
if not nb.check_consistency():
sys.stderr.write("ERROR: " + args.brical + " is not consistent!\n")
exit(-1)
if not nb.check_grounding():
sys.stderr.write("ERROR: " + args.brical + " is not grounded!\n")
exit(-1)
observation_dim = config['env']['observation_dim']
input_shape = [-1, observation_dim]
motor_obs_dim = config["motor_obs_dim"]
env = gym.make(config['env']['name'])
train = {
"episode_count": args.episode_count,
"max_steps": args.max_steps,
'rl_agent': config['rl_agent']
}
if args.dump is not None:
try:
observation_dump = open(args.dump, mode='w')
except OSError as e:
sys.stderr.write(str(e) + '\n')
sys.exit(1)
else:
observation_dump = None
nb.unit_dic['minimalCA.VisualComponent'].__init__(observation_dim,
motor_obs_dim)
nb.unit_dic['minimalCA.MotorComponent'].__init__(observation_dim,
config["motor_n_action"],
True, train)
nb.make_ports()
if args.model is not None:
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
if config['visual']['model'] == 'SimpleAE':
visual_model = SimpleAutoencoder(
input_shape, config['visual']['model_config']).to(device)
else:
raise NotImplementedError('Model not supported: ' +
str(config['model']))
visual_model.load_state_dict(torch.load(args.model))
visual_model.eval()
nb.unit_dic['minimalCA.VisualComponent'].device = device
else:
visual_model = None
nb.unit_dic['minimalCA.VisualComponent'].model = visual_model
agent_builder = brical.AgentBuilder()
model = nb.unit_dic['minimalCA.CognitiveArchitecture']
agent = agent_builder.create_gym_agent(nb, model, env)
scheduler = brica1.VirtualTimeSyncScheduler(agent)
for i in range(train["episode_count"]):
reward_sum = 0.
last_token = 0
for j in range(train["max_steps"]):
scheduler.step()
nb.unit_dic['minimalCA.VisualComponent'].inputs[
'token_in'] = model.get_out_port('token_out').buffer
time.sleep(config["sleep"])
current_token = agent.get_out_port('token_out').buffer[0]
if last_token + 1 == current_token:
reward_sum += agent.get_in_port("reward").buffer[0]
last_token = current_token
env.render()
if observation_dump is not None:
observation_dump.write(
str(agent.get_in_port("observation").buffer.tolist()) +
'\n')
if agent.env.done:
agent.env.flush = True
scheduler.step()
while agent.get_in_port('token_in').buffer[
0] != agent.get_out_port('token_out').buffer[0]:
scheduler.step()
agent.env.reset()
nb.unit_dic['minimalCA.MotorComponent'].reset()
nb.unit_dic['minimalCA.VisualComponent'].results[
'token_out'] = np.array([0])
nb.unit_dic['minimalCA.VisualComponent'].out_ports[
'token_out'].buffer = np.array([0])
break
print(i, "Avr. reward: ", reward_sum / env.spec.max_episode_steps)
print("Close")
if observation_dump is not None:
observation_dump.close()
env.close()
