def test7(self): p0 = hp_uniform('p0', 0, 1) p1 = hp_normal('p1', 0, 1) p2 = hp_choice('p2', [1, p0]) p3 = hp_choice('p3', [2, p1, p2, hp_uniform('a0', 2, 3)]) self.expr = {'loss': p0 + p1 + p2 + p3} self.n_randints = 2 self.wanted = [[('p0', [0], [0.71295532052322719]), ('p1', [0], [0.28297849805199204]), ('p2.randint', [0], [0]), ('p3.arg:2', [0], [2.719468969785563]), ('p3.randint', [0], [2])], [('p0', [1], [0.78002776191207912]), ('p1', [1], [-1.506294713918092]), ('p2.randint', [1], [1]), ('p3.arg:2', [], []), ('p3.randint', [1], [1])], [('p0', [2], [0.57969429702261011]), ('p1', [2], [1.6796003743035337]), ('p2.randint', [2], [0]), ('p3.arg:2', [], []), ('p3.randint', [2], [1])], [('p0', [3], [0.43857224467962441]), ('p1', [3], [-1.3058031267484451]), ('p2.randint', [3], [1]), ('p3.arg:2', [], []), ('p3.randint', [3], [1])], [('p0', [4], [0.39804425533043142]), ('p1', [4], [-0.91948540682140967]), ('p2.randint', [4], [0]), ('p3.arg:2', [], []), ('p3.randint', [4], [0])]] self.foo()
def test_vectorize_multipath(): N = as_apply(15) p0 = hp_uniform("p0", 0, 1) loss = hp_choice("p1", [1, p0, -p0])**2 expr_idxs = scope.range(N) vh = VectorizeHelper(loss, expr_idxs, build=True) vloss = vh.v_expr print(vloss) full_output = as_apply([vloss, vh.idxs_by_label(), vh.vals_by_label()]) new_vc = recursive_set_rng_kwarg(full_output, as_apply(np.random.RandomState(1))) losses, idxs, vals = rec_eval(new_vc) print("losses", losses) print("idxs p0", idxs["p0"]) print("vals p0", vals["p0"]) print("idxs p1", idxs["p1"]) print("vals p1", vals["p1"]) p0dct = dict(list(zip(idxs["p0"], vals["p0"]))) p1dct = dict(list(zip(idxs["p1"], vals["p1"]))) for ii, li in enumerate(losses): print(ii, li) if p1dct[ii] != 0: assert li == p0dct[ii]**2 else: assert li == 1
def test_vectorize_multipath(): N = as_apply(15) p0 = hp_uniform('p0', 0, 1) loss = hp_choice('p1', [1, p0, -p0])**2 expr_idxs = scope.range(N) vh = VectorizeHelper(loss, expr_idxs, build=True) vloss = vh.v_expr print vloss full_output = as_apply([vloss, vh.idxs_by_label(), vh.vals_by_label()]) new_vc = recursive_set_rng_kwarg( full_output, as_apply(np.random.RandomState(1)), ) losses, idxs, vals = rec_eval(new_vc) print 'losses', losses print 'idxs p0', idxs['p0'] print 'vals p0', vals['p0'] print 'idxs p1', idxs['p1'] print 'vals p1', vals['p1'] p0dct = dict(zip(idxs['p0'], vals['p0'])) p1dct = dict(zip(idxs['p1'], vals['p1'])) for ii, li in enumerate(losses): print ii, li if p1dct[ii] != 0: assert li == p0dct[ii]**2 else: assert li == 1
def test_distributions(): # test that the distributions come out right # XXX: test more distributions bandit = base.Bandit({ 'loss': hp_loguniform('lu', -2, 2) + hp_qloguniform('qlu', np.log(1 + 0.01), np.log(20), 2) + hp_quniform('qu', -4.999, 5, 1) + hp_uniform('u', 0, 10) }) algo = base.Random(bandit) trials = base.Trials() exp = base.Experiment(trials, algo) exp.catch_bandit_exceptions = False N = 1000 exp.run(N) assert len(trials) == N idxs, vals = base.miscs_to_idxs_vals(trials.miscs) print idxs.keys() COUNTMAX = 130 COUNTMIN = 70 # -- loguniform log_lu = np.log(vals['lu']) assert len(log_lu) == N assert -2 < np.min(log_lu) assert np.max(log_lu) < 2 h = np.histogram(log_lu)[0] print h assert np.all(COUNTMIN < h) assert np.all(h < COUNTMAX) # -- quantized log uniform qlu = vals['qlu'] assert np.all(np.fmod(qlu, 2) == 0) assert np.min(qlu) == 2 assert np.max(qlu) == 20 bc_qlu = np.bincount(qlu) assert bc_qlu[2] > bc_qlu[4] > bc_qlu[6] > bc_qlu[8] # -- quantized uniform qu = vals['qu'] assert np.min(qu) == -5 assert np.max(qu) == 5 assert np.all(np.fmod(qu, 1) == 0) bc_qu = np.bincount(np.asarray(qu).astype('int') + 5) assert np.all(40 < bc_qu), bc_qu # XXX: how to get the distribution flat # with new rounding rule? assert np.all(bc_qu < 125), bc_qu assert np.all(bc_qu < COUNTMAX) # -- uniform u = vals['u'] assert np.min(u) > 0 assert np.max(u) < 10 h = np.histogram(u)[0] print h assert np.all(COUNTMIN < h) assert np.all(h < COUNTMAX)
def test_vectorize_simple(): N = as_apply(15) p0 = hp_uniform('p0', 0, 1) loss = p0**2 print loss expr_idxs = scope.range(N) vh = VectorizeHelper(loss, expr_idxs, build=True) vloss = vh.v_expr full_output = as_apply([vloss, vh.idxs_by_label(), vh.vals_by_label()]) fo2 = replace_repeat_stochastic(full_output) new_vc = recursive_set_rng_kwarg( fo2, as_apply(np.random.RandomState(1)), ) #print new_vc losses, idxs, vals = rec_eval(new_vc) print 'losses', losses print 'idxs p0', idxs['p0'] print 'vals p0', vals['p0'] p0dct = dict(zip(idxs['p0'], vals['p0'])) for ii, li in enumerate(losses): assert p0dct[ii]**2 == li
def test_vectorize_multipath(): N = as_apply(15) p0 = hp_uniform('p0', 0, 1) loss = hp_choice('p1', [1, p0, -p0]) ** 2 expr_idxs = scope.range(N) vh = VectorizeHelper(loss, expr_idxs, build=True) vloss = vh.v_expr print(vloss) full_output = as_apply([vloss, vh.idxs_by_label(), vh.vals_by_label()]) new_vc = recursive_set_rng_kwarg( full_output, as_apply(np.random.RandomState(1)), ) losses, idxs, vals = rec_eval(new_vc) print('losses', losses) print('idxs p0', idxs['p0']) print('vals p0', vals['p0']) print('idxs p1', idxs['p1']) print('vals p1', vals['p1']) p0dct = dict(list(zip(idxs['p0'], vals['p0']))) p1dct = dict(list(zip(idxs['p1'], vals['p1']))) for ii, li in enumerate(losses): print(ii, li) if p1dct[ii] != 0: assert li == p0dct[ii] ** 2 else: assert li == 1
def test_vectorize_simple(): N = as_apply(15) p0 = hp_uniform('p0', 0, 1) loss = p0 ** 2 print(loss) expr_idxs = scope.range(N) vh = VectorizeHelper(loss, expr_idxs, build=True) vloss = vh.v_expr full_output = as_apply([vloss, vh.idxs_by_label(), vh.vals_by_label()]) fo2 = replace_repeat_stochastic(full_output) new_vc = recursive_set_rng_kwarg( fo2, as_apply(np.random.RandomState(1)), ) #print new_vc losses, idxs, vals = rec_eval(new_vc) print('losses', losses) print('idxs p0', idxs['p0']) print('vals p0', vals['p0']) p0dct = dict(list(zip(idxs['p0'], vals['p0']))) for ii, li in enumerate(losses): assert p0dct[ii] ** 2 == li
def test_distributions(): # test that the distributions come out right # XXX: test more distributions bandit = base.Bandit({ 'loss': hp_loguniform('lu', -2, 2) + hp_qloguniform('qlu', np.log(1 + 0.01), np.log(20), 2) + hp_quniform('qu', -4.999, 5, 1) + hp_uniform('u', 0, 10)}) algo = base.Random(bandit) trials = base.Trials() exp = base.Experiment(trials, algo) exp.catch_bandit_exceptions = False N = 1000 exp.run(N) assert len(trials) == N idxs, vals = base.miscs_to_idxs_vals(trials.miscs) print idxs.keys() COUNTMAX = 130 COUNTMIN = 70 # -- loguniform log_lu = np.log(vals['lu']) assert len(log_lu) == N assert -2 < np.min(log_lu) assert np.max(log_lu) < 2 h = np.histogram(log_lu)[0] print h assert np.all(COUNTMIN < h) assert np.all(h < COUNTMAX) # -- quantized log uniform qlu = vals['qlu'] assert np.all(np.fmod(qlu, 2) == 0) assert np.min(qlu) == 2 assert np.max(qlu) == 20 bc_qlu = np.bincount(qlu) assert bc_qlu[2] > bc_qlu[4] > bc_qlu[6] > bc_qlu[8] # -- quantized uniform qu = vals['qu'] assert np.min(qu) == -5 assert np.max(qu) == 5 assert np.all(np.fmod(qu, 1) == 0) bc_qu = np.bincount(np.asarray(qu).astype('int') + 5) assert np.all(40 < bc_qu), bc_qu # XXX: how to get the distribution flat # with new rounding rule? assert np.all(bc_qu < 125), bc_qu assert np.all(bc_qu < COUNTMAX) # -- uniform u = vals['u'] assert np.min(u) > 0 assert np.max(u) < 10 h = np.histogram(u)[0] print h assert np.all(COUNTMIN < h) assert np.all(h < COUNTMAX)
def test0(self): self.expr = {'loss': hp_uniform('p0', 0, 1)} self.wanted = [[('p0', [0], [0.69646918559786164])], [('p0', [1], [0.28613933495037946])], [('p0', [2], [0.22685145356420311])], [('p0', [3], [0.55131476908289123])], [('p0', [4], [0.71946896978556307])]] self.foo()
def test0(self): self.expr = {'loss': hp_uniform('p0', 0, 1)} self.wanted = [ [('p0', [0], [0.69646918559786164])], [('p0', [1], [0.28613933495037946])], [('p0', [2], [0.22685145356420311])], [('p0', [3], [0.55131476908289123])], [('p0', [4], [0.71946896978556307])]] self.foo()
def test_quadratic1_rand(): report = fmin( fn=lambda x: (x - 3) ** 2, space=hp_uniform('x', -5, 5), algo=rand.suggest, max_evals=500) assert len(report.trials) == 500 assert abs(report.trials.argmin['x'] - 3.0) < .25
def many_dists(): a=hp_choice('a', [0, 1, 2]) b=hp_randint('b', 10) c=hp_uniform('c', 4, 7) d=hp_loguniform('d', -2, 0) e=hp_quniform('e', 0, 10, 3) f=hp_qloguniform('f', 0, 3, 2) g=hp_normal('g', 4, 7) h=hp_lognormal('h', -2, 2) i=hp_qnormal('i', 0, 10, 2) j=hp_qlognormal('j', 0, 2, 1) z = a + b + c + d + e + f + g + h + i + j return {'loss': scope.float(scope.log(1e-12 + z ** 2))}
def many_dists(): a = hp_choice('a', [0, 1, 2]) b = hp_randint('b', 10) c = hp_uniform('c', 4, 7) d = hp_loguniform('d', -2, 0) e = hp_quniform('e', 0, 10, 3) f = hp_qloguniform('f', 0, 3, 2) g = hp_normal('g', 4, 7) h = hp_lognormal('h', -2, 2) i = hp_qnormal('i', 0, 10, 2) j = hp_qlognormal('j', 0, 2, 1) z = a + b + c + d + e + f + g + h + i + j return {'loss': scope.float(scope.log(1e-12 + z**2))}
def test7(self): p0 = hp_uniform('p0', 0, 1) p1 = hp_normal('p1', 0, 1) p2 = hp_choice('p2', [1, p0]) p3 = hp_choice('p3', [2, p1, p2, hp_uniform('a0', 2, 3)]) self.expr = {'loss': p0 + p1 + p2 + p3} self.n_randints = 2 self.wanted = [ [ ('p0', [0], [0.71295532052322719]), ('p1', [0], [0.28297849805199204]), ('p2.randint', [0], [0]), ('p3.arg:2', [0], [2.719468969785563]), ('p3.randint', [0], [2])], [ ('p0', [1], [0.78002776191207912]), ('p1', [1], [-1.506294713918092]), ('p2.randint', [1], [1]), ('p3.arg:2', [], []), ('p3.randint', [1], [1])], [ ('p0', [2], [0.57969429702261011]), ('p1', [2], [1.6796003743035337]), ('p2.randint', [2], [0]), ('p3.arg:2', [], []), ('p3.randint', [2], [1])], [ ('p0', [3], [0.43857224467962441]), ('p1', [3], [-1.3058031267484451]), ('p2.randint', [3], [1]), ('p3.arg:2', [], []), ('p3.randint', [3], [1])], [ ('p0', [4], [0.39804425533043142]), ('p1', [4], [-0.91948540682140967]), ('p2.randint', [4], [0]), ('p3.arg:2', [], []), ('p3.randint', [4], [0])]] self.foo()
def test_vectorize_trivial(): N = as_apply(15) p0 = hp_uniform("p0", 0, 1) loss = p0 print(loss) expr_idxs = scope.range(N) vh = VectorizeHelper(loss, expr_idxs, build=True) vloss = vh.v_expr full_output = as_apply([vloss, vh.idxs_by_label(), vh.vals_by_label()]) fo2 = replace_repeat_stochastic(full_output) new_vc = recursive_set_rng_kwarg(fo2, as_apply(np.random.RandomState(1))) # print new_vc losses, idxs, vals = rec_eval(new_vc) print("losses", losses) print("idxs p0", idxs["p0"]) print("vals p0", vals["p0"]) p0dct = dict(list(zip(idxs["p0"], vals["p0"]))) for ii, li in enumerate(losses): assert p0dct[ii] == li
num_filters1 = scope.int(hp_qloguniform('num_filters1',np.log(16), np.log(96), q=16)) filter1_size = scope.int(hp_quniform('filter1_shape', 2, 12, 1)) num_filters2 = scope.int(hp_qloguniform('num_filters2',np.log(16), np.log(96), q=16)) filter2_size = scope.int(hp_quniform('filter2_shape', 2, 12, 1)) num_filters3 = scope.int(hp_qloguniform('num_filters3',np.log(16), np.log(96), q=16)) filter3_size = scope.int(hp_quniform('filter3_shape', 2, 9, 1)) num_filters4 = scope.int(hp_qloguniform('num_filters4',np.log(16), np.log(64), q=16)) filter4_size = scope.int(hp_quniform('filter4_shape', 2, 9, 1)) pool1_sizex = scope.int(hp_quniform('pool1_sizex', 2, 5, 1)) pool1_type = hp_choice('pool1_type', ['max', 'avg', hp_uniform('pool_order_1', 1, 12)]) pool2_sizex = scope.int(hp_quniform('pool2_sizex', 2, 5, 1)) pool2_type = hp_choice('pool2_type', ['max', 'avg', hp_uniform('pool_order_2', 1, 4)]) rnorm1_size = scope.int(hp_quniform('rnorm1_size', 5, 12, 1)) rnorm2_size = scope.int(hp_quniform('rnorm2_size', 5, 12, 1)) layer_def_template = OrderedDict([('data', OrderedDict([('type', 'data'), ('dataidx', 0)])), ('labels', OrderedDict([('type', 'data'), ('dataidx', 1)])), ('conv1', OrderedDict([('type', 'conv'), ('inputs', 'data'), ('channels', 3),
def test_distributions(): # test that the distributions come out right # XXX: test more distributions space = { 'loss': ( hp_loguniform('lu', -2, 2) + hp_qloguniform('qlu', np.log(1 + 0.01), np.log(20), 2) + hp_quniform('qu', -4.999, 5, 1) + hp_uniform('u', 0, 10)), 'status': 'ok'} trials = base.Trials() N = 1000 fmin(lambda x: x, space=space, algo=rand.suggest, trials=trials, max_evals=N, rstate=np.random.RandomState(124), catch_eval_exceptions=False) assert len(trials) == N idxs, vals = base.miscs_to_idxs_vals(trials.miscs) print(list(idxs.keys())) COUNTMAX = 130 COUNTMIN = 70 # -- loguniform log_lu = np.log(vals['lu']) assert len(log_lu) == N assert -2 < np.min(log_lu) assert np.max(log_lu) < 2 h = np.histogram(log_lu)[0] print(h) assert np.all(COUNTMIN < h) assert np.all(h < COUNTMAX) # -- quantized log uniform qlu = vals['qlu'] assert np.all(np.fmod(qlu, 2) == 0) assert np.min(qlu) == 2 assert np.max(qlu) == 20 bc_qlu = np.bincount(qlu) assert bc_qlu[2] > bc_qlu[4] > bc_qlu[6] > bc_qlu[8] # -- quantized uniform qu = vals['qu'] assert np.min(qu) == -5 assert np.max(qu) == 5 assert np.all(np.fmod(qu, 1) == 0) bc_qu = np.bincount(np.asarray(qu).astype('int') + 5) assert np.all(40 < bc_qu), bc_qu # XXX: how to get the distribution flat # with new rounding rule? assert np.all(bc_qu < 125), bc_qu assert np.all(bc_qu < COUNTMAX) # -- uniform u = vals['u'] assert np.min(u) > 0 assert np.max(u) < 10 h = np.histogram(u)[0] print(h) assert np.all(COUNTMIN < h) assert np.all(h < COUNTMAX)
def test_vectorize_config0(): p0 = hp_uniform('p0', 0, 1) p1 = hp_loguniform('p1', 2, 3) p2 = hp_choice('p2', [-1, p0]) p3 = hp_choice('p3', [-2, p1]) p4 = 1 p5 = [3, 4, p0] p6 = hp_choice('p6', [-3, p1]) d = locals() d['p1'] = None # -- don't sample p1 all the time, only if p3 says so config = as_apply(d) N = as_apply('N:TBA') expr = config expr_idxs = scope.range(N) vh = VectorizeHelper(expr, expr_idxs, build=True) vconfig = vh.v_expr full_output = as_apply([vconfig, vh.idxs_by_label(), vh.vals_by_label()]) if 1: print('=' * 80) print('VECTORIZED') print(full_output) print('\n' * 1) fo2 = replace_repeat_stochastic(full_output) if 0: print('=' * 80) print('VECTORIZED STOCHASTIC') print(fo2) print('\n' * 1) new_vc = recursive_set_rng_kwarg( fo2, as_apply(np.random.RandomState(1)) ) if 0: print('=' * 80) print('VECTORIZED STOCHASTIC WITH RNGS') print(new_vc) Nval = 10 foo, idxs, vals = rec_eval(new_vc, memo={N: Nval}) print('foo[0]', foo[0]) print('foo[1]', foo[1]) assert len(foo) == Nval if 0: # XXX refresh these values to lock down sampler assert foo[0] == { 'p0': 0.39676747423066994, 'p1': None, 'p2': 0.39676747423066994, 'p3': 2.1281244479293568, 'p4': 1, 'p5': (3, 4, 0.39676747423066994) } assert foo[1] != foo[2] print(idxs) print(vals['p3']) print(vals['p6']) print(idxs['p1']) print(vals['p1']) assert len(vals['p3']) == Nval assert len(vals['p6']) == Nval assert len(idxs['p1']) < Nval p1d = dict(list(zip(idxs['p1'], vals['p1']))) for ii, (p3v, p6v) in enumerate(zip(vals['p3'], vals['p6'])): if p3v == p6v == 0: assert ii not in idxs['p1'] if p3v: assert foo[ii]['p3'] == p1d[ii] if p6v: print('p6', foo[ii]['p6'], p1d[ii]) assert foo[ii]['p6'] == p1d[ii]
def test_vectorize_config0(): p0 = hp_uniform('p0', 0, 1) p1 = hp_loguniform('p1', 2, 3) p2 = hp_choice('p2', [-1, p0]) p3 = hp_choice('p3', [-2, p1]) p4 = 1 p5 = [3, 4, p0] p6 = hp_choice('p6', [-3, p1]) d = locals() d['p1'] = None # -- don't sample p1 all the time, only if p3 says so config = as_apply(d) N = as_apply('N:TBA') expr = config expr_idxs = scope.range(N) vh = VectorizeHelper(expr, expr_idxs, build=True) vconfig = vh.v_expr full_output = as_apply([vconfig, vh.idxs_by_label(), vh.vals_by_label()]) if 1: print '=' * 80 print 'VECTORIZED' print full_output print '\n' * 1 fo2 = replace_repeat_stochastic(full_output) if 0: print '=' * 80 print 'VECTORIZED STOCHASTIC' print fo2 print '\n' * 1 new_vc = recursive_set_rng_kwarg(fo2, as_apply(np.random.RandomState(1))) if 0: print '=' * 80 print 'VECTORIZED STOCHASTIC WITH RNGS' print new_vc Nval = 10 foo, idxs, vals = rec_eval(new_vc, memo={N: Nval}) print 'foo[0]', foo[0] print 'foo[1]', foo[1] assert len(foo) == Nval if 0: # XXX refresh these values to lock down sampler assert foo[0] == { 'p0': 0.39676747423066994, 'p1': None, 'p2': 0.39676747423066994, 'p3': 2.1281244479293568, 'p4': 1, 'p5': (3, 4, 0.39676747423066994) } assert foo[1] != foo[2] print idxs print vals['p3'] print vals['p6'] print idxs['p1'] print vals['p1'] assert len(vals['p3']) == Nval assert len(vals['p6']) == Nval assert len(idxs['p1']) < Nval p1d = dict(zip(idxs['p1'], vals['p1'])) for ii, (p3v, p6v) in enumerate(zip(vals['p3'], vals['p6'])): if p3v == p6v == 0: assert ii not in idxs['p1'] if p3v: assert foo[ii]['p3'] == p1d[ii] if p6v: print 'p6', foo[ii]['p6'], p1d[ii] assert foo[ii]['p6'] == p1d[ii]
def test_vectorize_config0(): p0 = hp_uniform("p0", 0, 1) p1 = hp_loguniform("p1", 2, 3) p2 = hp_choice("p2", [-1, p0]) p3 = hp_choice("p3", [-2, p1]) p4 = 1 p5 = [3, 4, p0] p6 = hp_choice("p6", [-3, p1]) d = locals() d["p1"] = None # -- don't sample p1 all the time, only if p3 says so config = as_apply(d) N = as_apply("N:TBA") expr = config expr_idxs = scope.range(N) vh = VectorizeHelper(expr, expr_idxs, build=True) vconfig = vh.v_expr full_output = as_apply([vconfig, vh.idxs_by_label(), vh.vals_by_label()]) if 1: print("=" * 80) print("VECTORIZED") print(full_output) print("\n" * 1) fo2 = replace_repeat_stochastic(full_output) if 0: print("=" * 80) print("VECTORIZED STOCHASTIC") print(fo2) print("\n" * 1) new_vc = recursive_set_rng_kwarg(fo2, as_apply(np.random.RandomState(1))) if 0: print("=" * 80) print("VECTORIZED STOCHASTIC WITH RNGS") print(new_vc) Nval = 10 foo, idxs, vals = rec_eval(new_vc, memo={N: Nval}) print("foo[0]", foo[0]) print("foo[1]", foo[1]) assert len(foo) == Nval if 0: # XXX refresh these values to lock down sampler assert foo[0] == { "p0": 0.39676747423066994, "p1": None, "p2": 0.39676747423066994, "p3": 2.1281244479293568, "p4": 1, "p5": (3, 4, 0.39676747423066994), } assert (foo[1].keys() != foo[2].keys()) or (foo[1].values() != foo[2].values()) print(idxs) print(vals["p3"]) print(vals["p6"]) print(idxs["p1"]) print(vals["p1"]) assert len(vals["p3"]) == Nval assert len(vals["p6"]) == Nval assert len(idxs["p1"]) < Nval p1d = dict(list(zip(idxs["p1"], vals["p1"]))) for ii, (p3v, p6v) in enumerate(zip(vals["p3"], vals["p6"])): if p3v == p6v == 0: assert ii not in idxs["p1"] if p3v: assert foo[ii]["p3"] == p1d[ii] if p6v: print("p6", foo[ii]["p6"], p1d[ii]) assert foo[ii]["p6"] == p1d[ii]
def test_distributions(): # test that the distributions come out right # XXX: test more distributions space = { 'loss': (hp_loguniform('lu', -2, 2) + hp_qloguniform('qlu', np.log(1 + 0.01), np.log(20), 2) + hp_quniform('qu', -4.999, 5, 1) + hp_uniform('u', 0, 10)), 'status': 'ok' } trials = base.Trials() N = 1000 fmin(lambda x: x, space=space, algo=rand.suggest, trials=trials, max_evals=N, rstate=np.random.RandomState(124), catch_eval_exceptions=False) assert len(trials) == N idxs, vals = base.miscs_to_idxs_vals(trials.miscs) print(list(idxs.keys())) COUNTMAX = 130 COUNTMIN = 70 # -- loguniform log_lu = np.log(vals['lu']) assert len(log_lu) == N assert -2 < np.min(log_lu) assert np.max(log_lu) < 2 h = np.histogram(log_lu)[0] print(h) assert np.all(COUNTMIN < h) assert np.all(h < COUNTMAX) # -- quantized log uniform qlu = vals['qlu'] assert np.all(np.fmod(qlu, 2) == 0) assert np.min(qlu) == 2 assert np.max(qlu) == 20 bc_qlu = np.bincount(qlu) assert bc_qlu[2] > bc_qlu[4] > bc_qlu[6] > bc_qlu[8] # -- quantized uniform qu = vals['qu'] assert np.min(qu) == -5 assert np.max(qu) == 5 assert np.all(np.fmod(qu, 1) == 0) bc_qu = np.bincount(np.asarray(qu).astype('int') + 5) assert np.all(40 < bc_qu), bc_qu # XXX: how to get the distribution flat # with new rounding rule? assert np.all(bc_qu < 125), bc_qu assert np.all(bc_qu < COUNTMAX) # -- uniform u = vals['u'] assert np.min(u) > 0 assert np.max(u) < 10 h = np.histogram(u)[0] print(h) assert np.all(COUNTMIN < h) assert np.all(h < COUNTMAX)
def uslm_domain(Xcm, batchsize, chmjr_image_shape, output_sizes, n_patches=50000, max_n_features=16000, max_layer_sizes=(64, 128), batched_lmap_speed_thresh=None, permit_affine_warp=True, abort_on_rows_larger_than=None, ): """ This function works by creating a linear pipeline, with multiple exit points that could be the feature representation for classification. The function returns a switch among all of these exit points. """ start_time = time.time() XC, XH, XW = chmjr_image_shape osize = hp_choice('warp_osize', output_sizes) assert XW > 3, chmjr_image_shape # -- make sure we don't screw up channel-major warp_options = [ # -- option 1: simple resize partial(slm_affine_image_warp, rot=0, shear=0, scale=[s_float(osize) / XH, s_float(osize) / XW], trans=[0, 0], oshape=[osize, osize]), ] if permit_affine_warp: # -- option 2: resize with rotation, shear, translation warp_options.append( partial(slm_affine_image_warp, rot=hp_uniform('warp_rot', low=-0.3, high=0.3), shear=hp_uniform('warp_shear', low=-0.3, high=0.3), # -- most of the scaling comes via osize scale=[ hp_uniform('warp_scale_h', low=0.8, high=1.2) * osize / XH, hp_uniform('warp_scale_v', low=0.8, high=1.2) * osize / XW, ], trans=[ hp_uniform('warp_trans_h', low=-0.2, high=0.2) * osize, hp_uniform('warp_trans_v', low=-0.2, high=0.2) * osize, ], oshape=[osize, osize] )) pipeline = [slm_img_uint8_to_float32, hp_choice('warp', warp_options)] Xcm = pyll_theano_batched_lmap( partial(callpipe1, pipeline), Xcm, batchsize=batchsize, print_progress_every=10, speed_thresh=batched_lmap_speed_thresh, abort_on_rows_larger_than=abort_on_rows_larger_than, x_dtype='uint8', )[:] exits = pipeline_exits( pipeline, layer_num=0, Xcm=Xcm, n_patches=n_patches, max_n_features=max_n_features) for layer_i, max_layer_size in enumerate(max_layer_sizes): extension = pipeline_extension( 'l%i' % layer_i, Xcm, n_patches, max_layer_size) pipeline.extend(extension) Xcm = pyll_theano_batched_lmap( partial(callpipe1, extension), Xcm, # scope.print_ndarray_summary('Xcm %i' % layer_i, Xcm), batchsize=batchsize, print_progress_every=10, speed_thresh=batched_lmap_speed_thresh, abort_on_rows_larger_than=abort_on_rows_larger_than, )[:] # -- indexing computes all the values (during rec_eval) exits.extend( pipeline_exits( pipeline=pipeline, layer_num=layer_i + 1, Xcm=Xcm, n_patches=n_patches, max_n_features=max_n_features)) return hp_choice("exit", exits)
filter1_size = scope.int(hp_quniform('filter1_shape', 5, 12, 1)) num_filters2 = scope.int(hp_quniform('num_filters2', 64, 400, 16)) filter2_size = scope.int(hp_quniform('filter2_shape', 4, 7, 1)) num_filters3 = scope.int(hp_quniform('num_filters3', 64, 400, 16)) filter3_size = scope.int(hp_quniform('filter3_shape', 3, 5, 1)) num_filters4 = scope.int(hp_quniform('num_filters4', 64, 400, 16)) filter4_size = scope.int(hp_quniform('filter4_shape', 3, 4, 1)) num_filters5 = scope.int(hp_quniform('num_filters5', 64, 400, 16)) filter5_size = scope.int(hp_quniform('filter5_shape', 2, 3, 1)) pool1_sizex = scope.int(hp_quniform('pool1_sizex', 2, 4, 1)) pool1_type = hp_choice('pool1_type', ['max', 'avg', hp_uniform('pool_order_1', 1, 4)]) pool2_sizex = scope.int(hp_quniform('pool2_sizex', 2, 4, 1)) pool2_type = hp_choice('pool2_type', ['max', 'avg', hp_uniform('pool_order_2', 1, 4)]) pool3_sizex = scope.int(hp_quniform('pool3_sizex', 2, 4, 1)) pool3_type = hp_choice('pool3_type', ['max', 'avg', hp_uniform('pool_order_3', 1, 4)]) rnorm1_size = scope.int(hp_quniform('rnorm1_size', 4, 6, 1)) rnorm2_size = scope.int(hp_quniform('rnorm2_size', 4, 6, 1)) rnorm3_size = scope.int(hp_quniform('rnorm3_size', 4, 6, 1)) rnorm4_size = scope.int(hp_quniform('rnorm4_size', 4, 6, 1)) rnorm5_size = scope.int(hp_quniform('rnorm5_size', 4, 6, 1)) layer_def_template = OrderedDict([('data', OrderedDict([('type', 'data'), ('dataidx', 0)])),