def test_structured_params(make_quadratic, make_random): random = make_random a, b, c, data, _ = make_quadratic w0 = [ Parameter(random.randn(2), Bound()), Parameter(random.randn(1), Bound()) ] qobj_struc = lambda w12, w3, data: q_struc(w12, w3, data, qobj) assert_opt = lambda Eab, Ec: \ np.allclose((a, b, c), (Eab[0], Eab[1], Ec), atol=1e-3, rtol=0) nmin = structured_minimizer(minimize) res = nmin(qobj_struc, w0, args=(data, ), jac=True, method='L-BFGS-B') assert_opt(*res.x) nsgd = structured_sgd(sgd) res = nsgd(qobj_struc, w0, data, eval_obj=True, random_state=make_random) assert_opt(*res.x) qf_struc = lambda w12, w3, data: q_struc(w12, w3, data, qfun) qg_struc = lambda w12, w3, data: q_struc(w12, w3, data, qgrad) res = nmin(qf_struc, w0, args=(data, ), jac=qg_struc, method='L-BFGS-B') assert_opt(*res.x)
def test_rand_start(make_quadratic, make_random): random = make_random a, b, c, data, _ = make_quadratic w0 = [Parameter(gamma(1), Positive(), shape=(2, )), Parameter(1., Bound())] qobj_struc = lambda w12, w3, data: q_struc(w12, w3, data, qobj) assert_opt = lambda Eab, Ec: \ np.allclose((a, b, c), (Eab[0], Eab[1], Ec), atol=1e-3, rtol=0) nmin = structured_minimizer(logtrick_minimizer(minimize)) res = nmin(qobj_struc, w0, args=(data, ), jac=True, method='L-BFGS-B', random_state=random, nstarts=100) assert_opt(*res.x) nsgd = structured_sgd(logtrick_sgd(sgd)) res = nsgd(qobj_struc, w0, data, eval_obj=True, nstarts=100, random_state=random) assert_opt(*res.x)
def test_log_params(make_quadratic): a, b, c, data, _ = make_quadratic w0 = np.abs(np.random.randn(3)) bounds = [Positive(), Bound(), Positive()] assert_opt = lambda Ea, Eb, Ec: \ np.allclose((a, b, c), (Ea, Eb, Ec), atol=1e-3, rtol=0) nmin = logtrick_minimizer(minimize) res = nmin(qobj, w0, args=(data, ), jac=True, method='L-BFGS-B', bounds=bounds) assert_opt(*res.x) nsgd = logtrick_sgd(sgd) res = nsgd(qobj, w0, data, eval_obj=True, bounds=bounds, random_state=randstate) assert_opt(*res.x) nmin = logtrick_minimizer(minimize) res = nmin(qfun, w0, args=(data, ), jac=qgrad, method='L-BFGS-B', bounds=bounds) assert_opt(*res.x)
def learn(X, y, kerneldef, opt_criterion=None, verbose=False, ftol=1e-8, maxiter=10000): n, d = X.shape if opt_criterion is None: opt_criterion = criterions.negative_log_marginal_likelihood else: pass # check type cov_fn = compose(kerneldef) # Automatically determine the range meta = get_meta(kerneldef) params = [ Parameter(i, Bound(l, h)) for i, l, h in zip( meta.initial_val, meta.lower_bound, meta.upper_bound) ] def criterion(*theta): K = cov_fn(X, X, theta, True) # learn with noise! factors = np.linalg.svd(K) value = opt_criterion(y, factors) if verbose: log.info("[{0}] {1}".format(value, theta)) return value # up to here nmin = structured_minimizer(minimize) result = nmin(criterion, params, tol=ftol, options={'maxiter': maxiter}, jac=False, method='L-BFGS-B') print(result) return result.x
def test_bases(make_gaus_data): X, _, _ = make_gaus_data N, d = X.shape nC = 10 bases = [ bs.BiasBasis(), bs.LinearBasis(onescol=True), bs.PolynomialBasis(order=2), bs.RadialBasis(centres=X[:nC, :]), bs.RadialBasis(centres=X[:nC, :], lenscale_init=Parameter(np.ones(d), Positive())), bs.SigmoidalBasis(centres=X[:nC, :]), bs.SigmoidalBasis(centres=X[:nC, :], lenscale_init=Parameter(np.ones(d), Positive())), bs.RandomRBF(Xdim=d, nbases=10), bs.RandomRBF(Xdim=d, nbases=10, lenscale_init=Parameter(np.ones(d), Positive())), bs.FastFoodRBF(Xdim=d, nbases=10), bs.FastFoodRBF(Xdim=d, nbases=10, lenscale_init=Parameter(np.ones(d), Positive())), bs.FastFoodGM(Xdim=d, nbases=10), bs.FastFoodGM(Xdim=d, nbases=10, mean_init=Parameter(np.zeros(d), Bound()), lenscale_init=Parameter(np.ones(d), Positive())), ] hypers = [(), (), (), (1., ), (np.ones(d), ), (1., ), (np.ones(d), ), (1., ), (np.ones(d), ), (1., ), (np.ones(d), ), (np.ones(d), np.ones(d)), (np.ones(d), np.ones(d))] for b, h in zip(bases, hypers): P = b.transform(X, *h) dP = b.grad(X, *h) assert P.shape[0] == N if not issequence(dP): assert dP.shape[0] == N if not isinstance(dP, list) else dP == [] else: for dp in dP: assert dp.shape[0] == N assert P.ndim == 2 bcat = reduce(add, bases) hyps = [] for h in hypers: hyps.extend(list(h)) P = bcat.transform(X, *hyps) dP = bcat.grad(X, *hyps) assert bcat.get_dim(X) == P.shape[1] assert P.shape[0] == N assert P.ndim == 2 for dp in dP: if not issequence(dP): assert dP.shape[0] == N if not isinstance(dP, list) else dP == [] else: for dp in dP: assert dp.shape[0] == N