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 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]
def experiment(period,
std,
delay,
decay,
Nh,
repeat,
bidirectional,
sigma=0.01):
"""
A run of experiment
Parameters
----------
period : int
period of the wave
std : float
standard deviation of noise
delay : int
delay
decay : list
list of decay rates
Nh : int
number of hidden units
repeat : int
number of iterations of training
bidirectional : boolean
whether to train bidirectionally
sigma : float
std of random initialization
0.01 is recommended in
https://www.cs.toronto.edu/~hinton/absps/guideTR.pdf
"""
"""
Prepare data generators
"""
dim = 1 # dimension of the wave
phase = amath.zeros(dim) # initial phase of the wave
# forward sequence
wave = NoisySawtooth(0, period, std, dim, phase, False)
wave.reset(seed=0)
# backward sequence
revwave = NoisySawtooth(0, period, std, dim, phase, True)
revwave.reset(seed=1)
"""
Prepare a Gaussian Bernoulli DyBM
"""
Nv = dim # number of visible units
sgd = AdaGrad()
dybm = GaussianBernoulliDyBM([delay, delay], [decay, decay], [Nv, Nh],
[sgd, deepcopy(sgd)],
sigma=sigma,
insert_to_etrace="w_delay")
dybm.layers[0].layers[1].SGD.set_learning_rate(0)
dybm.layers[1].layers[1].SGD.set_learning_rate(0)
"""
Learn
"""
error = list() # list of numpy array
bi_end = 0.5
bi_factor = 2
for i in range(repeat):
# update internal states by reading forward sequence
wave.add_length(period)
dybm.get_predictions(wave)
if bidirectional and i % (bi_factor + 1) == 0 and bi_factor > 0 \
and i < repeat * bi_end:
# make a time-reversed DyBM
dybm._time_reversal()
# update internal states by reading backward sequence
revwave.add_length(period)
dybm.get_predictions(revwave)
# learn backward sequence for one period
revwave.add_length(period)
dybm.learn(revwave, get_result=False)
# make a non time-reversed DyBM
dybm._time_reversal()
else:
# update internal states by reading forward sequence
wave.add_length(period)
dybm.get_predictions(wave)
# learn forward sequence
wave.add_length(period)
result = dybm.learn(wave, get_result=True)
if i % (bi_factor + 1) == bi_factor:
rmse = RMSE(result["actual"], result["prediction"])
rmse = amath.to_numpy(rmse)
error.append(rmse)
return error, dybm, wave
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"))
filename = get_filename(period, std, delay, decay, Nh, repeat,
bidirectional)
print("Loading " + directory + filename + ".pkl")
dybm = pickle.load(open(directory + filename + ".pkl", "r"))
print("Loading " + directory + filename + "_wave.pkl")
wave = pickle.load(open(directory + filename + "_wave.pkl", "r"))
wave.reset()
wave.limit = period * 22
wave.std = 0
predictions = dybm.get_predictions(wave)
target = wave.to_list()[-period * 2:]
predictions = [amath.to_numpy(x)[0]
for x in predictions[-period * 2:]]
print "predictions", predictions
target = [amath.to_numpy(x)[0] for x in target]
print "target", target
style, label = get_style_label(bidirectional, Nh)
plt.plot(predictions, label=label, color="black",
linestyle=style)
if not bidirectional and Nh == 0:
plt.plot(target, label="Target", color="red")
plt.legend(loc="upper center", ncol=2, fontsize=17)
plt.xlabel("Steps", fontsize=17)
plt.ylabel("Target or predicted value", fontsize=17)
def experiment(dataset, delay, Nh, repeat, bi_factor, bi_end, sigma, rate):
"""
A run of experiment
Parameters
----------
delay : int
delay
Nh : int
number of hidden units
repeat : int
number of iterations of training
bi_factor : boolean
amount of bidirectional training
rate : float
initial learning rate
sigma : float
standard deviation of noise
"""
Nv = dataset.train.get_dim() # number of visible units
decay = [0.0]
# Prepare a Gaussian Bernoulli DyBM
dybm = GaussianBernoulliDyBM([delay, delay], [decay, decay], [Nv, Nh],
sigma=sigma)
if len(dybm.layers[0].layers[0].variables["W"]) > 0:
dybm.layers[0].layers[0].variables["W"][0] += amath.eye(Nv)
for i in range(2):
dybm.layers[i].layers[0].SGD.set_learning_rate(rate)
dybm.layers[i].layers[1].SGD.set_learning_rate(0)
# Learn
train_rmse = list()
test_rmse = list()
step = list()
dybm.init_state()
dataset.warmup.reset()
dataset.train.reset()
dybm.get_predictions(dataset.warmup)
prediction = dybm.get_predictions(dataset.train)
rmse = RMSE(dataset.train.to_list(), prediction)
rmse = amath.to_numpy(rmse)
train_rmse.append(rmse)
print("init", rmse)
dybm.init_state()
dataset.cooldown.reset()
dataset.test.reset()
dybm.get_predictions(dataset.cooldown)
prediction = dybm.get_predictions(dataset.test)
rmse = RMSE(dataset.test_seq, prediction)
rmse = amath.to_numpy(rmse)
print(rmse)
test_rmse.append(rmse)
step.append(0)
for i in range(repeat):
dybm.init_state()
dataset.warmup.reset()
dataset.train.reset()
dataset.cooldown.reset()
if i % (bi_factor + 1) == 0 and bi_factor > 0 and i < repeat * bi_end:
print("backward")
# make a time-reversed DyBM and dataset
dybm._time_reversal()
dataset.warmup.reverse()
dataset.train.reverse()
dataset.cooldown.reverse()
# update internal states by reading backward sequence
dybm.get_predictions(dataset.cooldown)
# learn backward sequence
dybm.learn(dataset.train, get_result=False)
dybm.learn(dataset.warmup, get_result=False)
# make a non time-reversed DyBM
dybm._time_reversal()
dataset.warmup.reverse()
dataset.train.reverse()
dataset.cooldown.reverse()
else:
print("forward")
# update internal states by reading forward sequence
dybm.get_predictions(dataset.warmup)
# learn forward sequence
dybm.learn(dataset.train, get_result=False)
dybm.learn(dataset.cooldown, get_result=False)
if i % (bi_factor + 1) == bi_factor:
print("evaluate")
dybm.init_state()
dataset.warmup.reset()
dataset.train.reset()
dybm.get_predictions(dataset.warmup)
prediction = dybm.get_predictions(dataset.train)
rmse = RMSE(dataset.train.to_list(), prediction)
rmse = amath.to_numpy(rmse)
train_rmse.append(rmse)
print(i, rmse)
dybm.init_state()
dataset.cooldown.reset()
dataset.test.reset()
dybm.get_predictions(dataset.cooldown)
prediction = dybm.get_predictions(dataset.test)
rmse = RMSE(dataset.test_seq, prediction)
rmse = amath.to_numpy(rmse)
test_rmse.append(rmse)
print(rmse)
step.append(i + 1)
return (train_rmse, test_rmse, step, dybm)
