Ejemplo n.º 1
0
    def test_compute_hessian_parameters_for_sample(self):
        point = np.array([[95.0]])
        candidate_point = np.array([[99.15, 0]])
        val = self.gp_complete_2.compute_hessian_parameters_for_sample(
            point, candidate_point)

        dh = 0.01
        finite_diff = FiniteDifferences.second_order_central(
            lambda x: self.gp_complete_2.compute_parameters_for_sample(
                x.reshape(
                    (1, len(point))), candidate_point, clear_cache=False)['a'],
            point[0, :], np.array([dh]))

        npt.assert_almost_equal(finite_diff[(0, 0)], val['a'][0, :], decimal=5)

        dh = 0.1
        finite_diff = FiniteDifferences.second_order_central(
            lambda x: self.gp_complete_2.compute_parameters_for_sample(
                x.reshape(
                    (1, len(point))), candidate_point, clear_cache=False)['b'],
            point[0, :], np.array([dh]))

        npt.assert_almost_equal(finite_diff[(0, 0)], val['b'], decimal=5)
Ejemplo n.º 2
0
    def test_hessian_posterior_mean(self):

        gp = self.gp_complete

        point = np.array([[80.5]])

        # Test evaluate_grad_quadrature_cross_cov
        hessian = gp.hessian_posterior_mean(point)

        dh = 0.1
        finite_diff = FiniteDifferences.second_order_central(
            lambda points: gp.compute_posterior_parameters(
                points.reshape((1, len(points))), only_mean=True)['mean'],
            point[0, :], np.array([dh]))

        npt.assert_almost_equal(finite_diff[(0, 0)], hessian[0, 0])
    def test_evaluate_hessian_respect_point(self):
        point = np.array([[4.5, 7.5]])
        inputs = np.array([[5.0, 6.0], [8.0, 9.0]])
        params = np.array([1.0, 5.0])
        result = Matern52.evaluate_hessian_respect_point(
            params, point, inputs, 2)

        dh = 0.00001
        finite_diff = FiniteDifferences.second_order_central(
            lambda x: Matern52.evaluate_cross_cov_defined_by_params(
                params, x.reshape((1, len(x))), inputs, 2), point[0, :],
            np.array([dh]))

        for i in xrange(2):
            for j in xrange(2):
                print i, j
                npt.assert_almost_equal(
                    finite_diff[i, j],
                    np.array([[result[0, i, j], result[1, i, j]]]),
                    decimal=5)
    def test_hessian_distance_length_scale_respect_point(self):
        params = np.array([1.0, 5.0])
        point = np.array([[4.5, 7.5]])
        inputs = np.array([[5.0, 6.0], [8.0, 9.0]])
        result = Distances.gradient_distance_length_scale_respect_point(
            params, point, inputs, second=True)
        result = result['second']

        dh = 0.00001
        finite_diff = FiniteDifferences.second_order_central(
            lambda x: np.sqrt(
                Distances.dist_square_length_scale(
                    params, x.reshape((1, len(x))), inputs)), point[0, :],
            np.array([dh]))

        for i in xrange(2):
            for j in xrange(2):
                print i, j
                npt.assert_almost_equal(
                    finite_diff[i, j],
                    np.array([[result[0, i, j], result[1, i, j]]]),
                    decimal=5)
    def test_second_order_central(self):
        self.x = np.array([1.5, 1.5, 1.5])
        h = np.array([0.1])
        result = FiniteDifferences.second_order_central(self.f, self.x, h)

        base_eval = \
            Matern52.evaluate_cov_defined_by_params(self.x, np.array([[2.0, 0.0], [0.0, 2.0]]), 2)

        for i in xrange(3):
                val = result[(i, i)]
                new_x = deepcopy(self.x)
                new_x[i] += h[0]
                new_eval = \
                    Matern52.evaluate_cov_defined_by_params(
                        new_x, np.array([[2.0, 0.0], [0.0, 2.0]]), 2)

                new_x = deepcopy(self.x)
                new_x[i] -= h[0]
                new_eval_2 = \
                    Matern52.evaluate_cov_defined_by_params(
                        new_x, np.array([[2.0, 0.0], [0.0, 2.0]]), 2)
                assert np.all(val == (new_eval + new_eval_2 - 2.0 * base_eval) / (h[0] ** 2))

        for i in xrange(3):
            for j in xrange(3):
                if j == i:
                    continue

                val = result[(i, j)]

                new_x = deepcopy(self.x)
                new_x[i] += h[0]
                new_x[j] += h[0]
                new_eval = \
                    Matern52.evaluate_cov_defined_by_params(
                        new_x, np.array([[2.0, 0.0], [0.0, 2.0]]), 2)

                val_2 = new_eval

                new_x = deepcopy(self.x)
                new_x[i] -= h[0]
                new_x[j] -= h[0]
                new_eval_2 = \
                    Matern52.evaluate_cov_defined_by_params(
                        new_x, np.array([[2.0, 0.0], [0.0, 2.0]]), 2)

                val_2 += new_eval_2
                new_x = deepcopy(self.x)
                new_x[i] += h[0]
                new_x[j] -= h[0]
                new_eval = \
                    Matern52.evaluate_cov_defined_by_params(
                        new_x, np.array([[2.0, 0.0], [0.0, 2.0]]), 2)

                val_2 -= new_eval


                new_x = deepcopy(self.x)
                new_x[i] -= h[0]
                new_x[j] += h[0]
                new_eval_2 = \
                    Matern52.evaluate_cov_defined_by_params(
                        new_x, np.array([[2.0, 0.0], [0.0, 2.0]]), 2)

                val_2 -= new_eval_2

                val_2 /= (4.0 * h * h)

                assert np.all(val_2 == val)