def test_incomplete_cholesky_asymmetric():
    kernel = lambda X, Y = None : gaussian_kernel(X, Y, sigma=1.)
    X = np.random.randn(1000, 10)
    Y = np.random.randn(100, 10)
    
    low_rank_dim = int(len(X)*0.8)
    temp = incomplete_cholesky(X, kernel, eta=low_rank_dim)
    R, I, nu = (temp["R"], temp["I"], temp["nu"])
    
    # construct train-train kernel matrix approximation using one by one calls
    R_test = incomplete_cholesky_new_points(X, Y, kernel, I, R, nu)
    
    assert_allclose(kernel(X, Y), R.T.dot(R_test), atol=10e-1)
예제 #2
0
def test_incomplete_cholesky_asymmetric():
    kernel = lambda X, Y=None: gaussian_kernel(X, Y, sigma=1.)
    X = np.random.randn(1000, 10)
    Y = np.random.randn(100, 10)

    low_rank_dim = int(len(X) * 0.8)
    temp = incomplete_cholesky(X, kernel, eta=low_rank_dim)
    R, I, nu = (temp["R"], temp["I"], temp["nu"])

    # construct train-train kernel matrix approximation using one by one calls
    R_test = incomplete_cholesky_new_points(X, Y, kernel, I, R, nu)

    assert_allclose(kernel(X, Y), R.T.dot(R_test), atol=10e-1)
def test_incomplete_cholesky_new_points_euqals_new_point():
    kernel = lambda X, Y = None : gaussian_kernel(X, Y, sigma=200.)
    X = np.random.randn(1000, 10)
    low_rank_dim = 15
    temp = incomplete_cholesky(X, kernel, eta=low_rank_dim)
    R, I, nu = (temp["R"], temp["I"], temp["nu"])
    
    R_test_full = incomplete_cholesky_new_points(X, X, kernel, I, R, nu)

    # construct train-train kernel matrix approximation using one by one calls
    R_test = np.zeros(R.shape)
    for i in range(low_rank_dim):
        R_test[:, i] = incomplete_cholesky_new_point(X, X[i], kernel, I, R, nu)
        assert_allclose(R_test[:, i], R_test_full[:, i], atol=0.001)
예제 #4
0
def test_incomplete_cholesky_new_points_euqals_new_point():
    kernel = lambda X, Y=None: gaussian_kernel(X, Y, sigma=200.)
    X = np.random.randn(1000, 10)
    low_rank_dim = 15
    temp = incomplete_cholesky(X, kernel, eta=low_rank_dim)
    R, I, nu = (temp["R"], temp["I"], temp["nu"])

    R_test_full = incomplete_cholesky_new_points(X, X, kernel, I, R, nu)

    # construct train-train kernel matrix approximation using one by one calls
    R_test = np.zeros(R.shape)
    for i in range(low_rank_dim):
        R_test[:, i] = incomplete_cholesky_new_point(X, X[i], kernel, I, R, nu)
        assert_allclose(R_test[:, i], R_test_full[:, i], atol=0.001)
def test_compute_b_matches_full():
    sigma = 1.
    X = np.random.randn(100, 2)
    Y = np.random.randn(50, 2)

    low_rank_dim = int(len(X) * 0.9)
    kernel = lambda X, Y: gaussian_kernel(X, Y, sigma=sigma)
    K_XY = kernel(X, Y)
    temp = incomplete_cholesky(X, kernel, eta=low_rank_dim)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])
    R_test = incomplete_cholesky_new_points(X, Y, kernel, I, R, nu)

    x = gaussian.compute_b(X, Y, K_XY, sigma)
    y = gaussian_low_rank.compute_b(X, Y, R.T, R_test.T, sigma)
    assert_allclose(x, y, atol=5e-1)
def test_compute_b_matches_full():
    sigma = 1.
    X = np.random.randn(100, 2)
    Y = np.random.randn(50, 2)
    
    low_rank_dim = int(len(X) * 0.9)
    kernel = lambda X, Y: gaussian_kernel(X, Y, sigma=sigma)
    K_XY = kernel(X, Y)
    temp = incomplete_cholesky(X, kernel, eta=low_rank_dim)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])
    R_test = incomplete_cholesky_new_points(X, Y, kernel, I, R, nu)
    
    x = gaussian.compute_b(X, Y, K_XY, sigma)
    y = gaussian_low_rank.compute_b(X, Y, R.T, R_test.T, sigma)
    assert_allclose(x, y, atol=5e-1)
