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