vopy.algorithms

Algorithms for Vector Optimization

NaiveElimination

class vopy.algorithms.NaiveElimination(epsilon: float, delta: float, dataset_name: str, order: PolyhedralConeOrder, noise_var: float, L: int | None = None)

Implement the Naive Elimination algorithm.

Parameters:
  • epsilon (float) – Determines the accuracy of the PAC-learning framework.

  • delta (float) – Determines the success probability of the PAC-learning framework.

  • dataset_name (str) – Name of the dataset to be used.

  • order (Order) – Order to be used.

  • noise_var (float) – Variance of the Gaussian sampling noise.

  • L (Optional[int]) – Number of samples to be taken for each arm. If None, theoretical sampling count is used.

The algorithm sequentially samples design rewards with a multivariate white Gaussian noise whose diagonal entries are specified by the user.

Example:
>>> from vopy.order import ComponentwiseOrder
>>> from vopy.algorithms import NaiveElimination
>>>
>>> epsilon, delta, noise_var = 0.1, 0.05, 0.01
>>> dataset_name = "DiscBrake"
>>> order_right = ComponentwiseOrder(2)
>>>
>>> algorithm = NaiveElimination(epsilon, delta, dataset_name, order_right, noise_var)
>>>
>>> while True:
>>>     is_done = algorithm.run_one_step()
>>>
>>>     if is_done:
>>>          break
>>>
>>> pareto_indices = algorithm.P
Reference:

“Vector Optimization with Stochastic Bandit Feedback”, Ararat, Tekin, AISTATS, ‘23 https://proceedings.mlr.press/v206/ararat23a.html

property P: numpy.ndarray

Calculate the Pareto set ordering by sample means.

Returns:

Indices for the Pareto set.

Return type:

np.ndarray

run_one_step() bool

Run one step of the algorithm and return algorithm status.

Returns:

True if the algorithm is over, False otherwise.

Return type:

bool

PaVeBa

class vopy.algorithms.PaVeBa(epsilon: float, delta: float, dataset_name: str, order: PolyhedralConeOrder, noise_var: float, conf_contraction: float = 32)

Implement the Pareto Vector Bandits (PaVeBa) algorithm.

Parameters:
  • epsilon (float) – Determines the accuracy of the PAC-learning framework.

  • delta (float) – Determines the success probability of the PAC-learning framework.

  • dataset_name (str) – Name of the dataset to be used.

  • order (Order) – Order to be used.

  • noise_var (float) – Variance of the Gaussian sampling noise.

  • conf_contraction (float) – Contraction coefficient to shrink the confidence regions empirically. Defaults to 32.

The algorithm sequentially samples design rewards with a multivariate white Gaussian noise whose diagonal entries are specified by the user.

Example:
>>> from vopy.order import ComponentwiseOrder
>>> from vopy.algorithms import PaVeBa
>>>
>>> epsilon, delta, noise_var = 0.1, 0.05, 0.01
>>> dataset_name = "DiscBrake"
>>> order_right = ComponentwiseOrder(2)
>>>
>>> algorithm = PaVeBa(epsilon, delta, dataset_name, order_right, noise_var)
>>>
>>> while True:
>>>     is_done = algorithm.run_one_step()
>>>
>>>     if is_done:
>>>          break
>>>
>>> pareto_indices = algorithm.P
Reference:

“Learning the Pareto Set Under Incomplete Preferences: Pure Exploration in Vector Bandits”, Karagözlü, Yıldırım, Ararat, Tekin, AISTATS, ‘24 https://proceedings.mlr.press/v238/karagozlu24a.html

compute_radius() float

Compute the radius of the confidence regions of the current round to be used in modeling.

Returns:

The radius of the confidence regions.

Return type:

float

discarding()

Discard the designs that are highly likely to be suboptimal using the confidence regions.

evaluating()

Observe the active designs via sampling and update the model.

modeling()

Construct the confidence regions of all active designs given all past observations.

pareto_updating()

Identify the designs that are highly likely to be epsilon-optimal using the confidence regions.

