From 618119ccf35200bbf2049a225d59337233cbe908 Mon Sep 17 00:00:00 2001 From: Martin Fitzner Date: Tue, 18 Jun 2024 20:02:28 +0200 Subject: [PATCH 01/12] Add posterior standard deviation --- baybe/acquisition/__init__.py | 8 ++++++-- baybe/acquisition/acqfs.py | 14 +++++++++++++- tests/hypothesis_strategies/acquisition.py | 2 ++ 3 files changed, 21 insertions(+), 3 deletions(-) diff --git a/baybe/acquisition/__init__.py b/baybe/acquisition/__init__.py index d68b0a283..056eaf50d 100644 --- a/baybe/acquisition/__init__.py +++ b/baybe/acquisition/__init__.py @@ -4,6 +4,7 @@ ExpectedImprovement, LogExpectedImprovement, PosteriorMean, + PosteriorStandardDeviation, ProbabilityOfImprovement, UpperConfidenceBound, qExpectedImprovement, @@ -18,6 +19,7 @@ ) PM = PosteriorMean +PSTD = PosteriorStandardDeviation qSR = qSimpleRegret EI = ExpectedImprovement qEI = qExpectedImprovement @@ -36,8 +38,9 @@ ######################### Acquisition functions # Knowledge Gradient "qKnowledgeGradient", - # Posterior Mean + # Posterior Statistics "PosteriorMean", + "PosteriorStandardDeviation", # Simple Regret "qSimpleRegret", # Expected Improvement @@ -57,8 +60,9 @@ ######################### Abbreviations # Knowledge Gradient "qKG", - # Posterior Mean + # Posterior Statistics "PM", + "PSTD", # Simple Regret "qSR", # Expected Improvement diff --git a/baybe/acquisition/acqfs.py b/baybe/acquisition/acqfs.py index b83dcda8c..fc57e5cb5 100644 --- a/baybe/acquisition/acqfs.py +++ b/baybe/acquisition/acqfs.py @@ -149,7 +149,7 @@ class qKnowledgeGradient(AcquisitionFunction): ######################################################################################## -### Posterior Mean +### Posterior Statistics @define(frozen=True) class PosteriorMean(AcquisitionFunction): """Posterior mean.""" @@ -157,6 +157,18 @@ class PosteriorMean(AcquisitionFunction): abbreviation: ClassVar[str] = "PM" +@define(frozen=True) +class PosteriorStandardDeviation(AcquisitionFunction): + """Posterior standard deviation.""" + + abbreviation: ClassVar[str] = "PSTD" + + maximize: bool = field(default=True, validator=instance_of(bool)) + """Consider the problem a maximization problem. If set to False, acqf value is + negated. As a consequence, optimize_* will return -1 * minimum of the posterior + standard deviation.""" + + ######################################################################################## ### Simple Regret @define(frozen=True) diff --git a/tests/hypothesis_strategies/acquisition.py b/tests/hypothesis_strategies/acquisition.py index c6bae45e4..a260478a1 100644 --- a/tests/hypothesis_strategies/acquisition.py +++ b/tests/hypothesis_strategies/acquisition.py @@ -6,6 +6,7 @@ ExpectedImprovement, LogExpectedImprovement, PosteriorMean, + PosteriorStandardDeviation, ProbabilityOfImprovement, UpperConfidenceBound, qExpectedImprovement, @@ -49,6 +50,7 @@ def _qNIPV_strategy(draw: st.DrawFn): st.builds(ProbabilityOfImprovement), st.builds(UpperConfidenceBound, beta=finite_floats(min_value=0.0)), st.builds(PosteriorMean), + st.builds(PosteriorStandardDeviation, maximize=st.sampled_from([True, False])), st.builds(LogExpectedImprovement), st.builds(qExpectedImprovement), st.builds(qProbabilityOfImprovement), From 215f927b9579b6b47a749143f9e90db9e4642c40 Mon Sep 17 00:00:00 2001 From: Martin Fitzner Date: Tue, 18 Jun 2024 20:02:38 +0200 Subject: [PATCH 02/12] Add userguide --- docs/userguide/active_learning.md | 68 +++++++++++++++++++++++++++++++ docs/userguide/userguide.md | 1 + 2 files changed, 69 insertions(+) create mode 100644 docs/userguide/active_learning.md diff --git a/docs/userguide/active_learning.md b/docs/userguide/active_learning.md new file mode 100644 index 000000000..64a41e909 --- /dev/null +++ b/docs/userguide/active_learning.md @@ -0,0 +1,68 @@ +# Active Learning +When labeling unmeasured data points, e.g. for a data acquisition campaign to gather +data for a machine learning model, it can be beneficial to follow a guided approach +rather than randomly measuring data. If this is done via iteratively measuring points +according to a criterion proportional to the current model's uncertainty, the +method is called `active learning`. + +Active learning can be seen as a special case of Bayesian optimization. If we have the +above-mentioned criterion and set up a Bayesian optimization campaign to recommend +points with the highest uncertainty, we achieve active learning via Bayesian +optimization. In practice, we can leverage the fact that we have a posterior +distribution, and compute an acquisition function that represents the overall +uncertainty about any given point in the searchspace. + +Below you find which acquisition functions in BayBE are suitable for this endeavor +including a few guidelines. Furthermore, BayBE offers you the ability to choose a +custom surrogate model. This means you can use the model you intend to measure points +for already during the data acquisition phase (more on this soon). + +## Single-Point Uncertainty +In BayBE, there are two acquisition functions that can be chosen to search for the +points with the highest predicted model uncertainty: +- [`PosteriorStandardDeviation`](baybe.acquisition.acqfs.PosteriorStandardDeviation) +- [`UpperConfidenceBound`](baybe.acquisition.acqfs.UpperConfidenceBound) / + [`qUpperConfidenceBound`](baybe.acquisition.acqfs.qUpperConfidenceBound) with high + `beta`: A high `beta` will effectively cause that the mean part of the acquisition + function becomes irrelevant, and it only searches for points with the highest + posterior variability. We recommend values `beta > 10.0`. + +## Integrated Uncertainty +BayBE also offers the +[`qNegIntegratedPosteriorVariance`](baybe.acquisition.acqfs.qNegIntegratedPosteriorVariance) +(short [`qNIPV`](baybe.acquisition.acqfs.qNegIntegratedPosteriorVariance)). It integrates +the posterior variance on the entire searchspace. If your campaign selects points based +on this acquisition function, it thus chooses the ones which contribute most to the +current global model uncertainty and recommends them for measurement. This approach is +often superior to using a single point uncertainty estimate as acquisition function. + +Due to the computational complexity, it can be prohibitive to integrate over the entire +searchspace. For this reason we offer the ability to sub-sample parts of it, configured +in `qNIPV`: + +```python +from baybe.acquisition import qNIPV +from baybe.utils.sampling_algorithms import DiscreteSamplingMethod + +# Will integrate over the entire searchspace +qNIPV() + +# Will integrate over 50% of the searchspace, randomly sampled +qNIPV(sampling_fraction=0.5) + +# Will integrate over 100 points, chosen by farthest point sampling +# Both lines are equivalent +qNIPV(sampling_n_points=100, sampling_method="FPS") +qNIPV(sampling_n_points=100, sampling_method=DiscreteSamplingMethod.FPS) +``` + +**Sampling of the continuous part of the searchspace will always be random**, while +sampling of the discrete part can be controlled by providing a corresponding +[`DiscreteSamplingMethod`](baybe.utils.sampling_algorithms.DiscreteSamplingMethod) for +`sampling_method`. + +```{admonition} Purely Continuous SearchSpaces +:class: important +Please be aware that in case of a purely continuous searchspace, the number of points +to sample for integration must be specified via `sampling_n_points`. +``` \ No newline at end of file diff --git a/docs/userguide/userguide.md b/docs/userguide/userguide.md index 772e84ffa..e3c08815d 100644 --- a/docs/userguide/userguide.md +++ b/docs/userguide/userguide.md @@ -1,6 +1,7 @@ # User guide ```{toctree} +Active Learning Campaigns Constraints Environment Vars From e603c917e975af2dcd33e2ab4e29a0430e4d73e2 Mon Sep 17 00:00:00 2001 From: Martin Fitzner Date: Thu, 27 Jun 2024 10:11:32 +0200 Subject: [PATCH 03/12] Change tab position --- docs/userguide/userguide.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/userguide/userguide.md b/docs/userguide/userguide.md index e3c08815d..eb978b25e 100644 --- a/docs/userguide/userguide.md +++ b/docs/userguide/userguide.md @@ -1,8 +1,8 @@ # User guide ```{toctree} -Active Learning Campaigns +Active Learning Constraints Environment Vars Objectives From a52bca499b470a77f1b63a6e6e0be4dd96578d1e Mon Sep 17 00:00:00 2001 From: Martin Fitzner Date: Thu, 27 Jun 2024 10:15:05 +0200 Subject: [PATCH 04/12] Improve text --- baybe/acquisition/acqfs.py | 2 +- docs/userguide/active_learning.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/baybe/acquisition/acqfs.py b/baybe/acquisition/acqfs.py index fc57e5cb5..660021949 100644 --- a/baybe/acquisition/acqfs.py +++ b/baybe/acquisition/acqfs.py @@ -164,7 +164,7 @@ class PosteriorStandardDeviation(AcquisitionFunction): abbreviation: ClassVar[str] = "PSTD" maximize: bool = field(default=True, validator=instance_of(bool)) - """Consider the problem a maximization problem. If set to False, acqf value is + """Consider the problem a maximization problem. If set to `False`, acqf value is negated. As a consequence, optimize_* will return -1 * minimum of the posterior standard deviation.""" diff --git a/docs/userguide/active_learning.md b/docs/userguide/active_learning.md index 64a41e909..b3c6ea990 100644 --- a/docs/userguide/active_learning.md +++ b/docs/userguide/active_learning.md @@ -3,7 +3,7 @@ When labeling unmeasured data points, e.g. for a data acquisition campaign to ga data for a machine learning model, it can be beneficial to follow a guided approach rather than randomly measuring data. If this is done via iteratively measuring points according to a criterion proportional to the current model's uncertainty, the -method is called `active learning`. +method is called **active learning**. Active learning can be seen as a special case of Bayesian optimization. If we have the above-mentioned criterion and set up a Bayesian optimization campaign to recommend From c79d88f93cfd8c6aec56922fd540de67752430a2 Mon Sep 17 00:00:00 2001 From: Martin Fitzner Date: Thu, 27 Jun 2024 10:57:11 +0200 Subject: [PATCH 05/12] Remove custom surrogate statement. --- docs/userguide/active_learning.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/docs/userguide/active_learning.md b/docs/userguide/active_learning.md index b3c6ea990..785b3d04e 100644 --- a/docs/userguide/active_learning.md +++ b/docs/userguide/active_learning.md @@ -13,9 +13,7 @@ distribution, and compute an acquisition function that represents the overall uncertainty about any given point in the searchspace. Below you find which acquisition functions in BayBE are suitable for this endeavor -including a few guidelines. Furthermore, BayBE offers you the ability to choose a -custom surrogate model. This means you can use the model you intend to measure points -for already during the data acquisition phase (more on this soon). +including a few guidelines. ## Single-Point Uncertainty In BayBE, there are two acquisition functions that can be chosen to search for the From dcfff428516ba48ae340317947eaadf15f575801 Mon Sep 17 00:00:00 2001 From: Martin Fitzner Date: Tue, 18 Jun 2024 20:03:39 +0200 Subject: [PATCH 06/12] Update CHANGELOG.md --- CHANGELOG.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8d3067e3a..538639d87 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,8 +21,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `SubspaceDiscrete.to_searchspace` and `SubspaceContinuous.to_searchspace` convenience constructor - Validators for `Campaign` attributes -_ `_optional` subpackage for managing optional dependencies -- Acquisition function for active learning: `qNIPV` +- `_optional` subpackage for managing optional dependencies +- New acquisition functions for active learning: `qNIPV` (negative integrated posterior + variance) and `PosteriorStandardDeviation` - Acquisition function: `qKG` (knowledge gradient) - Abstract `ContinuousNonlinearConstraint` class - Abstract `CardinalityConstraint` class and @@ -42,6 +43,7 @@ _ `_optional` subpackage for managing optional dependencies - Validation and translation tests for kernels - `BasicKernel` and `CompositeKernel` base classes - Activated `pre-commit.ci` with auto-update +- User guide for active learning ### Changed - Passing an `Objective` to `Campaign` is now optional From 7c0bcf4f03cdff08e2f2ab93f53e6c99a8f00714 Mon Sep 17 00:00:00 2001 From: AdrianSosic Date: Mon, 15 Jul 2024 21:39:24 +0200 Subject: [PATCH 07/12] Revise content --- docs/userguide/active_learning.md | 65 ++++++++++++++++++------------- 1 file changed, 37 insertions(+), 28 deletions(-) diff --git a/docs/userguide/active_learning.md b/docs/userguide/active_learning.md index 785b3d04e..096f920a5 100644 --- a/docs/userguide/active_learning.md +++ b/docs/userguide/active_learning.md @@ -12,55 +12,64 @@ optimization. In practice, we can leverage the fact that we have a posterior distribution, and compute an acquisition function that represents the overall uncertainty about any given point in the searchspace. -Below you find which acquisition functions in BayBE are suitable for this endeavor +Below you find which acquisition functions in BayBE are suitable for this endeavor, including a few guidelines. -## Single-Point Uncertainty -In BayBE, there are two acquisition functions that can be chosen to search for the -points with the highest predicted model uncertainty: -- [`PosteriorStandardDeviation`](baybe.acquisition.acqfs.PosteriorStandardDeviation) -- [`UpperConfidenceBound`](baybe.acquisition.acqfs.UpperConfidenceBound) / - [`qUpperConfidenceBound`](baybe.acquisition.acqfs.qUpperConfidenceBound) with high - `beta`: A high `beta` will effectively cause that the mean part of the acquisition - function becomes irrelevant, and it only searches for points with the highest - posterior variability. We recommend values `beta > 10.0`. +## Local Uncertainty Reduction +In BayBE, there are two types of acquisition function that can be chosen to search for +the points with the highest predicted model uncertainty: +- [`PosteriorStandardDeviation`](baybe.acquisition.acqfs.PosteriorStandardDeviation) (`PSTD`) +- [`UpperConfidenceBound`](baybe.acquisition.acqfs.UpperConfidenceBound) (`UCB`) / + [`qUpperConfidenceBound`](baybe.acquisition.acqfs.qUpperConfidenceBound) (`qUCB`) + with high `beta`: + Increasing values of `beta` effectively eliminate the effect of the posterior mean on + the acquisition value, yielding a selection of points driven primarily by the + posterior variance. However, we generally recommend to use this acquisition function + only if a small exploratory component is desired – otherwise, the + [`PosteriorStandardDeviation`](baybe.acquisition.acqfs.PosteriorStandardDeviation) + acquisition function is what you are looking for. -## Integrated Uncertainty +## Global Uncertainty Reduction BayBE also offers the [`qNegIntegratedPosteriorVariance`](baybe.acquisition.acqfs.qNegIntegratedPosteriorVariance) -(short [`qNIPV`](baybe.acquisition.acqfs.qNegIntegratedPosteriorVariance)). It integrates -the posterior variance on the entire searchspace. If your campaign selects points based -on this acquisition function, it thus chooses the ones which contribute most to the -current global model uncertainty and recommends them for measurement. This approach is -often superior to using a single point uncertainty estimate as acquisition function. +(`qNIPV`), which integrates +the posterior variance over the entire search space. +Choosing candidates based on this acquisition function is tantamount to selecting the +set of points resulting in the largest reduction of global uncertainty when added to +the already existing experimental design. -Due to the computational complexity, it can be prohibitive to integrate over the entire -searchspace. For this reason we offer the ability to sub-sample parts of it, configured -in `qNIPV`: +Because of its ability to quantify uncertainty on a global scale, this approach is often superior to using a point-based uncertainty criterion as acquisition function. +However, due to its computational complexity, it can be prohibitive to integrate over +the entire search space. For this reason, we offer the option to sub-sample parts of it, +configurable via the constructor: ```python from baybe.acquisition import qNIPV from baybe.utils.sampling_algorithms import DiscreteSamplingMethod -# Will integrate over the entire searchspace +# Will integrate over the entire search space qNIPV() -# Will integrate over 50% of the searchspace, randomly sampled +# Will integrate over 50% of the search space, randomly sampled qNIPV(sampling_fraction=0.5) -# Will integrate over 100 points, chosen by farthest point sampling +# Will integrate over 250 points, chosen by farthest point sampling # Both lines are equivalent -qNIPV(sampling_n_points=100, sampling_method="FPS") -qNIPV(sampling_n_points=100, sampling_method=DiscreteSamplingMethod.FPS) +qNIPV(sampling_n_points=250, sampling_method="FPS") +qNIPV(sampling_n_points=250, sampling_method=DiscreteSamplingMethod.FPS) ``` -**Sampling of the continuous part of the searchspace will always be random**, while +```{admonition} Sub-Sampling Method +:class: note +Sampling of the continuous part of the search space will always be random, while sampling of the discrete part can be controlled by providing a corresponding [`DiscreteSamplingMethod`](baybe.utils.sampling_algorithms.DiscreteSamplingMethod) for `sampling_method`. +``` -```{admonition} Purely Continuous SearchSpaces +```{admonition} Purely Continuous Search Spaces :class: important -Please be aware that in case of a purely continuous searchspace, the number of points -to sample for integration must be specified via `sampling_n_points`. +Please be aware that in case of a purely continuous search space, the number of points +to sample for integration must be specified via `sampling_n_points` (since providing +a fraction becomes meaningless). ``` \ No newline at end of file From 0fd3c93a7ced737ee22b715165dd28efbe859d91 Mon Sep 17 00:00:00 2001 From: Martin Fitzner <17951239+Scienfitz@users.noreply.github.com> Date: Tue, 16 Jul 2024 11:34:18 +0200 Subject: [PATCH 08/12] Add suggestions Co-authored-by: AdrianSosic --- CHANGELOG.md | 2 +- baybe/acquisition/acqfs.py | 6 +++--- docs/userguide/active_learning.md | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 538639d87..30a45fb99 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -23,7 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Validators for `Campaign` attributes - `_optional` subpackage for managing optional dependencies - New acquisition functions for active learning: `qNIPV` (negative integrated posterior - variance) and `PosteriorStandardDeviation` + variance) and `PSTD` (posterior standard deviation) - Acquisition function: `qKG` (knowledge gradient) - Abstract `ContinuousNonlinearConstraint` class - Abstract `CardinalityConstraint` class and diff --git a/baybe/acquisition/acqfs.py b/baybe/acquisition/acqfs.py index 660021949..6dc92ccdf 100644 --- a/baybe/acquisition/acqfs.py +++ b/baybe/acquisition/acqfs.py @@ -164,9 +164,9 @@ class PosteriorStandardDeviation(AcquisitionFunction): abbreviation: ClassVar[str] = "PSTD" maximize: bool = field(default=True, validator=instance_of(bool)) - """Consider the problem a maximization problem. If set to `False`, acqf value is - negated. As a consequence, optimize_* will return -1 * minimum of the posterior - standard deviation.""" + """If ``True``, points with maximum posterior standard deviation are selected. + If ``False``, the acquisition function value is negated, yielding a selection + with minimal posterior standard deviation.""" ######################################################################################## diff --git a/docs/userguide/active_learning.md b/docs/userguide/active_learning.md index 096f920a5..0f22e1f96 100644 --- a/docs/userguide/active_learning.md +++ b/docs/userguide/active_learning.md @@ -2,7 +2,7 @@ When labeling unmeasured data points, e.g. for a data acquisition campaign to gather data for a machine learning model, it can be beneficial to follow a guided approach rather than randomly measuring data. If this is done via iteratively measuring points -according to a criterion proportional to the current model's uncertainty, the +according to a criterion reflecting the current model's uncertainty, the method is called **active learning**. Active learning can be seen as a special case of Bayesian optimization. If we have the From 8f5f6ba98882d4ec3b83d9e724782592b21b9f0a Mon Sep 17 00:00:00 2001 From: Martin Fitzner Date: Tue, 16 Jul 2024 12:02:17 +0200 Subject: [PATCH 09/12] Rephrase sentence --- docs/userguide/active_learning.md | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/docs/userguide/active_learning.md b/docs/userguide/active_learning.md index 0f22e1f96..c696849a7 100644 --- a/docs/userguide/active_learning.md +++ b/docs/userguide/active_learning.md @@ -1,9 +1,9 @@ # Active Learning -When labeling unmeasured data points, e.g. for a data acquisition campaign to gather -data for a machine learning model, it can be beneficial to follow a guided approach -rather than randomly measuring data. If this is done via iteratively measuring points -according to a criterion reflecting the current model's uncertainty, the -method is called **active learning**. +When deciding which experiments to perform next, e.g. for a data acquisition campaign +to gather data for a machine learning model, it can be beneficial to follow a guided +approach rather than selecting experiments randomly. If this is done via iteratively +measuring points according to a criterion reflecting the current model's uncertainty, +the method is called **active learning**. Active learning can be seen as a special case of Bayesian optimization. If we have the above-mentioned criterion and set up a Bayesian optimization campaign to recommend @@ -25,7 +25,7 @@ the points with the highest predicted model uncertainty: Increasing values of `beta` effectively eliminate the effect of the posterior mean on the acquisition value, yielding a selection of points driven primarily by the posterior variance. However, we generally recommend to use this acquisition function - only if a small exploratory component is desired – otherwise, the + only if a small exploratory component is desired - otherwise, the [`PosteriorStandardDeviation`](baybe.acquisition.acqfs.PosteriorStandardDeviation) acquisition function is what you are looking for. @@ -38,7 +38,8 @@ Choosing candidates based on this acquisition function is tantamount to selectin set of points resulting in the largest reduction of global uncertainty when added to the already existing experimental design. -Because of its ability to quantify uncertainty on a global scale, this approach is often superior to using a point-based uncertainty criterion as acquisition function. +Because of its ability to quantify uncertainty on a global scale, this approach is often +superior to using a point-based uncertainty criterion as acquisition function. However, due to its computational complexity, it can be prohibitive to integrate over the entire search space. For this reason, we offer the option to sub-sample parts of it, configurable via the constructor: From 0185636f307d43831d7c65b5e3a3e9ce9b1fb102 Mon Sep 17 00:00:00 2001 From: AdrianSosic Date: Fri, 19 Jul 2024 13:29:48 +0200 Subject: [PATCH 10/12] Fix dash --- docs/userguide/active_learning.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/userguide/active_learning.md b/docs/userguide/active_learning.md index c696849a7..5c4a8cbf8 100644 --- a/docs/userguide/active_learning.md +++ b/docs/userguide/active_learning.md @@ -25,7 +25,7 @@ the points with the highest predicted model uncertainty: Increasing values of `beta` effectively eliminate the effect of the posterior mean on the acquisition value, yielding a selection of points driven primarily by the posterior variance. However, we generally recommend to use this acquisition function - only if a small exploratory component is desired - otherwise, the + only if a small exploratory component is desired – otherwise, the [`PosteriorStandardDeviation`](baybe.acquisition.acqfs.PosteriorStandardDeviation) acquisition function is what you are looking for. From 24d0b2bb355dce4254bd0be941239f69f2fd9498 Mon Sep 17 00:00:00 2001 From: AdrianSosic Date: Fri, 19 Jul 2024 14:06:54 +0200 Subject: [PATCH 11/12] Rephrase active learning section --- docs/userguide/active_learning.md | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/docs/userguide/active_learning.md b/docs/userguide/active_learning.md index 5c4a8cbf8..439927170 100644 --- a/docs/userguide/active_learning.md +++ b/docs/userguide/active_learning.md @@ -5,12 +5,13 @@ approach rather than selecting experiments randomly. If this is done via iterati measuring points according to a criterion reflecting the current model's uncertainty, the method is called **active learning**. -Active learning can be seen as a special case of Bayesian optimization. If we have the -above-mentioned criterion and set up a Bayesian optimization campaign to recommend -points with the highest uncertainty, we achieve active learning via Bayesian -optimization. In practice, we can leverage the fact that we have a posterior -distribution, and compute an acquisition function that represents the overall -uncertainty about any given point in the searchspace. +Active learning can be seen as a special case of Bayesian optimization: If we have the +above-mentioned criterion and set up a Bayesian optimization campaign to recommend +points with the highest uncertainty, we achieve active learning via Bayesian +optimization. In practice, this is procedure is implemented by setting up a +probabilistic model of our measurement process that allows us to quantify uncertainty +in the form of a posterior posterior distribution, from which we can then construct an +uncertainty-based acquisition function to guide the exploration process. Below you find which acquisition functions in BayBE are suitable for this endeavor, including a few guidelines. From d16251443835fa67c3d6a010c80fea77fcaac0a8 Mon Sep 17 00:00:00 2001 From: Martin Fitzner Date: Fri, 19 Jul 2024 15:21:44 +0200 Subject: [PATCH 12/12] Remove repetition --- docs/userguide/active_learning.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/userguide/active_learning.md b/docs/userguide/active_learning.md index 439927170..06ce8c1d2 100644 --- a/docs/userguide/active_learning.md +++ b/docs/userguide/active_learning.md @@ -10,7 +10,7 @@ above-mentioned criterion and set up a Bayesian optimization campaign to recomme points with the highest uncertainty, we achieve active learning via Bayesian optimization. In practice, this is procedure is implemented by setting up a probabilistic model of our measurement process that allows us to quantify uncertainty -in the form of a posterior posterior distribution, from which we can then construct an +in the form of a posterior distribution, from which we can then construct an uncertainty-based acquisition function to guide the exploration process. Below you find which acquisition functions in BayBE are suitable for this endeavor,