def test_singular_values(self):
# Check that the PCA output has the correct singular values
rng = np.random.RandomState(0)
n_samples = 100
n_features = 80
X = mt.tensor(rng.randn(n_samples, n_features))
pca = PCA(n_components=2, svd_solver='full', random_state=rng).fit(X)
rpca = PCA(n_components=2, svd_solver='randomized',
random_state=rng).fit(X)
assert_array_almost_equal(pca.singular_values_.fetch(),
rpca.singular_values_.fetch(), 1)
# Compare to the Frobenius norm
X_pca = pca.transform(X)
X_rpca = rpca.transform(X)
assert_array_almost_equal(
mt.sum(pca.singular_values_**2.0).to_numpy(),
(mt.linalg.norm(X_pca, "fro")**2.0).to_numpy(), 12)
assert_array_almost_equal(
mt.sum(rpca.singular_values_**2.0).to_numpy(),
(mt.linalg.norm(X_rpca, "fro")**2.0).to_numpy(), 0)
# Compare to the 2-norms of the score vectors
assert_array_almost_equal(
pca.singular_values_.fetch(),
mt.sqrt(mt.sum(X_pca**2.0, axis=0)).to_numpy(), 12)
assert_array_almost_equal(
rpca.singular_values_.fetch(),
mt.sqrt(mt.sum(X_rpca**2.0, axis=0)).to_numpy(), 2)
# Set the singular values and see what we get back
rng = np.random.RandomState(0)
n_samples = 100
n_features = 110
X = mt.tensor(rng.randn(n_samples, n_features))
pca = PCA(n_components=3, svd_solver='full', random_state=rng)
rpca = PCA(n_components=3, svd_solver='randomized', random_state=rng)
X_pca = pca.fit_transform(X)
X_pca /= mt.sqrt(mt.sum(X_pca**2.0, axis=0))
X_pca[:, 0] *= 3.142
X_pca[:, 1] *= 2.718
X_hat = mt.dot(X_pca, pca.components_)
pca.fit(X_hat)
rpca.fit(X_hat)
assert_array_almost_equal(pca.singular_values_.fetch(),
[3.142, 2.718, 1.0], 14)
assert_array_almost_equal(rpca.singular_values_.fetch(),
[3.142, 2.718, 1.0], 14)
def testFetch(self):
sess = new_session()
arr1 = mt.ones((10, 5), chunk_size=3)
r1 = sess.run(arr1)
r2 = sess.run(arr1)
np.testing.assert_array_equal(r1, r2)
executor = sess._sess._executor
executor.chunk_result[get_tiled(arr1).chunks[0].key] = np.ones(
(3, 3)) * 2
r3 = sess.run(arr1 + 1)
np.testing.assert_array_equal(r3[:3, :3], np.ones((3, 3)) * 3)
# rerun to ensure arr1's chunk results still exist
r4 = sess.run(arr1 + 1)
np.testing.assert_array_equal(r4[:3, :3], np.ones((3, 3)) * 3)
arr2 = mt.ones((10, 5), chunk_size=3)
r5 = sess.run(arr2)
np.testing.assert_array_equal(r5[:3, :3], np.ones((3, 3)) * 2)
r6 = sess.run(arr2 + 1)
np.testing.assert_array_equal(r6[:3, :3], np.ones((3, 3)) * 3)
# test fetch multiple tensors
raw = np.random.rand(5, 10)
arr1 = mt.ones((5, 10), chunk_size=5)
arr2 = mt.tensor(raw, chunk_size=3)
arr3 = mt.sum(arr2)
sess.run(arr1, arr2, arr3)
fetch1, fetch2, fetch3 = sess.fetch(arr1, arr2, arr3)
np.testing.assert_array_equal(fetch1, np.ones((5, 10)))
np.testing.assert_array_equal(fetch2, raw)
np.testing.assert_almost_equal(fetch3, raw.sum())
fetch1, fetch2, fetch3 = sess.fetch([arr1, arr2, arr3])
np.testing.assert_array_equal(fetch1, np.ones((5, 10)))
np.testing.assert_array_equal(fetch2, raw)
np.testing.assert_almost_equal(fetch3, raw.sum())
raw = np.random.rand(5, 10)
arr = mt.tensor(raw, chunk_size=5)
s = arr.sum()
self.assertAlmostEqual(s.execute().fetch(), raw.sum())
def _execute_ds(*_): # pragma: no cover
raise ValueError('cannot run random again')
try:
register(ArrayDataSource, _execute_ds)
self.assertAlmostEqual(s.fetch(), raw.sum())
finally:
del Executor._op_runners[ArrayDataSource]
def testFetch(self):
sess = new_session()
arr1 = mt.ones((10, 5), chunk_size=3)
r1 = sess.run(arr1)
r2 = sess.run(arr1)
np.testing.assert_array_equal(r1, r2)
executor = sess._sess._executor
executor.chunk_result[get_tiled(arr1).chunks[0].key] = np.ones(
(3, 3)) * 2
r3 = sess.run(arr1 + 1)
np.testing.assert_array_equal(r3[:3, :3], np.ones((3, 3)) * 3)
# rerun to ensure arr1's chunk results still exist
r4 = sess.run(arr1 + 1)
np.testing.assert_array_equal(r4[:3, :3], np.ones((3, 3)) * 3)
arr2 = mt.ones((10, 5), chunk_size=3)
r5 = sess.run(arr2)
np.testing.assert_array_equal(r5[:3, :3], np.ones((3, 3)) * 2)
r6 = sess.run(arr2 + 1)
np.testing.assert_array_equal(r6[:3, :3], np.ones((3, 3)) * 3)
# test fetch multiple tensors
raw = np.random.rand(5, 10)
arr1 = mt.ones((5, 10), chunk_size=5)
arr2 = mt.tensor(raw, chunk_size=3)
arr3 = mt.sum(arr2)
sess.run(arr1, arr2, arr3)
fetch1, fetch2, fetch3 = sess.fetch(arr1, arr2, arr3)
np.testing.assert_array_equal(fetch1, np.ones((5, 10)))
np.testing.assert_array_equal(fetch2, raw)
np.testing.assert_almost_equal(fetch3, raw.sum())
fetch1, fetch2, fetch3 = sess.fetch([arr1, arr2, arr3])
np.testing.assert_array_equal(fetch1, np.ones((5, 10)))
np.testing.assert_array_equal(fetch2, raw)
np.testing.assert_almost_equal(fetch3, raw.sum())
def testBuildFusedGraph(self):
t = mt.random.rand(9, 9, chunk_size=3)
t1 = (t + 1) * 2
g = t1.build_graph(tiled=True, fuse_enabled=True)
graph_nodes = list(g)
self.assertTrue(
all(isinstance(n.op, TensorFuseChunk) for n in graph_nodes))
self.assertTrue(all(n.shape == (3, 3) for n in graph_nodes))
fuse_node = graph_nodes[0]
self.assertEqual(fuse_node.shape, (3, 3))
self.assertEqual(len(fuse_node.composed), 3)
self.assertIsInstance(fuse_node.composed[0].op, TensorRand)
self.assertIsInstance(fuse_node.composed[1].op, TensorAdd)
self.assertIsInstance(fuse_node.composed[2].op, TensorMultiply)
t2 = mt.sum((t / 2) - 1, axis=0)
g = t2.build_graph(tiled=True, fuse_enabled=True)
graph_nodes = list(g.bfs())
self.assertTrue(
all(isinstance(n.op, TensorFuseChunk) for n in graph_nodes))
reduction_node = graph_nodes[-1]
self.assertEqual(reduction_node.shape, (3, ))
self.assertEqual(len(reduction_node.composed), 2)
self.assertEqual(reduction_node.inputs,
reduction_node.composed[0].inputs)
self.assertIsInstance(reduction_node.composed[0].op, TensorConcatenate)
self.assertIsInstance(reduction_node.composed[1].op, TensorSum)
agg_node = graph_nodes[0]
self.assertEqual(agg_node.shape, (1, 3))
self.assertEqual(len(agg_node.composed), 4)
self.assertIsInstance(agg_node.composed[0].op, TensorRand)
self.assertIsInstance(agg_node.composed[1].op,
(TensorTrueDiv, TensorDivide))
self.assertIsInstance(agg_node.composed[2].op, TensorSubtract)
self.assertIsInstance(agg_node.composed[3].op, TensorSum)
def test_singular_values(setup):
# Check that the TruncatedSVD output has the correct singular values
# Set the singular values and see what we get back
rng = np.random.RandomState(0)
n_samples = 100
n_features = 110
X = rng.randn(n_samples, n_features)
rpca = TruncatedSVD(n_components=3,
algorithm='randomized',
random_state=rng)
X_rpca = rpca.fit_transform(X)
X_rpca /= mt.sqrt(mt.sum(X_rpca**2.0, axis=0))
X_rpca[:, 0] *= 3.142
X_rpca[:, 1] *= 2.718
X_hat_rpca = mt.dot(X_rpca, rpca.components_)
rpca.fit(X_hat_rpca)
assert_array_almost_equal(rpca.singular_values_.to_numpy(),
[3.142, 2.718, 1.0], 14)
