def test_mu(self):
""" check mu given by get_conditional_negative_energy
"""
in_patterns = [
amath.array([1, 0, 0, 0]),
amath.array([0, 1, 0, 0]),
amath.array([0, 0, 1, 0])
]
self.model._update_state(in_patterns[2])
self.model._update_state(in_patterns[1])
self.model._update_state(in_patterns[0])
fifo_array = self.model.fifo.to_array()
self.assertTrue(amath.allclose(fifo_array[0], in_patterns[0]))
self.assertTrue(amath.allclose(fifo_array[1], in_patterns[1]))
self.assertTrue(amath.allclose(fifo_array[2], in_patterns[2]))
mu_test = deepcopy(self.model.variables["b"])
u_tilde = self.model._get_u_tilde()
# naive implementation of sigmoid
sig_u_tilde = sigmoid(u_tilde)
for d in xrange(self.order):
mu_test += self.model.variables["W"][d, d, :]
mu_test += sig_u_tilde.dot(self.model.variables["V"])
self.assertTrue(
amath.allclose(self.model._get_conditional_negative_energy(),
mu_test))
pass
def _compute_rmse(self, predictions, targets):
rmse = 0.0
for i, pred in enumerate(predictions):
#print(type(amath.array(pred.to_list())), amath.array(pred.to_list()))
#print(type(amath.array(targets[i])), amath.array(targets[i]))
a = amath.array(pred.to_list(), dtype=float)
b = amath.array(targets[i])
rmse += amath.sqrt(amath.mean((a - b)**2))
return rmse
def test_obj(self):
""" test run _get_obj
"""
in_patterns = [amath.array([1, 0, 0, 0]),
amath.array([0, 1, 0, 0]),
amath.array([0, 0, 1, 0])]
self.model._update_state(in_patterns[2])
self.model._update_state(in_patterns[1])
self.model._update_state(in_patterns[0])
out_pattern = amath.array([2.0, 1.0])
print("\n * obj = {}".format(self.model._get_obj(out_pattern)))
def test_u_tilde(self):
""" check _get_u_tilde
"""
in_patterns = [amath.array([1, 0, 0, 0]),
amath.array([0, 1, 0, 0]),
amath.array([0, 0, 1, 0])]
self.model._update_state(in_patterns[2])
self.model._update_state(in_patterns[1])
self.model._update_state(in_patterns[0])
u_tilde_test = amath.zeros(self.dim_hidden)
for d in xrange(self.order):
u_tilde_test += self.model.variables["U"][d, d, :]
u_tilde_test += self.model.variables["b_h"]
self.assertTrue(amath.allclose(u_tilde_test, self.model._get_u_tilde()))
pass
def testOneDimensional(self):
eps = 1e-2
period = 10
for Wave in [NoisySin, NoisySawtooth]:
for std in [0.0, 0.1, 1.0]:
print("NoisyWaveTestCase.testOneDimensional " + str(Wave) +
" with std: " + str(std))
length = period * 10
dim = 1
phase = None
reverse = False
if Wave == NoisySin:
angles = 2 * amath.pi * amath.arange(length) / period
target = amath.sin(angles)
elif Wave == NoisySawtooth:
r = 1. * amath.arange(length) / period
target = r % 1
else:
print(Wave)
wave = Wave(length, period, std, dim, phase, reverse)
sequence = list()
for pattern in wave:
sequence.append(pattern[0])
sequence = amath.array(sequence, dtype=float)
diff = target - sequence
rmse = amath.sqrt(amath.dot(diff, diff) / len(diff))
print("RMSE: %f" % rmse)
self.assertLessEqual(amath.abs(rmse - std), std * eps)
def test_grad(self):
""" test run _get_gradient
"""
in_patterns = [amath.array([1, 0, 0, 0]),
amath.array([0, 1, 0, 0]),
amath.array([0, 0, 1, 0])]
self.model._update_state(in_patterns[2])
self.model._update_state(in_patterns[1])
self.model._update_state(in_patterns[0])
out_pattern = amath.array([2.0, 1.0])
grad = self.model._get_gradient(out_pattern)
self.assertTrue(grad["b"].shape == (self.out_dim,))
self.assertTrue(grad["W"].shape ==
(self.order, self.in_dim, self.out_dim))
self.assertTrue(grad["U"].shape ==
(self.order, self.in_dim, self.dim_hidden))
self.assertTrue(grad["V"].shape == (self.dim_hidden, self.out_dim))
def setUp(self):
self.max_repeat = 100000
self.in_dim = 3 # dimension of input sequence
self.out_dim = 2 # dimension of target sequence
self.rnn_dim = 10
self.sparsity = 0.1
self.spectral_radius = 0.95
self.leak = 1.0
self.decay_rates = amath.array([0.2, 0.5, 0.8])
def testRandom(self):
print("SequenceTestCase.testRandom")
target = amath.random.random((10, 3))
gen = SequenceGenerator(target.tolist())
sequence = list()
for pattern in gen:
sequence.append(pattern)
sequence = amath.array(sequence, dtype=float)
diff = sequence - target
self.assertEqual(amath.max(diff), 0)
def testOneDimensional(self):
eps = 1e-2
length = 10000
dim = 1
for low, high in product(range(3), range(3)):
print("UniformTestCase.testOneDimensional Uniform[%d, %d]" %
(low, high))
gen = Uniform(length, low, high, dim)
sequence = list()
for pattern in gen:
sequence.append(pattern[0])
sequence = amath.array(sequence, dtype=float)
print("Mean: %f, Median: %f, Variance: %f" %
(amath.mean(sequence), amath.median(sequence),
amath.var(sequence)))
self.assertLessEqual(
amath.abs(amath.mean(sequence) - 0.5 * (low + high)),
amath.abs(high - low) * eps)
self.assertLessEqual(
amath.abs(amath.median(sequence) - 0.5 * (low + high)),
amath.abs(high - low) * eps)
self.assertLessEqual(
amath.abs(amath.var(sequence) - (high - low)**2 / 12.),
(high - low)**2 * eps)
sequence = amath.to_numpy(sequence)
self.assertLessEqual(
amath.abs(np.mean(sequence) - 0.5 * (low + high)),
amath.abs(high - low) * eps)
self.assertLessEqual(
amath.abs(np.median(sequence) - 0.5 * (low + high)),
amath.abs(high - low) * eps)
self.assertLessEqual(
amath.abs(np.var(sequence) - (high - low)**2 / 12.),
(high - low)**2 * eps)
def _compute_rmse(self, prediction, target):
a = amath.array(prediction.to_list(), dtype=float)
b = amath.array(target)
rmse = amath.sqrt(amath.mean((a - b)**2))
return rmse
def test_UpdateState(self):
""" testing fifo, eligibility trace, and update_state method in
LinearDyBM
"""
print("\n * testing fifo, eligibility trace, and update_state method"
" in LinearDyBM \n")
in_dim = 3
delay = 3
decay_rate = 0.5
len_ts = 10
print("testing wo_delay, single e_trace")
model = LinearDyBM(in_dim,
delay=delay,
decay_rates=[decay_rate],
insert_to_etrace="wo_delay")
random = np.random.RandomState(0)
in_patterns = np.random.uniform(size=(len_ts, in_dim))
fifo_test = np.zeros((delay - 1, in_dim))
e_trace_test = np.zeros((1, in_dim))
for i in xrange(len_ts):
self.assertTrue(
np.allclose(amath.to_numpy(model.fifo.to_array()), fifo_test))
self.assertTrue(
np.allclose(amath.to_numpy(model.e_trace), e_trace_test))
model.learn_one_step(amath.array(in_patterns[i]))
model._update_state(amath.array(in_patterns[i]))
fifo_test[1:] = fifo_test[:-1]
fifo_test[0] = in_patterns[i]
e_trace_test = e_trace_test * decay_rate + in_patterns[i]
print("testing w_delay, single e_trace")
model = LinearDyBM(in_dim,
delay=delay,
decay_rates=[decay_rate],
insert_to_etrace="w_delay")
random = np.random.RandomState(0)
in_patterns = np.random.uniform(size=(len_ts, in_dim))
fifo_test = np.zeros((delay - 1, in_dim))
e_trace_test = np.zeros((1, in_dim))
for i in xrange(len_ts):
self.assertTrue(
np.allclose(amath.to_numpy(model.fifo.to_array()), fifo_test))
self.assertTrue(
np.allclose(amath.to_numpy(model.e_trace), e_trace_test))
model.learn_one_step(amath.array(in_patterns[i]))
model._update_state(amath.array(in_patterns[i]))
fifo_test[1:] = fifo_test[:-1]
fifo_test[0] = in_patterns[i]
if i < delay - 1:
pass
else:
e_trace_test = e_trace_test * decay_rate \
+ in_patterns[i - delay + 1]
print("testing w_delay, two e_traces")
model = LinearDyBM(in_dim,
delay=delay,
decay_rates=[decay_rate, decay_rate**2],
insert_to_etrace="w_delay")
random = np.random.RandomState(0)
in_patterns = np.random.uniform(size=(len_ts, in_dim))
fifo_test = np.zeros((delay - 1, in_dim))
e_trace_test = np.zeros((2, in_dim))
for i in xrange(len_ts):
self.assertTrue(
np.allclose(amath.to_numpy(model.fifo.to_array()), fifo_test))
self.assertTrue(
np.allclose(amath.to_numpy(model.e_trace), e_trace_test))
model.learn_one_step(amath.array(in_patterns[i]))
model._update_state(amath.array(in_patterns[i]))
fifo_test[1:] = fifo_test[:-1]
fifo_test[0] = in_patterns[i]
if i < delay - 1:
pass
else:
e_trace_test[0] = e_trace_test[0] * decay_rate \
+ in_patterns[i - delay + 1]
e_trace_test[1] = e_trace_test[1] * (decay_rate**2) \
+ in_patterns[i - delay + 1]
print("testing w_delay, single e_trace, delay=1")
delay = 1
model = LinearDyBM(in_dim,
delay=delay,
decay_rates=[decay_rate],
insert_to_etrace="w_delay")
random = np.random.RandomState(0)
in_patterns = random.uniform(size=(len_ts, in_dim))
e_trace_test = np.zeros((1, in_dim))
for i in xrange(len_ts):
self.assertTrue(
np.allclose(amath.to_numpy(model.e_trace), e_trace_test))
model.learn_one_step(amath.array(in_patterns[i]))
model._update_state(amath.array(in_patterns[i]))
if i < delay - 1:
pass
else:
e_trace_test = e_trace_test * decay_rate \
+ in_patterns[i - delay + 1]
Nh = int(args.Nh) # number of hidden units
if args.bidirectional in ["true", "True"]:
bidirectional = True
else:
bidirectional = False
delay = 4
decay = 0.0
std = 0.01 # standard deviation of noise
# run experiments
directory = "sawtooth_results/"
if not os.path.exists(directory):
print("Creating directory " + directory)
os.mkdir(directory)
repeat = get_repeat(period)
filename = get_filename(period, std, delay, decay, Nh, repeat,
bidirectional)
print("Making " + filename)
if not os.path.exists(directory + filename + ".npy"):
error, dybm, wave = experiment(period, std, delay, [decay], Nh, repeat,
bidirectional)
# error is list()
error = amath.array(error)
error = amath.to_numpy(error)
error.dump(directory + filename + ".npy")
pickle.dump(dybm, open(directory + filename + ".pkl", "w"))
pickle.dump(wave, open(directory + filename + "_wave.pkl", "w"))
def test_binary_model(model, max_repeat=1000, generator=False):
"""
minimal test with learning a constant with noise
"""
in_dim = model.get_input_dimension()
out_dim = model.get_target_dimension()
batch = in_dim
eps = 1e-2
in_seq = amath.array([[i % in_dim == j % in_dim for j in range(in_dim)]
for i in range(batch)],
dtype=int)
if in_dim == out_dim:
print("Testing generative learning")
out_seq = in_seq
else:
print("Testing discriminative learning")
out_seq = amath.array(
[[i % out_dim == j % out_dim for j in range(out_dim)]
for i in range(batch)],
dtype=int)
in_gen = SequenceGenerator(in_seq)
out_gen = SequenceGenerator(out_seq)
i = 0
for i in xrange(max_repeat):
if in_dim == out_dim:
if generator:
in_gen.reset()
model.learn(in_gen)
else:
model._learn_sequence(in_seq)
else:
if generator:
in_gen.reset()
out_gen.reset()
model.learn(in_gen, out_gen)
else:
model._learn_sequence(in_seq, out_seq)
if i % 1000 == 0:
if in_dim == out_dim:
if generator:
in_gen.reset()
predictions = model.get_predictions(in_gen)
else:
predictions = model.get_predictions(in_seq)
else:
if generator:
in_gen.reset()
predictions = model.get_predictions(in_gen)
else:
predictions = model.get_predictions(in_seq)
"""
diffs = predictions - out_seq
SE = [np.dot(diff, diff) for diff in diffs]
RMSE2 = np.sqrt(np.mean(SE))
"""
rmse = RMSE(predictions, out_seq)
print("%d\t%1.3f" % (i, rmse))
if rmse < eps * out_dim:
print("Successfully completed in %d iterations with RMSE: %f" %
(i + 1, rmse))
break
if in_dim == out_dim:
LL = model.get_LL_sequence(in_seq)
else:
LL = model.get_LL_sequence(in_seq, out_seq)
print("LL: %f" % amath.mean(LL))
return i + 1
def test_complex_model(model, max_repeat=100):
dim = [layer.get_input_dimension() for layer in model.layers]
activations = model.activations
random = amath.random.RandomState(0)
mean = 1.0
batch = np.prod(dim)
d = 0.01
seqs = list()
for dimension, activation in zip(dim, activations):
if activation == "linear":
seq = random.uniform(low=mean - d,
high=mean + d,
size=(batch, dimension))
elif activation == "sigmoid":
seq = amath.array(
[[i % dimension == j % dimension for j in range(dimension)]
for i in range(batch)],
dtype=int)
seq = amath.array(
[[i % dimension == j % dimension for j in range(dimension)]
for i in range(batch)],
dtype=float)
seqs.append(seq)
in_seq = list()
i = 0
for i in xrange(batch):
pattern = [s[i] for s in seqs]
in_seq.append(pattern)
for i in xrange(max_repeat):
model._learn_sequence(in_seq)
predictions = model.get_predictions(in_seq)
predictions = np.concatenate(predictions).reshape(
(len(predictions), len(predictions[0])))
rmse = 0
start = 0
j = 0
for j, (dimension, sequence) in enumerate(zip(dim, seqs)):
sub_prediction = predictions[:, j]
sub_prediction = amath.concatenate(sub_prediction).reshape(
(len(sub_prediction), len(sub_prediction[0])))
start += dimension
rmse += amath.sqrt(amath.mean((sub_prediction - sequence)**2))
if i % 1000 == 0:
print("rmse at %d:\t%1.4f" % (i, rmse))
if rmse < d * sum(dim):
print("Successfully completed in %d iterations with rmse: %f" %
(i + 1, rmse))
break
LL = model.get_LL_sequence(in_seq)
print("LL: ", LL)
return i + 1
