def generate(data_folder, net=None, alpha=1000.0):
beta = alpha / 4.0
# generate the Function Space
forces, _, _ = forcing_functions.load_folder(data_folder,
rhythmic=True,
alpha=alpha,
beta=beta)
# make an array out of all the possible functions we want to represent
force_space = np.vstack(forces)
# use this array as our space to perform svd over
fs = nengo.FunctionSpace(space=force_space, n_basis=10)
# store the weights for each trajectory
weights_x = []
weights_y = []
for ii in range(len(forces)):
forces = force_space[ii * 2:ii * 2 + 2]
# load up the forces to be output by the forcing function
# calculate the corresponding weights over the basis functions
weights_x.append(np.dot(fs.basis.T, forces[0]))
weights_y.append(np.dot(fs.basis.T, forces[1]))
if net is None:
net = nengo.Network()
with net:
# --------------------- Inputs --------------------------
net.input = nengo.Node(size_in=2, label='input')
number = nengo.Node(output=[0], label='number')
# ------------------- Point Attractors --------------------
net.x = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(net.input[0], net.x.input[0], synapse=None)
net.y = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(net.input[1], net.y.input[0], synapse=None)
# -------------------- Oscillators ----------------------
kick = nengo.Node(nengo.utils.functions.piecewise({
0: 1,
.05: 0
}),
label='kick')
osc = oscillator.generate(net, n_neurons=2000, speed=.025)
osc.label = 'oscillator'
nengo.Connection(kick, osc[0])
# ------------------- Forcing Functions --------------------
def dmp_weights_func(t, x):
x = int(min(max(x, 0), len(forces)))
# load weights for generating this number's x and y forces
return np.hstack([weights_x[x], weights_y[x]])
# create input switch for generating weights for different numbers
# NOTE: this should be switched to an associative memory
dmp_weights_gen = nengo.Node(output=dmp_weights_func,
size_in=1,
size_out=fs.n_basis * 2,
label='dmp weights gen')
nengo.Connection(number, dmp_weights_gen)
# -------------------- Product for decoding -----------------------
product_x = nengo.Network('Product X')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_x,
input_magnitude=1.0)
product_y = nengo.Network('Product Y')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_y,
input_magnitude=1.0)
# get the largest basis function value for normalization
max_basis = np.max(fs.basis * fs.scale)
domain = np.linspace(-np.pi, np.pi, fs.basis.shape[0])
domain_cossin = np.array([np.cos(domain), np.sin(domain)]).T
for ff, product in zip(
[dmp_weights_gen[:fs.n_basis], dmp_weights_gen[fs.n_basis:]],
[product_x, product_y]):
for ii in range(fs.n_basis):
# find the value of a basis function at a value of (x, y)
target_function = nengo.utils.connection.target_function(
domain_cossin, fs.basis[:, ii] * fs.scale / max_basis)
nengo.Connection(osc, product.B[ii], **target_function)
# multiply the value of each basis function at x by its weight
nengo.Connection(ff, product.A)
nengo.Connection(product_x.output,
net.x.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
nengo.Connection(product_y.output,
net.y.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
# -------------------- Output ------------------------------
net.output = nengo.Node(size_in=2, label='output')
nengo.Connection(net.x.output, net.output[0])
nengo.Connection(net.y.output, net.output[1])
# create a node to give a plot of the represented function
ff_plot = fs.make_plot_node(domain=domain, lines=2, ylim=[-50, 50])
nengo.Connection(dmp_weights_gen[:fs.n_basis],
ff_plot[:fs.n_basis],
synapse=0.1)
nengo.Connection(dmp_weights_gen[fs.n_basis:],
ff_plot[fs.n_basis:],
synapse=0.1)
return net
domain = np.linspace(-1, 1, n_samples)
# define kinds of functions you'd like to represent
def gaussian(mag, mean, sd):
return mag * np.exp(-(domain - mean)**2 / (2 * sd**2))
# create a distribution for generating encoders and eval points
gaussian_space = nengo.dists.Function(gaussian,
mean=nengo.dists.Uniform(-1, 1),
sd=nengo.dists.Uniform(0.01, 0.1),
mag=nengo.dists.Uniform(-1, 1))
# build the function space, generate the basis functions
fs = nengo.FunctionSpace(gaussian_space, n_basis=30)
model = nengo.Network()
with model:
# ensemble that store weights over basis functions
# for the compressed function representation
weights = nengo.Ensemble(n_neurons=1500, dimensions=fs.n_basis, radius=5)
# set encoders to be sampled from weights for common functions
weights.encoders = fs.project(gaussian_space)
# set eval points to be sampled from weights for common functions
weights.eval_points = fs.project(gaussian_space)
# input to the stimulus population, whose output projects the
# compressed function representation weights into weights
# change stim_control for learning different functions in
if mean < domain_min:
mean += domain_range
try:
# Adding gaussians offset by the domain range to simulate cycling
return mag * ( np.exp(-(domain - mean)**2 / (2 * std**2)) +\
np.exp(-(domain - mean - domain_range)**2 / (2 * std**2)) +\
np.exp(-(domain - mean + domain_range)**2 / (2 * std**2))
)
except FloatingPointError:
return domain * 0
fs = nengo.FunctionSpace(nengo.dists.Function(gaussian,
mean=nengo.dists.Uniform(
domain_min, domain_max),
std=nengo.dists.Uniform(.1, .7),
mag=1),
n_basis=n_basis_1d)
fs2d = nengo.FunctionSpace(nengo.dists.Function(
gaussian2d,
mean_x=nengo.dists.Uniform(domain_min, domain_max),
mean_y=nengo.dists.Uniform(domain_min, domain_max),
std=nengo.dists.Uniform(.1, .7),
mag=1),
n_basis=n_basis_2d,
n_samples=n_samples)
model = nengo.Network(seed=13)
model.config[nengo.Ensemble].neuron_type = nengo.Direct(
) #TODO: temp, just use direct for debugging
ps_neuron_type = nengo.LIF(
def generate(input_signal, alpha=1000.0):
beta = alpha / 4.0
# Read in the class mean for numbers from vision network
weights_data = np.load('models/mnist_vision_data/params.npz')
weights = weights_data['Wc']
means_data = np.load('models/mnist_vision_data/class_means.npz')
means = np.matrix(1.0 / means_data['means'])
sps = np.multiply(weights.T, means.T)[:10]
sps_labels = [
'ZERO', 'ONE', 'TWO', 'THREE', 'FOUR', 'FIVE', 'SIX', 'SEVEN', 'EIGHT',
'NINE'
]
dimensions = weights.shape[0]
# generate the Function Space
forces, _, goals = forcing_functions.load_folder(
'models/handwriting_trajectories',
rhythmic=False,
alpha=alpha,
beta=beta)
# make an array out of all the possible functions we want to represent
force_space = np.vstack(forces)
# use this array as our space to perform svd over
fs = nengo.FunctionSpace(space=force_space, n_basis=10)
# store the weights for each number
weights_x = []
weights_y = []
for ii in range(len(goals)):
forces = force_space[ii * 2:ii * 2 + 2]
# load up the forces to be output by the forcing function
# calculate the corresponding weights over the basis functions
weights_x.append(np.dot(fs.basis.T, forces[0]))
weights_y.append(np.dot(fs.basis.T, forces[1]))
# Create our vocabularies
rng = np.random.RandomState(0)
vocab_vision = Vocabulary(dimensions=dimensions, rng=rng)
vocab_dmp_weights_x = Vocabulary(dimensions=fs.n_basis + 2, rng=rng)
vocab_dmp_weights_y = Vocabulary(dimensions=fs.n_basis + 2, rng=rng)
for label, sp, wx, wy, goal in zip(sps_labels, sps, weights_x, weights_y,
goals):
vocab_vision.add(label,
np.array(sp)[0] / np.linalg.norm(np.array(sp)[0]))
vocab_dmp_weights_x.add(label, np.hstack([wx, goal[0][0], goal[1][0]]))
vocab_dmp_weights_y.add(label, np.hstack([wy, goal[0][1], goal[1][1]]))
net = spa.SPA()
# net.config[nengo.Ensemble].neuron_type = nengo.Direct()
with net:
# def input_func(t):
# return vocab_vision.parse(input_signal).v
# net.input = nengo.Node(input_func, label='input')
net.input = spa.State(dimensions, subdimensions=10, vocab=vocab_vision)
time_func = lambda t: min(max((t * 2) % 4 - 2.5, -1), 1)
timer_node = nengo.Node(output=time_func, label='timer')
# ------------------- Point Attractors --------------------
def goals_func(t, x):
if (x[0] + 1) < 1e-5:
return x[1], x[2]
return x[3], x[4]
goal_node = nengo.Node(goals_func,
size_in=5,
size_out=2,
label='goals')
nengo.Connection(timer_node, goal_node[0])
net.x = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(goal_node[0], net.x.input[0], synapse=None)
net.y = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(goal_node[1], net.y.input[0], synapse=None)
# -------------------- Ramp ------------------------------
ramp_node = nengo.Node(output=time_func, label='ramp node')
ramp = nengo.Ensemble(n_neurons=1000, dimensions=1, label='ramp')
nengo.Connection(ramp_node, ramp)
# ------------------- Forcing Functions --------------------
net.assoc_mem_x = spa.AssociativeMemory(
input_vocab=vocab_vision,
output_vocab=vocab_dmp_weights_x,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_x.input)
nengo.Connection(net.assoc_mem_x.output[[-2, -1]], goal_node[[1, 3]])
net.assoc_mem_y = spa.AssociativeMemory(
input_vocab=vocab_vision,
output_vocab=vocab_dmp_weights_y,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_y.input)
nengo.Connection(net.assoc_mem_y.output[[-2, -1]], goal_node[[2, 4]])
# -------------------- Product for decoding -----------------------
net.product_x = nengo.Network('Product X')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=net.product_x,
input_magnitude=1.0)
net.product_y = nengo.Network('Product Y')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=net.product_y,
input_magnitude=1.0)
# get the largest basis function value for normalization
max_basis = np.max(fs.basis * fs.scale)
domain = np.linspace(-1, 1, fs.basis.shape[0])
for ff, product in zip(
[net.assoc_mem_x.output, net.assoc_mem_y.output],
[net.product_x, net.product_y]):
for ii in range(fs.n_basis):
# find the value of a basis function at a value of x
def basis_fn(x, jj=ii):
index = int(x[0] * len(domain) / 2.0 + len(domain) / 2.0)
index = max(min(index, len(domain) - 1), 0)
return fs.basis[index][jj] * fs.scale / max_basis
# multiply the value of each basis function at x by its weight
nengo.Connection(ramp, product.B[ii], function=basis_fn)
nengo.Connection(ff[ii], product.A[ii])
def relay_func(t, x):
t = time_func(t)
if t <= -1:
return [0, 0]
return x
relay = nengo.Node(output=relay_func,
size_in=2,
size_out=2,
label='relay')
nengo.Connection(net.product_x.output,
relay[0],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
nengo.Connection(net.product_y.output,
relay[1],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
nengo.Connection(relay[0], net.x.input[1], synapse=None)
nengo.Connection(relay[1], net.y.input[1], synapse=None)
# -------------------- Output ------------------------------
net.output = nengo.Node(size_in=2)
nengo.Connection(net.x.output, net.output[0], synapse=0.01)
nengo.Connection(net.y.output, net.output[1], synapse=0.01)
# create a node to give a plot of the represented function
ff_plot = fs.make_plot_node(domain=domain, lines=2, ylim=[-75, 75])
nengo.Connection(net.assoc_mem_x.output[:fs.n_basis],
ff_plot[:fs.n_basis],
synapse=0.1)
nengo.Connection(net.assoc_mem_y.output[:fs.n_basis],
ff_plot[fs.n_basis:],
synapse=0.1)
return net
if mean < domain_min:
mean += domain_range
try:
# Adding gaussians offset by the domain range to simulate cycling
return mag * ( np.exp(-(domain - mean)**2 / (2 * std**2)) +\
np.exp(-(domain - mean - domain_range)**2 / (2 * std**2)) +\
np.exp(-(domain - mean + domain_range)**2 / (2 * std**2))
)
except FloatingPointError:
return domain * 0
fs = nengo.FunctionSpace(nengo.dists.Function(gaussian,
mean=nengo.dists.Uniform(
domain_min, domain_max),
std=nengo.dists.Uniform(.1, .7),
mag=1),
n_basis=10)
model = nengo.Network(seed=13)
model.config[nengo.Ensemble].neuron_type = nengo.Direct(
) #TODO: temp, just use direct for debugging
ps_neuron_type = nengo.LIF() # neuron type for posecells
with model:
# Node that handles ROS communication
# in: best_x, best_y, best_th
# out: vtrans, vrot, stim_x, stim_y, stim_th, energy
if __name__ == '__main__':
posecell_node = nengo.Node(NengoPosecellNetwork(),
size_in=3,
def generate(input_signal, alpha=1000.0):
beta = alpha / 4.0
# Read in the class mean for numbers from vision network
weights_data = np.load('models/mnist_vision_data/params.npz')
weights = weights_data['Wc']
means_data = np.load('models/mnist_vision_data/class_means.npz')
means = np.matrix(1.0 / means_data['means'])
sps = np.multiply(weights.T, means.T)[:10]
sps_labels = [
'ZERO', 'ONE', 'TWO', 'THREE', 'FOUR',
'FIVE', 'SIX', 'SEVEN', 'EIGHT', 'NINE']
dimensions = weights.shape[0]
# generate the Function Space
forces, _, _ = forcing_functions.load_folder(
'models/handwriting_trajectories', rhythmic=True,
alpha=alpha, beta=beta)
# make an array out of all the possible functions we want to represent
force_space = np.vstack(forces)
# use this array as our space to perform svd over
fs = nengo.FunctionSpace(space=force_space, n_basis=10)
# store the weights for each trajectory
weights_x = []
weights_y = []
for ii in range(len(forces)):
forces = force_space[ii*2:ii*2+2]
# load up the forces to be output by the forcing function
# calculate the corresponding weights over the basis functions
weights_x.append(np.dot(fs.basis.T, forces[0]))
weights_y.append(np.dot(fs.basis.T, forces[1]))
# Create our vocabularies
rng = np.random.RandomState(0)
vocab_vision = Vocabulary(dimensions=dimensions, rng=rng)
vocab_dmp_weights_x = Vocabulary(dimensions=fs.n_basis, rng=rng)
vocab_dmp_weights_y = Vocabulary(dimensions=fs.n_basis, rng=rng)
for label, sp, wx, wy in zip(
sps_labels, sps, weights_x, weights_y):
vocab_vision.add(
label, np.array(sp)[0] / np.linalg.norm(np.array(sp)[0]))
vocab_dmp_weights_x.add(label, wx)
vocab_dmp_weights_y.add(label, wy)
net = spa.SPA()
# net.config[nengo.Ensemble].neuron_type = nengo.Direct()
with net:
# --------------------- Inputs --------------------------
# def input_func(t):
# return vocab_vision.parse(input_signal).v
# net.input = nengo.Node(input_func, label='input')
net.input = spa.State(dimensions, subdimensions=10,
vocab=vocab_vision)
number = nengo.Node(output=[0], label='number')
# ------------------- Point Attractors --------------------
net.x = point_attractor.generate(
n_neurons=1000, alpha=alpha, beta=beta)
net.y = point_attractor.generate(
n_neurons=1000, alpha=alpha, beta=beta)
# -------------------- Oscillators ----------------------
kick = nengo.Node(nengo.utils.functions.piecewise({0: 1, .05: 0}),
label='kick')
osc = oscillator.generate(net, n_neurons=2000, speed=.05)
osc.label = 'oscillator'
nengo.Connection(kick, osc[0])
# ------------------- Forcing Functions --------------------
net.assoc_mem_x = spa.AssociativeMemory(
input_vocab=vocab_vision,
output_vocab=vocab_dmp_weights_x,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_x.input)
net.assoc_mem_y = spa.AssociativeMemory(
input_vocab=vocab_vision,
output_vocab=vocab_dmp_weights_y,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_y.input)
# -------------------- Product for decoding -----------------------
net.product_x = nengo.Network('Product X')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=net.product_x,
input_magnitude=1.0)
net.product_y = nengo.Network('Product Y')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=net.product_y,
input_magnitude=1.0)
# get the largest basis function value for normalization
max_basis = np.max(fs.basis*fs.scale)
domain = np.linspace(-np.pi, np.pi, fs.basis.shape[0])
domain_cossin = np.array([np.cos(domain), np.sin(domain)]).T
for ff, product in zip([net.assoc_mem_x.output,
net.assoc_mem_y.output],
[net.product_x, net.product_y]):
for ii in range(fs.n_basis):
# find the value of a basis function at a value of (x, y)
target_function = nengo.utils.connection.target_function(
domain_cossin, fs.basis[:, ii]*fs.scale/max_basis)
nengo.Connection(osc, product.B[ii], **target_function)
# multiply the value of each basis function at x by its weight
nengo.Connection(ff, product.A)
nengo.Connection(net.product_x.output, net.x.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
nengo.Connection(net.product_y.output, net.y.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
# -------------------- Output ------------------------------
net.output = nengo.Node(size_in=2, label='output')
nengo.Connection(net.x.output, net.output[0])
nengo.Connection(net.y.output, net.output[1])
# create a node to give a plot of the represented function
ff_plot = fs.make_plot_node(domain=domain, lines=2,
ylim=[-1000000, 1000000])
nengo.Connection(net.assoc_mem_x.output,
ff_plot[:fs.n_basis], synapse=0.1)
nengo.Connection(net.assoc_mem_y.output,
ff_plot[fs.n_basis:], synapse=0.1)
return net
def generate(input_signal, alpha=1000.0):
beta = alpha / 4.0
# generate the Function Space
forces, _, goals = forcing_functions.load_folder(
'models/locomotion_trajectories',
rhythmic=True,
alpha=alpha,
beta=beta)
# make an array out of all the possible functions we want to represent
force_space = np.vstack(forces)
# use this array as our space to perform svd over
fs = nengo.FunctionSpace(space=force_space, n_basis=10)
# store the weights for each movement
weights_a = [] # ankle
weights_k = [] # knee
weights_h = [] # hip
# NOTE: things are added to weights based on the order files are read
for ii in range(int(len(goals) / 6)):
forces = force_space[ii * 6:ii * 6 + 6]
# load up the forces to be output by the forcing function
# calculate the corresponding weights over the basis functions
weights_a.append(
np.hstack([
np.dot(fs.basis.T, forces[0]), # ankle 1
np.dot(fs.basis.T, forces[1])
])) # ankle 2
weights_h.append(
np.hstack([
np.dot(fs.basis.T, forces[2]), # hip 1
np.dot(fs.basis.T, forces[3])
])) # hip 2
weights_k.append(
np.hstack([
np.dot(fs.basis.T, forces[4]), # knee 1
np.dot(fs.basis.T, forces[5])
])) # knee 2
# Create our vocabularies
sps_labels = ['GALLOP', 'RUNNING', 'WALKING']
rng = np.random.RandomState(0)
dimensions = 50 # some arbitrary number
vocab_input = Vocabulary(dimensions=dimensions, rng=rng)
vocab_dmp_weights_a = Vocabulary(dimensions=fs.n_basis * 2, rng=rng)
vocab_dmp_weights_k = Vocabulary(dimensions=fs.n_basis * 2, rng=rng)
vocab_dmp_weights_h = Vocabulary(dimensions=fs.n_basis * 2, rng=rng)
for ii, (label, wa, wk,
wh) in enumerate(zip(sps_labels, weights_a, weights_k,
weights_h)):
vocab_input.parse(label) # randomly generate input vector
vocab_dmp_weights_a.add(label, wa)
vocab_dmp_weights_k.add(label, wk)
vocab_dmp_weights_h.add(label, wh)
net = spa.SPA()
net.config[nengo.Ensemble].neuron_type = nengo.LIFRate()
with net:
config = nengo.Config(nengo.Ensemble)
config[nengo.Ensemble].neuron_type = nengo.Direct()
with config:
# --------------------- Inputs --------------------------
# def input_func(t):
# return vocab_input.parse(input_signal).v
# net.input = nengo.Node(input_func)
net.input = spa.State(dimensions,
subdimensions=10,
vocab=vocab_input)
# ------------------- Point Attractors --------------------
zero = nengo.Node([0])
net.a1 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.a1.input[0], synapse=None)
net.a2 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.a1.input[0], synapse=None)
net.k1 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.k1.input[0], synapse=None)
net.k2 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.k2.input[0], synapse=None)
net.h1 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.h1.input[0], synapse=None)
net.h2 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.h2.input[0], synapse=None)
# -------------------- Oscillators ----------------------
kick = nengo.Node(nengo.utils.functions.piecewise({
0: 1,
.05: 0
}),
label='kick')
osc = oscillator.generate(net, n_neurons=3000, speed=.01)
osc.label = 'oscillator'
nengo.Connection(kick, osc[0])
# ------------------- Forcing Functions --------------------
with config:
net.assoc_mem_a = spa.AssociativeMemory(
input_vocab=vocab_input,
output_vocab=vocab_dmp_weights_a,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_a.input)
net.assoc_mem_k = spa.AssociativeMemory(
input_vocab=vocab_input,
output_vocab=vocab_dmp_weights_k,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_k.input)
net.assoc_mem_h = spa.AssociativeMemory(
input_vocab=vocab_input,
output_vocab=vocab_dmp_weights_h,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_h.input)
# -------------------- Product for decoding -----------------------
product_a1 = nengo.Network('Product A1')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_a1)
product_a2 = nengo.Network('Product A2')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_a2)
product_h1 = nengo.Network('Product H1')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_h1)
product_h2 = nengo.Network('Product H2')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_h2)
product_k1 = nengo.Network('Product K1')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_k1)
product_k2 = nengo.Network('Product K2')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_k2)
# get the largest basis function value for normalization
max_basis = np.max(fs.basis * fs.scale)
domain = np.linspace(-np.pi, np.pi, fs.basis.shape[0])
domain_cossin = np.array([np.cos(domain), np.sin(domain)]).T
for ff, product in zip([
net.assoc_mem_a.output[:fs.n_basis],
net.assoc_mem_a.output[fs.n_basis:],
net.assoc_mem_k.output[:fs.n_basis],
net.assoc_mem_k.output[fs.n_basis:],
net.assoc_mem_h.output[:fs.n_basis],
net.assoc_mem_h.output[fs.n_basis:]
], [
product_a1, product_a2, product_k1, product_k2, product_h1,
product_h2
]):
for ii in range(fs.n_basis):
# find the value of a basis function at a value of (x, y)
target_function = nengo.utils.connection.target_function(
domain_cossin, fs.basis[:, ii] * fs.scale / max_basis)
nengo.Connection(osc, product.B[ii], **target_function)
# multiply the value of each basis function at x by its weight
nengo.Connection(ff, product.A)
nengo.Connection(product_a1.output,
net.a1.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
nengo.Connection(product_a2.output,
net.a2.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
nengo.Connection(product_k1.output,
net.k1.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
nengo.Connection(product_k2.output,
net.k2.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
nengo.Connection(product_h1.output,
net.h1.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
nengo.Connection(product_h2.output,
net.h2.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
# -------------------- Output ------------------------------
net.output = nengo.Node(size_in=6, label='output')
nengo.Connection(net.a1.output, net.output[0], synapse=0.01)
nengo.Connection(net.a2.output, net.output[1], synapse=0.01)
nengo.Connection(net.k1.output, net.output[2], synapse=0.01)
nengo.Connection(net.k2.output, net.output[3], synapse=0.01)
nengo.Connection(net.h1.output, net.output[4], synapse=0.01)
nengo.Connection(net.h2.output, net.output[5], synapse=0.01)
# add in the goal offsets
nengo.Connection(net.assoc_mem_a.output[[-2, -1]],
net.output[[0, 1]],
synapse=None)
nengo.Connection(net.assoc_mem_k.output[[-2, -1]],
net.output[[2, 3]],
synapse=None)
nengo.Connection(net.assoc_mem_h.output[[-2, -1]],
net.output[[4, 5]],
synapse=None)
# create a node to give a plot of the represented function
ff_plot_a = fs.make_plot_node(domain=domain,
lines=2,
ylim=[-1000000, 1000000])
nengo.Connection(net.assoc_mem_a.output, ff_plot_a, synapse=0.1)
ff_plot_k = fs.make_plot_node(domain=domain,
lines=2,
ylim=[-1000000, 1000000])
nengo.Connection(net.assoc_mem_k.output, ff_plot_k, synapse=0.1)
ff_plot_h = fs.make_plot_node(domain=domain,
lines=2,
ylim=[-1000000, 1000000])
nengo.Connection(net.assoc_mem_h.output, ff_plot_h, synapse=0.1)
return net
pZA = prior
logpZA = np.log(pZA)
M = len(prior)
# --------------------------------------------------------------------------------- #
## MODEL
for index in range(num_iterations):
def prior_space():
idx = np.random.randint(0, len(pZA))
return pZA[idx]
n_basis = 20
space = nengo.FunctionSpace(nengo.dists.Function(prior_space),
n_basis=n_basis)
from copy import deepcopy
space_raw = deepcopy(space.space)
### ----------------------------------------------------------------------------------------------- #
# initial input
global p, i, k, spy
i = 0
k = 0
srch_space = M
beta = 0.65
dt = 0.001
return post
ages = np.linspace(start=1, stop=100, num=100, dtype=np.int32)
data = {}
n_basis = 20
for x in ages:
if x < 5:
pad = 5 - x + 1
else:
pad = 0
# define sub-spaces
space = nengo.FunctionSpace(nengo.dists.Function(
skew_gauss,
skew=nengo.dists.Uniform(skew - 1, skew + 2),
loc=nengo.dists.Uniform(loc - 1, loc + 2),
scale=nengo.dists.Uniform(scale - 1, scale + 2)),
n_basis=n_basis)
from copy import deepcopy
space_raw = deepcopy(space.space)
lik_space = nengo.FunctionSpace(nengo.dists.Function(likelihood,
x=nengo.dists.Uniform(
x - 5 + pad,
x + 5 + pad)),
n_basis=n_basis)
lik_space_raw = deepcopy(lik_space.space)
post_space = nengo.FunctionSpace(nengo.dists.Function(
def generate(data_folder, net=None, alpha=1000.0):
beta = alpha / 4.0
# generate the Function Space
forces, _, goals = forcing_functions.load_folder(data_folder,
rhythmic=False,
alpha=alpha,
beta=beta)
# make an array out of all the possible functions we want to represent
force_space = np.vstack(forces)
# use this array as our space to perform svd over
fs = nengo.FunctionSpace(space=force_space, n_basis=10)
range_goals = np.array(range(len(goals)))
# store the weights for each number
weights_x = []
weights_y = []
for ii in range(len(goals)):
forces = force_space[ii * 2:ii * 2 + 2]
# load up the forces to be output by the forcing function
# calculate the corresponding weights over the basis functions
weights_x.append(np.dot(fs.basis.T, forces[0]))
weights_y.append(np.dot(fs.basis.T, forces[1]))
if net is None:
net = nengo.Network()
# net.config[nengo.Ensemble].neuron_type = nengo.Direct()
with net:
time_func = lambda t: min(max((t * 2) % 4 - 2.5, -1), 1)
timer_node = nengo.Node(output=time_func)
net.number = nengo.Node(output=lambda t, x: x / (len(goals) / 2.0) - 1,
size_in=1,
size_out=1)
# ------------------- Point Attractors --------------------
goal_net = goal_network.generate(goals)
nengo.Connection(net.number, goal_net.input)
nengo.Connection(timer_node, goal_net.inhibit_node)
net.x = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(goal_net.output[0], net.x.input[0], synapse=None)
net.y = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(goal_net.output[1], net.y.input[0], synapse=None)
# -------------------- Ramp ------------------------------
ramp_node = nengo.Node(output=time_func)
ramp = nengo.Ensemble(n_neurons=1000, dimensions=1, label='ramp')
nengo.Connection(ramp_node, ramp)
# ------------------- Forcing Functions --------------------
# n_basis_functions dimensions to represent the weights, + 1 to
# represent the x position to decode from
ff_x = nengo.Ensemble(n_neurons=1000,
dimensions=fs.n_basis,
radius=np.sqrt(fs.n_basis))
ff_y = nengo.Ensemble(n_neurons=1000,
dimensions=fs.n_basis,
radius=np.sqrt(fs.n_basis))
def dmp_weights_func(x, x_or_y):
# find the nearest value
num = range_goals[min(
max(
np.abs(range_goals -
((x + 1) * len(goals) / 2.0)).argmin(), 0),
len(goals))]
# load weights for generating this number's x and y forces
if x_or_y == 'x':
return weights_x[num]
elif x_or_y == 'y':
return weights_y[num]
# generate weights for different numbers
dmp_weights_gen = nengo.Ensemble(n_neurons=2000,
dimensions=1,
label='dmp_weights_gen')
nengo.Connection(net.number, dmp_weights_gen)
nengo.Connection(dmp_weights_gen,
ff_x,
function=lambda x: dmp_weights_func(x, x_or_y='x'),
synapse=.01)
nengo.Connection(dmp_weights_gen,
ff_y,
function=lambda x: dmp_weights_func(x, x_or_y='y'),
synapse=.01)
# -------------------- Product for decoding -----------------------
product_x = nengo.Network('Product X')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_x)
product_y = nengo.Network('Product Y')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_y)
# get the largest basis function value for normalization
max_basis = np.max(fs.basis * fs.scale)
domain = np.linspace(-1, 1, fs.basis.shape[0])
for ff, product in zip([ff_x, ff_y], [product_x, product_y]):
for ii in range(fs.n_basis):
# find the value of a basis function at a value of x
def basis_fn(x, jj=ii):
index = int(x[0] * len(domain) / 2.0 + len(domain) / 2.0)
index = max(min(index, len(domain) - 1), 0)
return fs.basis[index][jj] * fs.scale / max_basis
# multiply the value of each basis function at x by its weight
nengo.Connection(ramp, product.B[ii], function=basis_fn)
nengo.Connection(ff[ii], product.A[ii])
def relay_func(t, x):
t = time_func(t)
if t <= -1:
return [0, 0]
return x
relay = nengo.Node(output=relay_func, size_in=2, size_out=2)
nengo.Connection(product_x.output,
relay[0],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
nengo.Connection(product_y.output,
relay[1],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
nengo.Connection(relay[0], net.x.input[1], synapse=None)
nengo.Connection(relay[1], net.y.input[1], synapse=None)
# -------------------- Output ------------------------------
net.output = nengo.Node(size_in=2)
nengo.Connection(net.x.output, net.output[0], synapse=0.01)
nengo.Connection(net.y.output, net.output[1], synapse=0.01)
# create a node to give a plot of the represented function
ff_plot = fs.make_plot_node(domain=domain, lines=2, ylim=[-50, 50])
nengo.Connection(ff_x, ff_plot[:fs.n_basis], synapse=0.1)
nengo.Connection(ff_y, ff_plot[fs.n_basis:], synapse=0.1)
return net