run_one_step() bool

Run one step of the algorithm and return algorithm status.

Returns:

True if the algorithm is over, False otherwise.

Return type:

bool

useful_updating()

Identify the designs that are decided to be Pareto, that would help with decisions of other designs.

PaVeBaGP

class vopy.algorithms.PaVeBaGP(epsilon: float, delta: float, dataset_name: str, order: PolyhedralConeOrder, noise_var: float, conf_contraction: float = 32, type: Literal['IH', 'DE'] = 'IH', batch_size: int = 1)

Implement the GP-based Pareto Vector Bandits (PaVeBa) algorithm.

Parameters:
  • epsilon (float) – Determines the accuracy of the PAC-learning framework.

  • delta (float) – Determines the success probability of the PAC-learning framework.

  • dataset_name (str) – Name of the dataset to be used.

  • order (Order) – Order to be used.

  • noise_var (float) – Variance of the Gaussian sampling noise.

  • conf_contraction (float) – Contraction coefficient to shrink the confidence regions empirically. Defaults to 32.

  • type (Literal["IH", "DE"]) – Specifies if the algorithm uses dependent ellipsoidal or independent hyperrectangular confidence regions. Defaults to “IH”.

  • batch_size (int) – Number of samples to be taken in each round. Defaults to 1.

The algorithm sequentially samples design rewards with a multivariate white Gaussian noise whose diagonal entries are specified by the user. It uses Gaussian Process regression to model the rewards and confidence regions.

Example:
>>> from vopy.order import ComponentwiseOrder
>>> from vopy.algorithms import PaVeBaGP
>>>
>>> epsilon, delta, noise_var = 0.1, 0.05, 0.01
>>> dataset_name = "DiscBrake"
>>> order_right = ComponentwiseOrder(2)
>>>
>>> algorithm = PaVeBaGP(epsilon, delta, dataset_name, order_right, noise_var)
>>>
>>> while True:
>>>     is_done = algorithm.run_one_step()
>>>
>>>     if is_done:
>>>          break
>>>
>>> pareto_indices = algorithm.P
Reference:

“Learning the Pareto Set Under Incomplete Preferences: Pure Exploration in Vector Bandits”, Karagözlü, Yıldırım, Ararat, Tekin, AISTATS, ‘24 https://proceedings.mlr.press/v238/karagozlu24a.html

compute_alpha() float

Compute the radius of the confidence regions of the current round to be used in modeling.

Returns:

The radius of the confidence regions.

Return type:

float

discarding()

Discard the designs that are highly likely to be suboptimal using the confidence regions.

evaluating()

Observe the self.batch_size number of designs from active designs, selecting by largest sum of variances and update the model.

modeling()

Construct the confidence regions of all active designs given all past observations.

pareto_updating()

Identify the designs that are highly likely to be epsilon-optimal using the confidence regions.

run_one_step() bool

Run one step of the algorithm and return algorithm status.

Returns:

True if the algorithm is over, False otherwise.

Return type:

bool

useful_updating()

Identify the designs that are decided to be Pareto, that would help with decisions of other designs.

VOGP

class vopy.algorithms.VOGP(epsilon: float, delta: float, dataset_name: str, order: PolyhedralConeOrder, noise_var: float, conf_contraction: float = 32, batch_size: int = 1)

Implement the Vector Optimization with Gaussian Process (VOGP) algorithm.

Parameters:
  • epsilon (float) – Accuracy parameter for the PAC algorithm.

  • delta (float) – Confidence parameter for the PAC algorithm.

  • dataset_name (str) – Name of the dataset to be used.

  • order (Order) – An instance of the Order class for managing comparisons.

  • noise_var (float) – Variance of the Gaussian sampling noise.

  • conf_contraction (float) – Contraction coefficient to shrink the confidence regions empirically. Defaults to 32.

  • batch_size (int) – Number of samples to be taken in each round. Defaults to 1.

The algorithm sequentially samples design rewards with a multivariate white Gaussian noise whose diagonal entries are specified by the user. It uses Gaussian Process regression to model the rewards and confidence regions.

