def __init__( self, stim_provider, items, contexts, n_pos, rng=None, extra_pos=3): super(Vocabularies, self).__init__() vocabs = Config.default(spa.Network, 'vocabs') if vocabs is None: vocabs = VocabularyMap(rng=rng) self.vocabs = vocabs self.items = items if is_integer(contexts): contexts = spa.Vocabulary(contexts, rng=rng) self.contexts = contexts self.positions = spa.Vocabulary(self.items.dimensions, rng=rng) self.items.populate(';'.join(stim_provider.get_all_items())) if stim_provider.n_distractors_per_epoch > 0: self.items.populate(';'.join(stim_provider.get_all_distractors())) for i in range(self.items.dimensions): self.contexts.populate('CTX' + str(i)) for i in range(n_pos + extra_pos): self.positions.populate('P' + str(i))
def test_reinterpret(rng): v1 = spa.Vocabulary(16, pointer_gen=rng) v1.populate("A; B") v2 = spa.Vocabulary(16, pointer_gen=rng) v2.populate("A; B") assert_equal( spa.reinterpret(PointerSymbol("A", TVocabulary(v1)), v2).evaluate().v, v1["A"].v)
def test_no_magic_vocab_transform(): d = 16 v1 = spa.Vocabulary(d) v2 = spa.Vocabulary(d) with spa.Network() as model: model.a = spa.State(vocab=v1) model.b = spa.State(vocab=v2) with pytest.raises(SpaTypeError): model.a >> model.b
def test_translate(rng): v1 = spa.Vocabulary(16, pointer_gen=rng) v1.populate('A; B') v2 = spa.Vocabulary(16, pointer_gen=rng) v2.populate('A; B') assert_allclose(spa.translate(PointerSymbol('A', TVocabulary(v1)), v2).evaluate().dot(v2['A']), 1., atol=0.2)
def test_translate(rng): v1 = spa.Vocabulary(16, pointer_gen=rng) v1.populate("A; B") v2 = spa.Vocabulary(16, pointer_gen=rng) v2.populate("A; B") assert_allclose( spa.translate(PointerSymbol("A", TVocabulary(v1)), v2).evaluate().dot(v2["A"]), 1.0, atol=0.2, )
def test_dynamic_translate(Simulator, rng): v1 = spa.Vocabulary(64, pointer_gen=rng) v1.populate("A; B") v2 = spa.Vocabulary(64, pointer_gen=rng) v2.populate("A; B") with spa.Network() as model: source = spa.Transcode("A", output_vocab=v1) x = spa.translate(source, v2) p = nengo.Probe(x.construct(), synapse=0.03) with nengo.Simulator(model) as sim: sim.run(0.5) assert_sp_close(sim.trange(), sim.data[p], v2["A"], skip=0.3, atol=0.2)
def test_missing_pointer(): vocab = spa.Vocabulary(16) with spa.Network(): a = spa.State(vocab) assert a with pytest.raises(SpaParseError): spa.sym.A >> a
def create_random_vocab(dim, num_vector_items, seed, b_unitary=False, spatial_ids=['X', 'Y']): """create a random spa vocab with a certain number of vectors :dim: dimension of the vectors :num_vector_items: number of vectors in the Vocabulary :seed: random number seed :b_unitary: bool indication if the created vector shall be unitary :spatial_ids: list of ids for the spatial vectors, which shall be unitary :returns: an instance of a spa vocabulary """ vocab = spa.Vocabulary(dimensions=dim, pointer_gen=np.random.RandomState(seed=seed)) for k in spatial_ids: vocab.populate(k + '.unitary()') for i in np.arange(num_vector_items): k = 'C%s' % str(i).zfill(len(str(num_vector_items))) if b_unitary: vocab.populate(k + '.unitary()') else: vocab.populate(k) return vocab
def test_run(Simulator, algebra, seed): rng = np.random.RandomState(seed) vocab = spa.Vocabulary(16, pointer_gen=rng, algebra=algebra) vocab.populate('A; B') with spa.Network(seed=seed) as model: model.bind = spa.Bind(vocab) def inputA(t): if 0 <= t < 0.1: return 'A' else: return 'B' model.input = spa.Transcode(inputA, output_vocab=vocab) model.input >> model.bind.input_left spa.sym.A >> model.bind.input_right with model: p = nengo.Probe(model.bind.output, synapse=0.03) with Simulator(model) as sim: sim.run(0.2) error = rmse(vocab.parse("(B*A).normalized()").v, sim.data[p][-1]) assert error < 0.15 error = rmse(vocab.parse("(A*A).normalized()").v, sim.data[p][100]) assert error < 0.15
def create_vocab(D, keys, rng=None): vocab = spa.Vocabulary(int(D), pointer_gen=rng, max_similarity=0) if type(keys) is list: vocab.populate(';'.join(keys)) else: vocab.populate(keys) return vocab
def test_run(Simulator, algebra, seed): rng = np.random.RandomState(seed) vocab = spa.Vocabulary(32, pointer_gen=rng, algebra=algebra) vocab.populate('A; B') with spa.Network(seed=seed, vocabs=VocabularyMap([vocab])) as model: model.superpos = spa.Superposition(2, vocab=32) def inputA(t): if 0 <= t < 0.1: return 'A' else: return 'B' model.input = spa.Transcode(inputA, output_vocab=vocab) model.input >> model.superpos.inputs[0] spa.sym.A >> model.superpos.inputs[1] with model: p = nengo.Probe(model.superpos.output, synapse=0.03) with Simulator(model) as sim: sim.run(0.2) error = rmse(vocab.parse("(B+A).normalized()").v, sim.data[p][-1]) assert error < 0.1 error = rmse(vocab.parse("(A+A).normalized()").v, sim.data[p][100]) assert error < 0.2
def test_unbind(Simulator, side, seed): rng = np.random.RandomState(seed) vocab = spa.Vocabulary(36, pointer_gen=rng, algebra=VtbAlgebra()) vocab.populate("A; B") with spa.Network(seed=seed) as model: vtb = VTB(100, 36, unbind_left=(side == "left"), unbind_right=(side == "right")) if side == "left": left = nengo.Node(vocab["B"].v) right = nengo.Node(vocab.parse("B*A").v) elif side == "right": left = nengo.Node(vocab.parse("A*B").v) right = nengo.Node(vocab["B"].v) else: raise ValueError("Invalid 'side' value.") nengo.Connection(left, vtb.input_left) nengo.Connection(right, vtb.input_right) p = nengo.Probe(vtb.output, synapse=0.03) with Simulator(model) as sim: sim.run(0.2) assert_sp_close(sim.trange(), sim.data[p], vocab.parse("A * B * ~B"), skip=0.15, atol=0.3)
def test_unbind(Simulator, algebra, side, seed): rng = np.random.RandomState(seed) vocab = spa.Vocabulary(64, pointer_gen=rng, algebra=algebra) vocab.populate('A; B') with spa.Network(seed=seed) as model: model.bind = spa.Bind(vocab, unbind_left=(side == 'left'), unbind_right=(side == 'right')) if side == 'left': spa.sym.B >> model.bind.input_left spa.sym.B * spa.sym.A >> model.bind.input_right elif side == 'right': spa.sym.A * spa.sym.B >> model.bind.input_left spa.sym.B >> model.bind.input_right else: raise ValueError("Invalid 'side' value.") with model: p = nengo.Probe(model.bind.output, synapse=0.03) with Simulator(model) as sim: sim.run(0.2) assert_sp_close(sim.trange(), sim.data[p], vocab.parse('A * B * ~B'), skip=0.15, atol=0.3)
def test_fixed_dot_matmul(rng): vocab = spa.Vocabulary(16, pointer_gen=rng) vocab.populate("A; B") v = TVocabulary(vocab) # noqa: F841 assert_allclose( eval("PointerSymbol('A', v) @ PointerSymbol('A', v)").evaluate(), 1.0)
def test_additive_op_fixed_scalar_and_pointer_symbol(op, rng): vocab = spa.Vocabulary(16, pointer_gen=rng) vocab.populate("A") with spa.Network(): with pytest.raises(TypeError): eval("2" + op + "PointerSymbol('A')")
def test_binary_operation_on_modules_with_fixed_pointer( Simulator, algebra, op, order, rng): vocab = spa.Vocabulary(16, pointer_gen=rng, algebra=algebra) vocab.populate("A; B") b = SemanticPointer(vocab["B"].v) # noqa: F841 with spa.Network() as model: a = spa.Transcode("A", output_vocab=vocab) # noqa: F841 if order == "AB": x = eval("a" + op + "b") elif order == "BA": x = eval("b" + op + "a") else: raise ValueError("Invalid order argument.") p = nengo.Probe(x.construct(), synapse=0.03) with Simulator(model) as sim: sim.run(0.3) assert_sp_close( sim.trange(), sim.data[p], vocab.parse(order[0] + op + order[1]), skip=0.2, atol=0.3, )
def build_actions_map(paths, base_vocab): '''Built key, value vocabs for matching obj, goal combos to actions''' action_key_vocab = spa.Vocabulary(dim) actions = [] for idx, path in enumerate(paths): goal_sum = 'GOAL_' + str(idx) + '_SUM' for x in range(len(path) - 1): immediate_goal = path[x] action = 'ADD_' + immediate_goal sp = base_vocab['OBJECT'] * base_vocab[goal_sum] + \ base_vocab['GOAL'] * base_vocab[immediate_goal] actions.append(action) action_key_vocab.add(action + '_KEY', sp.v) # add (main goal to last action) mapping action = 'ADD_' + path[-1] sp = base_vocab['OBJECT'] * base_vocab[goal_sum] + \ base_vocab['GOAL'] * base_vocab['GOAL_' + str(idx)] actions.append(action) action_key_vocab.add(action + '_KEY', sp.v) action_val_vocab = base_vocab.create_subset(actions) return action_key_vocab, action_val_vocab
def make_good_unitary_old(D, eps=np.pi * 1e-3, n_trials=10000): for _ in range(n_trials): d = spa.Vocabulary(D) sp = d.create_pointer().unitary() a = np.angle(np.fft.fft(sp.v)) if np.all(np.abs(a) > eps): return spa.SemanticPointer(sp.v) raise RuntimeError("bleh")
def test_unary_operation_on_pointer_symbol(op, rng): vocab = spa.Vocabulary(16, pointer_gen=rng) vocab.populate("A") with spa.Network(): x = eval(op + "PointerSymbol('A', TVocabulary(vocab))") node = x.construct() assert_equal(node.output, vocab.parse(op + "A").v)
def test_multiply_fixed_scalar_and_pointer_symbol(rng): vocab = spa.Vocabulary(16, pointer_gen=rng) vocab.populate("A") with spa.Network(): x = 2 * PointerSymbol("A", TVocabulary(vocab)) node = x.construct() assert_equal(node.output, vocab.parse("2 * A").v)
def test_pointer_symbol_network_creation(rng): vocab = spa.Vocabulary(16, pointer_gen=rng) vocab.populate("A") with spa.Network(): A = PointerSymbol("A", TVocabulary(vocab)) node = A.construct() assert_equal(node.output, vocab["A"].v)
def test_fixed_dot(rng): vocab = spa.Vocabulary(16, pointer_gen=rng) vocab.populate("A; B") v = TVocabulary(vocab) assert_allclose( spa.dot(PointerSymbol("A", v), PointerSymbol("A", v)).evaluate(), 1.0) assert spa.dot(PointerSymbol("A", v), PointerSymbol("B", v)).evaluate() <= 0.1
def test_binary_operation_on_pointer_symbols(op, rng): vocab = spa.Vocabulary(16, pointer_gen=rng) vocab.populate("A; B") with spa.Network(): v = TVocabulary(vocab) # noqa: F841 x = eval("PointerSymbol('A', v)" + op + "PointerSymbol('B', v)") node = x.construct() assert_equal(node.output, vocab.parse("A" + op + "B").v)
def __init__( self, seed=1, label="KerNengo", cats=None ): """ build the nengo network there will be as many input and Keras node objects as the categories to be searched in the image. The categories can be given in a list as cats argoments, otherwise the global categories is used """ self.probes = {} self.nodes = {} self.states = {} self.prob = {} self.v_dim = list(lg.n_coords.values())[ 0 ][ 0 ] self.voc = spa.Vocabulary( self.v_dim ) self.dl = nengo.Network( seed=seed, label='DL'+label ) self.spa = spa.Network( seed=seed+1, label='SPA'+label ) if cats is None: self.categories = lg.categories else: self.categories = cats # initialize probabilities for c in self.categories: self.prob[ c ] = numpy.zeros( ( self.v_dim, ) ) """ this is the part intended for using a vocabolary, but I have found no ways to use it (see NOTE in state()) n_cat = len( self.categories ) parse_str = (n_cat - 1 ) * "WHERE{}; " + "WHERE{}" spointers = parse_str.format( *self.categories ) self.voc.populate( spointers ) """ with self.dl: net = 'dl' for c in self.categories: inp = "input_" + c self.inode( c, net=net ) self.knode( c ) nengo.Connection( self.get_node( inp, net=net ), self.get_node( c, net=net ), synapse=None ) self.probe( self.get_node( c, net=net ), c, net=net ) with self.spa: net = 'spa' cfg = nengo.Config( nengo.Ensemble ) cfg[ nengo.Ensemble ].neuron_type = nengo.Direct() with cfg: for c in self.categories: inp = "input_" + c self.inode( c, net=net ) where = c + "_where" self.state( c ) nengo.Connection( self.get_node( inp, net=net ), self.states[ c ].input ) self.probe( self.states[ c ].output, where, net=net )
def test_spa_vocab(): # create a model without a vocab and check that it is empty model = spa.Network() assert len(model.vocabs) == 0 # create a model with a vocab and check that it's filled va = spa.Vocabulary(16) va.populate("PANTS") vb = spa.Vocabulary(32) vb.populate("SHOES") model = spa.Network(vocabs=VocabularyMap([va, vb])) assert list(model.vocabs[16].keys()) == ["PANTS"] assert list(model.vocabs[32].keys()) == ["SHOES"] # warning on vocabs with duplicate dimensions vc = spa.Vocabulary(16) vc.populate("SOCKS") with pytest.warns(UserWarning): model = spa.Network(vocabs=VocabularyMap([va, vb, vc])) assert list(model.vocabs[16].keys()) == ["SOCKS"] assert list(model.vocabs[32].keys()) == ["SHOES"]
def v_words(self): """ create the main vocabulary with the names of the objects selected among CIFAR categories, and extract the subsets of objects to be combined in sentences """ self.words = spa.Vocabulary(dimensions=n_class) vect = numpy.eye(n_class) for w, v in zip(classes, vect): self.words.add(w.upper(), v) self.word1 = self.words.create_subset(self.obj1) self.word2 = self.words.create_subset(self.obj2)
def test_unary_operation_on_module(Simulator, algebra, op, suffix, rng): vocab = spa.Vocabulary(16, pointer_gen=rng, algebra=algebra) vocab.populate("A") with spa.Network() as model: stimulus = spa.Transcode("A", output_vocab=vocab) # noqa: F841 x = eval(op + "stimulus" + suffix) p = nengo.Probe(x.construct(), synapse=0.03) with Simulator(model) as sim: sim.run(0.3) assert_sp_close(sim.trange(), sim.data[p], vocab.parse(op + "A"), skip=0.2)
def create_vectors(objs, D, axis={'X', 'Y'}): init_dic = spa.Vocabulary(dimensions=D, max_similarity=0.01) vec_dic = {} for a in axis: ax = make_good_unitary(D) init_dic.add(a, ax) vec_dic[a] = ax # for item in vecs: # init_dic.add(item, init_dic.create_pointer(unitary =True, attempts=5000)) #using one dictionary for both to reduce similarity for item in objs: init_dic.add(item, init_dic.create_pointer(attempts=5000)) obj_dic = spa.Vocabulary(dimensions=D, max_similarity=0.01) for item in objs: obj_dic.add(item, init_dic[item].v) return obj_dic, vec_dic
def test_assignment_of_pointer_symbol(Simulator, rng): vocab = spa.Vocabulary(16, pointer_gen=rng) vocab.populate("A") with spa.Network() as model: sink = spa.State(vocab) PointerSymbol("A") >> sink p = nengo.Probe(sink.output, synapse=0.03) with Simulator(model) as sim: sim.run(0.5) assert_sp_close(sim.trange(), sim.data[p], vocab["A"], skip=0.3)
def run_trial(dim, n_objects, n_goals, n_steps): '''Collect accuracy measure for a trial using the method''' goal_keys = ['GOAL_' + str(x) for x in range(n_goals)] object_keys = ['OBJ_' + str(x) for x in range(n_objects)] action_keys = ['ADD_' + x for x in object_keys] tags = ['GOAL', 'OBJECT'] paths = build_goal_paths(object_keys, n_goals, n_steps) # build all the vocabs for mapping between objects, actions, goals, precons base_vocab = spa.Vocabulary(dim) base_vocab.populate(';'.join(goal_keys + object_keys + action_keys + tags)) action_vocab, precon_vocab = build_precons_map(paths, base_vocab, goal_keys) goal_vocab, sums_vocab = build_objects_map(paths, base_vocab, goal_keys) action_key_vocab, action_val_vocab = build_actions_map(paths, base_vocab) total = 0 correct = 0 results = [] for idx, goal in enumerate(goal_keys): print('Current Goal: %s' % goal) print('Target Sequence: ', paths[idx]) plan = [] current_goal = goal for step in range(n_steps): goal_tag = 'GOAL_' + str(idx) + '_SUM' action_key = base_vocab['OBJECT'] * base_vocab[goal_tag] + \ base_vocab['GOAL'] * base_vocab[current_goal] action, _ = associate(action_key, action_key_vocab, action_val_vocab) print('Planned action: % s' % action) plan.append(action) precon, _ = associate(base_vocab[action], action_vocab, precon_vocab) current_goal = precon plan = [x.strip('ADD_') for x in plan] if list(reversed(plan)) == paths[idx]: correct += 1 total += 1 print('') return correct / total