new: first draft of the documentation

Author: GurjeetSinghSangra

.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 6ab4861fb0ec34198af10ae911faedff
+tags: 645f666f9bcd5a90fca523b33c5a78b7

.nojekyll

@@ -0,0 +1,37 @@
+# PyBADS Example 1: Basic usage
+# (code only - see Jupyter notebook for the tutorial)
+
+import numpy as np
+
+from pybads import BADS
+
+
+def rosenbrocks_fcn(x):
+    """Rosenbrock's 'banana' function in any dimension."""
+    x_2d = np.atleast_2d(x)
+    return np.sum(
+        100 * (x_2d[:, 0:-1] ** 2 - x_2d[:, 1:]) ** 2
+        + (x_2d[:, 0:-1] - 1) ** 2,
+        axis=1,
+    )
+
+
+target = rosenbrocks_fcn
+
+lb = np.array([-20, -20])  # Lower bounds
+ub = np.array([20, 20])  # Upper bounds
+plb = np.array([-5, -5])  # Plausible lower bounds
+pub = np.array([5, 5])  # Plausible upper bounds
+x0 = np.array([0, 0])
+# Starting point
+
+bads = BADS(target, x0, lb, ub, plb, pub)
+optimize_result = bads.optimize()
+
+x_min = optimize_result["x"]
+fval = optimize_result["fval"]
+
+print(f"BADS minimum at: x_min = {x_min.flatten()}, fval = {fval:.4g}")
+print(
+    f"total f-count: {optimize_result['func_count']}, time: {round(optimize_result['total_time'], 2)} s"
+)

_downloads/06743557a28bcbf4dca92af04c48319b/pybads_example_1_basic_usage.py

@@ -0,0 +1,60 @@
+# PyBADS Example 5: Extended usage
+# (code only - see Jupyter notebook for a tutorial)
+
+import numpy as np
+
+from pybads import BADS
+
+
+def camelback6(x):
+    """Six-hump camelback function."""
+    x_2d = np.atleast_2d(x)
+    x1 = x_2d[:, 0]
+    x2 = x_2d[:, 1]
+    f = (
+        (4 - 2.1 * (x1 * x1) + (x1 * x1 * x1 * x1) / 3.0) * (x1 * x1)
+        + x1 * x2
+        + (-4 + 4 * (x2 * x2)) * (x2 * x2)
+    )
+    return f
+
+
+lb = np.array([-3, -2])  # Lower bounds
+ub = np.array([3, 2])  # Upper bounds
+plb = np.array([-2.9, -1.9])  # Plausible lower bounds
+pub = np.array([2.9, 1.9])  # Plausible upper bounds
+
+options = {
+    "display": "off",  # We switch off the printing
+    "uncertainty_handling": False,  # Good to specify that this is a deterministic function
+}
+
+num_opts = 10
+optimize_results = []
+x_vec = np.zeros((num_opts, lb.shape[0]))
+fval_vec = np.zeros(num_opts)
+
+for opt_count in range(num_opts):
+    print("Running optimization " + str(opt_count) + "...")
+    x0 = np.random.uniform(low=plb, high=pub)
+    bads = BADS(camelback6, x0, lb, ub, plb, pub, options=options)
+    optimize_results.append(bads.optimize())
+    x_vec[opt_count] = optimize_results[opt_count].x
+    fval_vec[opt_count] = optimize_results[opt_count].fval
+
+print("Found solutions:")
+print(x_vec)
+
+print("Function values at solutions:")
+print(fval_vec)
+
+idx_best = np.argmin(fval_vec)
+result_best = optimize_results[idx_best]
+
+x_min = result_best["x"]
+fval = result_best["fval"]
+
+print(f"BADS minimum at x_min = {x_min.flatten()}")
+print(f"Function value at minimum fval = {fval}")
+
+result_best

_downloads/66a4a0a202d9e4aaa38aa89b13027fda/pybads_example_5_extended_usage.py

