def simulations():
# Setting Seeds
seeds = uniform(0, 10000, 1).astype(int)
# sine-wave target
target = lambda t0: cos(2 * pi * t0 / 10)
#Simulation parameters for FORCE
dt = .01 # time step
tmax = 100 # simulation length
tstop = 50 # learning stop time
g = 1.5 # gain factor?
N = 300 # size of stochastic pool
lr = 1 # learning rate
rho = 100 # SFORCE sharpness factor
errors = []
for seedling in seeds:
J, Wz, _, x0, u, w = seedutil.set_simulation_parameters(
seedling, N, 1, (.1, 1, 1))
# inp & z are dummy variables
def model(t0, x, tanh_x, inp, z):
return -x + g * dot(J, tanh_x) + Wz * z
x, t, z, _, wu, _ = jedi.force(target, model, lr, dt, tmax, tstop, x0,
w)
error = np.abs(z[0] - target(t))
errors.append(error)
errors = np.array(errors)
def main(seed, sig):
# Setting Seeds
seeds = seedutil.load_seeds("main_seeds.npy", "../../../data/stability")
if seed is not None:
seeds = seeds[:seed]
# sine-wave target
target = lambda t0: np.cos(2 * np.pi * t0/.5)
#Simulation parameters for FORCE
parameters = {}
parameters['dt'] = dt =.01 # time step
parameters['tmax'] = tmax = 10 # simulation length
parameters['tstop'] = tstop = 5 # learning stop time
parameters['tstart'] = tstart = 0 # learning start
parameters['N'] = N = 300 # size of stochastic pool
parameters['lr'] = lr = 1 # learning rate
parameters['rho'] = rho = 1.25 # spectral radius of J
parameters['sparsity'] = sparsity = (.1, 1, 1) # weight sparsity
errors = []
derrors = []
zs = []
dzs = []
for seedling in seeds:
J, Wz, _, x0, u, w = init_tools.set_simulation_parameters(seedling, N, 1, p=sparsity, rho=rho)
# inp & z are dummy variables
def model(t0, x, params):
tanh_x = params['tanh_x']
z = params['z']
return (-x + np.dot(J, tanh_x) + Wz*z)/dt
x, t, z, _, wu,_ = jedi.force(target, model, lr, dt, tmax, tstart, tstop, x0, w)
zs.append(z)
error = z-target(t)
errors.append(error)
x, t, z, _, wu,_ = jedi.dforce(jedi.step_decode, target, model, lr, dt, tmax, tstart, tstop, x0, w)
dzs.append(z)
derror = z-target(t)
derrors.append(derror)
try:
parameters['t'] = t
except NameError:
print "t was not defined; check seed args and script for errors"
noiseless_errors = {}
noiseless_errors['parameters'] = parameters
noiseless_errors['force'] = (errors, zs)
noiseless_errors['dforce'] = (derrors, dzs)
cPickle.dump(noiseless_errors, open("../../../data/stability/sin/base/base.p", "wb"))
if run_force:
# Checkpoint timer
timer = time.time()
for seed_num, seedling in enumerate(seeds):
J, Wz, _, x0, u, w = init_tools.set_simulation_parameters(seedling, N, I, pE=pE, p=sparsity, rho=rho)
# inp & z are dummy variables
def model(t0, x, params):
z = params['z']
tanh_x = params['tanh_x']
return (-x + dot(J, tanh_x) + Wz*z)/dt
x, t, z, _, wu,_ = jedi.force(targets, model, lr, dt, tmax, tstart, tstop, x0, w, 0)
xs.append(x)
zs.append(z)
wus.append(wu)
if verbose:
print "MC simulation %d complete." % seed_num
if seed_num % checkpoint == 0 and seed_num != 0:
xs = np.array(xs)
zs = np.array(zs)
wus = np.array(wus)
np.save(''.join(['../data/stability/lorenz/x/FORCE_xs_',
str(seed_num-checkpoint+1), '-', str(seed_num)]), xs)
def main(argv):
# Loading seeds
seeds = seedutil.load_seeds('main_seeds.npy', dir='../data/stability')
# Inputs and targets
targets = np.load("../data/stability/flipflop/targets_tmax10sec.npy")
inputs = np.load("../data/stability/flipflop/inputs_tmax10sec.npy")
I = 1
# Simulation parameters for FORCE
parameters = {}
parameters['dt'] = dt =.01 # time step
parameters['tmax'] = tmax = 10 # simulation length
parameters['tstop'] = tstop = 5 # learning stop time
parameters['tstart'] = tstart = 0 # learning start
parameters['N'] = N = 300 # size of stochastic pool
parameters['lr'] = lr = 1 # learning rate
parameters['rho'] = rho = 1.02 # spectral radius of J
parameters['pE'] = pE = .8 # excitatory percent
parameters['sparsity'] = sparsity = (.1,1,1) # weight sparsity
xs = []
zs = []
wus = []
# Script variables
send_email = False
ucsd_email = True
checkpoint = 100
run_dforce = True
run_force = True
write_params = True
verbose = False
if write_params:
param_file = open('../data/stability/flipflop/parameters.txt', 'w')
for key in parameters:
param_file.write(": ".join([key, str(parameters[key])]))
param_file.write('\n')
param_file.close()
# Seed subselection
seeds = seeds[:]
if run_force:
# Checkpoint timer
timer = time.time()
for seed_num, seedling in enumerate(seeds):
J, Wz, Wi, x0, u, w = init_tools.set_simulation_parameters(seedling, N, I, pE=pE, p=sparsity, rho=rho)
# inp & z are dummy variables
def model(t0, x, params):
z = params['z']
tanh_x = params['tanh_x']
inp = params['inputs']
return (-x + dot(J, tanh_x) + dot(Wi, inp) + Wz*z)/dt
x, t, z, _, wu, _ = jedi.force(targets, model, lr, dt, tmax, tstart, tstop, x0, w, 0, inputs=inputs)
xs.append(x)
zs.append(z)
wus.append(wu)
if verbose:
print "MC simulation %d complete." % seed_num
if seed_num % checkpoint == 0 and seed_num != 0:
xs = np.array(xs)
zs = np.array(zs)
wus = np.array(wus)
np.save(''.join(['../data/stability/flipflop/x/FORCE_xs_',
str(seed_num-checkpoint+1), '-', str(seed_num)]), xs)
np.save(''.join(['../data/stability/flipflop/z/FORCE_zs_',
str(seed_num-checkpoint+1), '-', str(seed_num)]), zs)
np.save(''.join(['../data/stability/flipflop/wu/FORCE_wus_',
str(seed_num-checkpoint+1), '-', str(seed_num)]), wus)
if send_email:
mailer.mail(argv, timer, seed_num, len(seeds), ucsd_email)
timer = time.time()
del xs, zs, wus
xs = []
zs = []
wus = []
if xs is not []:
xs = np.array(xs)
zs = np.array(zs)
wus = np.array(wus)
np.save(''.join(['../data/stability/flipflop/x/FORCE_xs_',
str(seed_num-len(xs)+1), '-', str(seed_num)]), xs)
np.save(''.join(['../data/stability/flipflop/z/FORCE_zs_',
str(seed_num-len(xs)+1), '-', str(seed_num)]), zs)
np.save(''.join(['../data/stability/flipflop/wu/FORCE_wus_',
str(seed_num-len(xs)+1), '-', str(seed_num)]), wus)
if send_email:
mailer.mail(argv, timer, seed_num, len(seeds), ucsd_email)
np.save('../data/stability/flipflop/t.npy', t)
if run_dforce:
xs = []
zs = []
wus = []
timer = time.time()
for seed_num, seedling in enumerate(seeds):
J, Wz, Wi, x0, u, w = init_tools.set_simulation_parameters(seedling, N, I, pE=pE, p=sparsity, rho=rho)
# inp & z are dummy variables
def model(t0, x, params):
z = params['z']
tanh_x = params['tanh_x']
inp = params['inputs']
return (-x + dot(J, tanh_x) + dot(Wi, inp) + Wz*z)/dt
x, t, z, _, wu, _ = jedi.dforce(jedi.step_decode, targets, model, lr, dt, tmax, tstart,
tstop, x0, w, 0, inputs=inputs)
xs.append(x)
zs.append(z)
wus.append(wu)
if verbose:
print "MC simulation %d complete." % seed_num
if seed_num % checkpoint == 0 and seed_num != 0:
xs = np.array(xs)
zs = np.array(zs)
wus = np.array(wus)
np.save(''.join(['../data/stability/flipflop/x/DFORCE_xs_',
str(seed_num-checkpoint+1), '-', str(seed_num)]), xs)
np.save(''.join(['../data/stability/flipflop/z/DFORCE_zs_',
str(seed_num-checkpoint+1), '-', str(seed_num)]), zs)
np.save(''.join(['../data/stability/flipflop/wu/DFORCE_wus_',
str(seed_num-checkpoint+1), '-', str(seed_num)]), wus)
if send_email:
mailer.mail(argv, timer, seed_num, len(seeds), ucsd_email)
timer = time.time()
del xs, zs, wus
xs = []
zs = []
wus = []
if xs is not []:
xs = np.array(xs)
zs = np.array(zs)
wus = np.array(wus)
np.save(''.join(['../data/stability/flipflop/x/DFORCE_xs_',
str(seed_num-len(xs)+1), '-', str(seed_num)]), xs)
np.save(''.join(['../data/stability/flipflop/z/DFORCE_zs_',
str(seed_num-len(xs)+1), '-', str(seed_num)]), zs)
np.save(''.join(['../data/stability/flipflop/wu/DFORCE_wus_',
str(seed_num-len(xs)+1), '-', str(seed_num)]), wus)
if send_email:
mailer.mail(argv, timer, seed_num, len(seeds), ucsd_email)
def main(seed):
# Setting Seeds
seeds = seedutil.load_seeds("main_seeds.npy", "../../../data/stability")
if seed is not None:
seeds = seeds[:seed]
#Simulation parameters for FORCE
parameters = {}
parameters['dt'] = dt = .01 # time step
parameters['tstart'] = tstart = 0 # learning start
parameters['N'] = N = 300 # size of stochastic pool
parameters['lr'] = lr = 1 # learning rate
parameters['rho'] = rho = 1.02 # spectral radius of J
parameters['pE'] = pE = .8 # excitatory percent
parameters['sparsity'] = sparsity = (.1, 1, 1) # weight sparsity
parameters['noise_int_var'] = noise_var = .3
parameters['trial_num'] = trial_num = 10
parameters['start_validate'] = start_validate = 7
# Romo task parameters
params = {
'callback_results': None,
'target_output': True,
'minibatch_index': 1,
'best_costs': None,
'name': "gradient"
}
noise_errors = {}
noise_errors['parameters'] = parameters
noise_errors['seeds'] = seeds
rng = np.random.RandomState(seeds[0])
parameters['trials'] = trials = [
romo.generate_trial(rng, 5, params) for _ in range(10)
]
for seedling in seeds:
J, Wz, Wi, x0, u, w = init_tools.set_simulation_parameters(seedling,
N,
1,
pE=pE,
p=sparsity,
rho=rho)
def model(t0, x, params):
index = params['index']
z = params['z']
tanh_x = params['tanh_x']
inp = params['inputs'][index]
return (-x + np.dot(J, tanh_x) + np.dot(Wi, inp) + Wz * z) / dt
errors_noise = []
derrors_noise = []
zs_noise = []
dzs_noise = []
w_ = None
for trial_num, trial in enumerate(trials):
targets = trial['outputs'][:, 1]
inputs = trial['inputs'][:, 1]
tmax = float(len(targets)) / 100 - .01
#Noise matrix
int_noise_mat = np.array([
np.random.normal(0, noise_var, N) for i in range(len(targets))
])
if trial_num >= start_validate:
tstop = .5 * tmax
else:
tstop = tmax
if w_ is not None:
w = w_
x0 = x[-1]
x, t, z, _, wu, _ = jedi.force(targets,
model,
lr,
dt,
tmax,
tstart,
tstop,
x0,
w,
inputs=inputs,
noise=int_noise_mat)
z = z[1:]
zs_noise.append(z)
error = z - np.array(targets)
errors_noise.append(error)
x, t, z, _, wu, _ = jedi.dforce(jedi.step_decode,
targets,
model,
lr,
dt,
tmax,
tstart,
tstop,
x0,
w,
pE=pE,
inputs=inputs,
noise=int_noise_mat)
z = z[1:]
dzs_noise.append(z)
derror = z - np.array(targets)
derrors_noise.append(derror)
noise_errors[seedling] = {}
noise_errors[seedling]['force'] = (errors_noise, zs_noise)
noise_errors[seedling]['dforce'] = (derrors_noise, dzs_noise)
cPickle.dump(
noise_errors,
open(
"../../../data/stability/romo/internal_noise/noise_var_" +
str(noise_var) + ".p", "wb"))
def main(seed):
# Setting Seeds
seeds = seedutil.load_seeds("main_seeds.npy", "../../../data/stability")
if seed is not None:
seeds = seeds[:seed]
# sine-wave target
target = lambda t0: np.cos(2 * np.pi * t0 / .5)
#Simulation parameters for FORCE
parameters = {}
parameters['dt'] = dt = .01 # time step
parameters['tmax'] = tmax = 10 # simulation length
parameters['tstop'] = tstop = 5 # learning stop time
parameters['tstart'] = tstart = 0 # learning start
parameters['N'] = N = 300 # size of stochastic pool
parameters['lr'] = lr = 1 # learning rate
parameters['rho'] = rho = 1.25 # spectral radius of J
parameters['pE'] = pE = .8 # excitatory percent
parameters['sparsity'] = sparsity = (.1, 1, 1) # weight sparsity
parameters['t_count'] = t_count = int(tmax / dt +
2) # number of time steps
parameters['noise_int_var'] = noise_int_var = .35
parameters['noise'] = noise = 'pink'
#Noise matrix
if noise == 'normal':
int_noise_mat = np.array(
[np.random.normal(0, noise_int_var, N) for _ in range(t_count)])
elif noise == 'pink':
int_noise_mat = np.array(
[noise_gen.voss(N, noise_int_var) for _ in range(t_count)])
errors_noise = []
derrors_noise = []
zs_noise = []
dzs_noise = []
for seedling in seeds:
J, Wz, _, x0, u, w = init_tools.set_simulation_parameters(seedling,
N,
1,
pE=pE,
p=sparsity,
rho=rho)
# inp & z are dummy variables
def model(t0, x, params):
index = params['index']
tanh_x = params['tanh_x']
z = params['z']
noise = params['noise'][index]
return (-x + np.dot(J, tanh_x) + Wz * z + noise) / dt
x, t, z, _, wu, _ = jedi.force(target,
model,
lr,
dt,
tmax,
tstart,
tstop,
x0,
w,
noise=int_noise_mat)
zs_noise.append(z)
error = z - target(t)
errors_noise.append(error)
x, t, z, _, wu, _ = jedi.dforce(jedi.step_decode,
target,
model,
lr,
dt,
tmax,
tstart,
tstop,
x0,
w,
noise=int_noise_mat,
pE=pE)
dzs_noise.append(z)
derror = z - target(t)
derrors_noise.append(derror)
try:
parameters['t'] = t
except NameError:
print "t was not defined; check seed args and script for errors"
noise_errors = {}
noise_errors['parameters'] = parameters
noise_errors['force'] = (errors_noise, zs_noise)
noise_errors['dforce'] = (derrors_noise, dzs_noise)
cPickle.dump(
noise_errors,
open(
"../../../data/stability/sin/internal_noise/noise_" +
str(noise_int_var) + ".p", "wb"))
def main(seed):
# Setting Seeds
seeds = seedutil.load_seeds("main_seeds.npy", "../../../data/stability")
if seed is not None:
seeds = seeds[:seed]
targets = np.load("../../../data/stability/flipflop/targets_tmax10sec.npy")
inputs = np.load("../../../data/stability/flipflop/inputs_tmax10sec.npy")
#Simulation parameters for FORCE
parameters = {}
parameters['dt'] = dt = .01 # time step
parameters['tmax'] = tmax = 10 # simulation length
parameters['tstop'] = tstop = 5 # learning stop time
parameters['tstart'] = tstart = 0 # learning start
parameters['N'] = N = 300 # size of stochastic pool
parameters['lr'] = lr = 1 # learning rate
parameters['rho'] = rho = 1.02 # spectral radius of J
parameters['sparsity'] = sparsity = (.1, 1, 1) # weight sparsity
parameters['t_count'] = t_count = int(tmax / dt + 2)
parameters['noise_var'] = noise_var = .35
parameters['noise'] = noise = 'normal'
#Noise matrix
if noise == 'normal':
noise_mat = np.array(
[np.random.normal(0, noise_var, N) for _ in range(t_count)])
elif noise == 'pink':
noise_mat = np.array(
[noise_gen.voss(N, noise_var) for _ in range(t_count)])
else:
raise ValueError("Noise '%s' invalid" % noise)
errors_noise = []
derrors_noise = []
zs_noise = []
dzs_noise = []
for seedling in seeds:
J, Wz, Wi, x0, u, w = init_tools.set_simulation_parameters(seedling,
N,
1,
p=sparsity,
rho=rho)
def model(t0, x, params):
index = params['index']
z = params['z']
tanh_x = params['tanh_x']
inp = params['inputs'][index]
noise = params['noise'][index]
return (-x + np.dot(J, tanh_x) + np.dot(Wi, inp) + Wz * z +
noise) / dt
x, t, z, _, wu, _ = jedi.force(targets,
model,
lr,
dt,
tmax,
tstart,
tstop,
x0,
w,
inputs=inputs,
noise=noise_mat)
zs_noise.append(z)
error = z - np.array(targets)
errors_noise.append(error)
x, t, z, _, wu, _ = jedi.dforce(jedi.step_decode,
targets,
model,
lr,
dt,
tmax,
tstart,
tstop,
x0,
w,
inputs=inputs,
noise=noise_mat)
dzs_noise.append(z)
derror = z - np.array(targets)
derrors_noise.append(derror)
try:
parameters['t'] = t
except NameError:
print "t was not defined; check seed args and script for errors"
noise_errors = {}
noise_errors['parameters'] = parameters
noise_errors['force'] = (errors_noise, zs_noise)
noise_errors['dforce'] = (derrors_noise, dzs_noise)
cPickle.dump(
noise_errors,
open(
"../../../data/stability/flipflop/internal_noise/noise_" +
str(noise_var) + ".p", "wb"))
def main(seed):
# Setting Seeds
seeds = seedutil.load_seeds("main_seeds.npy", "../../../data/stability")
if seed is not None:
seeds = seeds[:seed]
#
targets = np.load("../../../data/stability/flipflop/targets_tmax10sec.npy")
inputs = np.load("../../../data/stability/flipflop/inputs_tmax10sec.npy")
#Simulation parameters for FORCE
parameters = {}
parameters['dt'] = dt = .01 # time step
parameters['tmax'] = tmax = 10 # simulation length
parameters['tstop'] = tstop = 5 # learning stop time
parameters['tstart'] = tstart = 0 # learning start
parameters['N'] = N = 300 # size of stochastic pool
parameters['lr'] = lr = 1 # learning rate
parameters['rho'] = rho = 1.02 # spectral radius of J
parameters['sparsity'] = sparsity = (.1, 1, 1) # weight sparsity
parameters['t_count'] = t_count = int(tmax / dt + 2)
errors = []
derrors = []
zs = []
dzs = []
for seedling in seeds:
J, Wz, Wi, x0, u, w = init_tools.set_simulation_parameters(seedling,
N,
1,
p=sparsity,
rho=rho)
def model(t0, x, params):
index = params['index']
z = params['z']
tanh_x = params['tanh_x']
inp = params['inputs'][index]
return (-x + np.dot(J, tanh_x) + np.dot(Wi, inp) + Wz * z) / dt
x, t, z, _, wu, _ = jedi.force(targets,
model,
lr,
dt,
tmax,
tstart,
tstop,
x0,
w,
inputs=inputs)
zs.append(z)
error = z - np.array(targets)
errors.append(error)
x, t, z, _, wu, _ = jedi.dforce(jedi.step_decode,
targets,
model,
lr,
dt,
tmax,
tstart,
tstop,
x0,
w,
inputs=inputs)
dzs.append(z)
derror = z - np.array(targets)
derrors.append(derror)
try:
parameters['t'] = t
except NameError:
print "t was not defined; check seed args and script for errors"
noiseless_errors = {}
noiseless_errors['parameters'] = parameters
noiseless_errors['force'] = (errors, zs)
noiseless_errors['dforce'] = (derrors, dzs)
cPickle.dump(noiseless_errors,
open("../../../data/stability/flipflop/base/base.p", "wb"))
p=sparsity,
rho=rho)
def model(t0, x, params):
z = params['z']
tanh_x = params['tanh_x']
inp = params['inputs']
noise = params['noise']
return (-x + np.dot(J, tanh_x) + np.dot(Wi, inp) + Wz * z + noise) / dt
x, t, z, _, wu, _ = jedi.force(targets,
model,
lr,
dt,
tmax,
tstart,
tstop,
x0,
w,
noise=noise_mat,
inputs=inputs)
error = np.abs(z - np.array(targets))
errors.append(error)
errors = np.array(errors)
plt.figure(figsize=(12, 5))
plt.legend()
plt.subplot(2, 1, 2)
for i in range(20):
