示例#1
1
def test_tga_check_list():
    # Test that the projection by TGA on list data is correct
    X = [[1.0, 0.0], [0.0, 1.0]]
    X_transformed = TGA(n_components=1,
                        random_state=0).fit(X).transform(X)
    assert_equal(X_transformed.shape, (2, 1))
    assert_almost_equal(X_transformed.mean(), 0.00, 2)
    assert_almost_equal(X_transformed.std(), 0.71, 2)
示例#2
1
def test_tga_inverse():
    # Test that the projection of data can be inverted
    rng = np.random.RandomState(0)
    n, p = 50, 3
    X = rng.randn(n, p)  # spherical data
    X[:, 1] *= .00001  # make middle component relatively small
    X += [5, 4, 3]  # make a large mean

    # same check that we can find the original data from the transformed
    # signal (since the data is almost of rank n_components)
    tga = TGA(n_components=2).fit(X)
    Y = tga.transform(X)
    Y_inverse = tga.inverse_transform(Y)
    assert_almost_equal(X, Y_inverse, decimal=3)
示例#3
1
文件: demo_tga.py 项目: vyraun/tga
    ax.cla()
    ax.imshow(img.reshape(shape), cmap="gray", interpolation="nearest")
    ax.set_xticklabels([])
    ax.set_yticklabels([])


if __name__ == "__main__":
    import sys
    import glob
    import matplotlib.pyplot as pl

    use_data = str(sys.argv[1])
    M, shape = bitmap_to_mat(glob.glob(use_data + "/*.bmp")[:2000:2])
    print(M.shape)

    tga = TGA(n_components=5, random_state=1)
    start_time = time.time()
    tga.fit(M)
    print("fitted, time taken {0}s".format(time.time() - start_time))
    start_time = time.time()
    transformed = tga.transform(M)
    L = tga.inverse_transform(transformed)
    print('calculated L, time taken {0}s'.format(time.time() - start_time))
    S = M - L

    if not os.path.exists('results_tga'):
        os.makedirs('results_tga')

    directory = "results_tga/" + use_data
    if not os.path.exists(directory):
        os.makedirs(directory)
示例#4
1
def test_tga_median():
    # TGA on dense arrays
    tga = TGA(n_components=2, random_state=1, centering='median')
    X = iris.data
    X_r = tga.fit(X).transform(X)
    assert_equal(X_r.shape[1], 2)

    tga = TGA(n_components=2, random_state=1, centering='median')
    X_r2 = tga.fit_transform(X)
    assert_array_almost_equal(X_r, X_r2)

    tga = TGA(random_state=1, centering='median')
    tga.fit(X)
    X_r = tga.transform(X)
    tga = TGA(random_state=1, centering='median')
    X_r2 = tga.fit_transform(X)
    assert_array_almost_equal(X_r, X_r2)
示例#5
0
def test_pca_error():
    X = [[0, 1], [1, 0]]
    for n_components in [-1, 3]:
        assert_raises(ValueError, TGA(n_components).fit, X)
    for trim_p in [-0.1, 0.6]:
        assert_raises(ValueError, TGA(trim_proportion=trim_p).fit, X)
    assert_raises(ValueError, TGA(centering='invalid').fit, X)
示例#6
0
def test_tga_dim():
    # Check automated dimensionality setting
    rng = np.random.RandomState(0)
    n, p = 100, 5
    X = rng.randn(n, p) * .1
    tga = TGA().fit(X)
    assert_equal(tga.components_.shape[0], 5)
示例#7
0
def test_tga_check_projection():
    # Test that the projection by RandomizedPCA on dense data is correct
    rng = np.random.RandomState(0)
    n, p = 100, 3
    X = rng.randn(n, p) * .1
    X[:10] += np.array([3, 4, 5])
    Xt = 0.1 * rng.randn(1, p) + np.array([3, 4, 5])

    Yt = TGA(n_components=2, random_state=0).fit(X).transform(Xt)
    Yt /= np.sqrt((Yt ** 2).sum())

    assert_almost_equal(np.abs(Yt[0][0]), 1., 1)
 'sepnmf':
 lambda args: NimfaWrapper(nimfa.SepNMF, args.dims),
 'spca':
 lambda args: SparsePCA(
     n_components=args.dims, n_jobs=args.njobs, normalize_components=True),
 'spca-batch':
 lambda args: MiniBatchSparsePCA(
     n_components=args.dims, n_jobs=args.njobs, normalize_components=True),
 'spectral':
 lambda args: SpectralEmbedding(n_components=args.dims, n_jobs=args.njobs),
 'snmf':
 lambda args: NimfaWrapper(nimfa.Snmf, args.dims),
 'srp':
 lambda args: SparseRandomProjection(n_components=args.dims),
 'tga':
 lambda args: TGA(n_components=args.dims)
 if TGA_AVAILABLE else _embedding_error(),
 'tsvd':
 lambda args: TruncatedSVD(n_components=args.dims),
 'tsne':
 lambda args: TSNE(n_components=args.dims),
 'umap':
 lambda args: umap.UMAP(n_components=args.dims)
 if UMAP_AVAILABLE else _embedding_error(),
 'vpac':
 lambda args: VpacWrapper(args.dims)
 if VPAC_AVAILABLE else _embedding_error(),
 'vasc':
 lambda args: VascWrapper(args.dims)
 if VPAC_AVAILABLE else _embedding_error(),
 'zifa':