@@ -0,0 +1,55 @@
+# PyBADS Example 4: Noisy objective with user-provided noise estimates
+# (code only - see Jupyter notebook for a tutorial)
+
+import numpy as np
+
+from pybads import BADS
+
+
+def noisy_sphere_estimated_noise(x, scale=1.0):
+    """Quadratic function with heteroskedastic noise; also return noise estimate."""
+    x_2d = np.atleast_2d(x)
+    f = np.sum(x_2d**2, axis=1)
+    sigma = scale * (1.0 + np.sqrt(f))
+    y = f + sigma * np.random.normal(size=x_2d.shape[0])
+    return y, sigma
+
+
+x0 = np.array([-3, -3])
+# Starting point
+lb = np.array([-5, -5])  # Lower bounds
+ub = np.array([5, 5])  # Upper bounds
+plb = np.array([-2, -2])  # Plausible lower bounds
+pub = np.array([2, 2])  # Plausible upper bounds
+
+options = {
+    "uncertainty_handling": True,
+    "specify_target_noise": True,
+    "noise_final_samples": 100,
+}
+
+bads = BADS(
+    noisy_sphere_estimated_noise, x0, lb, ub, plb, pub, options=options
+)
+optimize_result = bads.optimize()
+
+x_min = optimize_result["x"]
+fval = optimize_result["fval"]
+fsd = optimize_result["fsd"]
+
+x_min = optimize_result["x"]
+fval = optimize_result["fval"]
+fsd = optimize_result["fsd"]
+
+print(
+    f"BADS minimum at: x_min = {x_min.flatten()}, fval (estimated) = {fval:.4g} +/- {fsd:.2g}"
+)
+print(
+    f"total f-count: {optimize_result['func_count']}, time: {round(optimize_result['total_time'], 2)} s"
+)
+print(f"final evaluations (shape): {optimize_result['yval_vec'].shape}")
+print(f"final evaluations SD (shape): {optimize_result['ysd_vec'].shape}")
+
+print(
+    f"The true, noiseless value of f(x_min) is {noisy_sphere_estimated_noise(x_min,scale=0)[0][0]:.3g}."
+)

_downloads/74f3ba26c810ad06a6a8c73b48d40b97/pybads_example_4_user_provided_noise.py

@@ -0,0 +1,47 @@
+# PyBADS Example 3: Noisy objective function
+# (code only - see Jupyter notebook for a tutorial)
+
+import numpy as np
+
+from pybads import BADS
+
+
+def noisy_sphere(x, sigma=1.0):
+    """Simple quadratic function with added noise."""
+    x_2d = np.atleast_2d(x)
+    f = np.sum(x_2d**2, axis=1)
+    noise = sigma * np.random.normal(size=x_2d.shape[0])
+    return f + noise
+
+
+x0 = np.array([-3, -3])
+# Starting point
+lb = np.array([-5, -5])  # Lower bounds
+ub = np.array([5, 5])  # Upper bounds
+plb = np.array([-2, -2])  # Plausible lower bounds
+pub = np.array([2, 2])  # Plausible upper bounds
+
+options = {
+    "uncertainty_handling": True,
+    "max_fun_evals": 300,
+    "noise_final_samples": 100,
+}
+
+bads = BADS(noisy_sphere, x0, lb, ub, plb, pub, options=options)
+optimize_result = bads.optimize()
+
+x_min = optimize_result["x"]
+fval = optimize_result["fval"]
+fsd = optimize_result["fsd"]
+
+print(
+    f"BADS minimum at: x_min = {x_min.flatten()}, fval (estimated) = {fval:.4g} +/- {fsd:.2g}"
+)
+print(
+    f"total f-count: {optimize_result['func_count']}, time: {round(optimize_result['total_time'], 2)} s"
+)
+print(f"final evaluations (shape): {optimize_result['yval_vec'].shape}")
+
+print(
+    f"The true, noiseless value of f(x_min) is {noisy_sphere(x_min,sigma=0)[0]:.3g}."
+)

_downloads/e438e0f5fc735fbcda36ef39de78ec93/pybads_example_3_noisy_objective.py

@@ -0,0 +1,42 @@
+# PyBADS Example 2: Non-box constraints
+# (code only - see Jupyter notebook for the tutorial)
+
+import numpy as np
+
+from pybads import BADS
+
+
+def rosenbrocks_fcn(x):
+    """Rosenbrock's 'banana' function in any dimension."""
+    x_2d = np.atleast_2d(x)
+    return np.sum(
+        100 * (x_2d[:, 0:-1] ** 2 - x_2d[:, 1:]) ** 2
+        + (x_2d[:, 0:-1] - 1) ** 2,
+        axis=1,
+    )
+
+
+x0 = np.array([0, 0])
+# Starting point
+lb = np.array([-1, -1])  # Lower bounds
+ub = np.array([1, 1])  # Upper bounds
+
+
+def circle_constr(x):
+    """Return constraints violation outside the unit circle."""
+    x_2d = np.atleast_2d(x)
+    # Note that nonboxcons assumes the function takes a 2D input
+    return np.sum(x_2d**2, axis=1) > 1
+
+
+bads = BADS(rosenbrocks_fcn, x0, lb, ub, non_box_cons=circle_constr)
+optimize_result = bads.optimize()
+
+x_min = optimize_result["x"]
+fval = optimize_result["fval"]
+
+print(f"BADS minimum at: x_min = {x_min.flatten()}, fval = {fval:.4g}")
+print(
+    f"total f-count: {optimize_result['func_count']}, time: {round(optimize_result['total_time'], 2)} s"
+)
+print(f"Problem type: {optimize_result['problem_type']}")