Example Usage:
>>> from vopy.order import ComponentwiseOrder
>>> from vopy.algorithms import VOGP
>>>
>>> epsilon, delta, noise_var = 0.1, 0.05, 0.01
>>> dataset_name = "DiscBrake"
>>> order_right = ComponentwiseOrder(2)
>>>
>>> algorithm = VOGP(epsilon, delta, dataset_name, order_right, noise_var)
>>>
>>> while True:
>>>     is_done = algorithm.run_one_step()
>>>
>>>     if is_done:
>>>          break
>>>
>>> pareto_set = algorithm.P
Reference:

“Vector Optimization with Gaussian Process Bandits”, Korkmaz, Yıldırım, Ararat, Tekin, arXiv preprint https://arxiv.org/abs/2412.02484

compute_beta() numpy.ndarray

Compute the confidence scaling parameter beta for Gaussian Process modeling.

Returns:

A vector representing beta for each dimension of the output space.

Return type:

np.ndarray

compute_pessimistic_set() set

The pessimistic Pareto set of the set S+P of designs.

Returns:

Set of pessimistic Pareto indices.

Return type:

set

compute_u_star() Tuple[numpy.ndarray, float]

Computes the normalized direction vector u_star and the ordering difficulty d1 of a polyhedral ordering cone defined in the order self.order.ordering_cone.

Returns:

A tuple containing u_star, the normalized direction vector of the cone, and d1, the Euclidean norm of the vector that gives u_star when normalized, _i.e._, z.

Return type:

Tuple[np.ndarray, float]

discarding()

Discards designs that are highly likely to be dominated based on current confidence regions.

epsiloncovering()

Identify and remove designs from S that are not covered by the confidence region of other designs, adding them to P as Pareto-optimal.

evaluating()

Selects self.batch_size number of designs for evaluation based on maximum diagonals and updates the model with new observations.

modeling()

Updates confidence regions for all active designs.

run_one_step() bool

Executes one iteration of the VOGP algorithm, performing modeling, discarding, epsilon-covering, and evaluating phases. Returns the algorithm termination status.

Returns:

True if the set S is empty, indicating termination, False otherwise.

Return type:

bool

Algorithms for Vector Optimization in Continuous Domains

VOGP_AD

class vopy.algorithms.VOGP_AD(epsilon: float, delta: float, problem: ContinuousProblem, order: PolyhedralConeOrder, noise_var: float, conf_contraction: float = 32, batch_size: int = 1)

Implement the Vector Optimization with Gaussian Process (VOGP) algorithm for continuous domains using adaptive discretization.

Parameters:
  • epsilon (float) – Accuracy parameter for the PAC algorithm.

  • delta (float) – Confidence parameter for the PAC algorithm.

  • problem (ContinuousProblem) – Problem instance to be optimized.

  • order (Order) – An instance of the Order class for managing comparisons.

  • noise_var (float) – Variance of the Gaussian sampling noise.

  • conf_contraction (float) – Contraction coefficient to shrink the confidence regions empirically. Defaults to 32.

  • batch_size (int) – Number of samples to be taken in each round. Defaults to 1.

The algorithm sequentially samples design rewards with a multivariate white Gaussian noise whose diagonal entries are specified by the user. It uses Gaussian Process regression to model the rewards and confidence regions of the continuous function defined with problem.

Example Usage:
>>> from vopy.algorithms import VOGP_AD
>>> from vopy.order import ComponentwiseOrder
>>> from vopy.maximization_problem import get_continuous_problem
>>>
>>> epsilon, delta, noise_var = 0.1, 0.05, 0.01
>>> problem = get_continuous_problem("BraninCurrin")
>>> order_right = ComponentwiseOrder(2)
>>>
>>> algorithm = VOGP_AD(epsilon, delta, problem, order_right, noise_var)
>>>
>>> while True:
>>>     is_done = algorithm.run_one_step()
>>>
>>>     if is_done:
>>>          break
>>>
>>> predictive_model = algorithm.model
Reference:

