Exemplo n.º 1
0
        def check(mu, Lambda, alpha, beta, ndim):

            X = GaussianGamma(
                mu,
                (
                    Lambda if isinstance(Lambda._moments, WishartMoments) else
                    Lambda.as_wishart(ndim=ndim)
                ),
                alpha,
                beta,
                ndim=ndim
            )

            self.assert_moments(
                X,
                postprocess=lambda u: [
                    u[0],
                    u[1] + linalg.transpose(u[1], ndim=ndim),
                    u[2],
                    u[3]
                ],
                rtol=1e-5,
                atol=1e-6,
                eps=1e-8
            )

            X.observe(
                (
                    np.random.randn(*(X.plates + X.dims[0])),
                    np.random.rand(*X.plates)
                )
            )

            self.assert_message_to_parent(X, mu)
            self.assert_message_to_parent(
                X,
                Lambda,
                postprocess=lambda m: [
                    m[0] + linalg.transpose(m[0], ndim=ndim),
                    m[1],
                ]
            )
            self.assert_message_to_parent(X, beta)
    def test_message_to_parents(self):
        """ Check gradient passed to inputs parent node """
        N = 3
        D = 2

        Mu = Gaussian(np.random.randn(D), random.covariance(D))
        Lambda = Wishart(D, random.covariance(D))
        A = Gaussian(np.random.randn(D,D), random.covariance(D))
        V = Gamma(D, np.random.rand(D))

        X = GaussianMarkovChain(Mu, Lambda, A, V, n=N+1)
        Y = Gaussian(X, random.covariance(D))

        self.assert_moments(
            X,
            postprocess=lambda u: [
                u[0],
                u[1] + linalg.transpose(u[1], ndim=1),
                u[2]
            ]
        )

        Y.observe(np.random.randn(N+1, D))

        self.assert_message_to_parent(X, Mu, eps=1e-8)
        self.assert_message_to_parent(
            X,
            Lambda,
            eps=1e-8,
            postprocess=lambda u: [
                u[0] + linalg.transpose(u[0], ndim=1),
                u[1],
            ]
        )
        self.assert_message_to_parent(X, A)
        self.assert_message_to_parent(X, V, eps=1e-10, atol=1e-5)

        pass
        def check(Mu, Lambda, A, V, U):

            X = GaussianMarkovChain(Mu, Lambda, A, V, inputs=U)
            Y = Gaussian(X, random.covariance(D))

            # Check moments
            self.assert_moments(
                X,
                postprocess=lambda u: [
                    u[0],
                    u[1] + linalg.transpose(u[1], ndim=1),
                    u[2]
                ]
            )

            Y.observe(np.random.randn(N+1, D))
            X.update()

            # Check gradient messages to parents
            self.assert_message_to_parent(X, Mu)
            self.assert_message_to_parent(
                X,
                Lambda,
                postprocess=lambda phi: [
                    phi[0] + linalg.transpose(phi[0], ndim=1),
                    phi[1]
                ]
            )
            self.assert_message_to_parent(
                X,
                A,
                postprocess=lambda phi: [
                    phi[0],
                    phi[1] + linalg.transpose(phi[1], ndim=1),
                ]
            )
            self.assert_message_to_parent(X, V)
            self.assert_message_to_parent(X, U)
Exemplo n.º 4
0
    def _compute_moments(self, *u_parents):
        """
        Compute the moments of the sum
        """

        u0 = functools.reduce(np.add, (u_parent[0] for u_parent in u_parents))
        u1 = functools.reduce(np.add, (u_parent[1] for u_parent in u_parents))

        for i in range(self.N):
            for j in range(i + 1, self.N):
                xi_xj = linalg.outer(u_parents[i][0],
                                     u_parents[j][0],
                                     ndim=self.ndim)
                xj_xi = linalg.transpose(xi_xj, ndim=self.ndim)
                u1 = u1 + xi_xj + xj_xi

        return [u0, u1]
Exemplo n.º 5
0
    def _compute_moments(self, *u_parents):
        """
        Compute the moments of the sum
        """

        u0 = functools.reduce(np.add,
                              (u_parent[0] for u_parent in u_parents))
        u1 = functools.reduce(np.add,
                              (u_parent[1] for u_parent in u_parents))

        for i in range(self.N):
            for j in range(i+1, self.N):
                xi_xj = linalg.outer(u_parents[i][0], u_parents[j][0], ndim=self.ndim)
                xj_xi = linalg.transpose(xi_xj, ndim=self.ndim)
                u1 = u1 + xi_xj + xj_xi
                                                                     
        return [u0, u1]