def test_fit_matches_sym():
    sigma = 1.
    lmbda = 1.
    Z = np.random.randn(100, 2)
    low_rank_dim = int(len(Z) * .9)

    kernel = lambda X, Y: gaussian_kernel(X, Y, sigma=sigma)

    temp = incomplete_cholesky(Z, kernel, eta=low_rank_dim)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])
    R_test = incomplete_cholesky_new_points(Z, Z, kernel, I, R, nu)

    a = gaussian_low_rank.fit(Z, Z, sigma, lmbda, R.T, R_test.T)
    a_sym = develop_gaussian_low_rank.fit_sym(Z, sigma, lmbda, R.T)

    assert_allclose(a, a_sym, atol=1e-5)
def test_fit_matches_sym():
    sigma = 1.
    lmbda = 1.
    Z = np.random.randn(100, 2)
    low_rank_dim = int(len(Z) * .9)
    
    kernel = lambda X, Y: gaussian_kernel(X, Y, sigma=sigma)
    
    temp = incomplete_cholesky(Z, kernel, eta=low_rank_dim)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])
    R_test = incomplete_cholesky_new_points(Z, Z, kernel, I, R, nu)
    
    a = gaussian_low_rank.fit(Z, Z, sigma, lmbda, R.T, R_test.T)
    a_sym = develop_gaussian_low_rank.fit_sym(Z, sigma, lmbda, R.T)
    
    assert_allclose(a, a_sym)
def apply_C_matches_sym():
    sigma = 1.
    N_X = 100
    X = np.random.randn(N_X, 2)

    kernel = lambda X, Y: gaussian_kernel(X, Y, sigma=sigma)
    temp = incomplete_cholesky(X, kernel, eta=0.1)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])

    R_test = incomplete_cholesky_new_points(X, X, kernel, I, R, nu)

    v = np.random.randn(N_X.shape[0])
    lmbda = 1.

    x = gaussian_low_rank.apply_left_C(v, X, X, R.T, R_test.T, lmbda)
    y = develop_gaussian_low_rank.apply_left_C_sym(v, X, R.T, lmbda)
    assert_allclose(x, y)
def apply_C_matches_sym():
    sigma = 1.
    N_X = 100
    X = np.random.randn(N_X, 2)
    
    kernel = lambda X, Y: gaussian_kernel(X, Y, sigma=sigma)
    temp = incomplete_cholesky(X, kernel, eta=0.1)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])
    
    R_test = incomplete_cholesky_new_points(X, X, kernel, I, R, nu)
    
    v = np.random.randn(N_X.shape[0])
    lmbda = 1.
    
    x = gaussian_low_rank.apply_left_C(v, X, X, R.T, R_test.T, lmbda)
    y = develop_gaussian_low_rank.apply_left_C_sym(v, X, R.T, lmbda)
    assert_allclose(x, y)
def test_objective_matches_sym():
    sigma = 1.
    lmbda = 1.
    Z = np.random.randn(100, 2)
    
    kernel = lambda X, Y: gaussian_kernel(X, Y, sigma=sigma)
    alpha = np.random.randn(len(Z))
    
    temp = incomplete_cholesky(Z, kernel, eta=0.1)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])
    
    R_test = incomplete_cholesky_new_points(Z, Z, kernel, I, R, nu)
    
    b = gaussian_low_rank.compute_b(Z, Z, R.T, R_test.T, sigma)
    
    J_sym = develop_gaussian_low_rank.objective_sym(Z, sigma, lmbda, alpha, R.T, b)
    J = gaussian_low_rank.objective(Z, Z, sigma, lmbda, alpha, R.T, R_test.T, b)
    
    assert_close(J, J_sym)
def test_apply_C_left_matches_full():
    sigma = 1.
    N = 100
    X = np.random.randn(N, 2)
    Y = np.random.randn(20, 2)
    low_rank_dim = int(len(X) * .9)
    kernel = lambda X, Y = None: gaussian_kernel(X, Y, sigma=sigma)
    K_XY = kernel(X, Y)
    K = kernel(X)
    
    temp = incomplete_cholesky(X, kernel, eta=low_rank_dim)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])
    R_test = incomplete_cholesky_new_points(X, Y, kernel, I, R, nu)
    
    v = np.random.randn(X.shape[0])
    lmbda = 1.
    
    x = (gaussian.compute_C(X, Y, K_XY, sigma) + (K + np.eye(len(X))) * lmbda).dot(v)
    y = gaussian_low_rank.apply_left_C(v, X, Y, R.T, R_test.T, lmbda)
    assert_allclose(x, y, atol=1e-1)
