Esempio n. 1
0
def run():
    all_xs = np.concatenate([
        make_circle(N_samples) * init_scale * (i + 1) + init_mu
        for i in range(num_rings)
    ])

    print "Running experiment..."
    results = defaultdict(list)
    for i in xrange(N_samples * num_rings):

        def callback(x, t, g, v):
            if i in sample_trails_ix:
                results[("trail_x", i)].append(x.copy())
            results[("likelihood", i)].append(-nllfun(x))
            if t in snapshot_times:
                results[("all_x", t)].append(x.copy())

        x = sgd(gradfun,
                x=all_xs[i],
                iters=N_iter,
                learn_rate=alpha,
                decay=0.0,
                callback=callback)
        callback(x, N_iter, 0.0, 0.0)
    return results
Esempio n. 2
0
def run():
    print "Running experiment..."
    sgd_optimized_points = []
    ed_optimized_points = []
    aed_optimized_points = []
    asgd_optimized_points = []
    for i in xrange(N_samples):
        rs = RandomState((seed, i))
        x0 = rs.randn(D) * x_init_scale
        v0 = rs.randn(D) * v_init_scale
        sgd_optimized_points.append(
            sgd(grad(nllfunt), x=x0, v=v0, learn_rate=alpha, decay=decay, iters=N_iter))

        rs = RandomState((seed, i))
        x0 = rs.randn(D) * x_init_scale
        v0 = rs.randn(D) * v_init_scale
        ed_optimized_points.append(
            entropic_descent(grad(nllfunt), x=x0, v=v0, learn_rate=alpha, decay=decay, iters=N_iter, theta=theta, rs=rs))
        entropy = np.log(decay) * D * N_iter

        rs = RandomState((seed, i))
        x0 = rs.randn(D) * x_init_scale
        v0 = rs.randn(D) * v_init_scale
        aed_optimized_points.append(
            adaptive_entropic_descent(grad(nllfunt), x=x0, v=v0, init_learn_rate=alpha, init_log_decay=np.log(decay), meta_learn_rate=meta_alpha, meta_decay=meta_decay, iters=N_iter))

        rs = RandomState((seed, i))
        x0 = rs.randn(D) * x_init_scale
        v0 = rs.randn(D) * v_init_scale
        asgd_optimized_points.append(
            adaptive_sgd(grad(nllfunt), x=x0, v=v0, init_learn_rate=alpha, init_log_decay=np.log(decay), meta_learn_rate=meta_alpha, meta_decay=meta_decay, iters=N_iter))

    return sgd_optimized_points, ed_optimized_points, aed_optimized_points, asgd_optimized_points, entropy
Esempio n. 3
0
def run():
    print "Running experiment..."
    sgd_optimized_points = []
    ed_optimized_points = []
    for i in xrange(N_samples):
        rs = RandomState((seed, i))
        x0 = rs.randn(D) * x_init_scale
        v0 = rs.randn(D) * v_init_scale
        sgd_optimized_points.append(
            sgd(grad(nllfunt),
                x=x0,
                v=v0,
                learn_rate=alpha,
                decay=decay,
                iters=N_iter))

        rs = RandomState((seed, i))
        x0 = rs.randn(D) * x_init_scale
        v0 = rs.randn(D) * v_init_scale
        ed_optimized_points.append(
            entropic_descent(grad(nllfunt),
                             x=x0,
                             v=v0,
                             learn_rate=alpha,
                             decay=decay,
                             iters=N_iter,
                             theta=theta,
                             rs=rs))
        entropy = np.log(decay) * D * N_iter

    return sgd_optimized_points, ed_optimized_points, entropy
Esempio n. 4
0
def run():
    print "Running experiment..."
    sgd_optimized_points = []
    for i in xrange(N_samples):
        rs = RandomState((seed, i))
        x0 = rs.randn(D) * x_init_scale
        v0 = rs.randn(D) * v_init_scale
        sgd_optimized_points.append(
            sgd(grad(nllfunt), x=x0, v=v0, learn_rate=alpha, decay=decay, iters=N_iter))

    return sgd_optimized_points, entropy
Esempio n. 5
0
def run():
    all_xs = np.concatenate([make_circle(N_samples) * init_scale*(i+1) + init_mu for i in range(num_rings)])

    print "Running experiment..."
    results = defaultdict(list)
    for i in xrange(N_samples * num_rings):
        def callback(x, t, g, v):
            if i in sample_trails_ix:
                results[("trail_x", i)].append(x.copy())
            results[("likelihood", i)].append(-nllfun(x))
            if t in snapshot_times:
                results[("all_x", t)].append(x.copy())

        x = sgd(gradfun, x=all_xs[i], iters=N_iter, learn_rate=alpha, decay=0.0, callback=callback)
        callback(x, N_iter, 0.0, 0.0)
    return results