Merge pull request #419 from leandrobbraga/fix-typos

Fix some typos

Author: bwheelz36

README.md

@@ -253,7 +253,7 @@ optimizer.maximize(
 )
 ```
 
-By default the previous data in the json file is removed. If you want to keep working with the same logger, the `reset` paremeter in `JSONLogger` should be set to False.
+By default the previous data in the json file is removed. If you want to keep working with the same logger, the `reset` parameter in `JSONLogger` should be set to False.
 
 ### 4.2 Loading progress
 

bayes_opt/domain_reduction.py

@@ -19,7 +19,7 @@ def transform(self, target_space: TargetSpace):
 
 class SequentialDomainReductionTransformer(DomainTransformer):
     """
-    A sequential domain reduction transformer bassed on the work by Stander, N. and Craig, K:
+    A sequential domain reduction transformer based on the work by Stander, N. and Craig, K:
     "On the robustness of a simple domain reduction scheme for simulation‐based optimization"
     """
 
@@ -68,8 +68,8 @@ def initialize(self, target_space: TargetSpace) -> None:
 
         self.r = self.contraction_rate * self.r
 
-        # check if the minimum window fits in the orignal bounds
-        self._window_bounds_compatiblity(self.original_bounds)
+        # check if the minimum window fits in the original bounds
+        self._window_bounds_compatibility(self.original_bounds)
 
     def _update(self, target_space: TargetSpace) -> None:
 
@@ -121,7 +121,7 @@ def _trim(self, new_bounds: np.array, global_bounds: np.array) -> np.array:
                 new_bounds[i, 1] += ddw_r
         return new_bounds
 
-    def _window_bounds_compatiblity(self, global_bounds: np.array) -> bool:
+    def _window_bounds_compatibility(self, global_bounds: np.array) -> bool:
         """Checks if global bounds are compatible with the minimum window sizes."""
         for i, entry in enumerate(global_bounds):
             global_window_width = abs(entry[1] - entry[0])

bayes_opt/util.py

@@ -51,7 +51,7 @@ def acq_max(ac, gp, y_max, bounds, random_state, constraint=None, n_warmup=10000
     x_max = x_tries[ys.argmax()]
     max_acq = ys.max()
 
-    # Explore the parameter space more throughly
+    # Explore the parameter space more thoroughly
     x_seeds = random_state.uniform(bounds[:, 0], bounds[:, 1],
                                    size=(n_iter, bounds.shape[0]))
 

examples/advanced-tour.ipynb

@@ -33,7 +33,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Let's start by defining our function, bounds, and instanciating an optimization object.\n",
+    "# Let's start by defining our function, bounds, and instantiating an optimization object.\n",
     "def black_box_function(x, y):\n",
     "    return -x ** 2 - (y - 1) ** 2 + 1"
    ]
@@ -347,12 +347,13 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### 3.3 Changing kernels\n",
     "\n",
-    "By default this package uses the Mattern 2.5 kernel. Depending on your use case you may find that tunning the GP kernel could be beneficial. You're on your own here since these are very specific solutions to very specific problems."
+    "By default this package uses the Matern 2.5 kernel. Depending on your use case you may find that tunning the GP kernel could be beneficial. You're on your own here since these are very specific solutions to very specific problems."
    ]
   },
   {

examples/basic-tour.ipynb

@@ -16,12 +16,13 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1. Specifying the function to be optimized\n",
     "\n",
-    "This is a function optimization package, therefore the first and most important ingreedient is, of course, the function to be optimized.\n",
+    "This is a function optimization package, therefore the first and most important ingredient is, of course, the function to be optimized.\n",
     "\n",
     "**DISCLAIMER:** We know exactly how the output of the function below depends on its parameter. Obviously this is just an example, and you shouldn't expect to know it in a real scenario. However, it should be clear that you don't need to. All you need in order to use this package (and more generally, this technique) is a function `f` that takes a known set of parameters and outputs a real number."
    ]
@@ -43,12 +44,13 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 2. Getting Started\n",
     "\n",
-    "All we need to get started is to instanciate a `BayesianOptimization` object specifying a function to be optimized `f`, and its parameters with their corresponding bounds, `pbounds`. This is a constrained optimization technique, so you must specify the minimum and maximum values that can be probed for each parameter in order for it to work"
+    "All we need to get started is to instantiate a `BayesianOptimization` object specifying a function to be optimized `f`, and its parameters with their corresponding bounds, `pbounds`. This is a constrained optimization technique, so you must specify the minimum and maximum values that can be probed for each parameter in order for it to work"
    ]
   },
   {
@@ -306,12 +308,13 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 4. Saving, loading and restarting\n",
     "\n",
-    "By default you can follow the progress of your optimization by setting `verbose>0` when instanciating the `BayesianOptimization` object. If you need more control over logging/alerting you will need to use an observer. For more information about observers checkout the advanced tour notebook. Here we will only see how to use the native `JSONLogger` object to save to and load progress from files.\n",
+    "By default you can follow the progress of your optimization by setting `verbose>0` when instantiating the `BayesianOptimization` object. If you need more control over logging/alerting you will need to use an observer. For more information about observers checkout the advanced tour notebook. Here we will only see how to use the native `JSONLogger` object to save to and load progress from files.\n",
     "\n",
     "### 4.1 Saving progress"
    ]
@@ -327,14 +330,15 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The observer paradigm works by:\n",
     "1. Instantiating an observer object.\n",
     "2. Tying the observer object to a particular event fired by an optimizer.\n",
     "\n",
-    "The `BayesianOptimization` object fires a number of internal events during optimization, in particular, everytime it probes the function and obtains a new parameter-target combination it will fire an `Events.OPTIMIZATION_STEP` event, which our logger will listen to.\n",
+    "The `BayesianOptimization` object fires a number of internal events during optimization, in particular, every time it probes the function and obtains a new parameter-target combination it will fire an `Events.OPTIMIZATION_STEP` event, which our logger will listen to.\n",
     "\n",
     "**Caveat:** The logger will not look back at previously probed points."
    ]

examples/constraints.ipynb

@@ -330,7 +330,7 @@
     "    else:\n",
     "        c_labels = [f\"constraint {i+1}\" for i in range(n_constraints)]\n",
     "    labels_top = [\"target\"] + c_labels + [\"masked target\"]\n",
-    "    labels_bot = [\"target estimate\"] + [c + \" estimate\" for c in c_labels] + [\"acqusition function\"]\n",
+    "    labels_bot = [\"target estimate\"] + [c + \" estimate\" for c in c_labels] + [\"acquisition function\"]\n",
     "    labels = [labels_top, labels_bot]\n",
     "\n",
     "    # Setup the grid to plot on\n",

examples/domain_reduction.ipynb

@@ -1,17 +1,18 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Sequential Domain Reduction\n",
     "\n",
     "## Background\n",
-    "Sequential domain reduction is a process where the bounds of the optimization problem are mutated (typically contracted) to reduce the time required to converge to an optimal value. The advantage of this method is typically seen when a cost function is particularly expensive to calculate, or if the optimization routine oscilates heavily. \n",
+    "Sequential domain reduction is a process where the bounds of the optimization problem are mutated (typically contracted) to reduce the time required to converge to an optimal value. The advantage of this method is typically seen when a cost function is particularly expensive to calculate, or if the optimization routine oscillates heavily. \n",
     "\n",
     "## Basics\n",
     "\n",
-    "The basic steps are a *pan* and a *zoom*. These two steps are applied at one time, therefore updating the problem search space evey iteration.\n",
+    "The basic steps are a *pan* and a *zoom*. These two steps are applied at one time, therefore updating the problem search space every iteration.\n",
     "\n",
     "**Pan**: recentering the region of interest around the most optimal point found.\n",
     "\n",
@@ -122,10 +123,11 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now we can set up two idential optimization problems, except one has the `bound_transformer` variable set."
+    "Now we can set up two identical optimization problems, except one has the `bound_transformer` variable set."
    ]
   },
   {
@@ -182,10 +184,11 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "After both have completed we can plot to see how the objectives performed. It's quite obvious to see that the Sequential Domain Reduction technique contracted onto the optimal point relativly quickly."
+    "After both have completed we can plot to see how the objectives performed. It's quite obvious to see that the Sequential Domain Reduction technique contracted onto the optimal point relatively quick."
    ]
   },
   {

examples/sklearn_example.py

@@ -42,7 +42,7 @@ def rfc_cv(n_estimators, min_samples_split, max_features, data, targets):
     of cross validation is returned.
 
     Our goal is to find combinations of n_estimators, min_samples_split, and
-    max_features that minimzes the log loss.
+    max_features that minimizes the log loss.
     """
     estimator = RFC(
         n_estimators=n_estimators,

examples/visualization.ipynb

@@ -16,6 +16,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -25,7 +26,7 @@
     "\n",
     "$$f(x) = e^{-(x - 2)^2} + e^{-\\frac{(x - 6)^2}{10}} + \\frac{1}{x^2 + 1}, $$ its maximum is at $x = 2$ and we will restrict the interval of interest to $x \\in (-2, 10)$.\n",
     "\n",
-    "Notice that, in practice, this function is unknown, the only information we have is obtained by sequentialy probing it at different points. Bayesian Optimization works by contructing a posterior distribution of functions that best fit the data observed and chosing the next probing point by balancing exploration and exploitation."
+    "Notice that, in practice, this function is unknown, the only information we have is obtained by sequentially probing it at different points. Bayesian Optimization works by constructing a posterior distribution of functions that best fit the data observed and choosing the next probing point by balancing exploration and exploitation."
    ]
   },
   {

tests/test_bayesian_optimization.py

@@ -180,7 +180,7 @@ def test_callback(event, instance):
         optimizer._events[Events.OPTIMIZATION_START].values()
     ])
 
-    # Check that prime subscriptions won't overight manual subscriptions
+    # Check that prime subscriptions won't overwrite manual subscriptions
     optimizer._prime_subscriptions()
     assert all([
         k == test_subscriber for k in