“Vector Optimization with Gaussian Process Bandits”, Korkmaz, Yıldırım, Ararat, Tekin, arXiv preprint https://arxiv.org/abs/2412.02484

compute_beta()

Compute the confidence scaling parameter beta for Gaussian Process modeling.

Returns:

A vector representing beta for each dimension of the output space.

Return type:

np.ndarray

compute_pessimistic_set() set

The pessimistic Pareto set of the set S+P of designs.

Returns:

Set of pessimistic Pareto indices.

Return type:

set

compute_u_star()

Computes the normalized direction vector u_star and the ordering difficulty d1 of a polyhedral ordering cone defined in the order self.order.ordering_cone.

Returns:

A tuple containing u_star, the normalized direction vector of the cone, and d1, the Euclidean norm of the vector that gives u_star when normalized, i.e., z.

Return type:

Tuple[np.ndarray, float]

discarding()

Discards design nodes that are highly likely to be dominated based on current confidence regions.

epsiloncovering()

Identify and remove design nodes from S that are not covered by the confidence region of other design nodes, adding them to P as Pareto-optimal. This stage is only enabled after all design nodes in S have reached the maximum discretization depth.

evaluate_refine()

Selects a design node for based on maximum diagonals and either updates the model with new observations or refines the design node.

modeling()

Updates confidence regions for all currently active design nodes.

run_one_step() bool

Run one step of the algorithm and return algorithm status.

Returns:

True if the algorithm is over, i.e., S is empty, False otherwise.

Return type:

bool

Algorithms for Vector Optimization with Decoupled Objectives

PaVeBaPartialGP

class vopy.algorithms.PaVeBaPartialGP(epsilon: float, delta: float, dataset_name: str, order: PolyhedralConeOrder, noise_var: float, conf_contraction: float = 32, costs: list | None = None, cost_budget: float | None = None, confidence_type: Literal['hyperrectangle', 'hyperellipsoid'] = 'hyperrectangle', batch_size: int = 1)

Implement the partially observable GP-based Pareto Vector Bandits (PaVeBa) algorithm.

Parameters:
  • epsilon (float) – Determines the accuracy of the PAC-learning framework.

  • delta (float) – Determines the success probability of the PAC-learning framework.

  • dataset_name (str) – Name of the dataset to be used.

  • order (Order) – Order to be used.

  • noise_var (float) – Variance of the Gaussian sampling noise.

  • conf_contraction (float) – Contraction coefficient to shrink the confidence regions empirically. Defaults to 32.

  • costs (Optional[list]) – Cost associated with sampling each objective. Defaults to None.

  • cost_budget (Optional[float]) – Cost budget for the algorithm. Defaults to None.

  • confidence_type (Literal["hyperrectangle", "hyperellipsoid"]) – Specifies if the algorithm uses ellipsoidal or hyperrectangular confidence regions. Defaults to “hyperrectangle”.

  • batch_size (int) – Number of samples to be taken in each round. Defaults to 1.

The algorithm sequentially samples design rewards with a multivariate white Gaussian noise whose diagonal entries are specified by the user. It uses Gaussian Process regression to model the rewards and confidence regions.

Example:
>>> from vopy.order import ComponentwiseOrder
>>> from vopy.algorithms import PaVeBaPartialGP
>>>
>>> epsilon, delta, noise_var = 0.1, 0.05, 0.01
>>> cost_budget = 64
>>> dataset_name = "DiscBrake"
>>> order_right = ComponentwiseOrder(2)
>>>
>>> algorithm = PaVeBaPartialGP(
>>>     epsilon, delta, dataset_name, order_right, noise_var, cost_budget=cost_budget
>>> )
>>>
>>> while True:
>>>     is_done = algorithm.run_one_step()
>>>
>>>     if is_done:
>>>          break
>>>
>>> pareto_indices = algorithm.P
compute_alpha()

Compute the radius of the confidence regions of the current round to be used in modeling.

Returns:

The radius of the confidence regions.

Return type:

float

discarding()

Discard the designs that are highly likely to be suboptimal using the confidence regions.

