Add constrained synthetic test functions (pytorch#1832)

Summary:
Pull Request resolved: pytorch#1832

Adds the following engineering-problem test functions:
- PressureVesselDesign
- WeldedBeam
- SpeedReducer
- TensionCompressionString

Reviewed By: SebastianAment

Differential Revision: D45821102

fbshipit-source-id: 9dfda0cb48d218588e3528e32c249fe131b56d70

botorch/test_functions/synthetic.py

@@ -6,7 +6,29 @@
 
 r"""
 Synthetic functions for optimization benchmarks.
-Reference: https://www.sfu.ca/~ssurjano/optimization.html
+
+
+References:
+
+.. [Bingham2013virtual]
+    D. Bingham, S. Surjanovic. Virtual Library of Simulation Experiments.
+    https://www.sfu.ca/~ssurjano/optimization.html
+
+.. [CoelloCoello2002constraint]
+    C. A. Coello Coello and E. Mezura Montes. Constraint-handling in genetic
+    algorithms through the use of dominance-based tournament selection.
+    Advanced Engineering Informatics, 16(3):193–203, 2002.
+
+.. [Hedar2006derivfree]
+    A.-R. Hedar and M. Fukushima. Derivative-free filter simulated annealing
+    method for constrained continuous global optimization. Journal of Global
+    Optimization, 35(4):521–549, 2006.
+
+.. [Lemonge2010constrained]
+    A. C. C. Lemonge, H. J. C. Barbosa, C. C. H. Borges, and F. B. dos Santos
+    Silva. Constrained optimization problems in mechanical engineering design
+    using a real-coded steady-state genetic algorithm. Mecánica Computacional,
+    XXIX:9287–9303, 2010.
 """
 
 from __future__ import annotations
@@ -15,7 +37,8 @@
 from typing import List, Optional, Tuple
 
 import torch
-from botorch.test_functions.base import BaseTestProblem
+from botorch.test_functions.base import BaseTestProblem, ConstrainedBaseTestProblem
+from botorch.test_functions.utils import round_nearest
 from torch import Tensor
 
 
@@ -791,3 +814,182 @@ class ThreeHumpCamel(SyntheticTestFunction):
     def evaluate_true(self, X: Tensor) -> Tensor:
         x1, x2 = X[..., 0], X[..., 1]
         return 2.0 * x1**2 - 1.05 * x1**4 + x1**6 / 6.0 + x1 * x2 + x2**2
+
+
+#  ------------ Constrained synthetic test functions ----------- #
+
+
+class PressureVesselDesign(SyntheticTestFunction, ConstrainedBaseTestProblem):
+    r"""Pressure vessel design problem with constraints.
+
+    The four-dimensional pressure vessel design problem with four black-box
+    constraints from [CoelloCoello2002constraint]_.
+    """
+
+    dim = 4
+    num_constraints = 4
+    _bounds = [(0.0, 10.0), (0.0, 10.0), (10.0, 50.0), (150.0, 200.0)]
+
+    def evaluate_true(self, X: Tensor) -> Tensor:
+        x1, x2, x3, x4 = X.unbind(-1)
+        x1 = round_nearest(x1, increment=0.0625, bounds=self._bounds[0])
+        x2 = round_nearest(x2, increment=0.0625, bounds=self._bounds[1])
+        return (
+            0.6224 * x1 * x3 * x4
+            + 1.7781 * x2 * (x3**2)
+            + 3.1661 * (x1**2) * x4
+            + 19.84 * (x1**2) * x3
+        )
+
+    def evaluate_slack_true(self, X: Tensor) -> Tensor:
+        x1, x2, x3, x4 = X.unbind(-1)
+        return -torch.stack(
+            [
+                -x1 + 0.0193 * x3,
+                -x2 + 0.00954 * x3,
+                -math.pi * (x3**2) * x4 - (4 / 3) * math.pi * (x3**3) + 1296000.0,
+                x4 - 240.0,
+            ],
+            dim=-1,
+        )
+
+
+class WeldedBeam(SyntheticTestFunction, ConstrainedBaseTestProblem):
+    r"""Welded beam design problem with constraints.
+
+    The four-dimensional welded beam design proble problem with six
+    black-box constraints from [CoelloCoello2002constraint]_.
+    """
+
+    dim = 4
+    num_constraints = 6
+    _bounds = [(0.125, 10.0), (0.1, 10.0), (0.1, 10.0), (0.1, 10.0)]
+
+    def evaluate_true(self, X: Tensor) -> Tensor:
+        x1, x2, x3, x4 = X.unbind(-1)
+        return 1.10471 * (x1**2) * x2 + 0.04811 * x3 * x4 * (14.0 + x2)
+
+    def evaluate_slack_true(self, X: Tensor) -> Tensor:
+        x1, x2, x3, x4 = X.unbind(-1)
+        P = 6000.0
+        L = 14.0
+        E = 30e6
+        G = 12e6
+        t_max = 13600.0
+        s_max = 30000.0
+        d_max = 0.25
+
+        M = P * (L + x2 / 2)
+        R = torch.sqrt(0.25 * (x2**2 + (x1 + x3) ** 2))
+        J = 2 * math.sqrt(2) * x1 * x2 * (x2**2 / 12 + 0.25 * (x1 + x3) ** 2)
+        P_c = (
+            4.013
+            * E
+            * x3
+            * (x4**3)
+            * 6
+            / (L**2)
+            * (1 - 0.25 * x3 * math.sqrt(E / G) / L)
+        )
+        t1 = P / (math.sqrt(2) * x1 * x2)
+        t2 = M * R / J
+        t = torch.sqrt(t1**2 + t1 * t2 * x2 / R + t2**2)
+        s = 6 * P * L / (x4 * x3**2)
+        d = 4 * P * L**3 / (E * x3**3 * x4)
+
+        return -torch.stack(
+            [
+                t - t_max,
+                s - s_max,
+                x1 - x4,
+                0.10471 * x1**2 + 0.04811 * x3 * x4 * (14.0 + x2) - 5.0,
+                d - d_max,
+                P - P_c,
+            ],
+            dim=-1,
+        )
+
+
+class TensionCompressionString(SyntheticTestFunction, ConstrainedBaseTestProblem):
+    r"""Tension compression string optimization problem with constraints.
+
+    The three-dimensional tension compression string optimization problem with
+    four black-box constraints from [Hedar2006derivfree]_.
+    """
+
+    dim = 3
+    num_constraints = 4
+    _bounds = [(0.01, 1.0), (0.01, 1.0), (0.01, 20.0)]
+
+    def evaluate_true(self, X: Tensor) -> Tensor:
+        x1, x2, x3 = X.unbind(-1)
+        return (x1**2) * x2 * (x3 + 2)
+
+    def evaluate_slack_true(self, X: Tensor) -> Tensor:
+        x1, x2, x3 = X.unbind(-1)
+        constraints = torch.stack(
+            [
+                1 - (x2**3) * x3 / (71785 * (x1**4)),
+                (4 * (x2**2) - x1 * x2) / (12566 * (x1**3) * (x2 - x1))
+                + 1 / (5108 * (x1**2))
+                - 1,
+                1 - 140.45 * x1 / (x3 * (x2**2)),
+                (x1 + x2) / 1.5 - 1,
+            ],
+            dim=-1,
+        )
+        return -constraints.clamp_max(100)
+
+
+class SpeedReducer(SyntheticTestFunction, ConstrainedBaseTestProblem):
+    r"""Speed Reducer design problem with constraints.
+
+    The seven-dimensional speed reducer design problem with eleven black-box
+    constraints from [Lemonge2010constrained]_.
+    """
+
+    dim = 7
+    num_constraints = 11
+    _bounds = [
+        (2.6, 3.6),
+        (0.7, 0.8),
+        (17.0, 28.0),
+        (7.3, 8.3),
+        (7.8, 8.3),
+        (2.9, 3.9),
+        (5.0, 5.5),
+    ]
+
+    def evaluate_true(self, X: Tensor) -> Tensor:
+        x1, x2, x3, x4, x5, x6, x7 = X.unbind(-1)
+        return (
+            0.7854 * x1 * (x2**2) * (3.3333 * (x3**2) + 14.9334 * x3 - 43.0934)
+            + -1.508 * x1 * (x6**2 + x7**2)
+            + 7.4777 * (x6**3 + x7**3)
+            + 0.7854 * (x4 * (x6**2) + x5 * (x7**2))
+        )
+
+    def evaluate_slack_true(self, X: Tensor) -> Tensor:
+        x1, x2, x3, x4, x5, x6, x7 = X.unbind(-1)
+        return -torch.stack(
+            [
+                27.0 * (1 / x1) * (1 / (x2**2)) * (1 / x3) - 1,
+                397.5 * (1 / x1) * (1 / (x2**2)) * (1 / (x3**2)) - 1,
+                1.93 * (1 / x2) * (1 / x3) * (x4**3) * (1 / (x6**4)) - 1,
+                1.93 * (1 / x2) * (1 / x3) * (x5**3) * (1 / (x7**4)) - 1,
+                1
+                / (0.1 * (x6**3))
+                * torch.sqrt((745 * x4 / (x2 * x3)) ** 2 + 16.9 * 1e6)
+                - 1100,
+                1
+                / (0.1 * (x7**3))
+                * torch.sqrt((745 * x5 / (x2 * x3)) ** 2 + 157.5 * 1e6)
+                - 850,
+                x2 * x3 - 40,
+                5 - x1 / x2,
+                x1 / x2 - 12,
+                (1.5 * x6 + 1.9) / x4 - 1,
+                (1.1 * x7 + 1.9) / x5 - 1,
+            ],
+            dim=-1,
+        )

botorch/test_functions/utils.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+import torch
+
+from torch import Tensor
+
+
+def round_nearest(
+    X: Tensor, increment: float, bounds: Optional[Tuple[float, float]]
+) -> Tensor:
+    X_round = torch.round(X / increment) * increment
+    if bounds is not None:
+        X_round = torch.where(X_round < bounds[0], X_round + increment, X_round)
+        X_round = torch.where(X_round > bounds[1], X_round - increment, X_round)
+    return X_round