Example #1
0
    def test_addition_adaptive_4_kernels(self, adata: AnnData):
        a, b, c, d = np.random.uniform(0, 10, 4)
        s = a + b + c + d
        adata.uns["velocity_variances"] = vv = np.random.random(
            size=(adata.n_obs, adata.n_obs))
        adata.uns["connectivity_variances"] = cv = np.random.random(
            size=(adata.n_obs, adata.n_obs))
        vk, ck = create_kernels(
            adata,
            velocity_variances="velocity_variances",
            connectivity_variances="connectivity_variances",
        )
        vk1, ck1 = create_kernels(
            adata,
            velocity_variances="velocity_variances",
            connectivity_variances="connectivity_variances",
        )

        k = a * vk ^ b * ck ^ c * vk1 ^ d * ck1
        expected = _normalize(a / s * vv * vk.transition_matrix +
                              b / s * cv * ck.transition_matrix +
                              c / s * vv * vk1.transition_matrix +
                              d / s * cv * ck1.transition_matrix)

        np.testing.assert_allclose(k.transition_matrix.A, expected)
Example #2
0
    def test_simple_addition(self, adata: AnnData):
        vk, ck = create_kernels(adata)  # diagonal + upper diag

        k = (vk + ck).compute_transition_matrix()
        expected = np.eye(adata.n_obs) * 0.75 + np.eye(adata.n_obs, k=1) * 0.25
        expected[-1, -1] = 1

        np.testing.assert_allclose(k.transition_matrix.A, expected)
Example #3
0
    def test_addtion_with_constant(self, adata: AnnData):
        vk, ck = create_kernels(adata)  # diagonal + upper diag

        k = (2 * vk + 3 * ck).compute_transition_matrix()
        expected = (np.eye(adata.n_obs) * (2 / 5) + np.eye(adata.n_obs) *
                    (3 / 5) * 0.5 + np.eye(adata.n_obs, k=1) * (3 / 5) * 0.5)
        expected[-1, -1] = 1

        np.testing.assert_allclose(k.transition_matrix.A, expected)
Example #4
0
    def test_addition_adaptive(self, adata):
        adata.uns["velocity_variances"] = vv = np.random.random(
            size=(adata.n_obs, adata.n_obs))
        adata.uns["connectivity_variances"] = cv = np.random.random(
            size=(adata.n_obs, adata.n_obs))
        vk, ck = create_kernels(adata)

        k = vk ^ ck
        expected = _normalize(0.5 * vv * vk.transition_matrix +
                              0.5 * cv * ck.transition_matrix)

        np.testing.assert_allclose(k.transition_matrix.A, expected)
Example #5
0
    def test_addition_adaptive_wrong_variances(self, adata):
        a, b = np.random.uniform(0, 10, 2)
        s = a + b
        adata.uns["velocity_variances"] = np.random.random(size=(adata.n_obs,
                                                                 adata.n_obs))
        adata.uns["connectivity_variances"] = np.random.random(
            size=(adata.n_obs, adata.n_obs))
        vk, ck = create_kernels(adata)

        k = a * vk ^ b * ck
        expected = _normalize(a / s * vk.transition_matrix +
                              b / s * ck.transition_matrix)

        assert not np.allclose(k.transition_matrix.A, expected.A)
Example #6
0
    def test_addition_adaptive_constants(self, adata):
        a, b = np.random.uniform(0, 10, 2)
        s = a + b
        adata.uns["velocity_variances"] = vv = np.random.random(
            size=(adata.n_obs, adata.n_obs))
        adata.uns["connectivity_variances"] = cv = np.random.random(
            size=(adata.n_obs, adata.n_obs))
        vk, ck = create_kernels(adata)  # diagonal + upper diag

        k = a * vk ^ b * ck
        expected = _normalize(a / s * vv * vk.transition_matrix +
                              b / s * cv * ck.transition_matrix)

        np.testing.assert_allclose(k.transition_matrix.A, expected)
Example #7
0
    def test_addition_3_kernels(self, adata: AnnData):
        vk, ck = create_kernels(adata)  # diagonal + upper diag
        vk1 = VelocityKernel(adata)
        vk1._transition_matrix = np.eye(adata.n_obs, k=-1) / 2 + np.eye(
            adata.n_obs) / 2
        vk1._transition_matrix[0, 0] = 1
        np.testing.assert_allclose(np.sum(ck._transition_matrix, axis=1),
                                   1)  # sanity check

        k = (vk + ck + vk1).compute_transition_matrix()
        expected = (np.eye(adata.n_obs) * (1 / 3 + 1 / 6 + 1 / 6) +
                    np.eye(adata._n_obs, k=1) * 1 / 6 +
                    np.eye(adata.n_obs, k=-1) * 1 / 6)
        expected[0, 0] = expected[-1, -1] = 2 / 3 + 1 / 3 * 0.5
        expected[0, 1] = expected[-1, -2] = 1 - expected[0, 0]

        np.testing.assert_allclose(k.transition_matrix.A, expected)