evaluating()

Observe the self.batch_size number of designs from active designs, selecting by largest variance across designs and objectives and update the model.

modeling()

Construct the confidence regions of all active designs given all past observations.

pareto_updating()

Identify the designs that are highly likely to be epsilon-optimal using the confidence regions.

run_one_step() bool

Run one step of the algorithm and return algorithm status.

Returns:

True if the algorithm is over, False otherwise.

Return type:

bool

useful_updating()

Identify the designs that are decided to be Pareto, that would help with decisions of other designs.

DecoupledGP

class vopy.algorithms.DecoupledGP(dataset_name: str, order: PolyhedralConeOrder, noise_var: float, cost_budget: float, costs: list, batch_size: int = 1)

Implement a partially observable GP-based minimal algorithm that runs an acquisition method for until a budget is reached.

Parameters:
  • dataset_name (str) – Name of the dataset to be used.

  • order (Order) – Order to be used.

  • noise_var (float) – Variance of the Gaussian sampling noise.

  • cost_budget (float) – Cost budget for the algorithm.

  • costs (list) – Cost associated with sampling each objective.

  • batch_size (int) – Number of samples to be taken in each round. Defaults to 1.

The algorithm sequentially samples design rewards with a multivariate white Gaussian noise whose diagonal entries are specified by the user. It uses Gaussian Process regression to model the rewards and confidence regions.

Example:
>>> from vopy.order import ComponentwiseOrder
>>> from vopy.algorithms import DecoupledGP
>>>
>>> noise_var = 0.01
>>> cost_budget = 64
>>> dataset_name = "DiscBrake"
>>> order_right = ComponentwiseOrder(2)
>>>
>>> algorithm = DecoupledGP(
>>>     dataset_name, order_right, noise_var, cost_budget
>>> )
>>>
>>> while True:
>>>     is_done = algorithm.run_one_step()
>>>
>>>     if is_done:
>>>          break
>>>
>>> pareto_indices = algorithm.P
evaluating()

Observe the self.batch_size number of designs from active designs, selecting by the ThompsonEntropyDecoupledAcquisition acquisition method and update the model.

pareto_updating()

Identify the designs that are optimal using the mean estimates.

run_one_step() bool

Run one step of the algorithm and return algorithm status.

Returns:

True if the algorithm is over, False otherwise.

Return type:

bool

Algorithms for Multi-Objective Optimization

Auer

class vopy.algorithms.Auer(epsilon: float, delta: float, dataset_name: str, noise_var: float, conf_contraction: int = 32, use_empirical_beta: bool = False)

Implement the Algorithm 1 from Auer et al. (2016).

Parameters:
  • epsilon (float) – Determines the accuracy of the PAC-learning framework.

  • delta (float) – Determines the success probability of the PAC-learning framework.

  • dataset_name (str) – Name of the dataset to be used.

  • noise_var (float) – Variance of the Gaussian sampling noise.

  • conf_contraction (float) – Contraction coefficient to shrink the confidence regions empirically.

The algorithm sequentially samples design rewards with a multivariate white Gaussian noise whose diagonal entries are specified by the user.

Example:
>>> from vopy.algorithms import Auer
>>>
>>> epsilon, delta, noise_var = 0.1, 0.05, 0.01
>>> dataset_name = "DiscBrake"
>>>
>>> algorithm = Auer(epsilon, delta, dataset_name, order_right, noise_var)
>>>
>>> while True:
>>>     is_done = algorithm.run_one_step()
>>>
>>>     if is_done:
>>>          break
>>>
>>> pareto_indices = algorithm.P
Reference:

“Pareto Front Identification from Stochastic Bandit Feedback”, Auer, Chiang, Ortner, Drugan, AISTATS, ‘16 https://proceedings.mlr.press/v51/auer16.html

big_m(i: numpy.ndarray, j: numpy.ndarray) float

This method calculates the M(i, j) value, which is the amount by which the values of vector j have to be increased such that vector i + epsilon would be weakly dominated by it.

