Skip to content

Objective

sgptools.objectives.Objective

Base class for objective functions used in optimization. Subclasses must implement the __call__ method to define the objective.

Source code in sgptools/objectives.py 
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
class Objective:
    """
    Base class for objective functions used in optimization.
    Subclasses must implement the `__call__` method to define the objective.
    """

    def __init__(self,
                 X_objective: np.ndarray,
                 kernel: gpflow.kernels.Kernel,
                 noise_variance: float,
                 jitter: float = 1e-6,
                 **kwargs: Any):
        """
        Initializes the base objective. This constructor primarily serves to define
        the expected parameters for all objective subclasses.

        Args:
            X_objective (np.ndarray): The fixed set of data points (e.g., candidate locations
                                      or training data points) against which MI is computed.
                                      Shape: (N, D).
            kernel (gpflow.kernels.Kernel): The GPflow kernel function to compute covariances.
            noise_variance (float): The observed data noise variance, which is added to the jitter.
            jitter (float): A small positive value to add for numerical stability to covariance
                            matrix diagonals. Defaults to 1e-6.
            **kwargs: Arbitrary keyword arguments.
        """
        self.X_objective = tf.constant(X_objective, dtype=tf.float64)
        self.kernel = kernel
        self.noise_variance = noise_variance
        # Total jitter includes the noise variance
        self._base_jitter = jitter
        self.jitter_fn = lambda cov: jitter_fn(
            cov, jitter=self._base_jitter + self.noise_variance)

    def __call__(self, X: tf.Tensor) -> tf.Tensor:
        """
        Computes the objective value for a given set of input points `X`.
        This method must be implemented by subclasses.

        Args:
            X (tf.Tensor): The input points for which the objective is to be computed.
                           Shape: (M, D) where M is number of points, D is dimension.

        Returns:
            tf.Tensor: The computed objective value.

        Raises:
            NotImplementedError: If the method is not implemented by a subclass.
        """
        raise NotImplementedError

    def update(self, kernel: gpflow.kernels.Kernel,
               noise_variance: float) -> None:
        """
        Updates the kernel and noise variance for the MI objective.
        This method is crucial for optimizing the GP hyperparameters externally
        and having the objective function reflect those changes.

        Args:
            kernel (gpflow.kernels.Kernel): The updated GPflow kernel function.
            noise_variance (float): The updated data noise variance.
        """
        # Update kernel's trainable variables (e.g., lengthscales, variance)
        for self_var, var in zip(self.kernel.trainable_variables,
                                 kernel.trainable_variables):
            self_var.assign(var)

        self.noise_variance = noise_variance
        # Update the jitter function to reflect the new noise variance
        self.jitter_fn = lambda cov: jitter_fn(
            cov, jitter=self._base_jitter + self.noise_variance)

__call__(X)

Computes the objective value for a given set of input points X. This method must be implemented by subclasses.

Parameters:

Name Type Description Default
X Tensor

The input points for which the objective is to be computed. Shape: (M, D) where M is number of points, D is dimension.

 required

Returns:

Type Description
Tensor

tf.Tensor: The computed objective value.

Raises:

Type Description
NotImplementedError

If the method is not implemented by a subclass.
Source code in sgptools/objectives.py 
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def __call__(self, X: tf.Tensor) -> tf.Tensor:
    """
    Computes the objective value for a given set of input points `X`.
    This method must be implemented by subclasses.

    Args:
        X (tf.Tensor): The input points for which the objective is to be computed.
                       Shape: (M, D) where M is number of points, D is dimension.

    Returns:
        tf.Tensor: The computed objective value.

    Raises:
        NotImplementedError: If the method is not implemented by a subclass.
    """
    raise NotImplementedError

__init__(X_objective, kernel, noise_variance, jitter=1e-06, **kwargs)

Initializes the base objective. This constructor primarily serves to define the expected parameters for all objective subclasses.

Parameters:

Name Type Description Default
X_objective ndarray

The fixed set of data points (e.g., candidate locations or training data points) against which MI is computed. Shape: (N, D).

 required
kernel Kernel

The GPflow kernel function to compute covariances.

 required
noise_variance float

The observed data noise variance, which is added to the jitter.

 required
jitter float

A small positive value to add for numerical stability to covariance matrix diagonals. Defaults to 1e-6.

 1e-06
**kwargs Any

Arbitrary keyword arguments.

 {}
Source code in sgptools/objectives.py 
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
def __init__(self,
             X_objective: np.ndarray,
             kernel: gpflow.kernels.Kernel,
             noise_variance: float,
             jitter: float = 1e-6,
             **kwargs: Any):
    """
    Initializes the base objective. This constructor primarily serves to define
    the expected parameters for all objective subclasses.

    Args:
        X_objective (np.ndarray): The fixed set of data points (e.g., candidate locations
                                  or training data points) against which MI is computed.
                                  Shape: (N, D).
        kernel (gpflow.kernels.Kernel): The GPflow kernel function to compute covariances.
        noise_variance (float): The observed data noise variance, which is added to the jitter.
        jitter (float): A small positive value to add for numerical stability to covariance
                        matrix diagonals. Defaults to 1e-6.
        **kwargs: Arbitrary keyword arguments.
    """
    self.X_objective = tf.constant(X_objective, dtype=tf.float64)
    self.kernel = kernel
    self.noise_variance = noise_variance
    # Total jitter includes the noise variance
    self._base_jitter = jitter
    self.jitter_fn = lambda cov: jitter_fn(
        cov, jitter=self._base_jitter + self.noise_variance)

update(kernel, noise_variance)

Updates the kernel and noise variance for the MI objective. This method is crucial for optimizing the GP hyperparameters externally and having the objective function reflect those changes.

Parameters:

Name Type Description Default
kernel Kernel

The updated GPflow kernel function.

 required
noise_variance float

The updated data noise variance.

 required
Source code in sgptools/objectives.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
def update(self, kernel: gpflow.kernels.Kernel,
           noise_variance: float) -> None:
    """
    Updates the kernel and noise variance for the MI objective.
    This method is crucial for optimizing the GP hyperparameters externally
    and having the objective function reflect those changes.

    Args:
        kernel (gpflow.kernels.Kernel): The updated GPflow kernel function.
        noise_variance (float): The updated data noise variance.
    """
    # Update kernel's trainable variables (e.g., lengthscales, variance)
    for self_var, var in zip(self.kernel.trainable_variables,
                             kernel.trainable_variables):
        self_var.assign(var)

    self.noise_variance = noise_variance
    # Update the jitter function to reflect the new noise variance
    self.jitter_fn = lambda cov: jitter_fn(
        cov, jitter=self._base_jitter + self.noise_variance)