def __init__(self, name, node, hrr=None, enter_f=None, exit_f=None, timer_f=None, timer_t=None, input=None): """Initializes a finite state machine state. Requires a name (which must be unique to the node) and the FSMNode which it will be a part of. Keyword arguments: hrr -- An HRR to be bound to this state. If it is not assigned, it will be randomly generated. enter_f -- A function to run when you enter this state. exit_f -- A function to run when you exit this state. timer_f -- A function to run after a certain amount of time has elapsed. timer_t -- The amount of time after which the timer function will run. input -- A function to run in response to some input. (Does this make sense to include?) """ self.name = name self.node = node self.enter_f = enter_f self.exit_f = exit_f self.timer_f = timer_f self.timer_t = timer_t self.input = input if not hrr: self.hrr = _hrr.HRR(N=node.state_dims) else: self.hrr = hrr
def termination_input(self,value): if self.normalizing: h=hrr.HRR(data=value) length=h.length() if length>1.2: h=h*(1.2/length) value=h.v self.X=value
def output(trial_length, main, main_vector, alternate, noise_func=default_noise): tick = 0 vector = main_vector main_hrr = hrr.HRR(data=main_vector) while True: if tick == trial_length : tick = 0 if main: vector = main_vector else: vector = noise_func(main_vector) u = hrr.HRR(data=vector) similarity = u.compare(main_hrr) print "Sim:", similarity if alternate: main = not main tick += 1 yield vector
def ortho_vector(input_vec, normalize=False): """ Returns a random vector orthogonal to the input vector. Args: input_vec -- Returned vector will be orthogonal to input_vec normalize -- whether to normalize the vector before returning """ normed_input = input_vec / np.linalg.norm(input_vec) dim = len(input_vec) ortho = hrr.HRR(dim).v proj = np.dot(normed_input, ortho) * normed_input ortho -= proj assert np.allclose([np.dot(ortho, input_vec)], [0]) if normalize: ortho = ortho / np.linalg.norm(ortho) return ortho
def f(input_vec): input_vec = hrr.HRR(data=input_vec) partner_key = random.choice(keys) pair_keys = filter(lambda x: x != partner_key, keys) pairs = random.sample(pair_keys, 2 * num) p0 = (pairs[x] for x in range(0, len(pairs), 2)) p1 = (pairs[x] for x in range(1, len(pairs), 2)) S = map(lambda x, y: noise_vocab[x].convolve(noise_vocab[y]), p0, p1) S = reduce(lambda x, y: x + y, S, noise_vocab[partner_key].convolve(input_vec)) S.normalize() reconstruction = S.convolve(~noise_vocab[partner_key]) reconstruction.normalize() return reconstruction.v
def hrr_noise(input_vec): noise_vocab = hrr.Vocabulary(D) keys = [noise_vocab.parse(str(x)) for x in range(2*num+1)] input_vec = hrr.HRR(data=input_vec) partner_key = random.choice(keys) pair_keys = filter(lambda x: x != partner_key, keys) pairs = random.sample(pair_keys, 2 * num) p0 = (pairs[x] for x in range(0,len(pairs),2)) p1 = (pairs[x] for x in range(1,len(pairs),2)) S = map(lambda x, y: noise_vocab[x].convolve(noise_vocab[y]), p0, p1) S = reduce(lambda x, y: x + y, S, noise_vocab[partner_key].convolve(input_vec)) S.normalize() vec_hrr = S.convolve(~noise_vocab[partner_key]) similarity = vec_hrr.compare(input_vec) similarities.append(similarity) return vec_hrr.v
def hrr_noise_from_string(input_vec): """ Uses expression, names, query_vectors from wrapper function Args: input_vec -- the vector to add noise to. Can be an HRR vector or a numpy ndarry. Returns a noisy vector of the same type as input_vec. """ use_ndarray = type(input_vec) == np.ndarray if use_ndarray: input_vec = hrr.HRR(data=input_vec) vocab = hrr.Vocabulary(D, unitary=unitary_names) for n, v in names.iteritems(): vocab.add(n, v) vocab.add(placeholder, input_vec) try: h = eval(expression, {}, vocab) except Exception as e: print 'Error evaluating HRR string ' + original raise e if normalize: h.normalize() vocab.add('h', h) noisy = eval('h * ~(' + ' * '.join(query_vectors) + ')', {}, vocab) if use_ndarray: noisy = noisy.v return noisy
def termination_symbol(self, x, dimensions=dimensions): self.sym = hrr.HRR(data=x)
def termination_C(self, x, dimensions=dimensions): self.col = hrr.HRR(data=x)
def termination_R(self, x, dimensions=dimensions): self.row = hrr.HRR(data=x)
def termination_R(self, x, dimensions=dimensions): self.content_R = hrr.HRR(data=x)
def termination_vision(self, x, dimensions=dimensions): self.content = hrr.HRR(data=x)
def termination_identifier(self, x, dimensions=dimensions): self.x = hrr.HRR(data=x)
def termination_salience(self, x, dimensions=dimensions): self.pairs = hrr.HRR(data=x)
def termination_6(self, x, dimensions=dimensions): self.v6 = hrr.HRR(data=x)
order = list(range(len(m_inputs))) random.shuffle(order) # compute the semantic pointers for each digit by averaging the encoded values for each category vocab = hrr.Vocabulary(50) for i, label in enumerate([ 'ZERO', 'ONE', 'TWO', 'THREE', 'FOUR', 'FIVE', 'SIX', 'SEVEN', 'EIGHT', 'NINE' ]): v = numeric.array([0] * 50, typecode='f') count = 0 for j, yy in enumerate(m_inputsy): if yy[0] == i: v += m_encode[j] count += 1 sp = hrr.HRR(data=v / count) sp.normalize() vocab.add(label, sp) print label, sp.v class Input(nef.SimpleNode): def origin_image(self): # present the visual input to the model index = int(self.t / presentation_time) % len(order) return m_inputs[order[index]] def origin_exact(self): # the exact correct value (as computed by index = int(self.t / presentation_time) % len( order) # the non-spiking RBM model). Used for return m_encode[order[index]] # comparison purposes only
def f(input_vec): v = input_vec + noise * hrr.HRR(D).v v = v / np.sqrt(sum(v**2)) return v
""" num_unitary_wildcards = expression.count('?u') expression = expression.replace('?u', '%s') unitary_names = ['u'+str(i) for i in range(num_unitary_wildcards)] expression = expression % tuple(unitary_names) num_wildcards = expression.count('?') expression = expression.replace('?', '%s') temp_names = ['h'+str(i) for i in range(num_wildcards)] expression = expression % tuple(temp_names) return expression, unitary_names, temp_names if __name__ == "__main__": D = 512 i = hrr.HRR(D) f = make_hrr_noise_from_string(D, '?u*?u*?*!*?u') x = f(i) print i.compare(x) i = hrr.HRR(D) noise_string = '?*? *? + ? * ? * ? + ? * ? * ! + ?*?' f = make_hrr_noise_from_string(D, noise_string, normalize=False) x = f(i) print i.compare(x) i = hrr.HRR(D) noise_string = '? * ! + ? * ?' f = make_hrr_noise_from_string(D, noise_string, normalize=False) x = f(i) print i.compare(x)