Parameters:
  • i (np.ndarray) – A D-vector.

  • j (np.ndarray) – A D-vector.

Returns:

The computed M(i, j) value.

Return type:

float

compute_beta() numpy.ndarray

Compute the beta values for the confidence regions of the current round to be used in modeling.

Returns:

The beta velues of the confidence regions.

Return type:

np.ndarray

discarding()

Discard the designs that are highly likely to be suboptimal using the confidence regions.

evaluating()

Observe the active designs via sampling.

modeling()

Construct the confidence regions of all active designs given all past observations.

pareto_updating()

Identify the designs that are highly likely to be epsilon-optimal using the confidence regions, by first identifying the designs that are useful.

run_one_step() bool

Run one step of the algorithm and return algorithm status.

Returns:

True if the algorithm is over, False otherwise.

Return type:

bool

small_m(i: numpy.ndarray, j: numpy.ndarray) float

This method calculates the m(i, j) value, which is the amount by which the vector i have to be increased such that it would not be strongly dominated by vector j.

Parameters:
  • vi (np.ndarray) – A D-vector.

  • vj (np.ndarray) – A D-vector.

Returns:

The computed m(i, j) value.

Return type:

float

property use_empirical_beta: bool

Property for the use_empirical_beta attribute.

Returns:

The value of the use_empirical_beta attribute.

Return type:

bool

EpsilonPAL

class vopy.algorithms.EpsilonPAL(epsilon: float, delta: float, dataset_name: str, noise_var: float, conf_contraction: float = 9, batch_size: int = 1)

Implement the GP-based \(\epsilon\)-Pareto Active Learning (\(\epsilon\)-PAL) algorithm.

Parameters:
  • epsilon (float) – Determines the accuracy of the PAC-learning framework.

  • delta (float) – Determines the success probability of the PAC-learning framework.

  • dataset_name (str) – Name of the dataset to be used.

  • noise_var (float) – Variance of the Gaussian sampling noise.

  • conf_contraction (float) – Contraction coefficient to shrink the confidence regions empirically. Defaults to 9.

  • batch_size (int) – Number of samples to be taken in each round. Defaults to 1.

The algorithm sequentially samples design rewards with a multivariate white Gaussian noise whose diagonal entries are specified by the user. It uses Gaussian Process regression to model the rewards and confidence regions.

Example:
>>> from vopy.order import ComponentwiseOrder
>>> from vopy.algorithms import EpsilonPAL
>>>
>>> epsilon, delta, noise_var = 0.1, 0.05, 0.01
>>> dataset_name = "DiscBrake"
>>>
>>> algorithm = EpsilonPAL(epsilon, delta, dataset_name, noise_var)
>>>
>>> while True:
>>>     is_done = algorithm.run_one_step()
>>>
>>>     if is_done:
>>>          break
>>>
>>> pareto_indices = algorithm.P
Reference:

\(\epsilon\)-PAL: An Active Learning Approach to the Multi-Objective Optimization Problem”, Zuluaga, Krause, Püschel, JMLR, ‘16 https://jmlr.org/papers/v17/15-047.html

compute_beta() numpy.ndarray

Compute the confidence scaling parameter beta for Gaussian Process modeling.

Returns:

A vector representing beta for each dimension of the output space.

Return type:

np.ndarray

compute_pessimistic_set() set

The pessimistic Pareto set of the set S+P of designs.

Returns:

Set of pessimistic Pareto indices.

Return type:

set

discarding()

Discards designs that are highly likely to be dominated based on current confidence regions.

epsiloncovering()

Identify and remove designs from S that are not covered by the confidence region of other designs, adding them to P as Pareto-optimal.

evaluating()

Selects self.batch_size number of designs for evaluation based on maximum diagonals and updates the model with new observations.

modeling()

Updates confidence regions for all active designs.

run_one_step() bool

Executes one iteration of the \(\epsilon\)-PAL algorithm, performing modeling, discarding, epsilon-covering, and evaluating phases. Returns the algorithm termination status.

Returns:

True if the set S is empty, indicating termination, False otherwise.

Return type:

bool