class TestSingleStiefelManifold(unittest.TestCase): def setUp(self): self.m = m = 20 self.n = n = 2 self.k = k = 1 self.man = Stiefel(m, n, k=k) self.proj = lambda x, u: u - npa.dot(x, npa.dot(x.T, u) + npa.dot(u.T, x)) / 2 def test_dim(self): assert self.man.dim == 0.5 * self.n * (2 * self.m - self.n - 1) # def test_typicaldist(self): # def test_dist(self): def test_inner(self): X = la.qr(rnd.randn(self.m, self.n))[0] A, B = rnd.randn(2, self.m, self.n) np_testing.assert_allclose(np.sum(A * B), self.man.inner(X, A, B)) def test_proj(self): # Construct a random point X on the manifold. X = rnd.randn(self.m, self.n) X = la.qr(X)[0] # Construct a vector H in the ambient space. H = rnd.randn(self.m, self.n) # Compare the projections. Hproj = H - X.dot(X.T.dot(H) + H.T.dot(X)) / 2 np_testing.assert_allclose(Hproj, self.man.proj(X, H)) def test_rand(self): # Just make sure that things generated are on the manifold and that # if you generate two they are not equal. X = self.man.rand() np_testing.assert_allclose(X.T.dot(X), np.eye(self.n), atol=1e-10) Y = self.man.rand() assert np.linalg.norm(X - Y) > 1e-6 def test_randvec(self): # Make sure things generated are in tangent space and if you generate # two then they are not equal. X = self.man.rand() U = self.man.randvec(X) np_testing.assert_allclose(multisym(X.T.dot(U)), np.zeros((self.n, self.n)), atol=1e-10) V = self.man.randvec(X) assert la.norm(U - V) > 1e-6 def test_retr(self): # Test that the result is on the manifold and that for small # tangent vectors it has little effect. x = self.man.rand() u = self.man.randvec(x) xretru = self.man.retr(x, u) np_testing.assert_allclose(xretru.T.dot(xretru), np.eye(self.n, self.n), atol=1e-10) u = u * 1e-6 xretru = self.man.retr(x, u) np_testing.assert_allclose(xretru, x + u) def test_ehess2rhess(self): # Test this function at some randomly generated point. x = self.man.rand() u = self.man.randvec(x) egrad = rnd.randn(self.m, self.n) ehess = rnd.randn(self.m, self.n) np_testing.assert_allclose(testing.ehess2rhess(self.proj)(x, egrad, ehess, u), self.man.ehess2rhess(x, egrad, ehess, u)) # def test_egrad2rgrad(self): def test_norm(self): x = self.man.rand() u = self.man.randvec(x) np_testing.assert_almost_equal(self.man.norm(x, u), la.norm(u)) # def test_transp(self): def test_exp(self): # Check that exp lies on the manifold and that exp of a small vector u # is close to x + u. s = self.man x = s.rand() u = s.randvec(x) xexpu = s.exp(x, u) np_testing.assert_allclose(xexpu.T.dot(xexpu), np.eye(self.n, self.n), atol=1e-10) u = u * 1e-6 xexpu = s.exp(x, u) np_testing.assert_allclose(xexpu, x + u)
class TestMultiStiefelManifold(unittest.TestCase): def setUp(self): self.m = m = 10 self.n = n = 3 self.k = k = 3 self.man = Stiefel(m, n, k=k) def test_dim(self): assert self.man.dim == 0.5 * self.k * self.n * (2 * self.m - self.n - 1) def test_typicaldist(self): np_testing.assert_almost_equal(self.man.typicaldist, np.sqrt(self.n * self.k)) # def test_dist(self): def test_inner(self): X = self.man.rand() A = self.man.randvec(X) B = self.man.randvec(X) np_testing.assert_allclose(np.sum(A * B), self.man.inner(X, A, B)) def test_proj(self): # Construct a random point X on the manifold. X = self.man.rand() # Construct a vector H in the ambient space. H = rnd.randn(self.k, self.m, self.n) # Compare the projections. Hproj = H - multiprod(X, multiprod(multitransp(X), H) + multiprod(multitransp(H), X)) / 2 np_testing.assert_allclose(Hproj, self.man.proj(X, H)) def test_rand(self): # Just make sure that things generated are on the manifold and that # if you generate two they are not equal. X = self.man.rand() np_testing.assert_allclose(multiprod(multitransp(X), X), multieye(self.k, self.n), atol=1e-10) Y = self.man.rand() assert np.linalg.norm(X - Y) > 1e-6 def test_randvec(self): # Make sure things generated are in tangent space and if you generate # two then they are not equal. X = self.man.rand() U = self.man.randvec(X) np_testing.assert_allclose(multisym(multiprod(multitransp(X), U)), np.zeros((self.k, self.n, self.n)), atol=1e-10) V = self.man.randvec(X) assert la.norm(U - V) > 1e-6 def test_retr(self): # Test that the result is on the manifold and that for small # tangent vectors it has little effect. x = self.man.rand() u = self.man.randvec(x) xretru = self.man.retr(x, u) np_testing.assert_allclose(multiprod(multitransp(xretru), xretru), multieye(self.k, self.n), atol=1e-10) u = u * 1e-6 xretru = self.man.retr(x, u) np_testing.assert_allclose(xretru, x + u) # def test_egrad2rgrad(self): def test_norm(self): x = self.man.rand() u = self.man.randvec(x) np_testing.assert_almost_equal(self.man.norm(x, u), la.norm(u)) # def test_transp(self): def test_exp(self): # Check that exp lies on the manifold and that exp of a small vector u # is close to x + u. s = self.man x = s.rand() u = s.randvec(x) xexpu = s.exp(x, u) np_testing.assert_allclose(multiprod(multitransp(xexpu), xexpu), multieye(self.k, self.n), atol=1e-10) u = u * 1e-6 xexpu = s.exp(x, u) np_testing.assert_allclose(xexpu, x + u)
class TestMultiStiefelManifold(ManifoldTestCase): def setUp(self): self.m = m = 10 self.n = n = 3 self.k = k = 3 self.manifold = Stiefel(m, n, k=k) self.manifold_polar = Stiefel(m, n, k=k, retraction="polar") super().setUp() def test_dim(self): assert self.manifold.dim == 0.5 * self.k * self.n * (2 * self.m - self.n - 1) def test_typical_dist(self): np_testing.assert_almost_equal(self.manifold.typical_dist, np.sqrt(self.n * self.k)) def test_inner_product(self): X = self.manifold.random_point() A = self.manifold.random_tangent_vector(X) B = self.manifold.random_tangent_vector(X) np_testing.assert_allclose(np.sum(A * B), self.manifold.inner_product(X, A, B)) def test_projection(self): # Construct a random point X on the manifold. X = self.manifold.random_point() # Construct a vector H in the ambient space. H = np.random.normal(size=(self.k, self.m, self.n)) # Compare the projections. Hproj = H - X @ (multitransp(X) @ H + multitransp(H) @ X) / 2 np_testing.assert_allclose(Hproj, self.manifold.projection(X, H)) def test_first_order_function_approximation(self): self.run_gradient_approximation_test() def test_second_order_function_approximation(self): self.run_hessian_approximation_test() def test_random_point(self): # Just make sure that things generated are on the manifold and that # if you generate two they are not equal. X = self.manifold.random_point() np_testing.assert_allclose(multitransp(X) @ X, multieye(self.k, self.n), atol=1e-10) Y = self.manifold.random_point() assert np.linalg.norm(X - Y) > 1e-6 def test_random_tangent_vector(self): # Make sure things generated are in tangent space and if you generate # two then they are not equal. X = self.manifold.random_point() U = self.manifold.random_tangent_vector(X) np_testing.assert_allclose( multisym(multitransp(X) @ U), np.zeros((self.k, self.n, self.n)), atol=1e-10, ) V = self.manifold.random_tangent_vector(X) assert np.linalg.norm(U - V) > 1e-6 @params("manifold", "manifold_polar") def test_retraction(self, manifold_attribute): manifold = getattr(self, manifold_attribute) # Test that the result is on the manifold and that for small # tangent vectors it has little effect. x = manifold.random_point() u = manifold.random_tangent_vector(x) xretru = manifold.retraction(x, u) np_testing.assert_allclose( multitransp(xretru) @ xretru, multieye(self.k, self.n), atol=1e-10, ) u = u * 1e-6 xretru = manifold.retraction(x, u) np_testing.assert_allclose(xretru, x + u) def test_norm(self): x = self.manifold.random_point() u = self.manifold.random_tangent_vector(x) np_testing.assert_almost_equal(self.manifold.norm(x, u), np.linalg.norm(u)) def test_exp(self): # Check that exp lies on the manifold and that exp of a small vector u # is close to x + u. s = self.manifold x = s.random_point() u = s.random_tangent_vector(x) xexpu = s.exp(x, u) np_testing.assert_allclose( multitransp(xexpu) @ xexpu, multieye(self.k, self.n), atol=1e-10, ) u = u * 1e-6 xexpu = s.exp(x, u) np_testing.assert_allclose(xexpu, x + u)
class TestSingleStiefelManifold(ManifoldTestCase): def setUp(self): self.m = m = 20 self.n = n = 2 self.k = k = 1 self.manifold = Stiefel(m, n, k=k) self.manifold_polar = Stiefel(m, n, k=k, retraction="polar") self.projection = lambda x, u: u - x @ (x.T @ u + u.T @ x) / 2 super().setUp() def test_dim(self): assert self.manifold.dim == 0.5 * self.n * (2 * self.m - self.n - 1) def test_inner_product(self): X = np.linalg.qr(np.random.normal(size=(self.m, self.n)))[0] A, B = np.random.normal(size=(2, self.m, self.n)) np_testing.assert_allclose(np.sum(A * B), self.manifold.inner_product(X, A, B)) def test_projection(self): # Construct a random point X on the manifold. X = np.random.normal(size=(self.m, self.n)) X = np.linalg.qr(X)[0] # Construct a vector H in the ambient space. H = np.random.normal(size=(self.m, self.n)) # Compare the projections. Hproj = H - X @ (X.T @ H + H.T @ X) / 2 np_testing.assert_allclose(Hproj, self.manifold.projection(X, H)) def test_first_order_function_approximation(self): self.run_gradient_approximation_test() def test_second_order_function_approximation(self): self.run_hessian_approximation_test() def test_random_point(self): # Just make sure that things generated are on the manifold and that # if you generate two they are not equal. X = self.manifold.random_point() np_testing.assert_allclose(X.T @ X, np.eye(self.n), atol=1e-10) Y = self.manifold.random_point() assert np.linalg.norm(X - Y) > 1e-6 def test_random_tangent_vector(self): # Make sure things generated are in tangent space and if you generate # two then they are not equal. X = self.manifold.random_point() U = self.manifold.random_tangent_vector(X) np_testing.assert_allclose(multisym(X.T @ U), np.zeros((self.n, self.n)), atol=1e-10) V = self.manifold.random_tangent_vector(X) assert np.linalg.norm(U - V) > 1e-6 @params("manifold", "manifold_polar") def test_retraction(self, manifold_attribute): manifold = getattr(self, manifold_attribute) # Test that the result is on the manifold and that for small # tangent vectors it has little effect. x = manifold.random_point() u = manifold.random_tangent_vector(x) xretru = manifold.retraction(x, u) np_testing.assert_allclose(xretru.T @ xretru, np.eye(self.n, self.n), atol=1e-10) u = u * 1e-6 xretru = manifold.retraction(x, u) np_testing.assert_allclose(xretru, x + u) def test_euclidean_to_riemannian_hessian(self): # Test this function at some randomly generated point. x = self.manifold.random_point() u = self.manifold.random_tangent_vector(x) egrad = np.random.normal(size=(self.m, self.n)) ehess = np.random.normal(size=(self.m, self.n)) np_testing.assert_allclose( testing.euclidean_to_riemannian_hessian(self.projection)(x, egrad, ehess, u), self.manifold.euclidean_to_riemannian_hessian(x, egrad, ehess, u), ) def test_norm(self): x = self.manifold.random_point() u = self.manifold.random_tangent_vector(x) np_testing.assert_almost_equal(self.manifold.norm(x, u), np.linalg.norm(u)) def test_exp(self): # Check that exp lies on the manifold and that exp of a small vector u # is close to x + u. s = self.manifold x = s.random_point() u = s.random_tangent_vector(x) xexpu = s.exp(x, u) np_testing.assert_allclose(xexpu.T @ xexpu, np.eye(self.n, self.n), atol=1e-10) u = u * 1e-6 xexpu = s.exp(x, u) np_testing.assert_allclose(xexpu, x + u)