def test_orthogonalize():
n = 10000
din, dout = 30, 10
rng = np.random
T = orthogonalize(rng.normal(size=(din, dout)))
X = rng.normal(size=(n, din))
Y = np.dot(X, T)
print(X.std(axis=1).mean())
print(Y.std(axis=1).mean())
Y2 = rng.normal(size=(n, dout))
X2 = np.dot(Y2, T.T)
print(X2.std(axis=1).mean())
print(Y2.std(axis=1).mean())
# n_per_batch = 20
n_per_show = 40
assert n_per_show % n_per_batch == 0
block_size = n_per_show // n_per_batch
# n = 2000
# n = 9000
# n = 12000
# n = 15000
n = 21000
alpha = 0
# --- problem dataset
T = orthogonalize(rng.normal(size=(din, dout)))
genX = lambda n: rng.normal(scale=1., size=(n, din))
genY = lambda X: np.dot(X, T)
Xref = genX(1000)
Yref = genY(Xref)
Yrms = rms(Yref, axis=1).mean()
# --- nonlinearity
tau_rc = 0.05
amp = 0.01
f_dfs = [
static_f_df('lifnone', tau_rc=tau_rc, amplitude=amp),
static_f_df('lifstep', tau_rc=tau_rc, amplitude=amp),
static_f_df('liflinear', tau_rc=tau_rc, amplitude=amp),
def objective(args):
eta = args['eta']
prestime = args['prestime']
n_examples = int(np.ceil(t_train / prestime))
# dataset
T = orthogonalize(rng.normal(size=(din, dout)))
genX = lambda n: rng.normal(scale=0.5, size=(n, din))
genY = lambda X: np.dot(X, T)
X = genX(n_examples)
Y = genY(X)
x_process = nengo.processes.PresentInput(X, prestime)
y_process = nengo.processes.PresentInput(Y, prestime)
Xtest = genX(1000)
Ytest = genY(Xtest)
Ytestrms = rms(Ytest, axis=1).mean()
weights = initial_weights([2 * din] + dhids + [dout],
kind='gaussian',
scale=5e-4,
rng=rng)
fa_args = dict(eta=eta,
seed=2,
n_output=20,
n_error=20,
o_encoders=eye_encoders(dout),
e_encoders=eye_encoders(dout),
e_intercepts=Uniform(0, 0.8),
b_kind='gaussian',
b_scale=1.7)
model = nengo.Network()
model.config[nengo.Ensemble].neuron_type = neuron_type
model.config[nengo.Connection].synapse = synapse
with model:
x = nengo.Node(x_process)
y = nengo.Node(y_process)
xe = Encoder(x, seed=1)
learner = FATwoStepNetwork(xe.output, y, weights, **fa_args)
xp = nengo.Probe(x)
yp = nengo.Probe(y)
xep = nengo.Probe(xe.output)
with nengo.Simulator(model) as sim:
sim.run(t_train)
XEtest = xe.encode(Xtest, sim=sim)
Ztest = learner.forward(sim, XEtest)
cost = rms(Ztest - Ytest, axis=1).mean() / Ytestrms
# save
dt = sim.dt
t = sim.trange()
x = sim.data[xp]
xe = sim.data[xep]
y = sim.data[yp]
z = sim.data[learner.yp]
data = dict(
eta=eta,
prestime=prestime,
dt=dt,
t_train=t_train,
din=din,
dhids=dhids,
dout=dout,
T=T,
X=X,
Y=Y,
Xtest=Xtest,
Ytest=Ytest,
XEtest=XEtest,
Ztest=Ztest,
# t=t, x=x, xe=xe, y=y, z=z,
cost=cost)
rargs = '_'.join('%s=%r' % (k, v) for k, v in args.items())
filename = os.path.join(filedir, 'trial_%s.npz' % (rargs))
np.savez(filename, **data)
print("Saved %r" % filename)
# result
status = hyperopt.STATUS_OK if np.isfinite(cost) else hyperopt.STATUS_FAIL
sargs = arg_string(args)
print("%s: %0.3e" % (sargs, cost))
return dict(loss=cost, status=status)