def test_apply_C_left_matches_full():
    sigma = 1.
    N = 100
    X = np.random.randn(N, 2)
    Y = np.random.randn(20, 2)
    low_rank_dim = int(len(X) * .9)
    kernel = lambda X, Y=None: gaussian_kernel(X, Y, sigma=sigma)
    K_XY = kernel(X, Y)
    K = kernel(X)

    temp = incomplete_cholesky(X, kernel, eta=low_rank_dim)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])
    R_test = incomplete_cholesky_new_points(X, Y, kernel, I, R, nu)

    v = np.random.randn(X.shape[0])
    lmbda = 1.

    x = (gaussian.compute_C(X, Y, K_XY, sigma) +
         (K + np.eye(len(X))) * lmbda).dot(v)
    y = gaussian_low_rank.apply_left_C(v, X, Y, R.T, R_test.T, lmbda)
    assert_allclose(x, y, atol=1e-1)
def test_objective_matches_sym():
    sigma = 1.
    lmbda = 1.
    Z = np.random.randn(100, 2)

    kernel = lambda X, Y: gaussian_kernel(X, Y, sigma=sigma)
    alpha = np.random.randn(len(Z))

    temp = incomplete_cholesky(Z, kernel, eta=0.1)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])

    R_test = incomplete_cholesky_new_points(Z, Z, kernel, I, R, nu)

    b = gaussian_low_rank.compute_b(Z, Z, R.T, R_test.T, sigma)

    J_sym = develop_gaussian_low_rank.objective_sym(Z, sigma, lmbda, alpha,
                                                    R.T, b)
    J = gaussian_low_rank.objective(Z, Z, sigma, lmbda, alpha, R.T, R_test.T,
                                    b)

    assert_close(J, J_sym)
def test_objective_matches_full():
    sigma = 1.
    lmbda = 1.
    X = np.random.randn(100, 2)
    Y = np.random.randn(10, 2)
    low_rank_dim = int(len(X) * 0.9)
    
    kernel = lambda X, Y: gaussian_kernel(X, Y, sigma=sigma)
    alpha = np.random.randn(len(X))
    
    K_XY = kernel(X, Y)
    C = gaussian.compute_C(X, Y, K_XY, sigma)
    b = gaussian.compute_b(X, Y, K_XY, sigma)
    J_full = gaussian.objective(X, Y, sigma, lmbda, alpha, K_XY=K_XY, b=b, C=C)
    
    temp = incomplete_cholesky(X, kernel, eta=low_rank_dim)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])
    R_test = incomplete_cholesky_new_points(X, Y, kernel, I, R, nu)
    b = gaussian_low_rank.compute_b(X, Y, R.T, R_test.T, sigma)
    J = gaussian_low_rank.objective(X, Y, sigma, lmbda, alpha, R.T, R_test.T, b)
    
    assert_close(J, J_full, decimal=1)
def test_objective_matches_full():
    sigma = 1.
    lmbda = 1.
    X = np.random.randn(100, 2)
    Y = np.random.randn(10, 2)
    low_rank_dim = int(len(X) * 0.9)

    kernel = lambda X, Y: gaussian_kernel(X, Y, sigma=sigma)
    alpha = np.random.randn(len(X))

    K_XY = kernel(X, Y)
    C = gaussian.compute_C(X, Y, K_XY, sigma)
    b = gaussian.compute_b(X, Y, K_XY, sigma)
    J_full = gaussian.objective(X, Y, sigma, lmbda, alpha, K_XY=K_XY, b=b, C=C)

    temp = incomplete_cholesky(X, kernel, eta=low_rank_dim)
    I, R, nu = (temp["I"], temp["R"], temp["nu"])
    R_test = incomplete_cholesky_new_points(X, Y, kernel, I, R, nu)
    b = gaussian_low_rank.compute_b(X, Y, R.T, R_test.T, sigma)
    J = gaussian_low_rank.objective(X, Y, sigma, lmbda, alpha, R.T, R_test.T,
                                    b)

    assert_close(J, J_full, decimal=1)