├── .github ├── ISSUE_TEMPLATE │ ├── bug_report.yml │ ├── config.yml │ └── feature_request.yml ├── PULL_REQUEST_TEMPLATE.md └── workflows │ ├── deploy_on_release.yml │ ├── docs.yml │ ├── lint.yml │ ├── nightly.yml │ ├── publish_website.yml │ ├── reusable_test.yml │ ├── reusable_tutorials.yml │ ├── test.yml │ ├── test_stable.yml │ └── tutorials_smoke_test.yml ├── .gitignore ├── .pre-commit-config.yaml ├── .readthedocs.yaml ├── CHANGELOG.md ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── LICENSE ├── MANIFEST.in ├── README.md ├── botorch ├── __init__.py ├── acquisition │ ├── __init__.py │ ├── acquisition.py │ ├── active_learning.py │ ├── analytic.py │ ├── bayesian_active_learning.py │ ├── cached_cholesky.py │ ├── cost_aware.py │ ├── decoupled.py │ ├── factory.py │ ├── fixed_feature.py │ ├── input_constructors.py │ ├── joint_entropy_search.py │ ├── knowledge_gradient.py │ ├── logei.py │ ├── max_value_entropy_search.py │ ├── monte_carlo.py │ ├── multi_objective │ │ ├── __init__.py │ │ ├── analytic.py │ │ ├── base.py │ │ ├── hypervolume_knowledge_gradient.py │ │ ├── joint_entropy_search.py │ │ ├── logei.py │ │ ├── max_value_entropy_search.py │ │ ├── monte_carlo.py │ │ ├── multi_fidelity.py │ │ ├── multi_output_risk_measures.py │ │ ├── objective.py │ │ ├── parego.py │ │ ├── predictive_entropy_search.py │ │ └── utils.py │ ├── multi_step_lookahead.py │ ├── objective.py │ ├── penalized.py │ ├── predictive_entropy_search.py │ ├── preference.py │ ├── prior_guided.py │ ├── proximal.py │ ├── risk_measures.py │ ├── thompson_sampling.py │ └── utils.py ├── cross_validation.py ├── exceptions │ ├── __init__.py │ ├── errors.py │ └── warnings.py ├── fit.py ├── generation │ ├── __init__.py │ ├── gen.py │ ├── sampling.py │ └── utils.py ├── logging.py ├── models │ ├── __init__.py │ ├── approximate_gp.py │ ├── contextual.py │ ├── contextual_multioutput.py │ ├── cost.py │ ├── deterministic.py │ ├── ensemble.py │ ├── fully_bayesian.py │ ├── fully_bayesian_multitask.py │ ├── gp_regression.py │ ├── gp_regression_fidelity.py │ ├── gp_regression_mixed.py │ ├── gpytorch.py │ ├── higher_order_gp.py │ ├── kernels │ │ ├── __init__.py │ │ ├── categorical.py │ │ ├── contextual_lcea.py │ │ ├── contextual_sac.py │ │ ├── downsampling.py │ │ ├── exponential_decay.py │ │ ├── infinite_width_bnn.py │ │ ├── linear_truncated_fidelity.py │ │ └── orthogonal_additive_kernel.py │ ├── latent_kronecker_gp.py │ ├── likelihoods │ │ ├── __init__.py │ │ ├── pairwise.py │ │ └── sparse_outlier_noise.py │ ├── map_saas.py │ ├── model.py │ ├── model_list_gp_regression.py │ ├── multitask.py │ ├── pairwise_gp.py │ ├── relevance_pursuit.py │ ├── robust_relevance_pursuit_model.py │ ├── transforms │ │ ├── __init__.py │ │ ├── factory.py │ │ ├── input.py │ │ ├── outcome.py │ │ └── utils.py │ └── utils │ │ ├── __init__.py │ │ ├── assorted.py │ │ ├── gpytorch_modules.py │ │ └── inducing_point_allocators.py ├── optim │ ├── __init__.py │ ├── closures │ │ ├── __init__.py │ │ ├── core.py │ │ └── model_closures.py │ ├── core.py │ ├── fit.py │ ├── homotopy.py │ ├── initializers.py │ ├── optimize.py │ ├── optimize_homotopy.py │ ├── optimize_mixed.py │ ├── parameter_constraints.py │ ├── stopping.py │ └── utils │ │ ├── __init__.py │ │ ├── acquisition_utils.py │ │ ├── common.py │ │ ├── model_utils.py │ │ ├── numpy_utils.py │ │ └── timeout.py ├── posteriors │ ├── __init__.py │ ├── base_samples.py │ ├── ensemble.py │ ├── fully_bayesian.py │ ├── gpytorch.py │ ├── higher_order.py │ ├── latent_kronecker.py │ ├── multitask.py │ ├── posterior.py │ ├── posterior_list.py │ ├── torch.py │ └── transformed.py ├── sampling │ ├── __init__.py │ ├── base.py │ ├── get_sampler.py │ ├── index_sampler.py │ ├── list_sampler.py │ ├── normal.py │ ├── pairwise_samplers.py │ ├── pathwise │ │ ├── __init__.py │ │ ├── features │ │ │ ├── __init__.py │ │ │ ├── generators.py │ │ │ └── maps.py │ │ ├── paths.py │ │ ├── posterior_samplers.py │ │ ├── prior_samplers.py │ │ ├── update_strategies.py │ │ └── utils.py │ ├── qmc.py │ └── stochastic_samplers.py ├── settings.py ├── test_functions │ ├── __init__.py │ ├── base.py │ ├── multi_fidelity.py │ ├── multi_objective.py │ ├── multi_objective_multi_fidelity.py │ ├── sensitivity_analysis.py │ ├── synthetic.py │ └── utils.py ├── test_utils │ ├── __init__.py │ └── mock.py └── utils │ ├── __init__.py │ ├── constants.py │ ├── constraints.py │ ├── containers.py │ ├── context_managers.py │ ├── datasets.py │ ├── dispatcher.py │ ├── evaluation.py │ ├── feasible_volume.py │ ├── low_rank.py │ ├── multi_objective │ ├── __init__.py │ ├── box_decompositions │ │ ├── __init__.py │ │ ├── box_decomposition.py │ │ ├── box_decomposition_list.py │ │ ├── dominated.py │ │ ├── non_dominated.py │ │ └── utils.py │ ├── hypervolume.py │ ├── pareto.py │ └── scalarization.py │ ├── multitask.py │ ├── objective.py │ ├── probability │ ├── __init__.py │ ├── bvn.py │ ├── lin_ess.py │ ├── linalg.py │ ├── mvnxpb.py │ ├── truncated_multivariate_normal.py │ ├── unified_skew_normal.py │ └── utils.py │ ├── rounding.py │ ├── safe_math.py │ ├── sampling.py │ ├── test_helpers.py │ ├── testing.py │ ├── torch.py │ ├── transforms.py │ └── types.py ├── botorch_community ├── README.md ├── __init__.py ├── acquisition │ ├── __init__.py │ ├── augmented_multisource.py │ ├── bayesian_active_learning.py │ ├── bll_thompson_sampling.py │ ├── discretized.py │ ├── hentropy_search.py │ ├── input_constructors.py │ ├── rei.py │ └── scorebo.py ├── models │ ├── __init__.py │ ├── blls.py │ ├── example.py │ ├── gp_regression_multisource.py │ ├── prior_fitted_network.py │ ├── utils │ │ └── prior_fitted_network.py │ ├── vbll_helper.py │ └── vblls.py ├── posteriors │ ├── __init__.py │ ├── bll_posterior.py │ └── riemann.py └── utils │ └── stat_dist.py ├── botorch_logo_lockup.png ├── botorch_logo_lockup.svg ├── docs ├── acquisition.md ├── assets │ ├── EI_MC_qMC.png │ ├── EI_optimal_val_hist.png │ ├── EI_optimizer_hist.png │ ├── EI_resampling_fixed.png │ ├── botorch_and_ax.svg │ ├── mc_acq_illustration.svg │ ├── overview_bayesopt.svg │ ├── overview_blackbox.svg │ └── overview_mcacquisition.svg ├── batching.md ├── botorch_and_ax.md ├── constraints.md ├── design_philosophy.md ├── getting_started.mdx ├── introduction.md ├── models.md ├── multi_objective.md ├── objectives.md ├── optimization.md ├── overview.md ├── papers.md ├── posteriors.md ├── samplers.md └── tutorials │ └── index.mdx ├── notebooks_community ├── README.md ├── clf_constrained_bo.ipynb ├── example.ipynb ├── hentropy_search.ipynb ├── multi_source_bo.ipynb └── vbll_thompson_sampling.ipynb ├── pyproject.toml ├── requirements-fmt.txt ├── requirements.txt ├── scripts ├── build_docs.sh ├── check_pre_commit_reqs.py ├── convert_ipynb_to_mdx.py ├── parse_sphinx.py ├── patch_site_config.py ├── run_tutorials.py ├── validate_sphinx.py └── verify_py_packages.sh ├── setup.cfg ├── setup.py ├── sphinx ├── Makefile ├── README.md ├── make.bat └── source │ ├── _static │ └── custom.css │ ├── acquisition.rst │ ├── conf.py │ ├── cross_validation.rst │ ├── exceptions.rst │ ├── fit.rst │ ├── generation.rst │ ├── index.rst │ ├── logging.rst │ ├── models.rst │ ├── optim.rst │ ├── posteriors.rst │ ├── sampling.rst │ ├── settings.rst │ ├── test_functions.rst │ ├── test_utils.rst │ └── utils.rst ├── test ├── __init__.py ├── acquisition │ ├── __init__.py │ ├── multi_objective │ │ ├── __init__.py │ │ ├── test_analytic.py │ │ ├── test_base.py │ │ ├── test_hypervolume_knowledge_gradient.py │ │ ├── test_joint_entropy_search.py │ │ ├── test_logei.py │ │ ├── test_max_value_entropy_search.py │ │ ├── test_monte_carlo.py │ │ ├── test_multi_fidelity.py │ │ ├── test_multi_output_risk_measures.py │ │ ├── test_objective.py │ │ ├── test_parego.py │ │ ├── test_predictive_entropy_search.py │ │ └── test_utils.py │ ├── test_acquisition.py │ ├── test_active_learning.py │ ├── test_analytic.py │ ├── test_bayesian_active_learning.py │ ├── test_cached_cholesky.py │ ├── test_cost_aware.py │ ├── test_decoupled.py │ ├── test_factory.py │ ├── test_fixed_feature.py │ ├── test_input_constructors.py │ ├── test_integration.py │ ├── test_joint_entropy_search.py │ ├── test_knowledge_gradient.py │ ├── test_logei.py │ ├── test_max_value_entropy_search.py │ ├── test_monte_carlo.py │ ├── test_multi_step_lookahead.py │ ├── test_objective.py │ ├── test_penalized.py │ ├── test_predictive_entropy_search.py │ ├── test_preference.py │ ├── test_prior_guided.py │ ├── test_proximal.py │ ├── test_risk_measures.py │ ├── test_thompson_sampling.py │ └── test_utils.py ├── exceptions │ ├── __init__.py │ ├── test_errors.py │ └── test_warnings.py ├── generation │ ├── __init__.py │ ├── test_gen.py │ ├── test_sampling.py │ └── test_utils.py ├── models │ ├── __init__.py │ ├── kernels │ │ ├── __init__.py │ │ ├── test_categorical.py │ │ ├── test_contextual.py │ │ ├── test_downsampling.py │ │ ├── test_exponential_decay.py │ │ ├── test_infinite_width_bnn.py │ │ ├── test_linear_truncated_fidelity.py │ │ └── test_orthogonal_additive_kernel.py │ ├── likelihoods │ │ └── test_pairwise_likelihood.py │ ├── test_approximate_gp.py │ ├── test_contextual.py │ ├── test_contextual_multioutput.py │ ├── test_cost.py │ ├── test_deterministic.py │ ├── test_ensemble.py │ ├── test_fully_bayesian.py │ ├── test_fully_bayesian_multitask.py │ ├── test_gp_regression.py │ ├── test_gp_regression_fidelity.py │ ├── test_gp_regression_mixed.py │ ├── test_gpytorch.py │ ├── test_higher_order_gp.py │ ├── test_latent_kronecker_gp.py │ ├── test_map_saas.py │ ├── test_model.py │ ├── test_model_list_gp_regression.py │ ├── test_multitask.py │ ├── test_pairwise_gp.py │ ├── test_relevance_pursuit.py │ ├── transforms │ │ ├── test_factory.py │ │ ├── test_input.py │ │ ├── test_outcome.py │ │ └── test_utils.py │ └── utils │ │ ├── __init__.py │ │ ├── test_assorted.py │ │ ├── test_gpytorch_modules.py │ │ └── test_inducing_point_allocators.py ├── optim │ ├── __init__.py │ ├── closures │ │ ├── __init__.py │ │ ├── test_core.py │ │ └── test_model_closures.py │ ├── test_core.py │ ├── test_fit.py │ ├── test_homotopy.py │ ├── test_initializers.py │ ├── test_numpy_converter.py │ ├── test_optimize.py │ ├── test_optimize_mixed.py │ ├── test_parameter_constraints.py │ ├── test_stopping.py │ └── utils │ │ ├── __init__.py │ │ ├── test_acquisition_utils.py │ │ ├── test_common.py │ │ ├── test_model_utils.py │ │ ├── test_numpy_utils.py │ │ └── test_timeout.py ├── posteriors │ ├── __init__.py │ ├── test_deterministic.py │ ├── test_ensemble.py │ ├── test_gpytorch.py │ ├── test_higher_order.py │ ├── test_multitask.py │ ├── test_posterior.py │ ├── test_posteriorlist.py │ ├── test_torch_posterior.py │ └── test_transformed.py ├── sampling │ ├── __init__.py │ ├── pathwise │ │ ├── __init__.py │ │ ├── features │ │ │ ├── __init__.py │ │ │ ├── test_generators.py │ │ │ └── test_maps.py │ │ ├── test_paths.py │ │ ├── test_posterior_samplers.py │ │ ├── test_prior_samplers.py │ │ ├── test_update_strategies.py │ │ └── test_utils.py │ ├── test_base.py │ ├── test_deterministic.py │ ├── test_get_sampler.py │ ├── test_index_sampler.py │ ├── test_list_sampler.py │ ├── test_normal.py │ ├── test_pairwise_sampler.py │ ├── test_qmc.py │ └── test_stochastic_samplers.py ├── test_cross_validation.py ├── test_cuda.py ├── test_end_to_end.py ├── test_fit.py ├── test_functions │ ├── __init__.py │ ├── test_base.py │ ├── test_multi_fidelity.py │ ├── test_multi_objective.py │ ├── test_multi_objective_multi_fidelity.py │ ├── test_sensitivity_analysis.py │ └── test_synthetic.py ├── test_logging.py ├── test_settings.py ├── test_utils │ └── test_mock.py └── utils │ ├── __init__.py │ ├── multi_objective │ ├── __init__.py │ ├── box_decompositions │ │ ├── __init__.py │ │ ├── test_box_decomposition.py │ │ ├── test_box_decomposition_list.py │ │ ├── test_dominated.py │ │ ├── test_non_dominated.py │ │ └── test_utils.py │ ├── test_hypervolume.py │ ├── test_pareto.py │ └── test_scalarization.py │ ├── probability │ ├── __init__.py │ ├── test_bvn.py │ ├── test_lin_ess.py │ ├── test_linalg.py │ ├── test_mvnxpb.py │ ├── test_truncated_multivariate_normal.py │ ├── test_unified_skew_normal.py │ └── test_utils.py │ ├── test_constants.py │ ├── test_constraints.py │ ├── test_containers.py │ ├── test_context_managers.py │ ├── test_datasets.py │ ├── test_dispatcher.py │ ├── test_evaluation.py │ ├── test_feasible_volume.py │ ├── test_low_rank.py │ ├── test_multitask.py │ ├── test_objective.py │ ├── test_rounding.py │ ├── test_safe_math.py │ ├── test_sampling.py │ ├── test_test_helpers.py │ ├── test_testing.py │ ├── test_torch.py │ └── test_transforms.py ├── test_community ├── __init__.py ├── acquisition │ ├── __init__.py │ ├── test_bayesian_active_learning.py │ ├── test_bll_thompson_sampling.py │ ├── test_discretized.py │ ├── test_hentropy_search.py │ ├── test_input_constructors.py │ ├── test_multi_source.py │ ├── test_rei.py │ └── test_scorebo.py ├── models │ ├── __init__.py │ ├── test_example.py │ ├── test_gp_regression_multisource.py │ ├── test_prior_fitted_network.py │ ├── test_vbll_helper.py │ └── test_vblls.py ├── posteriors │ ├── test_bll.py │ └── test_riemann.py └── utils │ └── test_stat_dist.py ├── tutorials ├── GIBBON_for_efficient_batch_entropy_search │ └── GIBBON_for_efficient_batch_entropy_search.ipynb ├── Multi_objective_multi_fidelity_BO │ └── Multi_objective_multi_fidelity_BO.ipynb ├── README.md ├── batch_mode_cross_validation │ └── batch_mode_cross_validation.ipynb ├── baxus │ └── baxus.ipynb ├── bo_with_warped_gp │ └── bo_with_warped_gp.ipynb ├── bope │ └── bope.ipynb ├── closed_loop_botorch_only │ └── closed_loop_botorch_only.ipynb ├── compare_mc_analytic_acquisition │ └── compare_mc_analytic_acquisition.ipynb ├── composite_bo_with_hogp │ └── composite_bo_with_hogp.ipynb ├── composite_mtbo │ └── composite_mtbo.ipynb ├── constrained_multi_objective_bo │ └── constrained_multi_objective_bo.ipynb ├── constraint_active_search │ └── constraint_active_search.ipynb ├── cost_aware_bayesian_optimization │ └── cost_aware_bayesian_optimization.ipynb ├── custom_acquisition │ └── custom_acquisition.ipynb ├── custom_model │ └── custom_model.ipynb ├── data │ └── twitter_flash_crash.csv ├── decoupled_mobo │ └── decoupled_mobo.ipynb ├── discrete_multi_fidelity_bo │ └── discrete_multi_fidelity_bo.ipynb ├── fit_model_with_torch_optimizer │ └── fit_model_with_torch_optimizer.ipynb ├── ibnn_bo │ └── ibnn_bo.ipynb ├── information_theoretic_acquisition_functions │ └── information_theoretic_acquisition_functions.ipynb ├── max_value_entropy │ └── max_value_entropy.ipynb ├── meta_learning_with_rgpe │ └── meta_learning_with_rgpe.ipynb ├── multi_fidelity_bo │ └── multi_fidelity_bo.ipynb ├── multi_objective_bo │ └── multi_objective_bo.ipynb ├── one_shot_kg │ └── one_shot_kg.ipynb ├── optimize_stochastic │ └── optimize_stochastic.ipynb ├── optimize_with_cmaes │ └── optimize_with_cmaes.ipynb ├── preference_bo │ └── preference_bo.ipynb ├── pretrained_models │ ├── mnist_cnn.pt │ └── mnist_vae.pt ├── relevance_pursuit_robust_regression │ └── relevance_pursuit_robust_regression.ipynb ├── risk_averse_bo_with_environmental_variables │ └── risk_averse_bo_with_environmental_variables.ipynb ├── risk_averse_bo_with_input_perturbations │ └── risk_averse_bo_with_input_perturbations.ipynb ├── robust_multi_objective_bo │ └── robust_multi_objective_bo.ipynb ├── saasbo │ └── saasbo.ipynb ├── scalable_constrained_bo │ └── scalable_constrained_bo.ipynb ├── thompson_sampling │ └── thompson_sampling.ipynb ├── turbo_1 │ └── turbo_1.ipynb └── vae_mnist │ └── vae_mnist.ipynb └── website ├── docusaurus.config.js ├── package.json ├── sidebars.js ├── src ├── components │ ├── CellOutput.jsx │ ├── LinkButtons.jsx │ └── Plotting.jsx ├── css │ └── customTheme.css └── pages │ └── index.js ├── static ├── .nojekyll ├── CNAME ├── css │ ├── alabaster.css │ ├── basic.css │ ├── code_block_buttons.css │ └── custom.css ├── img │ ├── botorch.ico │ ├── botorch.png │ ├── botorch_logo_lockup.png │ ├── botorch_logo_lockup.svg │ ├── botorch_logo_lockup_top.png │ ├── botorch_logo_lockup_white.png │ ├── expanding_arrows.svg │ ├── meta_opensource_logo_negative.svg │ ├── oss_logo.png │ ├── puzzle_pieces.svg │ └── pytorch_logo.svg ├── js │ └── code_block_buttons.js └── pygments.css ├── tutorials.json └── yarn.lock /.github/ISSUE_TEMPLATE/bug_report.yml: -------------------------------------------------------------------------------- 1 | name: 🐛 Bug Report 2 | description: File a bug report. 3 | labels: ["bug"] 4 | title: "[Bug]: " 5 | body: 6 | - type: markdown 7 | attributes: 8 | value: | 9 | Thank you for taking the time to fill out a bug report. We strive to make BoTorch a useful and stable library for all our users. 10 | - type: textarea 11 | id: what-happened 12 | attributes: 13 | label: What happened? 14 | description: Provide a detailed description of the bug as well as the expected behavior. 15 | validations: 16 | required: true 17 | - type: textarea 18 | id: repro 19 | attributes: 20 | label: Please provide a minimal, reproducible example of the unexpected behavior. 21 | description: Follow [these guidelines](https://stackoverflow.com/help/minimal-reproducible-example) for writing your example. Please ensure that the provided example is complete & runnable, including with dummy data if necessary. 22 | validations: 23 | required: true 24 | - type: textarea 25 | id: traceback 26 | attributes: 27 | label: Please paste any relevant traceback/logs produced by the example provided. 28 | description: This will be automatically formatted into code, so no need for backticks. 29 | render: shell 30 | - type: input 31 | id: botorch-version 32 | attributes: 33 | label: BoTorch Version 34 | description: What version of BoTorch are you using? 35 | validations: 36 | required: true 37 | - type: input 38 | id: python-version 39 | attributes: 40 | label: Python Version 41 | description: What version of Python are you using? 42 | validations: 43 | required: false 44 | - type: input 45 | id: os 46 | attributes: 47 | label: Operating System 48 | description: What operating system are you using? 49 | validations: 50 | required: false 51 | - type: textarea 52 | id: suggested-fix 53 | attributes: 54 | label: (Optional) Describe any potential fixes you've considered to the issue outlined above. 55 | - type: dropdown 56 | id: pull-request 57 | attributes: 58 | label: Pull Request 59 | description: Are you willing to open a pull request fixing the bug outlined in this issue? (See [Contributing to BoTorch](https://github.com/pytorch/botorch/blob/main/CONTRIBUTING.md)) 60 | options: 61 | - "Yes" 62 | - "No" 63 | - type: checkboxes 64 | id: terms 65 | attributes: 66 | label: Code of Conduct 67 | description: By submitting this issue, you agree to follow BoTorch's [Code of Conduct](https://github.com/pytorch/botorch/blob/main/CODE_OF_CONDUCT.md). 68 | options: 69 | - label: I agree to follow BoTorch's Code of Conduct 70 | required: true 71 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/config.yml: -------------------------------------------------------------------------------- 1 | blank_issues_enabled: false 2 | contact_links: 3 | - name: General Support & Discussions 4 | url: https://github.com/pytorch/botorch/discussions 5 | about: Please use discussions for general support requests and to ask broader questions related to BoTorch. This includes any support request that does not require changes to BoTorch source code. 6 | - name: Bug Bounty Program 7 | url: https://bugbounty.meta.com/ 8 | about: Meta has a bounty program for the safe disclosure of security bugs. Please go through the process outlined on that page and do not file a public issue. 9 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/feature_request.yml: -------------------------------------------------------------------------------- 1 | name: 🚀 Feature Request 2 | description: Request a feature or improvement to BoTorch. 3 | labels: ["enhancement"] 4 | title: "[FEATURE REQUEST]: " 5 | body: 6 | - type: markdown 7 | attributes: 8 | value: | 9 | Thank you for taking the time to request a feature! We strive to make BoTorch a useful and rich library for our users. 10 | - type: textarea 11 | id: motivation 12 | attributes: 13 | label: Motivation 14 | description: Provide a detailed description of the problem you would like to solve via this new feature or improvement. 15 | validations: 16 | required: true 17 | - type: textarea 18 | id: pitch 19 | attributes: 20 | label: Describe the solution you'd like to see implemented in BoTorch. 21 | validations: 22 | required: true 23 | - type: textarea 24 | id: alternatives 25 | attributes: 26 | label: Describe any alternatives you've considered to the above solution. 27 | - type: textarea 28 | id: related 29 | attributes: 30 | label: Is this related to an existing issue in BoTorch or another repository? If so please include links to those Issues here. 31 | - type: dropdown 32 | id: pull-request 33 | attributes: 34 | label: Pull Request 35 | description: Are you willing to open a pull request implementing this feature? (See [Contributing to BoTorch](https://github.com/pytorch/botorch/blob/main/CONTRIBUTING.md)) 36 | options: 37 | - "Yes" 38 | - "No" 39 | - type: checkboxes 40 | id: terms 41 | attributes: 42 | label: Code of Conduct 43 | description: By submitting this issue, you agree to follow BoTorch's [Code of Conduct](https://github.com/pytorch/botorch/blob/main/CODE_OF_CONDUCT.md). 44 | options: 45 | - label: I agree to follow BoTorch's Code of Conduct 46 | required: true 47 | -------------------------------------------------------------------------------- /.github/PULL_REQUEST_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | 8 | 9 | ## Motivation 10 | 11 | (Write your motivation here.) 12 | 13 | ### Have you read the [Contributing Guidelines on pull requests](https://github.com/pytorch/botorch/blob/main/CONTRIBUTING.md#pull-requests)? 14 | 15 | (Write your answer here.) 16 | 17 | ## Test Plan 18 | 19 | (Write your test plan here. If you changed any code, please provide us with clear instructions on how you verified your changes work. Bonus points for screenshots and videos!) 20 | 21 | ## Related PRs 22 | 23 | (If this PR adds or changes functionality, please take some time to update the docs at https://github.com/pytorch/botorch, and link to your PR here.) 24 | -------------------------------------------------------------------------------- /.github/workflows/docs.yml: -------------------------------------------------------------------------------- 1 | name: Docs 2 | 3 | on: 4 | push: 5 | branches: [ main ] 6 | pull_request: 7 | branches: [ main ] 8 | workflow_dispatch: 9 | 10 | 11 | jobs: 12 | 13 | docs: 14 | name: Build docs 15 | runs-on: ubuntu-latest 16 | strategy: 17 | fail-fast: false 18 | env: 19 | # `uv pip ...` requires venv by default. This skips that requirement. 20 | UV_SYSTEM_PYTHON: 1 21 | steps: 22 | - uses: actions/checkout@v4 23 | - name: Install uv 24 | uses: astral-sh/setup-uv@v5 25 | - name: Set up Python 26 | uses: actions/setup-python@v5 27 | with: 28 | python-version: "3.13" 29 | - name: Install dependencies 30 | env: 31 | ALLOW_LATEST_GPYTORCH_LINOP: true 32 | run: | 33 | uv pip install git+https://github.com/cornellius-gp/linear_operator.git 34 | uv pip install git+https://github.com/cornellius-gp/gpytorch.git 35 | uv pip install ."[dev, tutorials]" 36 | - name: Validate Sphinx 37 | run: | 38 | python scripts/validate_sphinx.py -p "$(pwd)" 39 | - name: Run sphinx 40 | run: | 41 | # warnings treated as errors 42 | sphinx-build -WT --keep-going sphinx/source sphinx/build 43 | - name: Validate and parse tutorials 44 | run: | 45 | python scripts/convert_ipynb_to_mdx.py --clean 46 | -------------------------------------------------------------------------------- /.github/workflows/lint.yml: -------------------------------------------------------------------------------- 1 | name: Lint 2 | 3 | on: 4 | push: 5 | branches: [ main ] 6 | pull_request: 7 | branches: [ main ] 8 | workflow_dispatch: 9 | 10 | 11 | jobs: 12 | 13 | lint: 14 | runs-on: ubuntu-latest 15 | env: 16 | # `uv pip ...` requires venv by default. This skips that requirement. 17 | UV_SYSTEM_PYTHON: 1 18 | steps: 19 | - uses: actions/checkout@v4 20 | - name: Install uv 21 | uses: astral-sh/setup-uv@v5 22 | - name: Set up Python 23 | uses: actions/setup-python@v5 24 | with: 25 | python-version: "3.13" 26 | 27 | - name: Install dependencies 28 | run: uv pip install pre-commit 29 | 30 | - name: Run pre-commit 31 | run: pre-commit run --all-files --show-diff-on-failure 32 | -------------------------------------------------------------------------------- /.github/workflows/nightly.yml: -------------------------------------------------------------------------------- 1 | name: Nightly Cron 2 | 3 | on: 4 | schedule: 5 | # 2:30 PST 6 | - cron: '30 10 * * *' 7 | workflow_dispatch: 8 | 9 | 10 | jobs: 11 | tests-and-coverage-nightly: 12 | name: Test & Coverage 13 | uses: ./.github/workflows/reusable_test.yml 14 | with: 15 | use_latest_pytorch_gpytorch: true 16 | secrets: inherit 17 | 18 | package-test-deploy-pypi: 19 | name: Package and test deployment to test.pypi.org 20 | runs-on: ubuntu-latest 21 | permissions: 22 | id-token: write # This is required for PyPI OIDC authentication. 23 | env: 24 | # `uv pip ...` requires venv by default. This skips that requirement. 25 | UV_SYSTEM_PYTHON: 1 26 | steps: 27 | - uses: actions/checkout@v4 28 | - name: Fetch all history for all tags and branches 29 | run: git fetch --prune --unshallow 30 | - name: Install uv 31 | uses: astral-sh/setup-uv@v5 32 | - name: Set up Python 33 | uses: actions/setup-python@v5 34 | with: 35 | python-version: "3.13" 36 | - name: Install dependencies 37 | env: 38 | ALLOW_LATEST_GPYTORCH_LINOP: true 39 | run: | 40 | uv pip install --pre torch --index-url https://download.pytorch.org/whl/nightly/cpu 41 | uv pip install git+https://github.com/cornellius-gp/linear_operator.git 42 | uv pip install git+https://github.com/cornellius-gp/gpytorch.git 43 | uv pip install .[test] 44 | uv pip install --upgrade build setuptools setuptools_scm wheel 45 | - name: Extract reduced version and save to env var 46 | # strip the commit hash from the version to enable upload to pypi 47 | # env var will persist for subsequent steps 48 | run: | 49 | no_local_version=$(python -m setuptools_scm | cut -d "+" -f 1) 50 | echo "SETUPTOOLS_SCM_PRETEND_VERSION=${no_local_version}" >> $GITHUB_ENV 51 | - name: Build packages (wheel and source distribution) 52 | env: 53 | ALLOW_LATEST_GPYTORCH_LINOP: true 54 | run: | 55 | python -m build --sdist --wheel 56 | - name: Verify packages 57 | env: 58 | ALLOW_LATEST_GPYTORCH_LINOP: true 59 | run: | 60 | ./scripts/verify_py_packages.sh 61 | - name: Deploy to Test PyPI 62 | uses: pypa/gh-action-pypi-publish@release/v1 63 | with: 64 | repository-url: https://test.pypi.org/legacy/ 65 | skip-existing: true 66 | verbose: true 67 | 68 | publish-latest-website: 69 | name: Publish latest website 70 | needs: [tests-and-coverage-nightly, package-test-deploy-pypi] 71 | uses: ./.github/workflows/publish_website.yml 72 | permissions: 73 | pages: write 74 | id-token: write 75 | contents: write 76 | 77 | run_tutorials: 78 | name: Run tutorials without smoke test on latest PyTorch / GPyTorch 79 | uses: ./.github/workflows/reusable_tutorials.yml 80 | with: 81 | smoke_test: false 82 | use_stable_pytorch_gpytorch: false 83 | -------------------------------------------------------------------------------- /.github/workflows/publish_website.yml: -------------------------------------------------------------------------------- 1 | name: Publish Website 2 | 3 | on: 4 | workflow_call: 5 | inputs: 6 | new_version: 7 | required: false 8 | type: string 9 | run_tutorials: 10 | required: false 11 | type: boolean 12 | default: false 13 | workflow_dispatch: 14 | 15 | 16 | jobs: 17 | 18 | build-website: 19 | runs-on: ubuntu-latest 20 | env: 21 | # `uv pip ...` requires venv by default. This skips that requirement. 22 | UV_SYSTEM_PYTHON: 1 23 | permissions: 24 | contents: write 25 | steps: 26 | - uses: actions/checkout@v4 27 | with: 28 | ref: 'docusaurus-versions' # release branch 29 | fetch-depth: 0 30 | - name: Install uv 31 | uses: astral-sh/setup-uv@v5 32 | - name: Sync release branch with main 33 | run: | 34 | git config --global user.name "github-actions[bot]" 35 | git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com" 36 | git merge origin/main 37 | # To avoid a large number of commits we don't push this sync commit to github until a new release. 38 | - name: Set up Python 39 | uses: actions/setup-python@v5 40 | with: 41 | python-version: "3.13" 42 | - if: ${{ !inputs.new_version }} 43 | name: Install latest GPyTorch and Linear Operator 44 | run: | 45 | uv pip install git+https://github.com/cornellius-gp/linear_operator.git 46 | uv pip install git+https://github.com/cornellius-gp/gpytorch.git 47 | - name: Install dependencies 48 | env: 49 | ALLOW_LATEST_GPYTORCH_LINOP: true 50 | run: | 51 | uv pip install ."[dev, tutorials]" 52 | - if: ${{ inputs.new_version }} 53 | name: Create new docusaurus version 54 | run: | 55 | python3 scripts/convert_ipynb_to_mdx.py --clean 56 | cd website 57 | yarn 58 | yarn docusaurus docs:version ${{ inputs.new_version }} 59 | 60 | git add versioned_docs/ versioned_sidebars/ versions.json 61 | git commit -m "Create version ${{ inputs.new_version }} of site in Docusaurus" 62 | git push --force origin HEAD:docusaurus-versions 63 | - name: Build website 64 | run: | 65 | bash scripts/build_docs.sh -b 66 | - name: Upload website build as artifact 67 | id: deployment 68 | uses: actions/upload-pages-artifact@v3 69 | with: 70 | path: website/build/ 71 | 72 | deploy-website: 73 | needs: build-website 74 | permissions: 75 | pages: write 76 | id-token: write 77 | environment: 78 | name: github-pages 79 | url: ${{ steps.deployment.outputs.page_url }} 80 | runs-on: ubuntu-latest 81 | steps: 82 | - name: Deploy to GitHub Pages 83 | id: deployment 84 | uses: actions/deploy-pages@v4 85 | -------------------------------------------------------------------------------- /.github/workflows/reusable_test.yml: -------------------------------------------------------------------------------- 1 | name: Reusable Test Workflow 2 | 3 | on: 4 | workflow_call: 5 | inputs: 6 | use_latest_pytorch_gpytorch: 7 | required: true 8 | type: boolean 9 | upload_coverage: 10 | required: false 11 | type: boolean 12 | default: true 13 | 14 | 15 | jobs: 16 | tests-and-coverage: 17 | name: Tests and coverage (Python ${{ matrix.python-version }}, ${{ matrix.os }}) 18 | runs-on: ${{ matrix.os }} 19 | strategy: 20 | fail-fast: false 21 | matrix: 22 | os: ["ubuntu-latest", "macos-14", "windows-latest"] 23 | python-version: ["3.10", "3.13"] 24 | env: 25 | # `uv pip ...` requires venv by default. This skips that requirement. 26 | UV_SYSTEM_PYTHON: 1 27 | steps: 28 | - uses: actions/checkout@v4 29 | - name: Install uv 30 | uses: astral-sh/setup-uv@v5 31 | - name: Set up Python ${{ matrix.python-version }} 32 | uses: actions/setup-python@v5 33 | with: 34 | python-version: ${{ matrix.python-version }} 35 | - name: Install (auto-install dependencies) 36 | if: ${{ !inputs.use_latest_pytorch_gpytorch }} 37 | run: | 38 | uv pip install .[test] 39 | - name: Install dependencies with latest PyTorch & GPyTorch 40 | if: ${{ inputs.use_latest_pytorch_gpytorch }} 41 | env: 42 | ALLOW_LATEST_GPYTORCH_LINOP: true 43 | run: | 44 | uv pip install --pre torch --index-url https://download.pytorch.org/whl/nightly/cpu 45 | uv pip install git+https://github.com/cornellius-gp/linear_operator.git 46 | uv pip install git+https://github.com/cornellius-gp/gpytorch.git 47 | uv pip install .[test] 48 | - name: Unit tests and coverage -- BoTorch 49 | run: | 50 | pytest -ra test/ --cov botorch/ --cov-report term-missing --cov-report xml:botorch_cov.xml 51 | - name: Unit tests and coverage -- BoTorch Community 52 | run: | 53 | pytest -ra test_community/ --cov botorch_community/ --cov-report term-missing --cov-report xml:botorch_community_cov.xml 54 | - name: Upload coverage 55 | if: ${{ inputs.upload_coverage && runner.os == 'Linux' && matrix.python-version == 3.10 }} 56 | uses: codecov/codecov-action@v4 57 | with: 58 | fail_ci_if_error: true 59 | token: ${{ secrets.CODECOV_TOKEN }} 60 | files: ./botorch_cov.xml,./botorch_community_cov.xml 61 | -------------------------------------------------------------------------------- /.github/workflows/reusable_tutorials.yml: -------------------------------------------------------------------------------- 1 | name: Reusable Tutorials Workflow 2 | 3 | on: 4 | workflow_dispatch: 5 | inputs: 6 | smoke_test: 7 | required: true 8 | type: boolean 9 | use_stable_pytorch_gpytorch: 10 | required: true 11 | type: boolean 12 | workflow_call: 13 | inputs: 14 | smoke_test: 15 | required: false 16 | type: boolean 17 | default: true 18 | use_stable_pytorch_gpytorch: 19 | required: false 20 | type: boolean 21 | default: false 22 | 23 | jobs: 24 | tutorials: 25 | name: Run tutorials 26 | runs-on: ubuntu-latest 27 | env: 28 | # `uv pip ...` requires venv by default. This skips that requirement. 29 | UV_SYSTEM_PYTHON: 1 30 | steps: 31 | - uses: actions/checkout@v4 32 | - name: Install uv 33 | uses: astral-sh/setup-uv@v5 34 | - name: Set up Python 35 | uses: actions/setup-python@v5 36 | with: 37 | python-version: "3.13" 38 | - name: Fetch all history for all tags and branches 39 | # We need to do this so setuptools_scm knows how to set the BoTorch version. 40 | run: git fetch --prune --unshallow 41 | - if: ${{ !inputs.use_stable_pytorch_gpytorch }} 42 | name: Install latest PyTorch & GPyTorch 43 | run: | 44 | uv pip install --pre torch torchvision --index-url https://download.pytorch.org/whl/nightly/cpu 45 | uv pip install git+https://github.com/cornellius-gp/linear_operator.git 46 | uv pip install git+https://github.com/cornellius-gp/gpytorch.git 47 | - if: ${{ inputs.use_stable_pytorch_gpytorch }} 48 | name: Install min required PyTorch, GPyTorch, and linear_operator 49 | run: | 50 | python setup.py egg_info 51 | req_txt="botorch.egg-info/requires.txt" 52 | min_torch_version=$(grep '\btorch[>=]=' ${req_txt} | sed 's/[^0-9.]//g') 53 | min_gpytorch_version=$(grep '\bgpytorch[>=]=' ${req_txt} | sed 's/[^0-9.]//g') 54 | min_linear_operator_version=$(grep '\blinear_operator[>=]=' ${req_txt} | sed 's/[^0-9.]//g') 55 | uv pip install "numpy<2" # Numpy >2.0 is not compatible with PyTorch <2.2. 56 | uv pip install "torch==${min_torch_version}" "gpytorch==${min_gpytorch_version}" "linear_operator==${min_linear_operator_version}" torchvision 57 | - name: Install BoTorch with tutorials dependencies 58 | env: 59 | ALLOW_LATEST_GPYTORCH_LINOP: true 60 | run: | 61 | uv pip install .[tutorials] 62 | - if: ${{ inputs.smoke_test }} 63 | name: Run tutorials with smoke test 64 | run: | 65 | python scripts/run_tutorials.py -p "$(pwd)" -s 66 | - if: ${{ !inputs.smoke_test }} 67 | name: Run tutorials without smoke test 68 | run: | 69 | python scripts/run_tutorials.py -p "$(pwd)" 70 | -------------------------------------------------------------------------------- /.github/workflows/test.yml: -------------------------------------------------------------------------------- 1 | name: Test 2 | 3 | on: 4 | push: 5 | branches: [ main ] 6 | pull_request: 7 | branches: [ main ] 8 | workflow_dispatch: 9 | 10 | jobs: 11 | 12 | tests-and-coverage: 13 | name: Test & Coverage 14 | uses: ./.github/workflows/reusable_test.yml 15 | with: 16 | use_latest_pytorch_gpytorch: true 17 | secrets: inherit 18 | -------------------------------------------------------------------------------- /.github/workflows/test_stable.yml: -------------------------------------------------------------------------------- 1 | name: Test against stable 2 | 3 | on: 4 | workflow_dispatch: 5 | 6 | jobs: 7 | 8 | tests-and-coverage-stable: 9 | name: Test & Coverage 10 | uses: ./.github/workflows/reusable_test.yml 11 | with: 12 | use_latest_pytorch_gpytorch: false 13 | upload_coverage: false 14 | secrets: inherit 15 | 16 | tests-and-coverage-min-req: 17 | name: Tests and coverage min req. torch, gpytorch & linear_operator versions (Python ${{ matrix.python-version }}, ${{ matrix.os }}) 18 | runs-on: ${{ matrix.os }} 19 | strategy: 20 | fail-fast: false 21 | matrix: 22 | os: ["ubuntu-latest", "macos-14"] 23 | python-version: ["3.10", "3.13"] 24 | env: 25 | # `uv pip ...` requires venv by default. This skips that requirement. 26 | UV_SYSTEM_PYTHON: 1 27 | steps: 28 | - uses: actions/checkout@v4 29 | - name: Install uv 30 | uses: astral-sh/setup-uv@v5 31 | - name: Set up Python ${{ matrix.python-version }} 32 | uses: actions/setup-python@v5 33 | with: 34 | python-version: ${{ matrix.python-version }} 35 | - name: Install dependencies 36 | run: | 37 | uv pip install setuptools # Needed for next line on Python 3.13. 38 | python setup.py egg_info 39 | req_txt="botorch.egg-info/requires.txt" 40 | min_torch_version=$(grep '\btorch[>=]=' ${req_txt} | sed 's/[^0-9.]//g') 41 | # The earliest PyTorch version on Python 3.13 available for all OS is 2.6.0. 42 | min_torch_version="$(if ${{ matrix.python-version == '3.13' }}; then echo "2.6.0"; else echo "${min_torch_version}"; fi)" 43 | min_gpytorch_version=$(grep '\bgpytorch[>=]=' ${req_txt} | sed 's/[^0-9.]//g') 44 | min_linear_operator_version=$(grep '\blinear_operator[>=]=' ${req_txt} | sed 's/[^0-9.]//g') 45 | uv pip install "numpy<2" # Numpy >2.0 is not compatible with PyTorch <2.2. 46 | uv pip install "torch==${min_torch_version}" "gpytorch==${min_gpytorch_version}" "linear_operator==${min_linear_operator_version}" 47 | uv pip install .[test] 48 | - name: Unit tests and coverage -- BoTorch 49 | run: | 50 | pytest -ra test/ --cov botorch/ --cov-report term-missing --cov-report xml:botorch_cov.xml 51 | - name: Unit tests and coverage -- BoTorch Community 52 | run: | 53 | pytest -ra test_community/ --cov botorch_community/ --cov-report term-missing --cov-report xml:botorch_community_cov.xml 54 | 55 | run_tutorials_stable: 56 | name: Run tutorials without smoke test on min req. versions of PyTorch & GPyTorch 57 | uses: ./.github/workflows/reusable_tutorials.yml 58 | with: 59 | smoke_test: false 60 | use_stable_pytorch_gpytorch: true 61 | 62 | run_tutorials_stable_smoke_test: 63 | name: Run tutorials with smoke test on min req. versions of PyTorch & GPyTorch 64 | uses: ./.github/workflows/reusable_tutorials.yml 65 | with: 66 | smoke_test: true 67 | use_stable_pytorch_gpytorch: true 68 | -------------------------------------------------------------------------------- /.github/workflows/tutorials_smoke_test.yml: -------------------------------------------------------------------------------- 1 | name: Tutorials with smoke test 2 | 3 | on: 4 | pull_request: 5 | branches: [ main ] 6 | push: 7 | branches: [ main ] 8 | workflow_dispatch: 9 | 10 | 11 | jobs: 12 | run_tutorials_with_smoke_test: 13 | name: Run tutorials with smoke test on latest PyTorch / GPyTorch 14 | uses: ./.github/workflows/reusable_tutorials.yml 15 | with: 16 | smoke_test: true 17 | use_stable_pytorch_gpytorch: false 18 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # Distribution / packaging 7 | .Python 8 | env/ 9 | build/ 10 | develop-eggs/ 11 | dist/ 12 | downloads/ 13 | eggs/ 14 | .eggs/ 15 | lib/ 16 | lib64/ 17 | parts/ 18 | sdist/ 19 | var/ 20 | wheels/ 21 | *.egg-info/ 22 | .installed.cfg 23 | *.egg 24 | 25 | # watchman 26 | # Watchman helper 27 | .watchmanconfig 28 | 29 | # OSX 30 | *.DS_Store 31 | 32 | # Atom plugin files and ctags 33 | .ftpconfig 34 | .ftpconfig.cson 35 | .ftpignore 36 | *.tags 37 | *.tags1 38 | 39 | # PyInstaller 40 | # Usually these files are written by a python script from a template 41 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 42 | *.manifest 43 | *.spec 44 | 45 | # Installer logs 46 | pip-log.txt 47 | pip-delete-this-directory.txt 48 | 49 | # Unit test / coverage reports 50 | htmlcov/ 51 | .tox/ 52 | .coverage 53 | .coverage.* 54 | .cache 55 | nosetests.xml 56 | coverage.xml 57 | *.cover 58 | .hypothesis/ 59 | .pytest_cache/ 60 | 61 | # PyBuilder 62 | target/ 63 | 64 | # Jupyter Notebook 65 | .ipynb_checkpoints 66 | 67 | # pyenv 68 | .python-version 69 | 70 | # dotenv 71 | .env 72 | 73 | # virtualenv 74 | .venv 75 | venv/ 76 | ENV/ 77 | 78 | # mypy 79 | .mypy_cache/ 80 | 81 | # vim 82 | *.swp 83 | 84 | # cython-generated C-code 85 | botorch/qmc/sobol.c* 86 | 87 | # version file 88 | botorch/version.py 89 | 90 | # Sphinx documentation 91 | sphinx/build/ 92 | 93 | # Docusaurus 94 | website/build/ 95 | website/i18n/ 96 | website/node_modules/ 97 | website/.docusaurus/ 98 | 99 | ## Generated for tutorials 100 | website/_tutorials/ 101 | website/static/files/ 102 | docs/tutorials/* 103 | !docs/tutorials/index.mdx 104 | 105 | ## Generated for Sphinx 106 | website/pages/api/ 107 | website/static/js/* 108 | !website/static/js/code_block_buttons.js 109 | website/static/_sphinx-sources/ 110 | -------------------------------------------------------------------------------- /.pre-commit-config.yaml: -------------------------------------------------------------------------------- 1 | repos: 2 | - repo: local 3 | hooks: 4 | - id: check-requirements-versions 5 | name: Check pre-commit formatting versions 6 | entry: python scripts/check_pre_commit_reqs.py 7 | language: python 8 | always_run: true 9 | pass_filenames: false 10 | additional_dependencies: 11 | - PyYAML 12 | 13 | - repo: https://github.com/omnilib/ufmt 14 | rev: v2.8.0 15 | hooks: 16 | - id: ufmt 17 | additional_dependencies: 18 | - black==24.4.2 19 | - usort==1.0.8.post1 20 | - ruff-api==0.1.0 21 | - stdlibs==2024.1.28 22 | args: [format] 23 | 24 | - repo: https://github.com/pycqa/flake8 25 | rev: 7.0.0 26 | hooks: 27 | - id: flake8 28 | additional_dependencies: 29 | - flake8-docstrings 30 | -------------------------------------------------------------------------------- /.readthedocs.yaml: -------------------------------------------------------------------------------- 1 | version: "2" 2 | 3 | build: 4 | os: "ubuntu-22.04" 5 | tools: 6 | python: "3.12" 7 | jobs: 8 | post_install: 9 | # Install latest botorch if not on a released version 10 | - | 11 | tag=$(eval "git name-rev --name-only --tags HEAD") 12 | if [ $tag = "undefined" ]; then 13 | pip install git+https://github.com/cornellius-gp/linear_operator.git 14 | pip install git+https://github.com/cornellius-gp/gpytorch.git 15 | fi 16 | 17 | python: 18 | install: 19 | - method: pip 20 | path: . 21 | extra_requirements: 22 | - dev 23 | 24 | sphinx: 25 | configuration: sphinx/source/conf.py 26 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) Meta Platforms, Inc. and affiliates. 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /MANIFEST.in: -------------------------------------------------------------------------------- 1 | include LICENSE 2 | recursive-exclude docs * 3 | recursive-exclude scripts * 4 | recursive-exclude sphinx * 5 | recursive-exclude test * 6 | recursive-exclude tutorials * 7 | recursive-exclude website * 8 | -------------------------------------------------------------------------------- /botorch/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import gpytorch.settings as gp_settings 8 | import linear_operator.settings as linop_settings 9 | from botorch import ( 10 | acquisition, 11 | exceptions, 12 | models, 13 | optim, 14 | posteriors, 15 | settings, 16 | test_functions, 17 | ) 18 | from botorch.cross_validation import batch_cross_validation 19 | from botorch.fit import fit_fully_bayesian_model_nuts, fit_gpytorch_mll 20 | from botorch.generation.gen import ( 21 | gen_candidates_scipy, 22 | gen_candidates_torch, 23 | get_best_candidates, 24 | ) 25 | from botorch.logging import logger 26 | from botorch.utils import manual_seed 27 | 28 | try: 29 | # Marking this as a manual import to avoid autodeps complaints 30 | # due to imports from non-existent file. 31 | # lint-ignore: UnusedImportsRule 32 | from botorch.version import version as __version__ # @manual 33 | except Exception: # pragma: no cover 34 | __version__ = "Unknown" 35 | 36 | logger.info( 37 | "Turning off `fast_computations` in linear operator and increasing " 38 | "`max_cholesky_size` and `max_eager_kernel_size` to 4096, and " 39 | "`cholesky_max_tries` to 6. The approximate computations available in " 40 | "GPyTorch aim to speed up GP training and inference in large data " 41 | "regime but they are generally not robust enough to be used in a BO-loop. " 42 | "See gpytorch.settings & linear_operator.settings for more details." 43 | ) 44 | linop_settings._fast_covar_root_decomposition._default = False 45 | linop_settings._fast_log_prob._default = False 46 | linop_settings._fast_solves._default = False 47 | linop_settings.cholesky_max_tries._global_value = 6 48 | linop_settings.max_cholesky_size._global_value = 4096 49 | gp_settings.max_eager_kernel_size._global_value = 4096 50 | 51 | 52 | __all__ = [ 53 | "acquisition", 54 | "batch_cross_validation", 55 | "exceptions", 56 | "fit_fully_bayesian_model_nuts", 57 | "fit_gpytorch_mll", 58 | "gen_candidates_scipy", 59 | "gen_candidates_torch", 60 | "get_best_candidates", 61 | "manual_seed", 62 | "models", 63 | "optim", 64 | "posteriors", 65 | "settings", 66 | "test_functions", 67 | ] 68 | -------------------------------------------------------------------------------- /botorch/acquisition/multi_objective/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.acquisition.multi_objective.analytic import ExpectedHypervolumeImprovement 8 | from botorch.acquisition.multi_objective.base import ( 9 | MultiObjectiveAnalyticAcquisitionFunction, 10 | MultiObjectiveMCAcquisitionFunction, 11 | ) 12 | from botorch.acquisition.multi_objective.hypervolume_knowledge_gradient import ( 13 | qHypervolumeKnowledgeGradient, 14 | qMultiFidelityHypervolumeKnowledgeGradient, 15 | ) 16 | from botorch.acquisition.multi_objective.logei import ( 17 | qLogExpectedHypervolumeImprovement, 18 | qLogNoisyExpectedHypervolumeImprovement, 19 | ) 20 | from botorch.acquisition.multi_objective.max_value_entropy_search import ( 21 | qMultiObjectiveMaxValueEntropy, 22 | ) 23 | from botorch.acquisition.multi_objective.monte_carlo import ( 24 | qExpectedHypervolumeImprovement, 25 | qNoisyExpectedHypervolumeImprovement, 26 | ) 27 | from botorch.acquisition.multi_objective.multi_fidelity import MOMF 28 | from botorch.acquisition.multi_objective.objective import ( 29 | IdentityMCMultiOutputObjective, 30 | MCMultiOutputObjective, 31 | WeightedMCMultiOutputObjective, 32 | ) 33 | from botorch.acquisition.multi_objective.utils import ( 34 | get_default_partitioning_alpha, 35 | prune_inferior_points_multi_objective, 36 | ) 37 | 38 | 39 | __all__ = [ 40 | "ExpectedHypervolumeImprovement", 41 | "get_default_partitioning_alpha", 42 | "IdentityMCMultiOutputObjective", 43 | "MCMultiOutputObjective", 44 | "MOMF", 45 | "MultiObjectiveAnalyticAcquisitionFunction", 46 | "MultiObjectiveMCAcquisitionFunction", 47 | "prune_inferior_points_multi_objective", 48 | "qExpectedHypervolumeImprovement", 49 | "qHypervolumeKnowledgeGradient", 50 | "qLogExpectedHypervolumeImprovement", 51 | "qLogNoisyExpectedHypervolumeImprovement", 52 | "qMultiFidelityHypervolumeKnowledgeGradient", 53 | "qMultiObjectiveMaxValueEntropy", 54 | "qNoisyExpectedHypervolumeImprovement", 55 | "WeightedMCMultiOutputObjective", 56 | ] 57 | -------------------------------------------------------------------------------- /botorch/exceptions/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.exceptions.errors import ( 8 | BotorchError, 9 | BotorchTensorDimensionError, 10 | CandidateGenerationError, 11 | InputDataError, 12 | ModelFittingError, 13 | OptimizationTimeoutError, 14 | UnsupportedError, 15 | ) 16 | from botorch.exceptions.warnings import ( 17 | BadInitialCandidatesWarning, 18 | BotorchTensorDimensionWarning, 19 | BotorchWarning, 20 | CostAwareWarning, 21 | InputDataWarning, 22 | NumericsWarning, 23 | OptimizationWarning, 24 | SamplingWarning, 25 | UserInputWarning, 26 | ) 27 | 28 | 29 | __all__ = [ 30 | "BadInitialCandidatesWarning", 31 | "BotorchError", 32 | "BotorchTensorDimensionError", 33 | "BotorchTensorDimensionWarning", 34 | "BotorchWarning", 35 | "CostAwareWarning", 36 | "InputDataWarning", 37 | "InputDataError", 38 | "BadInitialCandidatesWarning", 39 | "CandidateGenerationError", 40 | "ModelFittingError", 41 | "NumericsWarning", 42 | "OptimizationTimeoutError", 43 | "OptimizationWarning", 44 | "SamplingWarning", 45 | "UnsupportedError", 46 | "UserInputWarning", 47 | ] 48 | -------------------------------------------------------------------------------- /botorch/exceptions/errors.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | r""" 8 | Botorch Errors. 9 | """ 10 | 11 | from typing import Any 12 | 13 | import numpy.typing as npt 14 | 15 | 16 | class BotorchError(Exception): 17 | r"""Base botorch exception.""" 18 | 19 | pass 20 | 21 | 22 | class CandidateGenerationError(BotorchError): 23 | r"""Exception raised during generating candidates.""" 24 | 25 | pass 26 | 27 | 28 | class DeprecationError(BotorchError): 29 | r"""Exception raised due to deprecations""" 30 | 31 | pass 32 | 33 | 34 | class InputDataError(BotorchError): 35 | r"""Exception raised when input data does not comply with conventions.""" 36 | 37 | pass 38 | 39 | 40 | class UnsupportedError(BotorchError): 41 | r"""Currently unsupported feature.""" 42 | 43 | pass 44 | 45 | 46 | class BotorchTensorDimensionError(BotorchError): 47 | r"""Exception raised when a tensor violates a botorch convention.""" 48 | 49 | pass 50 | 51 | 52 | class ModelFittingError(Exception): 53 | r"""Exception raised when attempts to fit a model terminate unsuccessfully.""" 54 | 55 | pass 56 | 57 | 58 | class OptimizationTimeoutError(BotorchError): 59 | r"""Exception raised when optimization times out.""" 60 | 61 | def __init__( 62 | self, /, *args: Any, current_x: npt.NDArray, runtime: float, **kwargs: Any 63 | ) -> None: 64 | r""" 65 | Args: 66 | *args: Standard args to `BoTorchError`. 67 | current_x: A numpy array representing the current iterate. 68 | runtime: The total runtime in seconds after which the optimization 69 | timed out. 70 | **kwargs: Standard kwargs to `BoTorchError`. 71 | """ 72 | super().__init__(*args, **kwargs) 73 | self.current_x = current_x 74 | self.runtime = runtime 75 | 76 | 77 | class OptimizationGradientError(BotorchError, RuntimeError): 78 | r"""Exception raised when gradient array `gradf` containts NaNs.""" 79 | 80 | def __init__(self, /, *args: Any, current_x: npt.NDArray, **kwargs: Any) -> None: 81 | r""" 82 | Args: 83 | *args: Standard args to `BoTorchError`. 84 | current_x: A numpy array representing the current iterate. 85 | **kwargs: Standard kwargs to `BoTorchError`. 86 | """ 87 | super().__init__(*args, **kwargs) 88 | self.current_x = current_x 89 | 90 | 91 | class InfeasibilityError(BotorchError, ValueError): 92 | r"""Exception raised when infeasibility occurs.""" 93 | 94 | pass 95 | -------------------------------------------------------------------------------- /botorch/generation/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | 8 | from botorch.generation.gen import ( 9 | gen_candidates_scipy, 10 | gen_candidates_torch, 11 | get_best_candidates, 12 | ) 13 | from botorch.generation.sampling import BoltzmannSampling, MaxPosteriorSampling 14 | 15 | 16 | __all__ = [ 17 | "gen_candidates_scipy", 18 | "gen_candidates_torch", 19 | "get_best_candidates", 20 | "BoltzmannSampling", 21 | "MaxPosteriorSampling", 22 | ] 23 | -------------------------------------------------------------------------------- /botorch/logging.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import logging 8 | 9 | import torch 10 | 11 | LOG_LEVEL_DEFAULT = logging.CRITICAL 12 | 13 | 14 | def _get_logger( 15 | name: str = "botorch", level: int = LOG_LEVEL_DEFAULT 16 | ) -> logging.Logger: 17 | """Gets a default botorch logger 18 | 19 | Logging level can be tuned via botorch.setting.log_level 20 | 21 | Args: 22 | name: Name for logger instance 23 | level: Logging threshhold for the given logger. Logs of greater or 24 | equal severity will be printed to STDERR 25 | """ 26 | logger = logging.getLogger(name) 27 | logger.setLevel(level) 28 | # Add timestamps to log messages. 29 | console = logging.StreamHandler() 30 | formatter = logging.Formatter( 31 | fmt="[%(levelname)s %(asctime)s] %(name)s: %(message)s", 32 | datefmt="%m-%d %H:%M:%S", 33 | ) 34 | console.setFormatter(formatter) 35 | logger.addHandler(console) 36 | logger.propagate = False 37 | return logger 38 | 39 | 40 | def shape_to_str(shape: torch.Size) -> str: 41 | return f"`{' x '.join(str(i) for i in shape)}`" 42 | 43 | 44 | logger = _get_logger() 45 | -------------------------------------------------------------------------------- /botorch/models/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.models.approximate_gp import ( 8 | ApproximateGPyTorchModel, 9 | SingleTaskVariationalGP, 10 | ) 11 | from botorch.models.cost import AffineFidelityCostModel 12 | from botorch.models.deterministic import ( 13 | AffineDeterministicModel, 14 | GenericDeterministicModel, 15 | PosteriorMeanModel, 16 | ) 17 | from botorch.models.fully_bayesian import SaasFullyBayesianSingleTaskGP 18 | from botorch.models.fully_bayesian_multitask import SaasFullyBayesianMultiTaskGP 19 | 20 | from botorch.models.gp_regression import SingleTaskGP 21 | from botorch.models.gp_regression_fidelity import SingleTaskMultiFidelityGP 22 | from botorch.models.gp_regression_mixed import MixedSingleTaskGP 23 | from botorch.models.higher_order_gp import HigherOrderGP 24 | 25 | from botorch.models.map_saas import add_saas_prior, AdditiveMapSaasSingleTaskGP 26 | from botorch.models.model import ModelList 27 | from botorch.models.model_list_gp_regression import ModelListGP 28 | from botorch.models.multitask import KroneckerMultiTaskGP, MultiTaskGP 29 | from botorch.models.pairwise_gp import PairwiseGP, PairwiseLaplaceMarginalLogLikelihood 30 | 31 | __all__ = [ 32 | "add_saas_prior", 33 | "AdditiveMapSaasSingleTaskGP", 34 | "AffineDeterministicModel", 35 | "AffineFidelityCostModel", 36 | "ApproximateGPyTorchModel", 37 | "SaasFullyBayesianSingleTaskGP", 38 | "SaasFullyBayesianMultiTaskGP", 39 | "GenericDeterministicModel", 40 | "HigherOrderGP", 41 | "KroneckerMultiTaskGP", 42 | "MixedSingleTaskGP", 43 | "ModelList", 44 | "ModelListGP", 45 | "MultiTaskGP", 46 | "PairwiseGP", 47 | "PairwiseLaplaceMarginalLogLikelihood", 48 | "PosteriorMeanModel", 49 | "SingleTaskGP", 50 | "SingleTaskMultiFidelityGP", 51 | "SingleTaskVariationalGP", 52 | ] 53 | -------------------------------------------------------------------------------- /botorch/models/kernels/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.models.kernels.categorical import CategoricalKernel 8 | from botorch.models.kernels.downsampling import DownsamplingKernel 9 | from botorch.models.kernels.exponential_decay import ExponentialDecayKernel 10 | from botorch.models.kernels.infinite_width_bnn import InfiniteWidthBNNKernel 11 | from botorch.models.kernels.linear_truncated_fidelity import ( 12 | LinearTruncatedFidelityKernel, 13 | ) 14 | 15 | 16 | __all__ = [ 17 | "CategoricalKernel", 18 | "DownsamplingKernel", 19 | "ExponentialDecayKernel", 20 | "InfiniteWidthBNNKernel", 21 | "LinearTruncatedFidelityKernel", 22 | ] 23 | -------------------------------------------------------------------------------- /botorch/models/kernels/categorical.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import torch 8 | from gpytorch.kernels.kernel import Kernel 9 | from torch import Tensor 10 | 11 | 12 | class CategoricalKernel(Kernel): 13 | r"""A Kernel for categorical features. 14 | 15 | Computes `exp(-dist(x1, x2) / lengthscale)`, where 16 | `dist(x1, x2)` is zero if `x1 == x2` and one if `x1 != x2`. 17 | If the last dimension is not a batch dimension, then the 18 | mean is considered. 19 | 20 | Note: This kernel is NOT differentiable w.r.t. the inputs. 21 | """ 22 | 23 | has_lengthscale = True 24 | 25 | def forward( 26 | self, 27 | x1: Tensor, 28 | x2: Tensor, 29 | diag: bool = False, 30 | last_dim_is_batch: bool = False, 31 | ) -> Tensor: 32 | delta = x1.unsqueeze(-2) != x2.unsqueeze(-3) 33 | dists = delta / self.lengthscale.unsqueeze(-2) 34 | if last_dim_is_batch: 35 | dists = dists.transpose(-3, -1) 36 | else: 37 | dists = dists.mean(-1) 38 | res = torch.exp(-dists) 39 | if diag: 40 | res = torch.diagonal(res, dim1=-1, dim2=-2) 41 | return res 42 | -------------------------------------------------------------------------------- /botorch/models/likelihoods/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.models.likelihoods.pairwise import ( 8 | PairwiseLogitLikelihood, 9 | PairwiseProbitLikelihood, 10 | ) 11 | 12 | 13 | __all__ = [ 14 | "PairwiseProbitLikelihood", 15 | "PairwiseLogitLikelihood", 16 | ] 17 | -------------------------------------------------------------------------------- /botorch/models/transforms/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.models.transforms.factory import get_rounding_input_transform 8 | from botorch.models.transforms.input import ( 9 | ChainedInputTransform, 10 | Normalize, 11 | Round, 12 | Warp, 13 | ) 14 | from botorch.models.transforms.outcome import ( 15 | Bilog, 16 | ChainedOutcomeTransform, 17 | Log, 18 | Power, 19 | Standardize, 20 | ) 21 | 22 | 23 | __all__ = [ 24 | "get_rounding_input_transform", 25 | "Bilog", 26 | "ChainedInputTransform", 27 | "ChainedOutcomeTransform", 28 | "Log", 29 | "Normalize", 30 | "Power", 31 | "Round", 32 | "Standardize", 33 | "Warp", 34 | ] 35 | -------------------------------------------------------------------------------- /botorch/models/utils/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.models.utils.assorted import ( 8 | _make_X_full, 9 | add_output_dim, 10 | check_min_max_scaling, 11 | check_no_nans, 12 | check_standardization, 13 | consolidate_duplicates, 14 | detect_duplicates, 15 | fantasize, 16 | gpt_posterior_settings, 17 | mod_batch_shape, 18 | multioutput_to_batch_mode_transform, 19 | validate_input_scaling, 20 | ) 21 | 22 | 23 | __all__ = [ 24 | "_make_X_full", 25 | "add_output_dim", 26 | "check_no_nans", 27 | "check_min_max_scaling", 28 | "check_standardization", 29 | "fantasize", 30 | "gpt_posterior_settings", 31 | "multioutput_to_batch_mode_transform", 32 | "mod_batch_shape", 33 | "validate_input_scaling", 34 | "detect_duplicates", 35 | "consolidate_duplicates", 36 | ] 37 | -------------------------------------------------------------------------------- /botorch/optim/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.optim.closures import ( 8 | ForwardBackwardClosure, 9 | get_loss_closure, 10 | get_loss_closure_with_grads, 11 | ) 12 | from botorch.optim.core import ( 13 | OptimizationResult, 14 | OptimizationStatus, 15 | scipy_minimize, 16 | torch_minimize, 17 | ) 18 | from botorch.optim.homotopy import ( 19 | FixedHomotopySchedule, 20 | Homotopy, 21 | HomotopyParameter, 22 | LinearHomotopySchedule, 23 | LogLinearHomotopySchedule, 24 | ) 25 | from botorch.optim.initializers import ( 26 | initialize_q_batch, 27 | initialize_q_batch_nonneg, 28 | initialize_q_batch_topn, 29 | ) 30 | from botorch.optim.optimize import ( 31 | gen_batch_initial_conditions, 32 | optimize_acqf, 33 | optimize_acqf_cyclic, 34 | optimize_acqf_discrete, 35 | optimize_acqf_discrete_local_search, 36 | optimize_acqf_mixed, 37 | ) 38 | from botorch.optim.optimize_homotopy import optimize_acqf_homotopy 39 | from botorch.optim.optimize_mixed import optimize_acqf_mixed_alternating 40 | from botorch.optim.stopping import ExpMAStoppingCriterion 41 | 42 | 43 | __all__ = [ 44 | "ForwardBackwardClosure", 45 | "get_loss_closure", 46 | "get_loss_closure_with_grads", 47 | "gen_batch_initial_conditions", 48 | "initialize_q_batch", 49 | "initialize_q_batch_nonneg", 50 | "initialize_q_batch_topn", 51 | "OptimizationResult", 52 | "OptimizationStatus", 53 | "optimize_acqf", 54 | "optimize_acqf_cyclic", 55 | "optimize_acqf_discrete", 56 | "optimize_acqf_discrete_local_search", 57 | "optimize_acqf_mixed", 58 | "optimize_acqf_mixed_alternating", 59 | "optimize_acqf_homotopy", 60 | "scipy_minimize", 61 | "torch_minimize", 62 | "ExpMAStoppingCriterion", 63 | "FixedHomotopySchedule", 64 | "Homotopy", 65 | "HomotopyParameter", 66 | "LinearHomotopySchedule", 67 | "LogLinearHomotopySchedule", 68 | ] 69 | -------------------------------------------------------------------------------- /botorch/optim/closures/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.optim.closures.core import ( 8 | ForwardBackwardClosure, 9 | NdarrayOptimizationClosure, 10 | ) 11 | from botorch.optim.closures.model_closures import ( 12 | get_loss_closure, 13 | get_loss_closure_with_grads, 14 | ) 15 | 16 | 17 | __all__ = [ 18 | "ForwardBackwardClosure", 19 | "get_loss_closure", 20 | "get_loss_closure_with_grads", 21 | "NdarrayOptimizationClosure", 22 | ] 23 | -------------------------------------------------------------------------------- /botorch/optim/utils/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.optim.utils.acquisition_utils import ( 8 | columnwise_clamp, 9 | fix_features, 10 | get_X_baseline, 11 | ) 12 | from botorch.optim.utils.common import ( 13 | _handle_numerical_errors, 14 | _warning_handler_template, 15 | ) 16 | from botorch.optim.utils.model_utils import ( 17 | get_data_loader, 18 | get_name_filter, 19 | get_parameters, 20 | get_parameters_and_bounds, 21 | sample_all_priors, 22 | TorchAttr, 23 | ) 24 | from botorch.optim.utils.numpy_utils import ( 25 | as_ndarray, 26 | get_bounds_as_ndarray, 27 | get_tensors_as_ndarray_1d, 28 | set_tensors_from_ndarray_1d, 29 | ) 30 | from botorch.optim.utils.timeout import minimize_with_timeout 31 | 32 | __all__ = [ 33 | "_handle_numerical_errors", 34 | "_warning_handler_template", 35 | "as_ndarray", 36 | "columnwise_clamp", 37 | "fix_features", 38 | "get_name_filter", 39 | "get_bounds_as_ndarray", 40 | "get_data_loader", 41 | "get_parameters", 42 | "get_parameters_and_bounds", 43 | "get_tensors_as_ndarray_1d", 44 | "get_X_baseline", 45 | "minimize_with_timeout", 46 | "sample_all_priors", 47 | "set_tensors_from_ndarray_1d", 48 | "TorchAttr", 49 | ] 50 | -------------------------------------------------------------------------------- /botorch/optim/utils/common.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | r"""General-purpose optimization utilities.""" 8 | 9 | from __future__ import annotations 10 | 11 | from collections.abc import Callable 12 | 13 | from logging import debug as logging_debug 14 | from warnings import warn_explicit, WarningMessage 15 | 16 | import numpy as np 17 | import numpy.typing as npt 18 | from linear_operator.utils.errors import NanError, NotPSDError 19 | 20 | 21 | def _handle_numerical_errors( 22 | error: RuntimeError, x: npt.NDArray, dtype: np.dtype | None = None 23 | ) -> tuple[npt.NDArray, npt.NDArray]: 24 | if isinstance(error, NotPSDError): 25 | raise error 26 | error_message = error.args[0] if len(error.args) > 0 else "" 27 | if ( 28 | isinstance(error, NanError) 29 | or "singular" in error_message # old pytorch message 30 | or "input is not positive-definite" in error_message # since pytorch #63864 31 | ): 32 | _dtype = x.dtype if dtype is None else dtype 33 | return np.full((), "nan", dtype=_dtype), np.full_like(x, "nan", dtype=_dtype) 34 | raise error # pragma: nocover 35 | 36 | 37 | def _warning_handler_template( 38 | w: WarningMessage, 39 | debug: Callable[[WarningMessage], bool] | None = None, 40 | rethrow: Callable[[WarningMessage], bool] | None = None, 41 | ) -> bool: 42 | r"""Helper for making basic warning handlers. Typically used with functools.partial. 43 | 44 | Args: 45 | w: The WarningMessage to be resolved and filtered out or returned unresolved. 46 | debug: Optional callable used to specify that a warning should be 47 | resolved as a logging statement at the DEBUG level. 48 | rethrow: Optional callable used to specify that a warning should be 49 | resolved by rethrowing the warning. 50 | 51 | Returns: 52 | Boolean indicating whether or not the warning message was resolved. 53 | """ 54 | if debug and debug(w): 55 | logging_debug(str(w.message)) 56 | return True 57 | 58 | if rethrow and rethrow(w): 59 | warn_explicit(str(w.message), w.category, w.filename, w.lineno) 60 | return True 61 | 62 | return False 63 | -------------------------------------------------------------------------------- /botorch/posteriors/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.posteriors.fully_bayesian import ( 8 | FullyBayesianPosterior, 9 | GaussianMixturePosterior, 10 | ) 11 | from botorch.posteriors.gpytorch import GPyTorchPosterior 12 | from botorch.posteriors.higher_order import HigherOrderGPPosterior 13 | from botorch.posteriors.multitask import MultitaskGPPosterior 14 | from botorch.posteriors.posterior import Posterior 15 | from botorch.posteriors.posterior_list import PosteriorList 16 | from botorch.posteriors.torch import TorchPosterior 17 | from botorch.posteriors.transformed import TransformedPosterior 18 | 19 | __all__ = [ 20 | "GaussianMixturePosterior", 21 | "FullyBayesianPosterior", 22 | "GPyTorchPosterior", 23 | "HigherOrderGPPosterior", 24 | "MultitaskGPPosterior", 25 | "Posterior", 26 | "PosteriorList", 27 | "TorchPosterior", 28 | "TransformedPosterior", 29 | ] 30 | -------------------------------------------------------------------------------- /botorch/posteriors/base_samples.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | import torch 10 | from gpytorch.distributions.multitask_multivariate_normal import ( 11 | MultitaskMultivariateNormal, 12 | ) 13 | from torch import Tensor 14 | 15 | 16 | def _reshape_base_samples_non_interleaved( 17 | mvn: MultitaskMultivariateNormal, base_samples: Tensor, sample_shape: torch.Size 18 | ) -> Tensor: 19 | r"""Reshape base samples to account for non-interleaved MT-MVNs. 20 | 21 | This method is important for making sure that the `n`th base sample 22 | only effects the posterior sample for the `p`th point if `p >= n`. 23 | Without this reshaping, for M>=2, the posterior samples for all `n` 24 | points would be affected. 25 | 26 | Args: 27 | mvn: A MultitaskMultivariateNormal distribution. 28 | base_samples: A `sample_shape x `batch_shape` x n x m`-dim 29 | tensor of base_samples. 30 | sample_shape: The sample shape. 31 | 32 | Returns: 33 | A `sample_shape x `batch_shape` x n x m`-dim tensor of 34 | base_samples suitable for a non-interleaved-multi-task 35 | or single-task covariance matrix. 36 | """ 37 | if not mvn._interleaved: 38 | new_shape = sample_shape + mvn._output_shape[:-2] + mvn._output_shape[:-3:-1] 39 | base_samples = ( 40 | base_samples.transpose(-1, -2) 41 | .view(new_shape) 42 | .reshape(sample_shape + mvn.loc.shape) 43 | .view(base_samples.shape) 44 | ) 45 | return base_samples 46 | -------------------------------------------------------------------------------- /botorch/sampling/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.sampling.base import MCSampler 8 | from botorch.sampling.get_sampler import get_sampler 9 | from botorch.sampling.list_sampler import ListSampler 10 | from botorch.sampling.normal import IIDNormalSampler, SobolQMCNormalSampler 11 | from botorch.sampling.pairwise_samplers import ( 12 | PairwiseIIDNormalSampler, 13 | PairwiseMCSampler, 14 | PairwiseSobolQMCNormalSampler, 15 | ) 16 | from botorch.sampling.qmc import MultivariateNormalQMCEngine, NormalQMCEngine 17 | from botorch.sampling.stochastic_samplers import ForkedRNGSampler, StochasticSampler 18 | from torch.quasirandom import SobolEngine 19 | 20 | 21 | __all__ = [ 22 | "ForkedRNGSampler", 23 | "get_sampler", 24 | "IIDNormalSampler", 25 | "ListSampler", 26 | "MCSampler", 27 | "MultivariateNormalQMCEngine", 28 | "NormalQMCEngine", 29 | "PairwiseIIDNormalSampler", 30 | "PairwiseMCSampler", 31 | "PairwiseSobolQMCNormalSampler", 32 | "SobolEngine", 33 | "SobolQMCNormalSampler", 34 | "StochasticSampler", 35 | ] 36 | -------------------------------------------------------------------------------- /botorch/sampling/index_sampler.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | r""" 8 | Sampler to be used with `EnsemblePosteriors` to enable 9 | deterministic optimization of acquisition functions with ensemble models. 10 | """ 11 | 12 | from __future__ import annotations 13 | 14 | import torch 15 | from botorch.posteriors.ensemble import EnsemblePosterior 16 | from botorch.sampling.base import MCSampler 17 | from torch import Tensor 18 | 19 | 20 | class IndexSampler(MCSampler): 21 | r"""A sampler that calls `posterior.rsample_from_base_samples` to 22 | generate the samples via index base samples.""" 23 | 24 | def forward(self, posterior: EnsemblePosterior) -> Tensor: 25 | r"""Draws MC samples from the posterior. 26 | 27 | Args: 28 | posterior: The ensemble posterior to sample from. 29 | 30 | Returns: 31 | The samples drawn from the posterior. 32 | """ 33 | self._construct_base_samples(posterior=posterior) 34 | samples = posterior.rsample_from_base_samples( 35 | sample_shape=self.sample_shape, base_samples=self.base_samples 36 | ) 37 | return samples 38 | 39 | def _construct_base_samples(self, posterior: EnsemblePosterior) -> None: 40 | r"""Constructs base samples as indices to sample with them from 41 | the Posterior. 42 | 43 | Args: 44 | posterior: The ensemble posterior to construct the base samples 45 | for. 46 | """ 47 | if self.base_samples is None or self.base_samples.shape != self.sample_shape: 48 | with torch.random.fork_rng(): 49 | torch.manual_seed(self.seed) 50 | base_samples = torch.multinomial( 51 | posterior.weights, 52 | num_samples=self.sample_shape.numel(), 53 | replacement=True, 54 | ).reshape(self.sample_shape) 55 | self.register_buffer("base_samples", base_samples) 56 | if self.base_samples.device != posterior.device: 57 | self.to(device=posterior.device) # pragma: nocover 58 | 59 | def _update_base_samples( 60 | self, posterior: EnsemblePosterior, base_sampler: IndexSampler 61 | ) -> None: 62 | r"""Null operation just needed for compatibility with 63 | `CachedCholeskyAcquisitionFunction`.""" 64 | pass 65 | -------------------------------------------------------------------------------- /botorch/sampling/list_sampler.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | r""" 8 | A `SamplerList` for sampling from a `PosteriorList`. 9 | """ 10 | 11 | from __future__ import annotations 12 | 13 | import torch 14 | from botorch.exceptions.errors import UnsupportedError 15 | from botorch.posteriors.posterior_list import PosteriorList 16 | from botorch.sampling.base import MCSampler 17 | from torch import Tensor 18 | from torch.nn import ModuleList 19 | 20 | 21 | class ListSampler(MCSampler): 22 | def __init__(self, *samplers: MCSampler) -> None: 23 | r"""A list of samplers for sampling from a `PosteriorList`. 24 | 25 | Args: 26 | samplers: A variable number of samplers. This should include 27 | a sampler for each posterior. 28 | """ 29 | super(MCSampler, self).__init__() 30 | self.samplers = ModuleList(samplers) 31 | self._validate_samplers() 32 | 33 | def _validate_samplers(self) -> None: 34 | r"""Checks that the samplers share the same sample shape.""" 35 | sample_shapes = [s.sample_shape for s in self.samplers] 36 | if not all(sample_shapes[0] == ss for ss in sample_shapes): 37 | raise UnsupportedError( 38 | "ListSampler requires all samplers to have the same sample shape." 39 | ) 40 | 41 | @property 42 | def sample_shape(self) -> torch.Size: 43 | r"""The sample shape of the underlying samplers.""" 44 | self._validate_samplers() 45 | return self.samplers[0].sample_shape 46 | 47 | def forward(self, posterior: PosteriorList) -> Tensor: 48 | r"""Samples from the posteriors and concatenates the samples. 49 | 50 | Args: 51 | posterior: A `PosteriorList` to sample from. 52 | 53 | Returns: 54 | The samples drawn from the posterior. 55 | """ 56 | samples_list = [ 57 | s(posterior=p) for s, p in zip(self.samplers, posterior.posteriors) 58 | ] 59 | return posterior._reshape_and_cat(tensors=samples_list) 60 | 61 | def _update_base_samples( 62 | self, posterior: PosteriorList, base_sampler: ListSampler 63 | ) -> None: 64 | r"""Update the sampler to use the original base samples for X_baseline. 65 | 66 | This is used in CachedCholeskyAcquisitionFunctions to ensure consistency. 67 | 68 | Args: 69 | posterior: The posterior for which the base samples are constructed. 70 | base_sampler: The base sampler to retrieve the base samples from. 71 | """ 72 | self._instance_check(base_sampler=base_sampler) 73 | for s, p, bs in zip(self.samplers, posterior.posteriors, base_sampler.samplers): 74 | s._update_base_samples(posterior=p, base_sampler=bs) 75 | -------------------------------------------------------------------------------- /botorch/sampling/pathwise/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | 8 | from botorch.sampling.pathwise.features import ( 9 | gen_kernel_features, 10 | KernelEvaluationMap, 11 | KernelFeatureMap, 12 | ) 13 | from botorch.sampling.pathwise.paths import ( 14 | GeneralizedLinearPath, 15 | PathDict, 16 | PathList, 17 | SamplePath, 18 | ) 19 | from botorch.sampling.pathwise.posterior_samplers import ( 20 | draw_matheron_paths, 21 | get_matheron_path_model, 22 | MatheronPath, 23 | ) 24 | from botorch.sampling.pathwise.prior_samplers import draw_kernel_feature_paths 25 | from botorch.sampling.pathwise.update_strategies import gaussian_update 26 | 27 | 28 | __all__ = [ 29 | "draw_matheron_paths", 30 | "draw_kernel_feature_paths", 31 | "gen_kernel_features", 32 | "get_matheron_path_model", 33 | "gaussian_update", 34 | "GeneralizedLinearPath", 35 | "KernelEvaluationMap", 36 | "KernelFeatureMap", 37 | "MatheronPath", 38 | "SamplePath", 39 | "PathDict", 40 | "PathList", 41 | ] 42 | -------------------------------------------------------------------------------- /botorch/sampling/pathwise/features/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | 8 | from botorch.sampling.pathwise.features.generators import gen_kernel_features 9 | from botorch.sampling.pathwise.features.maps import ( 10 | FeatureMap, 11 | KernelEvaluationMap, 12 | KernelFeatureMap, 13 | ) 14 | 15 | __all__ = [ 16 | "FeatureMap", 17 | "gen_kernel_features", 18 | "KernelEvaluationMap", 19 | "KernelFeatureMap", 20 | ] 21 | -------------------------------------------------------------------------------- /botorch/sampling/stochastic_samplers.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | r""" 8 | Samplers to enable use cases that are not base sample driven, such as 9 | stochastic optimization of acquisition functions. 10 | """ 11 | 12 | from __future__ import annotations 13 | 14 | import torch 15 | from botorch.posteriors import Posterior 16 | from botorch.sampling.base import MCSampler 17 | from torch import Tensor 18 | 19 | 20 | class ForkedRNGSampler(MCSampler): 21 | r"""A sampler using `torch.fork_rng` to enable replicable sampling 22 | from a posterior that does not support base samples. 23 | 24 | NOTE: This approach is not a one-to-one replacement for base sample 25 | driven sampling. The main missing piece in this approach is that its 26 | outputs are not replicable across the batch dimensions. As a result, 27 | when an acquisition function is batch evaluated with repeated candidates, 28 | each candidate will produce a different acquisition value, which is not 29 | compatible with Sample Average Approximation. 30 | """ 31 | 32 | def forward(self, posterior: Posterior) -> Tensor: 33 | r"""Draws MC samples from the posterior in a `fork_rng` context. 34 | 35 | Args: 36 | posterior: The posterior to sample from. 37 | 38 | Returns: 39 | The samples drawn from the posterior. 40 | """ 41 | with torch.random.fork_rng(): 42 | torch.manual_seed(self.seed) 43 | return posterior.rsample(sample_shape=self.sample_shape) 44 | 45 | 46 | class StochasticSampler(MCSampler): 47 | r"""A sampler that simply calls `posterior.rsample` to generate the 48 | samples. This should only be used for stochastic optimization of the 49 | acquisition functions, e.g., via `gen_candidates_torch`. This should 50 | not be used with `optimize_acqf`, which uses deterministic optimizers 51 | under the hood. 52 | 53 | NOTE: This ignores the `seed` option. 54 | """ 55 | 56 | def forward(self, posterior: Posterior) -> Tensor: 57 | r"""Draws MC samples from the posterior. 58 | 59 | Args: 60 | posterior: The posterior to sample from. 61 | 62 | Returns: 63 | The samples drawn from the posterior. 64 | """ 65 | return posterior.rsample(sample_shape=self.sample_shape) 66 | -------------------------------------------------------------------------------- /botorch/settings.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | r""" 8 | BoTorch settings. 9 | """ 10 | 11 | from __future__ import annotations 12 | 13 | from botorch.logging import LOG_LEVEL_DEFAULT, logger 14 | 15 | 16 | class _Flag: 17 | r"""Base class for context managers for a binary setting.""" 18 | 19 | _state: bool = False 20 | 21 | @classmethod 22 | def on(cls) -> bool: 23 | return cls._state 24 | 25 | @classmethod 26 | def off(cls) -> bool: 27 | return not cls._state 28 | 29 | @classmethod 30 | def _set_state(cls, state: bool) -> None: 31 | cls._state = state 32 | 33 | def __init__(self, state: bool = True) -> None: 34 | self.prev = self.__class__.on() 35 | self.state = state 36 | 37 | def __enter__(self) -> None: 38 | self.__class__._set_state(self.state) 39 | 40 | def __exit__(self, *args) -> None: 41 | self.__class__._set_state(self.prev) 42 | 43 | 44 | class propagate_grads(_Flag): 45 | r"""Flag for propagating gradients to model training inputs / training data. 46 | 47 | When set to `True`, gradients will be propagated to the training inputs. 48 | This is useful in particular for propating gradients through fantasy models. 49 | """ 50 | 51 | _state: bool = False 52 | 53 | 54 | class validate_input_scaling(_Flag): 55 | r"""Flag for validating input normalization/standardization. 56 | 57 | When set to `True`, standard botorch models will validate (up to reasonable 58 | tolerance) that 59 | (i) none of the inputs contain NaN values 60 | (ii) the training data (`train_X`) is normalized to the unit cube 61 | (iii) the training targets (`train_Y`) are standardized (zero mean, unit var) 62 | No checks (other than the NaN check) are performed for observed variances 63 | (`train_Y_var`) at this point. 64 | """ 65 | 66 | _state: bool = True 67 | 68 | 69 | class log_level: 70 | r"""Flag for printing verbose logging statements. 71 | 72 | Applies the given level to logging.getLogger('botorch') calls. For 73 | instance, when set to logging.INFO, all logger calls of level INFO or 74 | above will be printed to STDERR 75 | """ 76 | 77 | level: int = LOG_LEVEL_DEFAULT 78 | 79 | @classmethod 80 | def _set_level(cls, level: int) -> None: 81 | cls.level = level 82 | logger.setLevel(level) 83 | 84 | def __init__(self, level: int = LOG_LEVEL_DEFAULT) -> None: 85 | r""" 86 | Args: 87 | level: The log level. Defaults to LOG_LEVEL_DEFAULT. 88 | """ 89 | self.prev = self.__class__.level 90 | self.level = level 91 | 92 | def __enter__(self) -> None: 93 | self.__class__._set_level(self.level) 94 | 95 | def __exit__(self, *args) -> None: 96 | self.__class__._set_level(self.prev) 97 | -------------------------------------------------------------------------------- /botorch/test_functions/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.test_functions.multi_fidelity import ( 8 | AugmentedBranin, 9 | AugmentedHartmann, 10 | AugmentedRosenbrock, 11 | ) 12 | from botorch.test_functions.multi_objective import ( 13 | BNH, 14 | BraninCurrin, 15 | C2DTLZ2, 16 | CarSideImpact, 17 | CONSTR, 18 | ConstrainedBraninCurrin, 19 | DiscBrake, 20 | DTLZ1, 21 | DTLZ2, 22 | DTLZ3, 23 | DTLZ4, 24 | DTLZ5, 25 | DTLZ7, 26 | GMM, 27 | MW7, 28 | OSY, 29 | Penicillin, 30 | SRN, 31 | ToyRobust, 32 | VehicleSafety, 33 | WeldedBeam, 34 | ZDT1, 35 | ZDT2, 36 | ZDT3, 37 | ) 38 | from botorch.test_functions.multi_objective_multi_fidelity import ( 39 | MOMFBraninCurrin, 40 | MOMFPark, 41 | ) 42 | from botorch.test_functions.synthetic import ( 43 | Ackley, 44 | Beale, 45 | Branin, 46 | Bukin, 47 | Cosine8, 48 | DixonPrice, 49 | DropWave, 50 | EggHolder, 51 | Griewank, 52 | Hartmann, 53 | HolderTable, 54 | Levy, 55 | Michalewicz, 56 | Powell, 57 | PressureVessel, 58 | Rastrigin, 59 | Rosenbrock, 60 | Shekel, 61 | SixHumpCamel, 62 | SpeedReducer, 63 | StyblinskiTang, 64 | SyntheticTestFunction, 65 | TensionCompressionString, 66 | ThreeHumpCamel, 67 | WeldedBeamSO, 68 | ) 69 | 70 | 71 | __all__ = [ 72 | "Ackley", 73 | "AugmentedBranin", 74 | "AugmentedHartmann", 75 | "AugmentedRosenbrock", 76 | "Beale", 77 | "BNH", 78 | "Branin", 79 | "BraninCurrin", 80 | "Bukin", 81 | "CONSTR", 82 | "Cosine8", 83 | "CarSideImpact", 84 | "ConstrainedBraninCurrin", 85 | "C2DTLZ2", 86 | "DiscBrake", 87 | "DixonPrice", 88 | "DropWave", 89 | "DTLZ1", 90 | "DTLZ2", 91 | "DTLZ3", 92 | "DTLZ4", 93 | "DTLZ5", 94 | "DTLZ7", 95 | "EggHolder", 96 | "GMM", 97 | "Griewank", 98 | "Hartmann", 99 | "HolderTable", 100 | "Levy", 101 | "Michalewicz", 102 | "MW7", 103 | "OSY", 104 | "Penicillin", 105 | "Powell", 106 | "PressureVessel", 107 | "Rastrigin", 108 | "Rosenbrock", 109 | "Shekel", 110 | "SixHumpCamel", 111 | "SpeedReducer", 112 | "SRN", 113 | "StyblinskiTang", 114 | "SyntheticTestFunction", 115 | "TensionCompressionString", 116 | "ThreeHumpCamel", 117 | "ToyRobust", 118 | "VehicleSafety", 119 | "WeldedBeam", 120 | "WeldedBeamSO", 121 | "ZDT1", 122 | "ZDT2", 123 | "ZDT3", 124 | "MOMFBraninCurrin", 125 | "MOMFPark", 126 | ] 127 | -------------------------------------------------------------------------------- /botorch/test_functions/utils.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | 8 | from __future__ import annotations 9 | 10 | import torch 11 | 12 | from torch import Tensor 13 | 14 | 15 | def round_nearest( 16 | X: Tensor, increment: float, bounds: tuple[float, float] | None 17 | ) -> Tensor: 18 | r"""Rounds the input tensor to the nearest multiple of `increment`. 19 | 20 | Args: 21 | X: The input to be rounded. 22 | increment: The increment to round to. 23 | bounds: An optional tuple of two floats representing the lower and upper 24 | bounds on `X`. If provided, this will round to the nearest multiple 25 | of `increment` that lies within the bounds. 26 | 27 | Returns: 28 | The rounded input. 29 | """ 30 | X_round = torch.round(X / increment) * increment 31 | if bounds is not None: 32 | X_round = torch.where(X_round < bounds[0], X_round + increment, X_round) 33 | X_round = torch.where(X_round > bounds[1], X_round - increment, X_round) 34 | return X_round 35 | -------------------------------------------------------------------------------- /botorch/test_utils/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | """ 8 | test_utils has its own directory with 'botorch/' to avoid circular dependencies: 9 | Anything in 'tests/' can depend on anything in 'botorch/test_utils/', and 10 | anything in 'botorch/test_utils/' can depend on anything in the rest of 11 | 'botorch/'. 12 | """ 13 | 14 | from botorch.test_utils.mock import mock_optimize 15 | 16 | __all__ = ["mock_optimize"] 17 | -------------------------------------------------------------------------------- /botorch/utils/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.utils.constraints import get_outcome_constraint_transforms 8 | from botorch.utils.feasible_volume import estimate_feasible_volume 9 | from botorch.utils.objective import apply_constraints, get_objective_weights_transform 10 | from botorch.utils.rounding import approximate_round 11 | from botorch.utils.sampling import ( 12 | batched_multinomial, 13 | draw_sobol_normal_samples, 14 | draw_sobol_samples, 15 | manual_seed, 16 | ) 17 | from botorch.utils.transforms import standardize, t_batch_mode_transform 18 | 19 | 20 | __all__ = [ 21 | "apply_constraints", 22 | "approximate_round", 23 | "batched_multinomial", 24 | "draw_sobol_normal_samples", 25 | "draw_sobol_samples", 26 | "estimate_feasible_volume", 27 | "get_objective_weights_transform", 28 | "get_outcome_constraint_transforms", 29 | "manual_seed", 30 | "standardize", 31 | "t_batch_mode_transform", 32 | ] 33 | -------------------------------------------------------------------------------- /botorch/utils/constants.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | from collections.abc import Iterator 10 | 11 | from functools import lru_cache 12 | from numbers import Number 13 | 14 | import torch 15 | from torch import Tensor 16 | 17 | 18 | @lru_cache(maxsize=None) 19 | def get_constants( 20 | values: Number | Iterator[Number], 21 | device: torch.device | None = None, 22 | dtype: torch.dtype | None = None, 23 | ) -> Tensor | tuple[Tensor, ...]: 24 | r"""Returns scalar-valued Tensors containing each of the given constants. 25 | Used to expedite tensor operations involving scalar arithmetic. Note that 26 | the returned Tensors should not be modified in-place.""" 27 | if isinstance(values, Number): 28 | return torch.full((), values, dtype=dtype, device=device) 29 | 30 | return tuple(torch.full((), val, dtype=dtype, device=device) for val in values) 31 | 32 | 33 | def get_constants_like( 34 | values: Number | Iterator[Number], 35 | ref: Tensor, 36 | ) -> Tensor | Iterator[Tensor]: 37 | return get_constants(values, device=ref.device, dtype=ref.dtype) 38 | -------------------------------------------------------------------------------- /botorch/utils/evaluation.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from math import log 8 | 9 | import torch 10 | from botorch.utils.transforms import is_fully_bayesian 11 | from gpytorch.models.exact_gp import ExactGP 12 | 13 | MLL = "MLL" 14 | AIC = "AIC" 15 | BIC = "BIC" 16 | 17 | 18 | def compute_in_sample_model_fit_metric(model: ExactGP, criterion: str) -> float: 19 | """Compute a in-sample model fit metric. 20 | 21 | Args: 22 | model: A fitted ExactGP. 23 | criterion: Evaluation criterion. One of "MLL", "AIC", "BIC". AIC 24 | penalizes the MLL based on the number of parameters. BIC uses 25 | a slightly different penalty based on the number of parameters 26 | and data points. 27 | 28 | Returns: 29 | The in-sample evaluation metric. 30 | """ 31 | if criterion not in (AIC, BIC, MLL): 32 | raise ValueError(f"Invalid evaluation criterion {criterion}.") 33 | if is_fully_bayesian(model=model): 34 | model.train(reset=False) 35 | else: 36 | model.train() 37 | with torch.no_grad(): 38 | output = model(*model.train_inputs) 39 | output = model.likelihood(output) 40 | mll = output.log_prob(model.train_targets) 41 | # compute average MLL over MCMC samples if the model is fully bayesian 42 | mll_scalar = mll.mean().item() 43 | model.eval() 44 | num_params = sum(p.numel() for p in model.parameters()) 45 | if is_fully_bayesian(model=model): 46 | num_params /= mll.shape[0] 47 | if criterion == AIC: 48 | return 2 * num_params - 2 * mll_scalar 49 | elif criterion == BIC: 50 | return num_params * log(model.train_inputs[0].shape[-2]) - 2 * mll_scalar 51 | return mll_scalar 52 | -------------------------------------------------------------------------------- /botorch/utils/multi_objective/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.utils.multi_objective.hypervolume import Hypervolume, infer_reference_point 8 | from botorch.utils.multi_objective.pareto import is_non_dominated 9 | from botorch.utils.multi_objective.scalarization import get_chebyshev_scalarization 10 | 11 | 12 | __all__ = [ 13 | "get_chebyshev_scalarization", 14 | "infer_reference_point", 15 | "is_non_dominated", 16 | "Hypervolume", 17 | ] 18 | -------------------------------------------------------------------------------- /botorch/utils/multi_objective/box_decompositions/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | 8 | from botorch.utils.multi_objective.box_decompositions.box_decomposition_list import ( # noqa E501 9 | BoxDecompositionList, 10 | ) 11 | from botorch.utils.multi_objective.box_decompositions.dominated import ( 12 | DominatedPartitioning, 13 | ) 14 | from botorch.utils.multi_objective.box_decompositions.non_dominated import ( 15 | FastNondominatedPartitioning, 16 | NondominatedPartitioning, 17 | ) 18 | from botorch.utils.multi_objective.box_decompositions.utils import ( 19 | compute_dominated_hypercell_bounds_2d, 20 | compute_non_dominated_hypercell_bounds_2d, 21 | ) 22 | 23 | 24 | __all__ = [ 25 | "compute_dominated_hypercell_bounds_2d", 26 | "compute_non_dominated_hypercell_bounds_2d", 27 | "BoxDecompositionList", 28 | "DominatedPartitioning", 29 | "FastNondominatedPartitioning", 30 | "NondominatedPartitioning", 31 | ] 32 | -------------------------------------------------------------------------------- /botorch/utils/multi_objective/box_decompositions/dominated.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | r"""Algorithms for partitioning the dominated space into hyperrectangles.""" 8 | 9 | from __future__ import annotations 10 | 11 | from botorch.utils.multi_objective.box_decompositions.box_decomposition import ( 12 | FastPartitioning, 13 | ) 14 | from botorch.utils.multi_objective.box_decompositions.utils import ( 15 | compute_dominated_hypercell_bounds_2d, 16 | get_partition_bounds, 17 | ) 18 | from torch import Tensor 19 | 20 | 21 | class DominatedPartitioning(FastPartitioning): 22 | r"""Partition dominated space into axis-aligned hyperrectangles. 23 | 24 | This uses the Algorithm 1 from [Lacour17]_. 25 | 26 | Example: 27 | >>> bd = DominatedPartitioning(ref_point, Y) 28 | """ 29 | 30 | def _partition_space_2d(self) -> None: 31 | r"""Partition the non-dominated space into disjoint hypercells. 32 | 33 | This direct method works for `m=2` outcomes. 34 | """ 35 | cell_bounds = compute_dominated_hypercell_bounds_2d( 36 | # flip self.pareto_Y because it is sorted in decreasing order (since 37 | # self._pareto_Y was sorted in increasing order and we multiplied by -1) 38 | pareto_Y_sorted=self.pareto_Y.flip(-2), 39 | ref_point=self.ref_point, 40 | ) 41 | self.hypercell_bounds = cell_bounds 42 | 43 | def _get_partitioning(self) -> None: 44 | r"""Get the bounds of each hypercell in the decomposition.""" 45 | minimization_cell_bounds = get_partition_bounds( 46 | Z=self._Z, U=self._U, ref_point=self._neg_ref_point.view(-1) 47 | ) 48 | cell_bounds = -minimization_cell_bounds.flip(0) 49 | self.hypercell_bounds = cell_bounds 50 | 51 | def _compute_hypervolume_if_y_has_data(self) -> Tensor: 52 | r"""Compute hypervolume that is dominated by the Pareto Frontier. 53 | 54 | Returns: 55 | A `(batch_shape)`-dim tensor containing the hypervolume dominated by 56 | each Pareto frontier. 57 | """ 58 | return ( 59 | (self.hypercell_bounds[1] - self.hypercell_bounds[0]) 60 | .prod(dim=-1) 61 | .sum(dim=-1) 62 | ) 63 | 64 | def _get_single_cell(self) -> None: 65 | r"""Set the partitioning to be a single cell in the case of no Pareto points.""" 66 | # Set lower and upper bounds to be the reference point to define an empty cell 67 | cell_bounds = self.ref_point.expand( 68 | 2, *self._neg_pareto_Y.shape[:-2], 1, self.num_outcomes 69 | ).clone() 70 | self.hypercell_bounds = cell_bounds 71 | -------------------------------------------------------------------------------- /botorch/utils/multitask.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | r""" 8 | Helpers for multitask modeling. 9 | """ 10 | 11 | from __future__ import annotations 12 | 13 | import torch 14 | from gpytorch.distributions import MultitaskMultivariateNormal 15 | from gpytorch.distributions.multivariate_normal import MultivariateNormal 16 | from linear_operator import to_linear_operator 17 | 18 | 19 | def separate_mtmvn(mvn: MultitaskMultivariateNormal) -> list[MultivariateNormal]: 20 | """ 21 | Separate a MTMVN into a list of MVNs, where covariance across data within each task 22 | are preserved, while covariance across task are dropped. 23 | """ 24 | # T150340766 Upstream as a class method on gpytorch MultitaskMultivariateNormal. 25 | full_covar = mvn.lazy_covariance_matrix 26 | num_data, num_tasks = mvn.mean.shape[-2:] 27 | if mvn._interleaved: 28 | data_indices = torch.arange( 29 | 0, num_data * num_tasks, num_tasks, device=full_covar.device 30 | ).view(-1, 1, 1) 31 | task_indices = torch.arange(num_tasks, device=full_covar.device) 32 | else: 33 | data_indices = torch.arange(num_data, device=full_covar.device).view(-1, 1, 1) 34 | task_indices = torch.arange( 35 | 0, num_data * num_tasks, num_data, device=full_covar.device 36 | ) 37 | slice_ = (data_indices + task_indices).transpose(-1, -3) 38 | data_covars = full_covar[..., slice_, slice_.transpose(-1, -2)] 39 | mvns = [] 40 | for c in range(num_tasks): 41 | mvns.append( 42 | MultivariateNormal( 43 | mvn.mean[..., c], to_linear_operator(data_covars[..., c, :, :]) 44 | ) 45 | ) 46 | return mvns 47 | -------------------------------------------------------------------------------- /botorch/utils/probability/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from botorch.utils.probability.bvn import bvn, bvnmom 8 | from botorch.utils.probability.lin_ess import LinearEllipticalSliceSampler 9 | from botorch.utils.probability.mvnxpb import MVNXPB 10 | from botorch.utils.probability.truncated_multivariate_normal import ( 11 | TruncatedMultivariateNormal, 12 | ) 13 | from botorch.utils.probability.unified_skew_normal import UnifiedSkewNormal 14 | from botorch.utils.probability.utils import ndtr 15 | 16 | 17 | __all__ = [ 18 | "bvn", 19 | "bvnmom", 20 | "LinearEllipticalSliceSampler", 21 | "MVNXPB", 22 | "ndtr", 23 | "TruncatedMultivariateNormal", 24 | "UnifiedSkewNormal", 25 | ] 26 | -------------------------------------------------------------------------------- /botorch/utils/types.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | 10 | class _DefaultType(type): 11 | r""" 12 | Private class whose sole instance `DEFAULT` is as a special indicator 13 | representing that a default value should be assigned to an argument. 14 | Typically used in cases where `None` is an allowed argument. 15 | """ 16 | 17 | 18 | DEFAULT = _DefaultType("DEFAULT", (), {}) 19 | -------------------------------------------------------------------------------- /botorch_community/README.md: -------------------------------------------------------------------------------- 1 | This directory contains methods contributed by the BoTorch community. 2 | 3 | Each file should list the GitHub handle of its contributors, who may be asked 4 | for help in maintaining & updating the code against future versions for BoTorch 5 | and dependencies. 6 | -------------------------------------------------------------------------------- /botorch_community/__init__.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) Meta Platforms, Inc. and affiliates. 2 | # 3 | # This source code is licensed under the MIT license found in the 4 | # LICENSE file in the root directory of this source tree. 5 | -------------------------------------------------------------------------------- /botorch_community/acquisition/__init__.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) Meta Platforms, Inc. and affiliates. 2 | # 3 | # This source code is licensed under the MIT license found in the 4 | # LICENSE file in the root directory of this source tree. 5 | 6 | from botorch_community.acquisition.bayesian_active_learning import ( 7 | qBayesianQueryByComittee, 8 | qBayesianVarianceReduction, 9 | qStatisticalDistanceActiveLearning, 10 | ) 11 | 12 | # NOTE: This import is needed to register the input constructors. 13 | from botorch_community.acquisition.input_constructors import ( # noqa F401 14 | acqf_input_constructor, 15 | ) 16 | from botorch_community.acquisition.rei import ( 17 | LogRegionalExpectedImprovement, 18 | qLogRegionalExpectedImprovement, 19 | ) 20 | from botorch_community.acquisition.scorebo import qSelfCorrectingBayesianOptimization 21 | 22 | __all__ = [ 23 | "LogRegionalExpectedImprovement", 24 | "qBayesianQueryByComittee", 25 | "qBayesianVarianceReduction", 26 | "qLogRegionalExpectedImprovement", 27 | "qSelfCorrectingBayesianOptimization", 28 | "qStatisticalDistanceActiveLearning", 29 | ] 30 | -------------------------------------------------------------------------------- /botorch_community/acquisition/input_constructors.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | r""" 8 | A registry of helpers for generating inputs to acquisition function 9 | constructors programmatically from a consistent input format. 10 | 11 | Contributor: hvarfner (bayesian_active_learning, scorebo) 12 | """ 13 | 14 | from __future__ import annotations 15 | 16 | from typing import List, Optional, Tuple 17 | 18 | import torch 19 | from botorch.acquisition.input_constructors import acqf_input_constructor 20 | from botorch.acquisition.objective import ScalarizedPosteriorTransform 21 | from botorch.acquisition.utils import get_optimal_samples 22 | from botorch.models.model import Model 23 | from botorch_community.acquisition.bayesian_active_learning import ( 24 | qBayesianQueryByComittee, 25 | qBayesianVarianceReduction, 26 | qStatisticalDistanceActiveLearning, 27 | ) 28 | from botorch_community.acquisition.scorebo import qSelfCorrectingBayesianOptimization 29 | from torch import Tensor 30 | 31 | 32 | @acqf_input_constructor( 33 | qBayesianQueryByComittee, 34 | qBayesianVarianceReduction, 35 | ) 36 | def construct_inputs_BAL( 37 | model: Model, 38 | X_pending: Optional[Tensor] = None, 39 | ): 40 | inputs = { 41 | "model": model, 42 | "X_pending": X_pending, 43 | } 44 | return inputs 45 | 46 | 47 | @acqf_input_constructor(qStatisticalDistanceActiveLearning) 48 | def construct_inputs_SAL( 49 | model: Model, 50 | distance_metric: str = "hellinger", 51 | X_pending: Optional[Tensor] = None, 52 | ): 53 | inputs = { 54 | "model": model, 55 | "distance_metric": distance_metric, 56 | "X_pending": X_pending, 57 | } 58 | return inputs 59 | 60 | 61 | @acqf_input_constructor(qSelfCorrectingBayesianOptimization) 62 | def construct_inputs_SCoreBO( 63 | model: Model, 64 | bounds: List[Tuple[float, float]], 65 | num_optima: int = 8, 66 | posterior_transform: Optional[ScalarizedPosteriorTransform] = None, 67 | distance_metric: str = "hellinger", 68 | X_pending: Optional[Tensor] = None, 69 | ): 70 | dtype = model.train_targets.dtype 71 | # the number of optima are per model 72 | optimal_inputs, optimal_outputs = get_optimal_samples( 73 | model=model, 74 | bounds=torch.as_tensor(bounds, dtype=dtype).T, 75 | num_optima=num_optima, 76 | posterior_transform=posterior_transform, 77 | return_transformed=True, 78 | ) 79 | inputs = { 80 | "model": model, 81 | "optimal_inputs": optimal_inputs, 82 | "optimal_outputs": optimal_outputs, 83 | "distance_metric": distance_metric, 84 | "posterior_transform": posterior_transform, 85 | "X_pending": X_pending, 86 | } 87 | return inputs 88 | -------------------------------------------------------------------------------- /botorch_community/models/__init__.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) Meta Platforms, Inc. and affiliates. 2 | # 3 | # This source code is licensed under the MIT license found in the 4 | # LICENSE file in the root directory of this source tree. 5 | -------------------------------------------------------------------------------- /botorch_community/models/blls.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | from abc import ABC, abstractmethod 10 | 11 | import torch 12 | import torch.nn as nn 13 | from botorch.models.model import Model 14 | from botorch_community.models.vbll_helper import DenseNormal, Normal 15 | from torch import Tensor 16 | 17 | 18 | class AbstractBLLModel(Model, ABC): 19 | def __init__(self): 20 | """Abstract class for Bayesian Last Layer (BLL) models.""" 21 | super().__init__() 22 | self.model = None 23 | 24 | @property 25 | def num_outputs(self) -> int: 26 | return self.model.num_outputs 27 | 28 | @property 29 | def num_inputs(self): 30 | return self.model.num_inputs 31 | 32 | @property 33 | def device(self): 34 | return self.model.device 35 | 36 | @abstractmethod 37 | def __call__(self, X: Tensor) -> Normal | DenseNormal: 38 | pass # pragma: no cover 39 | 40 | @abstractmethod 41 | def fit(self, *args, **kwargs): 42 | pass # pragma: no cover 43 | 44 | @abstractmethod 45 | def sample(self, sample_shape: torch.Size | None = None) -> nn.Module: 46 | pass # pragma: no cover 47 | -------------------------------------------------------------------------------- /botorch_community/models/example.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | """ 8 | This file contains a simple modification of SingleTaskGP as an example. 9 | 10 | References: 11 | 12 | .. [Example2024paper] 13 | S. Cakmak, D.Eriksson, M. Balandat, E. Bakshy. Example Paper. 14 | Proceedings of the Example Conference, 2024. 15 | 16 | Contributor: saitcakmak 17 | """ 18 | 19 | from typing import Optional 20 | 21 | from botorch.models.gp_regression import SingleTaskGP 22 | from gpytorch.kernels import RBFKernel, ScaleKernel 23 | from torch import Tensor 24 | 25 | 26 | class ExampleModel(SingleTaskGP): 27 | def __init__( 28 | self, train_X: Tensor, train_Y: Tensor, train_Yvar: Optional[Tensor] = None 29 | ) -> None: 30 | r"""Initialize the example model from [Example2024paper]_. 31 | 32 | Args: 33 | train_X: A `batch_shape x n x d` tensor of training features. 34 | train_Y: A `batch_shape x n x m` tensor of training observations. 35 | train_Yvar: An optional `batch_shape x n x m` tensor of observed 36 | measurement noise. 37 | """ 38 | super().__init__( 39 | train_X=train_X, 40 | train_Y=train_Y, 41 | train_Yvar=train_Yvar, 42 | covar_module=ScaleKernel(RBFKernel(ard_num_dims=train_X.shape[-1])), 43 | ) 44 | -------------------------------------------------------------------------------- /botorch_community/models/utils/prior_fitted_network.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import gzip 8 | import io 9 | import os 10 | from enum import Enum 11 | from typing import Optional 12 | 13 | try: 14 | import requests 15 | except ImportError: # pragma: no cover 16 | raise ImportError( 17 | "The `requests` library is required to run `download_model`. " 18 | "You can install it using pip: `pip install requests`" 19 | ) 20 | 21 | 22 | import torch 23 | import torch.nn as nn 24 | 25 | 26 | class ModelPaths(Enum): 27 | """Enum for PFN models""" 28 | 29 | pfns4bo_hebo = ( 30 | "https://github.com/automl/PFNs4BO/raw/refs/heads/main/pfns4bo" 31 | "/final_models/model_hebo_morebudget_9_unused_features_3.pt.gz" 32 | ) 33 | pfns4bo_bnn = ( 34 | "https://github.com/automl/PFNs4BO/raw/refs/heads/main/pfns4bo" 35 | "/final_models/model_sampled_warp_simple_mlp_for_hpob_46.pt.gz" 36 | ) 37 | 38 | 39 | def download_model( 40 | model_path: str | ModelPaths, 41 | proxies: Optional[dict[str, str]] = None, 42 | cache_dir: Optional[str] = None, 43 | ) -> nn.Module: 44 | """Download and load PFN model weights from a URL. 45 | 46 | Args: 47 | model_path: A string representing the URL of the model to load or a ModelPaths 48 | enum. 49 | proxies: An optional dictionary mapping from network protocols, e.g. ``http``, 50 | to proxy addresses. 51 | cache_dir: The cache dir to use, if not specified we will use 52 | ``/tmp/botorch_pfn_models`` 53 | 54 | Returns: 55 | A PFN model. 56 | """ 57 | if isinstance(model_path, ModelPaths): 58 | model_path = model_path.value 59 | 60 | cache_dir = cache_dir if cache_dir is not None else "/tmp/botorch_pfn_models" 61 | os.makedirs(cache_dir, exist_ok=True) 62 | cache_path = os.path.join(cache_dir, model_path.split("/")[-1]) 63 | 64 | if not os.path.exists(cache_path): 65 | # Download the model weights 66 | response = requests.get(model_path, proxies=proxies or None) 67 | response.raise_for_status() 68 | 69 | # Decompress the gzipped model weights 70 | with gzip.GzipFile(fileobj=io.BytesIO(response.content)) as gz: 71 | model = torch.load(gz, map_location=torch.device("cpu")) 72 | 73 | # Save the model to cache 74 | torch.save(model, cache_path) 75 | print("saved at: ", cache_path) 76 | else: 77 | # Load the model from cache 78 | model = torch.load(cache_path, map_location=torch.device("cpu")) 79 | print("loaded from cache: ", cache_path) 80 | 81 | return model 82 | -------------------------------------------------------------------------------- /botorch_community/posteriors/__init__.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) Meta Platforms, Inc. and affiliates. 2 | # 3 | # This source code is licensed under the MIT license found in the 4 | # LICENSE file in the root directory of this source tree. 5 | -------------------------------------------------------------------------------- /botorch_community/posteriors/bll_posterior.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | import math 10 | 11 | import torch 12 | from botorch.posteriors import GPyTorchPosterior, Posterior 13 | 14 | from botorch_community.models.blls import AbstractBLLModel 15 | 16 | from torch import Tensor 17 | 18 | 19 | class BLLPosterior(Posterior): 20 | def __init__( 21 | self, 22 | posterior: GPyTorchPosterior, 23 | model: AbstractBLLModel, 24 | X: Tensor, 25 | output_dim: int, 26 | ): 27 | """A posterior for Bayesian last layer models. 28 | 29 | Args: 30 | posterior: A posterior object. 31 | model: A BLL model 32 | X: Input data on which the posterior was computed. 33 | output_dim: Output dimension of the model. 34 | """ 35 | super().__init__() 36 | self.posterior = posterior 37 | self.model = model 38 | self.output_dim = output_dim 39 | self.X = X 40 | self._is_mt = output_dim > 1 41 | 42 | def rsample( 43 | self, 44 | sample_shape: torch.Size | None = None, 45 | ) -> Tensor: 46 | """ 47 | For VBLLs, we need to sample from W and then create the 48 | generalized linear model to get posterior samples. 49 | 50 | Args: 51 | sample_shape: The shape of the samples to be drawn. If None, a single 52 | sample is drawn. Otherwise, the shape should be a tuple of integers 53 | representing the desired dimensions. 54 | 55 | Returns: 56 | A `(sample_shape) x N x output_dim`-dim Tensor of maximum posterior samples. 57 | """ 58 | n_samples = 1 if sample_shape is None else math.prod(sample_shape) 59 | samples_list = [self.model.sample()(self.X) for _ in range(n_samples)] 60 | samples = torch.stack(samples_list, dim=0) 61 | 62 | # reshape to [sample_shape, n, output_dim] 63 | sample_shape = torch.Size([1]) if sample_shape is None else sample_shape 64 | new_shape = sample_shape + samples.shape[-2:] 65 | return samples.reshape(new_shape) 66 | 67 | @property 68 | def mean(self) -> Tensor: 69 | """The posterior mean.""" 70 | # Directly return the mean from the underlying posterior 71 | return self.posterior.mean 72 | 73 | @property 74 | def variance(self) -> Tensor: 75 | """The posterior variance.""" 76 | # Directly return the variance from the underlying posterior 77 | return self.posterior.variance 78 | 79 | @property 80 | def device(self) -> torch.device: 81 | return self.posterior.device 82 | 83 | @property 84 | def dtype(self) -> torch.dtype: 85 | """The torch dtype of the distribution.""" 86 | return self.posterior.dtype 87 | -------------------------------------------------------------------------------- /botorch_logo_lockup.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/botorch_logo_lockup.png -------------------------------------------------------------------------------- /docs/assets/EI_MC_qMC.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/docs/assets/EI_MC_qMC.png -------------------------------------------------------------------------------- /docs/assets/EI_optimal_val_hist.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/docs/assets/EI_optimal_val_hist.png -------------------------------------------------------------------------------- /docs/assets/EI_optimizer_hist.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/docs/assets/EI_optimizer_hist.png -------------------------------------------------------------------------------- /docs/assets/EI_resampling_fixed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/docs/assets/EI_resampling_fixed.png -------------------------------------------------------------------------------- /docs/constraints.md: -------------------------------------------------------------------------------- 1 | --- 2 | id: constraints 3 | title: Constraints 4 | --- 5 | 6 | BoTorch supports two distinct types of constraints: Parameter constraints 7 | and outcome constraints. 8 | 9 | 10 | ### Parameter Constraints 11 | 12 | Parameter constraints are constraints on the input space that restrict the 13 | values of the generated candidates. That is, rather than just living inside 14 | a bounding box defined by the `bounds` argument to `optimize_acqf` (or its 15 | derivates), candidate points may be further constrained by linear (in)equality 16 | constraints, specified by the `inequality_constraints` and `equality_constraints` 17 | arguments to `optimize_acqf`. 18 | 19 | Parameter constraints are used e.g. when certain configurations are infeasible 20 | to implement, or would result in excessive costs. These constraints do not affect 21 | the model directly, only indirectly in the sense that all newly generated and 22 | later observed points will satisfy these constraints. In particular, you may 23 | have a model that is fit on points that do not satisfy a certain set of parameter 24 | constraints, but still generate candidates subject to those constraints. 25 | 26 | 27 | ### Outcome Constraints 28 | 29 | In the context of Bayesian Optimization, outcome constraints usually mean 30 | constraints on a (black-box) outcome that needs to be modeled, just like 31 | the objective function is modeled by a surrogate model. Various approaches 32 | for handling these types of constraints have been proposed. A popular one that 33 | is also adopted by BoTorch for Monte Carlo acquistion functions is to multiply 34 | the acquisition utility by the feasibility indicator of the modeled outcome 35 | ([^Gardner2014], [^Letham2017]). The approach can be utilized by passing 36 | `constraints` to the constructors of compatible acquisition functions, 37 | e.g. any `SampleReducingMCAcqquisitionFunction` with a positive acquisition utility, 38 | like expected improvement. 39 | Notably, if the constraint and objective models are statistically independent, 40 | the constrained expected improvement variant is mathematically equivalent to the 41 | unconstrained expected improvement of the objective, multiplied by the probability of 42 | feasibility under the modeled outcome constraint. 43 | 44 | See the [Closed-Loop Optimization](tutorials/closed_loop_botorch_only) 45 | tutorial for an example of using outcome constraints in BoTorch. 46 | 47 | 48 | 49 | [^Gardner2014]: J.R. Gardner, M. J. Kusner, Z. E. Xu, K. Q. Weinberger and 50 | J. P. Cunningham. Bayesian Optimization with Inequality Constraints. ICML 2014. 51 | 52 | [^Letham2017]: B. Letham, B. Karrer, G. Ottoni and E. Bakshy. Constrained Bayesian optimization with noisy experiments. Bayesian Analysis 14(2), 2019. 53 | -------------------------------------------------------------------------------- /docs/posteriors.md: -------------------------------------------------------------------------------- 1 | --- 2 | id: posteriors 3 | title: Posteriors 4 | --- 5 | 6 | A BoTorch `Posterior` object is a layer of 7 | abstraction that separates the specific model used from the evaluation (and 8 | subsequent optimization) of acquisition functions. 9 | In the simplest case, a posterior is a lightweight wrapper around an explicit 10 | distribution object from `torch.distributions` (or `gpytorch.distributions`). 11 | However, a BoTorch `Posterior` can be any distribution (even an implicit one), 12 | so long as one can sample from that distribution. For example, a posterior could 13 | be represented implicitly by some base distribution mapped through a neural network. 14 | 15 | While the analytic acquisition functions assume that the posterior is a 16 | multivariate Gaussian, the Monte-Carlo (MC) based acquisition functions do not make any 17 | assumptions about the underlying distribution. Rather, the MC-based acquisition 18 | functions only require that the posterior can generate samples through an `rsample` 19 | method. As long as the posterior implements the [`Posterior`](https://botorch.readthedocs.io/en/latest/posteriors.html#botorch.posteriors.posterior.Posterior) 20 | interface, it can be used with an MC-based acquisition function. In addition, note that 21 | gradient-based acquisition function optimization requires the ability to back-propagate 22 | gradients through the MC samples. 23 | 24 | For GP models based on GPyTorch for which the posterior distribution is a 25 | multivariate Gaussian, 26 | [`GPyTorchPosterior`](https://botorch.readthedocs.io/en/latest/posteriors.html#botorch.posteriors.gpytorch.GPyTorchPosterior) should be used. 27 | -------------------------------------------------------------------------------- /docs/samplers.md: -------------------------------------------------------------------------------- 1 | --- 2 | id: samplers 3 | title: Monte Carlo Samplers 4 | --- 5 | 6 | MC-based acquisition functions rely on the reparameterization trick, which 7 | transforms some set of $\epsilon$ from some base distribution into a target 8 | distribution. For example, when drawing posterior samples from a Gaussian 9 | process, the classical parameterization is $\mu(x) + L(x) \epsilon$, where 10 | $\epsilon$ are i.i.d standard normal, $\mu$ is the mean of the posterior, and $L(x)$ is 11 | a root decomposition of the covariance matrix such that $L(x)L(x)^T = \Sigma(x)$. 12 | 13 | Exactly how base samples are generated when using the reparameterization trick 14 | can have substantial effects on the convergence of gradients estimated from 15 | these samples. Because of this, BoTorch implements a generic module capable of 16 | flexible sampling from any type of probabilistic model. 17 | 18 | A `MCSampler` is a `Module` that provides base samples from a `Posterior` object. 19 | These samplers may then in turn be used in conjunction with MC-based acquisition 20 | functions. BoTorch includes two types of MC samplers for sampling isotropic 21 | normal deviates: a vanilla, normal sampler (`IIDNormalSampler`) and randomized 22 | quasi-Monte Carlo sampler (`SobolQMCNormalSampler`). 23 | 24 | For most use cases, we recommend using `SobolQMCNormalSampler`, as it tends to 25 | produce more accurate (i.e. lower variance) gradient estimates with much fewer 26 | samples relative to the `IIDNormalSampler`. To experiment with alternative 27 | sampling procedures, please see the source code for `SobolQMCNormalSampler` as 28 | an example. 29 | -------------------------------------------------------------------------------- /docs/tutorials/index.mdx: -------------------------------------------------------------------------------- 1 | --- 2 | title: BoTorch Tutorials 3 | --- 4 | The tutorials here will help you understand and use BoTorch in 5 | your own work. They assume that you are familiar with both 6 | Bayesian optimization (BO) and PyTorch. 7 | * If you are new to BO, we recommend you start with the 8 | [Ax docs](https://ax.dev/docs/bayesopt) and the 9 | following 10 | [tutorial paper](https://arxiv.org/abs/1807.02811). 11 | * If you are new to PyTorch, the easiest way to get started is 12 | with the [What is PyTorch?](https://pytorch.org/tutorials/beginner/blitz/tensor_tutorial.html#sphx-glr-beginner-blitz-tensor-tutorial-py) 13 | tutorial. 14 | 15 | 16 |

Using BoTorch with Ax

17 | _For practitioners_ who are interested in running experiments 18 | to optimize various objectives using Bayesian optimization, 19 | we recommend using [Ax](https://ax.dev) rather than BoTorch. 20 | [Ax](https://ax.dev) provides a user-friendly interface for 21 | experiment configuration and orchestration, while choosing an 22 | appropriate Bayesian optimization algorithm to optimize the 23 | given objective, following BoTorch best practices. 24 | 25 | _For researchers_ who are interested in running experiments with 26 | their custom BoTorch models and acquisition functions, 27 | [Ax](https://ax.dev)'s Modular BoTorch Interface offers a convenient 28 | way to leverage custom BoTorch objects while utilizing 29 | [Ax](https://ax.dev) experiment configuration and orchestration. Check out 30 | [Modular BoTorch tutorial](https://ax.dev/docs/tutorials/modular_botorch/) 31 | to learn how to use custom BoTorch objects in Ax! 32 | See [this documentation](/docs/botorch_and_ax) 33 | for additional information. 34 | 35 |

Full Optimization Loops

36 | In some situations (e.g. when working in a non-standard setting, 37 | or if you want to understand and control various details of the 38 | BO loop), then you may also consider working purely in BoTorch. 39 | The tutorials in this section illustrate this approach. 40 | 41 |

Bite-Sized Tutorials

42 | Rather than guiding you through full end-to-end BO loops, the 43 | tutorials in this section focus on specific tasks that you will 44 | encounter in customizing your BO algorithms. For instance, you 45 | may want to 46 | [write a custom acquisition function](/docs/tutorials/custom_acquisition) 47 | and then 48 | [use a custom zero-th order optimizer](/docs/tutorials/optimize_with_cmaes) 49 | to optimize it. 50 | 51 |

Advanced Usage

52 | Tutorials in this section showcase more advanced ways of using 53 | BoTorch. For instance, 54 | [this tutorial](/docs/tutorials/vae_mnist) 55 | shows how to perform BO if your objective function is an image, 56 | by optimizing in the latent space of a variational auto-encoder 57 | (VAE). 58 | -------------------------------------------------------------------------------- /notebooks_community/README.md: -------------------------------------------------------------------------------- 1 | This directory contains notebooks contributed by the BoTorch community. 2 | 3 | Unlike BoTorch tutorials, the notebooks here are not subject to strict runtime 4 | limitations. As such, they can be used to demonstrate a method using longer 5 | running experiments or for comparing multiple methods. 6 | 7 | Each notebook should include a timestamp of last update, as well as the version 8 | of BoTorch that was used during execution. Each notebook should also list the 9 | GitHub handle of its contributors, who may be asked for help in maintaining & 10 | updating the notebook against future versions for BoTorch and dependencies. 11 | -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [build-system] 2 | requires = ["setuptools", "setuptools_scm[toml]", "wheel"] 3 | build-backend = "setuptools.build_meta" 4 | 5 | [tool.setuptools_scm] 6 | local_scheme = "node-and-date" 7 | write_to = "./botorch/version.py" 8 | 9 | [tool.usort] 10 | first_party_detection = false 11 | 12 | [tool.ufmt] 13 | formatter = "ruff-api" 14 | -------------------------------------------------------------------------------- /requirements-fmt.txt: -------------------------------------------------------------------------------- 1 | # generated by `pyfmt --requirements` 2 | black==24.4.2 3 | ruff-api==0.1.0 4 | stdlibs==2024.1.28 5 | ufmt==2.8.0 6 | usort==1.0.8.post1 7 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | typing_extensions 2 | pyre_extensions 3 | gpytorch==1.14 4 | linear_operator==0.6 5 | torch>=2.0.1 6 | pyro-ppl>=1.8.4 7 | scipy 8 | multipledispatch 9 | threadpoolctl 10 | -------------------------------------------------------------------------------- /scripts/build_docs.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | # run this script from the project root using `./scripts/build_docs.sh` 8 | 9 | usage() { 10 | echo "Usage: $0 [-b] [-o]" 11 | echo "" 12 | echo "Build BoTorch documentation. Must be executed from root of BoTorch repository." 13 | echo "" 14 | echo " -b Build static version of documentation (otherwise start server)." 15 | echo " -o Only Docusaurus (skip Sphinx, tutorials). Useful when just make change to Docusaurus settings." 16 | echo "" 17 | exit 1 18 | } 19 | 20 | BUILD_STATIC=false 21 | ONLY_DOCUSAURUS=false 22 | 23 | while getopts 'bho' flag; do 24 | case "${flag}" in 25 | b) 26 | BUILD_STATIC=true 27 | ;; 28 | h) 29 | usage 30 | ;; 31 | o) 32 | ONLY_DOCUSAURUS=true 33 | ;; 34 | *) 35 | usage 36 | ;; 37 | esac 38 | done 39 | 40 | 41 | if [[ $ONLY_DOCUSAURUS == false ]]; then 42 | echo "-----------------------------------" 43 | echo "Generating tutorials" 44 | echo "-----------------------------------" 45 | python3 scripts/convert_ipynb_to_mdx.py --clean 46 | fi 47 | 48 | echo "-----------------------------------" 49 | echo "Getting Docusaurus deps" 50 | echo "-----------------------------------" 51 | cd website || exit 52 | yarn 53 | 54 | if [[ $BUILD_STATIC == true ]]; then 55 | echo "-----------------------------------" 56 | echo "Building static site" 57 | echo "-----------------------------------" 58 | yarn build 59 | else 60 | echo "-----------------------------------" 61 | echo "Starting local server" 62 | echo "-----------------------------------" 63 | yarn start 64 | fi 65 | -------------------------------------------------------------------------------- /scripts/parse_sphinx.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | import argparse 10 | import os 11 | 12 | from bs4 import BeautifulSoup 13 | 14 | 15 | js_scripts = """ 16 | 17 | 18 | 19 | 20 | 21 | 22 | """ # noqa: E501 23 | 24 | search_js_scripts = """ 25 | 28 | 29 | 30 | """ 31 | 32 | 33 | def parse_sphinx(input_dir, output_dir): 34 | for cur, _, files in os.walk(input_dir): 35 | for fname in files: 36 | if fname.endswith(".html"): 37 | with open(os.path.join(cur, fname), "r") as f: 38 | soup = BeautifulSoup(f.read(), "html.parser") 39 | doc = soup.find("div", {"class": "document"}) 40 | wrapped_doc = doc.wrap(soup.new_tag("div", **{"class": "sphinx"})) 41 | # add js 42 | if fname == "search.html": 43 | out = js_scripts + search_js_scripts + str(wrapped_doc) 44 | else: 45 | out = js_scripts + str(wrapped_doc) 46 | output_path = os.path.join(output_dir, os.path.relpath(cur, input_dir)) 47 | os.makedirs(output_path, exist_ok=True) 48 | with open(os.path.join(output_path, fname), "w") as fout: 49 | fout.write(out) 50 | 51 | # update reference in JS file 52 | with open(os.path.join(input_dir, "_static/searchtools.js"), "r") as js_file: 53 | js = js_file.read() 54 | js = js.replace( 55 | "DOCUMENTATION_OPTIONS.URL_ROOT + '_sources/'", "'_sphinx-sources/'" 56 | ) 57 | with open(os.path.join(input_dir, "_static/searchtools.js"), "w") as js_file: 58 | js_file.write(js) 59 | 60 | 61 | if __name__ == "__main__": 62 | parser = argparse.ArgumentParser(description="Strip HTML body from Sphinx docs.") 63 | parser.add_argument( 64 | "-i", 65 | "--input_dir", 66 | metavar="path", 67 | required=True, 68 | help="Input directory for Sphinx HTML.", 69 | ) 70 | parser.add_argument( 71 | "-o", 72 | "--output_dir", 73 | metavar="path", 74 | required=True, 75 | help="Output directory in Docusaurus.", 76 | ) 77 | args = parser.parse_args() 78 | parse_sphinx(args.input_dir, args.output_dir) 79 | -------------------------------------------------------------------------------- /scripts/patch_site_config.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | import argparse 10 | import re 11 | 12 | 13 | def patch_config( 14 | config_file: str, base_url: str = None, disable_algolia: bool = True 15 | ) -> None: 16 | config = open(config_file, "r").read() 17 | 18 | if base_url is not None: 19 | config = re.sub("baseUrl = '/';", "baseUrl = '{}';".format(base_url), config) 20 | if disable_algolia is True: 21 | config = re.sub( 22 | "const includeAlgolia = true;", "const includeAlgolia = false;", config 23 | ) 24 | 25 | with open(config_file, "w") as outfile: 26 | outfile.write(config) 27 | 28 | 29 | if __name__ == "__main__": 30 | parser = argparse.ArgumentParser( 31 | description="Path Docusaurus siteConfig.js file when building site." 32 | ) 33 | parser.add_argument( 34 | "-f", 35 | "--config_file", 36 | metavar="path", 37 | required=True, 38 | help="Path to configuration file.", 39 | ) 40 | parser.add_argument( 41 | "-b", 42 | "--base_url", 43 | type=str, 44 | required=False, 45 | help="Value for baseUrl.", 46 | default=None, 47 | ) 48 | parser.add_argument( 49 | "--disable_algolia", 50 | required=False, 51 | action="store_true", 52 | help="Disable algolia.", 53 | ) 54 | args = parser.parse_args() 55 | patch_config(args.config_file, args.base_url, args.disable_algolia) 56 | -------------------------------------------------------------------------------- /scripts/verify_py_packages.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | # Get version number (created dynamically via setuptools-scm) 8 | version=$(python -m setuptools_scm) 9 | if [[ $? != "0" ]]; then 10 | echo "Determininig version via setuptools_scm failed." 11 | echo "Make sure that setuptools_scm is installed in your python environment." 12 | exit 1 13 | fi 14 | cur_dir=$(pwd) 15 | 16 | # set up temporary working directory 17 | work_dir=$(mktemp -d) 18 | cd "${work_dir}" || exit 19 | 20 | # we can re-use this path 21 | path="${cur_dir}/dist/botorch-${version}" 22 | 23 | # install wheel and verify import works and version is correct 24 | pip uninstall -y botorch 25 | pip install "${path}-py3-none-any.whl" 26 | wheel_version=$(python -c "import botorch; print(botorch.__version__)" | tail -n 1) 27 | if [[ $wheel_version != "$version" ]]; then 28 | echo "Incorrect wheel version. Expected: ${version}, Actual: ${wheel_version}" 29 | exit 1 30 | fi 31 | 32 | # do the same for the source dist 33 | pip uninstall -y botorch 34 | pip install "${path}.tar.gz" 35 | src_version=$(python -c "import botorch; print(botorch.__version__)" | tail -n 1) 36 | if [[ $src_version != "$version" ]]; then 37 | echo "Incorrect source dist version. Expected: ${version}, Actual: ${src_version}" 38 | exit 1 39 | fi 40 | pip uninstall -y botorch 41 | 42 | 43 | # clean up 44 | cd "${cur_dir}" || exit 45 | rm -rf "${work_dir}" 46 | -------------------------------------------------------------------------------- /setup.cfg: -------------------------------------------------------------------------------- 1 | [flake8] 2 | # E203: black and flake8 disagree on whitespace before ':' 3 | # W503: black and flake8 disagree on how to place operators 4 | # D: Don't run any docstring checks, except those specified in extend-select 5 | ignore = E203, E701, W503, D 6 | # D107: Missing docstring in public method `__init__` 7 | # D417: Missing argument descriptions in the docstring 8 | # D3*: Quotes issues 9 | # D207, D208, D214, D215: indentation 10 | extend-select = D107, D417, D3, D207, D208, D214, D215 11 | max-line-length = 88 12 | exclude = 13 | build, dist, tutorials, website, .eggs 14 | 15 | [coverage:report] 16 | omit = 17 | test/* 18 | setup.py 19 | -------------------------------------------------------------------------------- /sphinx/Makefile: -------------------------------------------------------------------------------- 1 | # Minimal makefile for Sphinx documentation 2 | # 3 | 4 | # You can set these variables from the command line. 5 | SPHINXOPTS = 6 | SPHINXBUILD = sphinx-build 7 | SOURCEDIR = source 8 | BUILDDIR = build 9 | 10 | # Put it first so that "make" without argument is like "make help". 11 | help: 12 | @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 13 | 14 | .PHONY: help Makefile 15 | 16 | # Catch-all target: route all unknown targets to Sphinx using the new 17 | # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). 18 | %: Makefile 19 | @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 20 | -------------------------------------------------------------------------------- /sphinx/README.md: -------------------------------------------------------------------------------- 1 | # sphinx API reference 2 | 3 | This file describes the sphinx setup for auto-generating the botorch API reference. 4 | 5 | 6 | ## Installation 7 | 8 | **Requirements**: 9 | - sphinx >= 3.0 (Install via `pip install sphinx`) 10 | 11 | 12 | ## Building 13 | 14 | From the `botorch/sphinx` directory, run `make html`. 15 | 16 | Generated HTML output can be found in the `botorch/sphinx/build` directory. The main index page is: `botorch/sphinx/build/html/index.html` 17 | 18 | 19 | ## Structure 20 | 21 | `source/index.rst` contains the main index. The API reference for each module lives in its own file, e.g. `models.rst` for the `botorch.models` module. 22 | -------------------------------------------------------------------------------- /sphinx/make.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | pushd %~dp0 4 | 5 | REM Command file for Sphinx documentation 6 | 7 | if "%SPHINXBUILD%" == "" ( 8 | set SPHINXBUILD=sphinx-build 9 | ) 10 | set SOURCEDIR=source 11 | set BUILDDIR=build 12 | 13 | if "%1" == "" goto help 14 | 15 | %SPHINXBUILD% >NUL 2>NUL 16 | if errorlevel 9009 ( 17 | echo. 18 | echo.The 'sphinx-build' command was not found. Make sure you have Sphinx 19 | echo.installed, then set the SPHINXBUILD environment variable to point 20 | echo.to the full path of the 'sphinx-build' executable. Alternatively you 21 | echo.may add the Sphinx directory to PATH. 22 | echo. 23 | echo.If you don't have Sphinx installed, grab it from 24 | echo.http://sphinx-doc.org/ 25 | exit /b 1 26 | ) 27 | 28 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% 29 | goto end 30 | 31 | :help 32 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% 33 | 34 | :end 35 | popd 36 | -------------------------------------------------------------------------------- /sphinx/source/_static/custom.css: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright (c) Meta Platforms, Inc. and affiliates. 3 | * 4 | * This source code is licensed under the MIT license found in the 5 | * LICENSE file in the root directory of this source tree. 6 | */ 7 | 8 | .wy-nav-content { 9 | max-width: initial; 10 | } 11 | -------------------------------------------------------------------------------- /sphinx/source/cross_validation.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | 5 | botorch.cross_validation 6 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 | .. automodule:: botorch.cross_validation 8 | :members: 9 | -------------------------------------------------------------------------------- /sphinx/source/exceptions.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | 5 | botorch.exceptions 6 | ======================================================== 7 | .. automodule:: botorch.exceptions 8 | 9 | 10 | Errors 11 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 12 | .. automodule:: botorch.exceptions.errors 13 | :members: 14 | 15 | Warnings 16 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 17 | .. automodule:: botorch.exceptions.warnings 18 | :members: 19 | -------------------------------------------------------------------------------- /sphinx/source/fit.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | 5 | botorch.fit 6 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 | .. automodule:: botorch.fit 8 | :members: 9 | -------------------------------------------------------------------------------- /sphinx/source/generation.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | 5 | botorch.generation 6 | ======================================================== 7 | .. automodule:: botorch.generation 8 | 9 | 10 | Candidate Generation Utilities for Acquisition Functions 11 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 12 | .. automodule:: botorch.generation.gen 13 | :members: 14 | 15 | 16 | Sampling Strategies 17 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 18 | 19 | .. automodule:: botorch.generation.sampling 20 | :members: 21 | 22 | 23 | Utilities 24 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 25 | 26 | .. automodule:: botorch.generation.utils 27 | :members: 28 | -------------------------------------------------------------------------------- /sphinx/source/index.rst: -------------------------------------------------------------------------------- 1 | :github_url: https://github.com/pytorch/botorch 2 | 3 | BoTorch API Reference 4 | =================================== 5 | 6 | .. toctree:: 7 | :maxdepth: 2 8 | :caption: Contents: 9 | 10 | .. toctree:: 11 | :maxdepth: 1 12 | :caption: API Reference 13 | 14 | acquisition 15 | models 16 | generation 17 | posteriors 18 | optim 19 | fit 20 | sampling 21 | cross_validation 22 | settings 23 | logging 24 | test_functions 25 | test_utils 26 | exceptions 27 | utils 28 | 29 | 30 | Indices and Tables 31 | ================== 32 | 33 | * :ref:`genindex` 34 | * :ref:`modindex` 35 | * :ref:`search` 36 | -------------------------------------------------------------------------------- /sphinx/source/logging.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | 5 | botorch.logging 6 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 | .. automodule:: botorch.logging 8 | :members: 9 | -------------------------------------------------------------------------------- /sphinx/source/optim.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | 5 | botorch.optim 6 | ======================================================== 7 | .. automodule:: botorch.optim 8 | 9 | 10 | Optimization 11 | ------------------------------------------- 12 | 13 | Core 14 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 15 | .. automodule:: botorch.optim.core 16 | :members: 17 | 18 | Acquisition Function Optimization 19 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 20 | .. automodule:: botorch.optim.optimize 21 | :members: 22 | 23 | Model Fitting Optimization 24 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 25 | .. automodule:: botorch.optim.fit 26 | :members: 27 | :exclude-members: OptimizationIteration 28 | 29 | Initialization Helpers 30 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 31 | .. automodule:: botorch.optim.initializers 32 | :members: 33 | 34 | Stopping Criteria 35 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 36 | .. automodule:: botorch.optim.stopping 37 | :members: 38 | 39 | Acquisition Function Optimization with Homotopy 40 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 41 | .. automodule:: botorch.optim.optimize_homotopy 42 | :members: 43 | 44 | Acquisition Function Optimization with Mixed Integer Variables 45 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 46 | .. automodule:: botorch.optim.optimize_mixed 47 | :members: 48 | 49 | Closures 50 | ------------------------------------------- 51 | 52 | Core 53 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 54 | .. automodule:: botorch.optim.closures.core 55 | :members: 56 | 57 | Model Fitting Closures 58 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 59 | .. automodule:: botorch.optim.closures.model_closures 60 | :members: 61 | 62 | 63 | Utilities 64 | ------------------------------------------- 65 | 66 | General Optimization Utilities 67 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 68 | .. automodule:: botorch.optim.utils.common 69 | :members: 70 | 71 | Acquisition Optimization Utilities 72 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 73 | .. automodule:: botorch.optim.utils.acquisition_utils 74 | :members: 75 | 76 | Model Fitting Utilities 77 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 78 | .. automodule:: botorch.optim.utils.model_utils 79 | :members: 80 | 81 | Numpy - Torch Conversion Tools 82 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 83 | .. automodule:: botorch.optim.utils.numpy_utils 84 | :members: 85 | 86 | Optimization with Timeouts 87 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 88 | .. automodule:: botorch.optim.utils.timeout 89 | :members: 90 | 91 | Parameter Constraint Utilities 92 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 93 | .. automodule:: botorch.optim.parameter_constraints 94 | :members: 95 | 96 | Homotopy Utilities 97 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 98 | .. automodule:: botorch.optim.homotopy 99 | :members: 100 | -------------------------------------------------------------------------------- /sphinx/source/posteriors.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | 5 | botorch.posteriors 6 | ======================================================== 7 | .. automodule:: botorch.posteriors 8 | 9 | 10 | Posterior APIs 11 | ------------------------------------------- 12 | 13 | Abstract Posterior API 14 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 15 | .. automodule:: botorch.posteriors.posterior 16 | :members: 17 | 18 | Posterior List API 19 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 20 | .. automodule:: botorch.posteriors.posterior_list 21 | :members: 22 | 23 | 24 | Posteriors 25 | ------------------------------------------- 26 | 27 | Torch Posterior 28 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 29 | .. automodule:: botorch.posteriors.torch 30 | :members: 31 | 32 | GPyTorch Posterior 33 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 34 | .. automodule:: botorch.posteriors.gpytorch 35 | :members: 36 | 37 | Ensemble Posterior 38 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 39 | .. automodule:: botorch.posteriors.ensemble 40 | :members: 41 | 42 | Higher Order GP Posterior 43 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 44 | .. automodule:: botorch.posteriors.higher_order 45 | :members: 46 | 47 | Latent Kronecker GP Posterior 48 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 49 | .. automodule:: botorch.posteriors.latent_kronecker 50 | :members: 51 | 52 | Multitask GP Posterior 53 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 54 | .. automodule:: botorch.posteriors.multitask 55 | :members: 56 | 57 | Transformed Posterior 58 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 59 | .. automodule:: botorch.posteriors.transformed 60 | :members: 61 | 62 | Fully Bayesian Posterior 63 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 64 | .. automodule:: botorch.posteriors.fully_bayesian 65 | :members: 66 | 67 | 68 | Utilities 69 | --------------------------------------------- 70 | 71 | Base Samples 72 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 73 | .. automodule:: botorch.posteriors.base_samples 74 | :members: 75 | -------------------------------------------------------------------------------- /sphinx/source/sampling.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | 5 | botorch.sampling 6 | ======================================================== 7 | .. automodule:: botorch.sampling 8 | 9 | 10 | Monte-Carlo Sampler API 11 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 12 | .. automodule:: botorch.sampling.base 13 | :members: 14 | 15 | Index Sampler 16 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 17 | .. automodule:: botorch.sampling.index_sampler 18 | :members: 19 | 20 | Get Sampler Helper 21 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 22 | .. automodule:: botorch.sampling.get_sampler 23 | :members: 24 | 25 | List Sampler 26 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 27 | .. automodule:: botorch.sampling.list_sampler 28 | :members: 29 | 30 | Gaussian Monte-Carlo Samplers 31 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 32 | .. automodule:: botorch.sampling.normal 33 | :members: 34 | 35 | Pairwise Monte-Carlo Samplers 36 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 37 | .. automodule:: botorch.sampling.pairwise_samplers 38 | :members: 39 | 40 | QMC Base Functionality 41 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 42 | .. automodule:: botorch.sampling.qmc 43 | :members: 44 | 45 | Stochastic Samplers 46 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 47 | .. automodule:: botorch.sampling.stochastic_samplers 48 | :members: 49 | 50 | 51 | Pathwise Sampling 52 | ------------------------------------------- 53 | 54 | Feature Maps 55 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 56 | .. automodule:: botorch.sampling.pathwise.features.maps 57 | :members: 58 | 59 | Feature Map Generators 60 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 61 | .. automodule:: botorch.sampling.pathwise.features.generators 62 | :members: 63 | 64 | Sample Paths 65 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 66 | .. automodule:: botorch.sampling.pathwise.paths 67 | :members: 68 | 69 | Pathwise Prior Samplers 70 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 71 | .. automodule:: botorch.sampling.pathwise.prior_samplers 72 | :members: 73 | 74 | Pathwise Posterior Samplers 75 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 76 | .. automodule:: botorch.sampling.pathwise.posterior_samplers 77 | :members: 78 | 79 | Pathwise Update Strategies 80 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 81 | .. automodule:: botorch.sampling.pathwise.update_strategies 82 | :members: 83 | 84 | Utilities 85 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 86 | .. automodule:: botorch.sampling.pathwise.utils 87 | :members: 88 | -------------------------------------------------------------------------------- /sphinx/source/settings.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | 5 | botorch.settings 6 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 | .. automodule:: botorch.settings 8 | :members: 9 | -------------------------------------------------------------------------------- /sphinx/source/test_functions.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | botorch.test_functions 5 | ======================================================== 6 | .. automodule:: botorch.test_functions 7 | 8 | 9 | Abstract Test Function API 10 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 11 | .. automodule:: botorch.test_functions.base 12 | :members: 13 | 14 | Synthetic Test Functions 15 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 16 | .. automodule:: botorch.test_functions.synthetic 17 | :members: 18 | 19 | Multi-Fidelity Synthetic Test Functions 20 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 21 | .. automodule:: botorch.test_functions.multi_fidelity 22 | :members: 23 | 24 | Multi-Objective Synthetic Test Functions 25 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 26 | .. automodule:: botorch.test_functions.multi_objective 27 | :members: 28 | 29 | Multi-Objective Multi-Fidelity Synthetic Test Functions 30 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 31 | .. automodule:: botorch.test_functions.multi_objective_multi_fidelity 32 | :members: 33 | 34 | Sensitivity Analysis Test Functions 35 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 36 | .. automodule:: botorch.test_functions.sensitivity_analysis 37 | :members: 38 | 39 | Utilities For Test Functions 40 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 41 | .. automodule:: botorch.test_functions.utils 42 | :members: 43 | -------------------------------------------------------------------------------- /sphinx/source/test_utils.rst: -------------------------------------------------------------------------------- 1 | .. role:: hidden 2 | :class: hidden-section 3 | 4 | 5 | botorch.test_utils 6 | ======================================================== 7 | .. automodule:: botorch.test_utils 8 | 9 | Mock 10 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 11 | .. automodule:: botorch.test_utils.mock 12 | :members: 13 | -------------------------------------------------------------------------------- /test/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/acquisition/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/acquisition/multi_objective/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/acquisition/test_acquisition.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import torch 8 | from botorch.acquisition.acquisition import ( 9 | AcquisitionFunction, 10 | MCSamplerMixin, 11 | MultiModelAcquisitionFunction, 12 | OneShotAcquisitionFunction, 13 | ) 14 | from botorch.models.model import ModelDict 15 | from botorch.sampling.normal import IIDNormalSampler 16 | from botorch.sampling.stochastic_samplers import StochasticSampler 17 | from botorch.utils.testing import BotorchTestCase, MockModel, MockPosterior 18 | 19 | 20 | class DummyMCAcqf(AcquisitionFunction, MCSamplerMixin): 21 | def __init__(self, model, sampler): 22 | r"""Dummy acqf for testing MCSamplerMixin.""" 23 | super().__init__(model) 24 | MCSamplerMixin.__init__(self, sampler) 25 | 26 | def forward(self, X): 27 | raise NotImplementedError 28 | 29 | 30 | class DummyMultiModelAcqf(MultiModelAcquisitionFunction): 31 | def forward(self, X): 32 | raise NotImplementedError 33 | 34 | 35 | class TestAcquisitionFunction(BotorchTestCase): 36 | def test_abstract_raises(self): 37 | with self.assertRaises(TypeError): 38 | AcquisitionFunction() 39 | 40 | 41 | class TestOneShotAcquisitionFunction(BotorchTestCase): 42 | def test_abstract_raises(self): 43 | with self.assertRaises(TypeError): 44 | OneShotAcquisitionFunction() 45 | 46 | 47 | class TestMCSamplerMixin(BotorchTestCase): 48 | def test_mc_sampler_mixin(self): 49 | mm = MockModel(MockPosterior(samples=torch.rand(1, 2))) 50 | acqf = DummyMCAcqf(model=mm, sampler=None) 51 | self.assertIsNone(acqf.sampler) 52 | samples = acqf.get_posterior_samples(mm._posterior) 53 | self.assertEqual(samples.shape, torch.Size([512, 1, 2])) 54 | self.assertIsInstance(acqf.sampler, StochasticSampler) 55 | sampler = IIDNormalSampler(sample_shape=torch.Size([2])) 56 | acqf.sampler = sampler 57 | self.assertIs(acqf.sampler, sampler) 58 | 59 | 60 | class TestMultiModelAcquisitionFunction(BotorchTestCase): 61 | def test_multi_model_acquisition_function(self): 62 | model_dict = ModelDict( 63 | m1=MockModel(MockPosterior()), 64 | m2=MockModel(MockPosterior()), 65 | ) 66 | with self.assertRaises(TypeError): 67 | MultiModelAcquisitionFunction(model_dict=model_dict) 68 | acqf = DummyMultiModelAcqf(model_dict=model_dict) 69 | self.assertIs(acqf.model_dict, model_dict) 70 | -------------------------------------------------------------------------------- /test/acquisition/test_predictive_entropy_search.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from itertools import product 8 | 9 | import torch 10 | from botorch.acquisition.predictive_entropy_search import qPredictiveEntropySearch 11 | from botorch.utils.test_helpers import get_model 12 | from botorch.utils.testing import BotorchTestCase 13 | 14 | 15 | class TestQPredictiveEntropySearch(BotorchTestCase): 16 | def test_predictive_entropy_search(self): 17 | torch.manual_seed(1) 18 | tkwargs = {"device": self.device} 19 | num_objectives = 1 20 | 21 | for ( 22 | dtype, 23 | use_model_list, 24 | standardize_model, 25 | maximize, 26 | ) in product( 27 | (torch.float, torch.double), 28 | (False, True), 29 | (False, True), 30 | (False, True), 31 | ): 32 | tkwargs["dtype"] = dtype 33 | input_dim = 2 34 | train_X = torch.rand(4, input_dim, **tkwargs) 35 | train_Y = torch.rand(4, num_objectives, **tkwargs) 36 | model = get_model( 37 | train_X=train_X, 38 | train_Y=train_Y, 39 | use_model_list=use_model_list, 40 | standardize_model=standardize_model, 41 | ) 42 | num_samples = 20 43 | optimal_inputs = torch.rand(num_samples, input_dim, **tkwargs) 44 | 45 | # test acquisition 46 | X_pending_list = [None, torch.rand(2, input_dim, **tkwargs)] 47 | for i in range(len(X_pending_list)): 48 | X_pending = X_pending_list[i] 49 | acq = qPredictiveEntropySearch( 50 | model=model, 51 | optimal_inputs=optimal_inputs, 52 | maximize=maximize, 53 | X_pending=X_pending, 54 | ) 55 | 56 | test_Xs = [ 57 | torch.rand(4, 1, input_dim, **tkwargs), 58 | torch.rand(4, 3, input_dim, **tkwargs), 59 | torch.rand(4, 5, 1, input_dim, **tkwargs), 60 | torch.rand(4, 5, 3, input_dim, **tkwargs), 61 | ] 62 | 63 | for j in range(len(test_Xs)): 64 | acq_X = acq(test_Xs[j]) 65 | # assess shape 66 | self.assertTrue(acq_X.shape == test_Xs[j].shape[:-2]) 67 | -------------------------------------------------------------------------------- /test/exceptions/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/exceptions/test_errors.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import numpy as np 8 | 9 | from botorch.exceptions.errors import ( 10 | BotorchError, 11 | BotorchTensorDimensionError, 12 | CandidateGenerationError, 13 | DeprecationError, 14 | InfeasibilityError, 15 | InputDataError, 16 | OptimizationGradientError, 17 | OptimizationTimeoutError, 18 | UnsupportedError, 19 | ) 20 | from botorch.utils.testing import BotorchTestCase 21 | 22 | 23 | class TestBotorchExceptions(BotorchTestCase): 24 | def test_botorch_exception_hierarchy(self): 25 | self.assertIsInstance(BotorchError(), Exception) 26 | for ErrorClass in [ 27 | CandidateGenerationError, 28 | DeprecationError, 29 | InputDataError, 30 | UnsupportedError, 31 | BotorchTensorDimensionError, 32 | InfeasibilityError, 33 | ]: 34 | self.assertIsInstance(ErrorClass(), BotorchError) 35 | 36 | def test_raise_botorch_exceptions(self): 37 | for ErrorClass in ( 38 | BotorchError, 39 | BotorchTensorDimensionError, 40 | CandidateGenerationError, 41 | InputDataError, 42 | UnsupportedError, 43 | InfeasibilityError, 44 | ): 45 | with self.assertRaises(ErrorClass): 46 | raise ErrorClass("message") 47 | 48 | def test_OptimizationTimeoutError(self): 49 | error = OptimizationTimeoutError( 50 | "message", current_x=np.array([1.0]), runtime=0.123 51 | ) 52 | self.assertEqual(error.runtime, 0.123) 53 | self.assertTrue(np.array_equal(error.current_x, np.array([1.0]))) 54 | with self.assertRaises(OptimizationTimeoutError): 55 | raise error 56 | 57 | def test_OptimizationGradientError(self): 58 | error = OptimizationGradientError("message", current_x=np.array([1.0])) 59 | self.assertTrue(np.array_equal(error.current_x, np.array([1.0]))) 60 | with self.assertRaisesRegex(OptimizationGradientError, "message"): 61 | raise error 62 | -------------------------------------------------------------------------------- /test/exceptions/test_warnings.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import warnings 8 | 9 | from botorch.exceptions.warnings import ( 10 | BadInitialCandidatesWarning, 11 | BotorchTensorDimensionWarning, 12 | BotorchWarning, 13 | CostAwareWarning, 14 | InputDataWarning, 15 | OptimizationWarning, 16 | SamplingWarning, 17 | UserInputWarning, 18 | ) 19 | from botorch.utils.testing import BotorchTestCase 20 | 21 | 22 | class TestBotorchWarnings(BotorchTestCase): 23 | def test_botorch_warnings_hierarchy(self): 24 | self.assertIsInstance(BotorchWarning(), Warning) 25 | self.assertIsInstance(BadInitialCandidatesWarning(), BotorchWarning) 26 | self.assertIsInstance(CostAwareWarning(), BotorchWarning) 27 | self.assertIsInstance(InputDataWarning(), BotorchWarning) 28 | self.assertIsInstance(OptimizationWarning(), BotorchWarning) 29 | self.assertIsInstance(SamplingWarning(), BotorchWarning) 30 | self.assertIsInstance(BotorchTensorDimensionWarning(), BotorchWarning) 31 | self.assertIsInstance(UserInputWarning(), BotorchWarning) 32 | 33 | def test_botorch_warnings(self): 34 | for WarningClass in ( 35 | BotorchTensorDimensionWarning, 36 | BotorchWarning, 37 | BadInitialCandidatesWarning, 38 | CostAwareWarning, 39 | InputDataWarning, 40 | OptimizationWarning, 41 | SamplingWarning, 42 | UserInputWarning, 43 | ): 44 | with warnings.catch_warnings(record=True) as ws: 45 | warnings.warn("message", WarningClass, stacklevel=1) 46 | self.assertEqual(len(ws), 1) 47 | self.assertTrue(issubclass(ws[-1].category, WarningClass)) 48 | self.assertTrue("message" in str(ws[-1].message)) 49 | -------------------------------------------------------------------------------- /test/generation/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/models/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/models/kernels/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/models/test_cost.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from random import random 8 | 9 | import torch 10 | from botorch.models.cost import AffineFidelityCostModel, FixedCostModel 11 | from botorch.utils.testing import BotorchTestCase 12 | 13 | 14 | class TestCostModels(BotorchTestCase): 15 | def test_affine_fidelity_cost_model(self): 16 | for dtype in (torch.float, torch.double): 17 | for batch_shape in ([], [2]): 18 | X = torch.rand(*batch_shape, 3, 4, device=self.device, dtype=dtype) 19 | # test default parameters 20 | model = AffineFidelityCostModel() 21 | self.assertEqual(model.num_outputs, 1) 22 | self.assertEqual(model.fidelity_dims, [-1]) 23 | self.assertEqual(model.fixed_cost, 0.01) 24 | cost = model(X) 25 | cost_exp = 0.01 + X[..., -1:] 26 | self.assertAllClose(cost, cost_exp) 27 | # test custom parameters 28 | fw = {2: 2.0, 0: 1.0} 29 | fc = random() 30 | model = AffineFidelityCostModel(fidelity_weights=fw, fixed_cost=fc) 31 | self.assertEqual(model.fidelity_dims, [0, 2]) 32 | self.assertEqual(model.fixed_cost, fc) 33 | cost = model(X) 34 | cost_exp = fc + sum(v * X[..., i : i + 1] for i, v in fw.items()) 35 | self.assertAllClose(cost, cost_exp) 36 | 37 | def test_fixed_cost_model(self): 38 | for dtype in (torch.float, torch.double): 39 | for batch_shape in ([], [2]): 40 | X = torch.rand(*batch_shape, 3, 2, device=self.device, dtype=dtype) 41 | # test default parameters 42 | fixed_cost = fixed_cost = torch.tensor( 43 | [1.0, 2.0], dtype=dtype, device=self.device 44 | ) 45 | model = FixedCostModel(fixed_cost=fixed_cost) 46 | self.assertEqual(model.num_outputs, 2) 47 | self.assertTrue(torch.equal(model.fixed_cost, fixed_cost)) 48 | cost = model(X) 49 | cost_exp = fixed_cost.view([1] * (X.ndim - 1) + [2]).expand( 50 | *X.shape[:-1], 2 51 | ) 52 | self.assertAllClose(cost, cost_exp) 53 | -------------------------------------------------------------------------------- /test/models/test_ensemble.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import torch 8 | from botorch.models.ensemble import EnsembleModel 9 | from botorch.utils.testing import BotorchTestCase 10 | 11 | 12 | class DummyEnsembleModel(EnsembleModel): 13 | r"""A dummy ensemble model.""" 14 | 15 | def __init__(self): 16 | r"""Init model.""" 17 | super().__init__() 18 | self._num_outputs = 2 19 | self.a = torch.rand(4, 3, 2) 20 | 21 | def forward(self, X): 22 | return torch.stack( 23 | [torch.einsum("...d,dm", X, self.a[i]) for i in range(4)], dim=-3 24 | ) 25 | 26 | 27 | class TestEnsembleModels(BotorchTestCase): 28 | def test_abstract_base_model(self): 29 | with self.assertRaises(TypeError): 30 | EnsembleModel() 31 | 32 | def test_DummyEnsembleModel(self): 33 | for shape in [(10, 3), (5, 10, 3)]: 34 | e = DummyEnsembleModel() 35 | X = torch.randn(*shape) 36 | p = e.posterior(X) 37 | self.assertEqual(p.ensemble_size, 4) 38 | -------------------------------------------------------------------------------- /test/models/utils/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/optim/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/optim/closures/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/optim/test_numpy_converter.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/optim/test_stopping.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | import torch 10 | from botorch.optim.stopping import ExpMAStoppingCriterion, StoppingCriterion 11 | from botorch.utils.testing import BotorchTestCase 12 | 13 | 14 | class TestStoppingCriterion(BotorchTestCase): 15 | def test_abstract_raises(self): 16 | with self.assertRaises(TypeError): 17 | StoppingCriterion() 18 | 19 | def test_exponential_moving_average(self): 20 | for dtype in (torch.float, torch.double): 21 | tkwargs = {"device": self.device, "dtype": dtype} 22 | 23 | # test max iter 24 | sc = ExpMAStoppingCriterion(maxiter=2) 25 | self.assertEqual(sc.maxiter, 2) 26 | self.assertEqual(sc.n_window, 10) 27 | self.assertEqual(sc.rel_tol, 1e-5) 28 | self.assertFalse(sc.evaluate(fvals=torch.ones(1, **tkwargs))) 29 | self.assertTrue(sc.evaluate(fvals=torch.zeros(1, **tkwargs))) 30 | 31 | # test convergence 32 | n_window = 4 33 | for minimize in (True, False): 34 | # test basic 35 | sc = ExpMAStoppingCriterion( 36 | minimize=minimize, n_window=n_window, rel_tol=0.0375 37 | ) 38 | self.assertEqual(sc.rel_tol, 0.0375) 39 | self.assertIsNone(sc._prev_fvals) 40 | weights_exp = torch.tensor([0.1416, 0.1976, 0.2758, 0.3849]) 41 | self.assertAllClose(sc.weights, weights_exp, atol=1e-4) 42 | f_vals = 1 + torch.linspace(1, 0, 25, **tkwargs) ** 2 43 | if not minimize: 44 | f_vals = -f_vals 45 | for i, fval in enumerate(f_vals): 46 | if sc.evaluate(fval): 47 | self.assertEqual(i, 10) 48 | break 49 | # test multiple components 50 | sc = ExpMAStoppingCriterion( 51 | minimize=minimize, n_window=n_window, rel_tol=0.0375 52 | ) 53 | df = torch.linspace(0, 0.1, 25, **tkwargs) 54 | if not minimize: 55 | df = -df 56 | f_vals = torch.stack([f_vals, f_vals + df], dim=-1) 57 | for i, fval in enumerate(f_vals): 58 | if sc.evaluate(fval): 59 | self.assertEqual(i, 10) 60 | break 61 | -------------------------------------------------------------------------------- /test/optim/utils/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/optim/utils/test_common.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | from functools import partial 10 | from warnings import catch_warnings, warn 11 | 12 | import numpy as np 13 | from botorch.optim.utils import _handle_numerical_errors, _warning_handler_template 14 | from botorch.utils.testing import BotorchTestCase 15 | from linear_operator.utils.errors import NanError, NotPSDError 16 | 17 | 18 | class TestUtilsCommon(BotorchTestCase): 19 | def test_handle_numerical_errors(self): 20 | x = np.zeros(1, dtype=np.float64) 21 | 22 | with self.assertRaisesRegex(NotPSDError, "foo"): 23 | _handle_numerical_errors(NotPSDError("foo"), x=x) 24 | 25 | for error in ( 26 | NanError(), 27 | RuntimeError("singular"), 28 | RuntimeError("input is not positive-definite"), 29 | ): 30 | fake_loss, fake_grad = _handle_numerical_errors(error, x=x) 31 | self.assertTrue(np.isnan(fake_loss)) 32 | self.assertEqual(fake_grad.shape, x.shape) 33 | self.assertTrue(np.isnan(fake_grad).all()) 34 | 35 | fake_loss, fake_grad = _handle_numerical_errors(error, x=x, dtype=np.float32) 36 | self.assertEqual(np.float32, fake_loss.dtype) 37 | self.assertEqual(np.float32, fake_grad.dtype) 38 | 39 | with self.assertRaisesRegex(RuntimeError, "foo"): 40 | _handle_numerical_errors(RuntimeError("foo"), x=x) 41 | 42 | def test_warning_handler_template(self): 43 | with catch_warnings(record=True) as ws: 44 | warn(DeprecationWarning("foo")) 45 | warn(RuntimeWarning("bar")) 46 | 47 | self.assertFalse(any(_warning_handler_template(w) for w in ws)) 48 | handler = partial( 49 | _warning_handler_template, 50 | debug=lambda w: issubclass(w.category, DeprecationWarning), 51 | rethrow=lambda w: True, 52 | ) 53 | with self.assertLogs(level="DEBUG") as logs, catch_warnings(record=True) as _ws: 54 | self.assertTrue(all(handler(w) for w in ws)) 55 | self.assertEqual(1, len(logs.output)) 56 | self.assertTrue("foo" in logs.output[0]) 57 | self.assertEqual(1, len(_ws)) 58 | self.assertEqual("bar", str(_ws[0].message)) 59 | -------------------------------------------------------------------------------- /test/posteriors/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/posteriors/test_deterministic.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/sampling/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/sampling/pathwise/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/sampling/pathwise/features/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/sampling/pathwise/features/test_maps.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | from unittest.mock import MagicMock, patch 10 | 11 | import torch 12 | from botorch.sampling.pathwise.features import KernelEvaluationMap, KernelFeatureMap 13 | from botorch.utils.testing import BotorchTestCase 14 | from gpytorch.kernels import MaternKernel 15 | from torch import Size 16 | 17 | 18 | class TestFeatureMaps(BotorchTestCase): 19 | def test_kernel_evaluation_map(self): 20 | kernel = MaternKernel(nu=2.5, ard_num_dims=2, batch_shape=Size([2])) 21 | kernel.to(device=self.device) 22 | with torch.random.fork_rng(): 23 | torch.manual_seed(0) 24 | kernel.lengthscale = 0.1 + 0.3 * torch.rand_like(kernel.lengthscale) 25 | 26 | with self.assertRaisesRegex(RuntimeError, "Shape mismatch"): 27 | KernelEvaluationMap(kernel=kernel, points=torch.rand(4, 3, 2)) 28 | 29 | for dtype in (torch.float32, torch.float64): 30 | kernel.to(dtype=dtype) 31 | X0, X1 = torch.rand(5, 2, dtype=dtype, device=self.device).split([2, 3]) 32 | kernel_map = KernelEvaluationMap(kernel=kernel, points=X1) 33 | self.assertEqual(kernel_map.batch_shape, kernel.batch_shape) 34 | self.assertEqual(kernel_map.num_outputs, X1.shape[-1]) 35 | self.assertTrue(kernel_map(X0).to_dense().equal(kernel(X0, X1).to_dense())) 36 | 37 | with patch.object( 38 | kernel_map, "output_transform", new=lambda z: torch.concat([z, z], dim=-1) 39 | ): 40 | self.assertEqual(kernel_map.num_outputs, 2 * X1.shape[-1]) 41 | 42 | def test_kernel_feature_map(self): 43 | d = 2 44 | m = 3 45 | weight = torch.rand(m, d, device=self.device) 46 | bias = torch.rand(m, device=self.device) 47 | kernel = MaternKernel(nu=2.5, batch_shape=Size([3])).to(self.device) 48 | feature_map = KernelFeatureMap( 49 | kernel=kernel, 50 | weight=weight, 51 | bias=bias, 52 | input_transform=MagicMock(side_effect=lambda x: x), 53 | output_transform=MagicMock(side_effect=lambda z: z.exp()), 54 | ) 55 | 56 | X = torch.rand(2, d, device=self.device) 57 | features = feature_map(X) 58 | feature_map.input_transform.assert_called_once_with(X) 59 | feature_map.output_transform.assert_called_once() 60 | self.assertTrue((X @ weight.transpose(-2, -1) + bias).exp().equal(features)) 61 | 62 | # Test batch_shape and num_outputs 63 | self.assertIs(feature_map.batch_shape, kernel.batch_shape) 64 | self.assertEqual(feature_map.num_outputs, weight.shape[-2]) 65 | with patch.object(feature_map, "output_transform", new=None): 66 | self.assertEqual(feature_map.num_outputs, weight.shape[-2]) 67 | -------------------------------------------------------------------------------- /test/sampling/test_deterministic.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/sampling/test_get_sampler.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import torch 8 | from botorch.posteriors.gpytorch import GPyTorchPosterior 9 | from botorch.posteriors.posterior_list import PosteriorList 10 | from botorch.posteriors.torch import TorchPosterior 11 | from botorch.posteriors.transformed import TransformedPosterior 12 | from botorch.sampling.get_sampler import get_sampler 13 | from botorch.sampling.list_sampler import ListSampler 14 | from botorch.sampling.normal import IIDNormalSampler, SobolQMCNormalSampler 15 | from botorch.utils.testing import BotorchTestCase 16 | from gpytorch.distributions import MultivariateNormal 17 | from torch.distributions.gamma import Gamma 18 | 19 | 20 | class TestGetSampler(BotorchTestCase): 21 | def test_get_sampler(self): 22 | # Basic usage w/ gpytorch posterior. 23 | mvn_posterior = GPyTorchPosterior( 24 | distribution=MultivariateNormal(torch.rand(2), torch.eye(2)) 25 | ) 26 | seed = 2 27 | n_samples = 10 28 | sampler = get_sampler( 29 | posterior=mvn_posterior, sample_shape=torch.Size([n_samples]), seed=seed 30 | ) 31 | self.assertIsInstance(sampler, SobolQMCNormalSampler) 32 | self.assertEqual(sampler.seed, seed) 33 | self.assertEqual(sampler.sample_shape, torch.Size([n_samples])) 34 | 35 | # Fallback to IID sampler. 36 | big_mvn_posterior = GPyTorchPosterior( 37 | distribution=MultivariateNormal(torch.rand(22000), torch.eye(22000)) 38 | ) 39 | sampler = get_sampler( 40 | posterior=big_mvn_posterior, sample_shape=torch.Size([n_samples]) 41 | ) 42 | self.assertIsInstance(sampler, IIDNormalSampler) 43 | self.assertEqual(sampler.sample_shape, torch.Size([n_samples])) 44 | 45 | # Transformed posterior. 46 | tf_post = TransformedPosterior( 47 | posterior=big_mvn_posterior, sample_transform=lambda X: X 48 | ) 49 | sampler = get_sampler(posterior=tf_post, sample_shape=torch.Size([n_samples])) 50 | self.assertIsInstance(sampler, IIDNormalSampler) 51 | self.assertEqual(sampler.sample_shape, torch.Size([n_samples])) 52 | 53 | # PosteriorList with transformed & original 54 | post_list = PosteriorList(tf_post, mvn_posterior) 55 | sampler = get_sampler(posterior=post_list, sample_shape=torch.Size([5])) 56 | self.assertIsInstance(sampler, ListSampler) 57 | self.assertIsInstance(sampler.samplers[0], IIDNormalSampler) 58 | self.assertIsInstance(sampler.samplers[1], SobolQMCNormalSampler) 59 | for s in sampler.samplers: 60 | self.assertEqual(s.sample_shape, torch.Size([5])) 61 | 62 | # Unknown torch posterior. 63 | posterior = TorchPosterior(distribution=Gamma(torch.rand(2), torch.rand(2))) 64 | with self.assertRaisesRegex(NotImplementedError, "A registered `MCSampler`"): 65 | get_sampler(posterior=posterior, sample_shape=torch.Size([5])) 66 | -------------------------------------------------------------------------------- /test/sampling/test_index_sampler.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import torch 8 | from botorch.posteriors.ensemble import EnsemblePosterior 9 | from botorch.sampling.index_sampler import IndexSampler 10 | from botorch.utils.testing import BotorchTestCase 11 | 12 | 13 | class TestIndexSampler(BotorchTestCase): 14 | def test_index_sampler(self): 15 | # Basic usage. 16 | posterior = EnsemblePosterior( 17 | values=torch.randn(torch.Size((50, 16, 1, 1))).to(self.device) 18 | ) 19 | sampler = IndexSampler(sample_shape=torch.Size((128,))) 20 | samples = sampler(posterior) 21 | self.assertTrue(samples.shape == torch.Size((128, 50, 1, 1))) 22 | self.assertTrue(sampler.base_samples.max() < 16) 23 | self.assertTrue(sampler.base_samples.min() >= 0) 24 | # check deterministic nature 25 | samples2 = sampler(posterior) 26 | self.assertAllClose(samples, samples2) 27 | # test construct base samples 28 | sampler = IndexSampler(sample_shape=torch.Size((4, 128)), seed=42) 29 | self.assertTrue(sampler.base_samples is None) 30 | sampler._construct_base_samples(posterior=posterior) 31 | self.assertTrue(sampler.base_samples.shape == torch.Size((4, 128))) 32 | self.assertTrue( 33 | sampler.base_samples.device.type 34 | == posterior.device.type 35 | == self.device.type 36 | ) 37 | base_samples = sampler.base_samples 38 | sampler = IndexSampler(sample_shape=torch.Size((4, 128)), seed=42) 39 | sampler._construct_base_samples(posterior=posterior) 40 | self.assertAllClose(base_samples, sampler.base_samples) 41 | -------------------------------------------------------------------------------- /test/sampling/test_list_sampler.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from unittest import mock 8 | 9 | import torch 10 | from botorch.exceptions.errors import UnsupportedError 11 | from botorch.posteriors.posterior_list import PosteriorList 12 | from botorch.sampling.list_sampler import ListSampler 13 | from botorch.sampling.normal import IIDNormalSampler, SobolQMCNormalSampler 14 | from botorch.sampling.stochastic_samplers import StochasticSampler 15 | from botorch.utils.testing import BotorchTestCase, MockPosterior 16 | 17 | 18 | class TestListSampler(BotorchTestCase): 19 | def test_list_sampler(self): 20 | # Test initialization. 21 | sampler = ListSampler( 22 | IIDNormalSampler(sample_shape=torch.Size([2])), 23 | StochasticSampler(sample_shape=torch.Size([2])), 24 | ) 25 | self.assertIsInstance(sampler.samplers[0], IIDNormalSampler) 26 | self.assertIsInstance(sampler.samplers[1], StochasticSampler) 27 | self.assertEqual(sampler.sample_shape, torch.Size([2])) 28 | 29 | # Test validation. 30 | with self.assertRaisesRegex(UnsupportedError, "all samplers to have the "): 31 | ListSampler( 32 | StochasticSampler(sample_shape=torch.Size([2])), 33 | StochasticSampler(sample_shape=torch.Size([3])), 34 | ) 35 | 36 | # Test basic usage. 37 | org_samples = torch.rand(1, 5) 38 | p1 = MockPosterior(samples=org_samples[:, :2]) 39 | p2 = MockPosterior(samples=org_samples[:, 2:]) 40 | p_list = PosteriorList(p1, p2) 41 | samples = sampler(p_list) 42 | self.assertAllClose(samples, org_samples.repeat(2, 1, 1)) 43 | 44 | # Test _update_base_samples. 45 | sampler = ListSampler( 46 | IIDNormalSampler(sample_shape=torch.Size([2])), 47 | SobolQMCNormalSampler(sample_shape=torch.Size([2])), 48 | ) 49 | sampler2 = ListSampler( 50 | IIDNormalSampler(sample_shape=torch.Size([2])), 51 | SobolQMCNormalSampler(sample_shape=torch.Size([2])), 52 | ) 53 | with mock.patch.object( 54 | sampler.samplers[0], "_update_base_samples" 55 | ) as update_0, mock.patch.object( 56 | sampler.samplers[1], "_update_base_samples" 57 | ) as update_1: 58 | sampler._update_base_samples(posterior=p_list, base_sampler=sampler2) 59 | update_0.assert_called_once_with( 60 | posterior=p1, base_sampler=sampler2.samplers[0] 61 | ) 62 | update_1.assert_called_once_with( 63 | posterior=p2, base_sampler=sampler2.samplers[1] 64 | ) 65 | -------------------------------------------------------------------------------- /test/sampling/test_stochastic_samplers.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from unittest import mock 8 | 9 | import torch 10 | from botorch.posteriors.torch import TorchPosterior 11 | from botorch.sampling.stochastic_samplers import ForkedRNGSampler, StochasticSampler 12 | from botorch.utils.testing import BotorchTestCase, MockPosterior 13 | from torch.distributions.exponential import Exponential 14 | 15 | 16 | class TestForkedRNGSampler(BotorchTestCase): 17 | def test_forked_rng_sampler(self): 18 | posterior = TorchPosterior(Exponential(rate=torch.rand(1, 2))) 19 | sampler = ForkedRNGSampler(sample_shape=torch.Size([2]), seed=0) 20 | with mock.patch.object( 21 | posterior.distribution, "rsample", wraps=posterior.distribution.rsample 22 | ) as mock_rsample: 23 | samples = sampler(posterior) 24 | mock_rsample.assert_called_once_with(sample_shape=torch.Size([2])) 25 | with torch.random.fork_rng(): 26 | torch.manual_seed(0) 27 | expected = posterior.rsample(sample_shape=torch.Size([2])) 28 | self.assertAllClose(samples, expected) 29 | 30 | 31 | class TestStochasticSampler(BotorchTestCase): 32 | def test_stochastic_sampler(self): 33 | # Basic usage. 34 | samples = torch.rand(1, 2) 35 | posterior = MockPosterior(samples=samples) 36 | sampler = StochasticSampler(sample_shape=torch.Size([2])) 37 | self.assertTrue(torch.equal(samples.repeat(2, 1, 1), sampler(posterior))) 38 | 39 | # Test _update_base_samples. 40 | with self.assertRaisesRegex(NotImplementedError, "_update_base_samples"): 41 | sampler._update_base_samples(posterior=posterior, base_sampler=sampler) 42 | -------------------------------------------------------------------------------- /test/test_cuda.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | r""" 8 | Monolithic CUDA tests. This implements a single monolithic test for all 9 | CUDA functionality. The main reason for doing this is that if individual tests 10 | are run in separate processes, the overhead of initializing the GPU can vastly 11 | outweight the speedup from parallelization, and, in addition, this can lead 12 | to the GPU running out of memory. 13 | """ 14 | 15 | import unittest 16 | from itertools import chain 17 | from pathlib import Path 18 | 19 | import torch 20 | from botorch.utils.testing import BotorchTestCase 21 | 22 | 23 | @unittest.skipIf(not torch.cuda.is_available(), "CUDA not available") 24 | class TestBotorchCUDA(unittest.TestCase): 25 | def test_cuda(self): 26 | test_dir = Path(__file__).parent.resolve() 27 | tests = unittest.TestLoader().discover(test_dir) 28 | self.assertTrue(run_cuda_tests(tests)) 29 | 30 | 31 | def run_cuda_tests(tests: unittest.TestCase | unittest.TestSuite) -> bool: 32 | """Function for running all tests on cuda (except TestBotorchCUDA itself)""" 33 | if isinstance(tests, BotorchTestCase): 34 | tests.device = torch.device("cuda") 35 | test_result = tests.run() 36 | if test_result is None: 37 | # some test runners may return None on skipped tests 38 | return True 39 | passed = test_result.wasSuccessful() 40 | if not passed: 41 | # print test name 42 | print(f"test: {tests}") 43 | for error in chain(test_result.errors, test_result.failures): 44 | # print traceback 45 | print(f"error: {error[1]}") 46 | return passed 47 | elif isinstance(tests, unittest.TestSuite): 48 | return all(run_cuda_tests(tests_) for tests_ in tests) 49 | elif ( 50 | isinstance(tests, unittest.TestCase) 51 | and tests.id() == "test_cuda.TestBotorchCUDA.test_cuda" 52 | ): 53 | # ignore TestBotorchCUDA 54 | return True 55 | elif isinstance(tests, unittest.loader._FailedTest): 56 | # test failed to load, often import error 57 | print(f"test: {tests}") 58 | print(f"exception: {tests._exception}") 59 | return False 60 | else: 61 | raise ValueError(f"Unexpected type for test: {tests}") 62 | -------------------------------------------------------------------------------- /test/test_functions/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/test_functions/test_multi_objective_multi_fidelity.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) Meta Platforms, Inc. and affiliates. 2 | # 3 | # This source code is licensed under the MIT license found in the 4 | # LICENSE file in the root directory of this source tree. 5 | 6 | import torch 7 | from botorch.test_functions.multi_objective_multi_fidelity import ( 8 | MOMFBraninCurrin, 9 | MOMFPark, 10 | ) 11 | from botorch.utils.testing import ( 12 | BaseTestProblemTestCaseMixIn, 13 | BotorchTestCase, 14 | MultiObjectiveTestProblemTestCaseMixin, 15 | ) 16 | 17 | 18 | class TestMOMFBraninCurrin( 19 | BotorchTestCase, 20 | BaseTestProblemTestCaseMixIn, 21 | MultiObjectiveTestProblemTestCaseMixin, 22 | ): 23 | functions = [MOMFBraninCurrin()] 24 | bounds = [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]] 25 | 26 | def test_init(self): 27 | for f in self.functions: 28 | self.assertEqual(f.num_objectives, 2) 29 | self.assertEqual(f.dim, 3) 30 | self.assertTrue( 31 | torch.equal(f.bounds, torch.tensor(self.bounds).to(f.bounds)) 32 | ) 33 | 34 | 35 | class TestMOMFPark( 36 | BotorchTestCase, 37 | BaseTestProblemTestCaseMixIn, 38 | MultiObjectiveTestProblemTestCaseMixin, 39 | ): 40 | functions = [MOMFPark()] 41 | bounds = [[0.0, 0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0, 1.0]] 42 | 43 | def test_init(self): 44 | for f in self.functions: 45 | self.assertEqual(f.num_objectives, 2) 46 | self.assertEqual(f.dim, 5) 47 | self.assertTrue( 48 | torch.equal(f.bounds, torch.tensor(self.bounds).to(f.bounds)) 49 | ) 50 | -------------------------------------------------------------------------------- /test/test_functions/test_sensitivity_analysis.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import torch 8 | from botorch.test_functions.sensitivity_analysis import Gsobol, Ishigami, Morris 9 | from botorch.utils.testing import BotorchTestCase 10 | 11 | 12 | class TestIshigami(BotorchTestCase): 13 | def testFunction(self): 14 | with self.assertRaises(ValueError): 15 | Ishigami(b=0.33) 16 | f = Ishigami(b=0.1) 17 | self.assertEqual(f.b, 0.1) 18 | f = Ishigami(b=0.05) 19 | self.assertEqual(f.b, 0.05) 20 | X = torch.tensor([[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]]) 21 | m1, m2, m3 = f.compute_dgsm(X) 22 | for m in [m1, m2, m3]: 23 | self.assertEqual(len(m), 3) 24 | Z = f.evaluate_true(X) 25 | Ztrue = torch.tensor([5.8401, 7.4245]) 26 | self.assertAllClose(Z, Ztrue, atol=1e-3) 27 | self.assertIsNone(f._optimizers) 28 | with self.assertRaises(NotImplementedError): 29 | f.optimal_value 30 | 31 | 32 | class TestGsobol(BotorchTestCase): 33 | def testFunction(self): 34 | for dim in [6, 8, 15]: 35 | f = Gsobol(dim=dim) 36 | self.assertIsNotNone(f.a) 37 | self.assertEqual(len(f.a), dim) 38 | f = Gsobol(dim=3, a=[1, 2, 3]) 39 | self.assertEqual(f.a, [1, 2, 3]) 40 | X = torch.tensor([[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]]) * 0.5 41 | Z = f.evaluate_true(X) 42 | Ztrue = torch.tensor([0.25, 2.5]) 43 | self.assertAllClose(Z, Ztrue, atol=1e-3) 44 | self.assertIsNone(f._optimizers) 45 | with self.assertRaises(NotImplementedError): 46 | f.optimal_value 47 | 48 | 49 | class TestMorris(BotorchTestCase): 50 | def testFunction(self): 51 | f = Morris() 52 | X = torch.stack((torch.zeros(20), torch.ones(20))) 53 | Z = f.evaluate_true(X) 54 | Ztrue = torch.tensor([5163.0, -8137.0]) 55 | self.assertAllClose(Z, Ztrue, atol=1e-3) 56 | self.assertIsNone(f._optimizers) 57 | with self.assertRaises(NotImplementedError): 58 | f.optimal_value 59 | -------------------------------------------------------------------------------- /test/test_logging.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import logging 8 | 9 | import torch 10 | 11 | from botorch import settings 12 | from botorch.logging import LOG_LEVEL_DEFAULT, logger, shape_to_str 13 | from botorch.utils.testing import BotorchTestCase 14 | 15 | 16 | class TestLogging(BotorchTestCase): 17 | def test_logger(self): 18 | # Verify log statements are properly captured 19 | # assertLogs() captures all log calls, ignoring the severity level 20 | with self.assertLogs(logger="botorch", level="INFO") as logs_cm: 21 | logger.info("Hello World!") 22 | logger.error("Goodbye Universe!") 23 | self.assertEqual( 24 | logs_cm.output, 25 | ["INFO:botorch:Hello World!", "ERROR:botorch:Goodbye Universe!"], 26 | ) 27 | 28 | def test_settings_log_level(self): 29 | # Verify the default level is applied 30 | self.assertEqual(logger.level, LOG_LEVEL_DEFAULT) 31 | # Next, verify the level of overwritten within the context manager 32 | with settings.log_level(logging.INFO): 33 | self.assertEqual(logger.level, logging.INFO) 34 | # Finally, verify the original level is set again 35 | self.assertEqual(logger.level, LOG_LEVEL_DEFAULT) 36 | 37 | def test_shape_to_str(self): 38 | self.assertEqual("``", shape_to_str(torch.Size([]))) 39 | self.assertEqual("`1`", shape_to_str(torch.Size([1]))) 40 | self.assertEqual("`1 x 2`", shape_to_str(torch.Size([1, 2]))) 41 | self.assertEqual("`1 x 2 x 3`", shape_to_str(torch.Size([1, 2, 3]))) 42 | -------------------------------------------------------------------------------- /test/test_settings.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | 8 | import gpytorch.settings as gp_settings 9 | import linear_operator.settings as linop_settings 10 | from botorch import settings 11 | from botorch.utils.testing import BotorchTestCase 12 | 13 | 14 | class TestSettings(BotorchTestCase): 15 | def test_flags(self): 16 | flag = settings.propagate_grads 17 | self.assertFalse(flag.on()) 18 | self.assertTrue(flag.off()) 19 | with flag(True): 20 | self.assertTrue(flag.on()) 21 | self.assertFalse(flag.off()) 22 | self.assertFalse(flag.on()) 23 | self.assertTrue(flag.off()) 24 | 25 | 26 | class TestDefaultGPyTorchLinOpSettings(BotorchTestCase): 27 | def test_default_gpytorch_linop_settings(self): 28 | self.assertTrue(linop_settings._fast_covar_root_decomposition.off()) 29 | self.assertTrue(linop_settings._fast_log_prob.off()) 30 | self.assertTrue(linop_settings._fast_solves.off()) 31 | self.assertEqual(linop_settings.cholesky_max_tries.value(), 6) 32 | self.assertEqual(linop_settings.max_cholesky_size.value(), 4096) 33 | self.assertEqual(gp_settings.max_eager_kernel_size.value(), 4096) 34 | -------------------------------------------------------------------------------- /test/utils/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/utils/multi_objective/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/utils/multi_objective/box_decompositions/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/utils/probability/__init__.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | -------------------------------------------------------------------------------- /test/utils/test_constants.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from __future__ import annotations 8 | 9 | from unittest.mock import patch 10 | 11 | import torch 12 | from botorch.utils import constants 13 | from botorch.utils.testing import BotorchTestCase 14 | 15 | 16 | class TestConstants(BotorchTestCase): 17 | def test_get_constants(self): 18 | tkwargs = {"device": self.device, "dtype": torch.float16} 19 | const = constants.get_constants(0.123, **tkwargs) 20 | self.assertEqual(const, 0.123) 21 | self.assertEqual(const.device.type, tkwargs["device"].type) 22 | self.assertEqual(const.dtype, tkwargs["dtype"]) 23 | 24 | try: # test in-place modification 25 | const.add_(1) 26 | const2 = constants.get_constants(0.123, **tkwargs) 27 | self.assertEqual(const2, 1.123) 28 | finally: 29 | const.sub_(1) 30 | 31 | # Test fetching of multiple constants 32 | const_tuple = constants.get_constants(values=(0, 1, 2), **tkwargs) 33 | self.assertIsInstance(const_tuple, tuple) 34 | self.assertEqual(len(const_tuple), 3) 35 | for i, const in enumerate(const_tuple): 36 | self.assertEqual(const, i) 37 | 38 | def test_get_constants_like(self): 39 | def mock_get_constants(values: torch.Tensor, **kwargs): 40 | return kwargs 41 | 42 | tkwargs = {"device": self.device, "dtype": torch.float16} 43 | with patch.object(constants, "get_constants", new=mock_get_constants): 44 | ref = torch.tensor([123], **tkwargs) 45 | other = constants.get_constants_like(0.123, ref=ref) 46 | self.assertEqual(other["device"].type, tkwargs["device"].type) 47 | self.assertEqual(other["dtype"], tkwargs["dtype"]) 48 | -------------------------------------------------------------------------------- /test/utils/test_evaluation.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) Meta Platforms, Inc. and affiliates. 2 | # 3 | # This source code is licensed under the MIT license found in the 4 | # LICENSE file in the root directory of this source tree. 5 | 6 | from itertools import product 7 | from math import log, pi 8 | 9 | import torch 10 | from botorch.fit import fit_fully_bayesian_model_nuts, fit_gpytorch_mll 11 | from botorch.models.fully_bayesian import SaasFullyBayesianSingleTaskGP 12 | from botorch.models.gp_regression import SingleTaskGP 13 | from botorch.test_utils.mock import mock_optimize 14 | from botorch.utils.evaluation import AIC, BIC, compute_in_sample_model_fit_metric, MLL 15 | from botorch.utils.testing import BotorchTestCase 16 | from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood 17 | 18 | 19 | class TestEvaluation(BotorchTestCase): 20 | @mock_optimize 21 | def test_compute_in_sample_model_fit_metric(self): 22 | torch.manual_seed(0) 23 | for dtype, model_cls in product( 24 | (torch.float, torch.double), (SingleTaskGP, SaasFullyBayesianSingleTaskGP) 25 | ): 26 | train_X = torch.linspace( 27 | 0, 1, 10, dtype=dtype, device=self.device 28 | ).unsqueeze(-1) 29 | train_Y = torch.sin(2 * pi * train_X) 30 | model = model_cls(train_X=train_X, train_Y=train_Y) 31 | if model_cls is SingleTaskGP: 32 | fit_gpytorch_mll(ExactMarginalLogLikelihood(model.likelihood, model)) 33 | else: 34 | fit_fully_bayesian_model_nuts( 35 | model, 36 | warmup_steps=8, 37 | num_samples=6, 38 | thinning=2, 39 | disable_progbar=True, 40 | ) 41 | num_params = sum(p.numel() for p in model.parameters()) 42 | if model_cls is SaasFullyBayesianSingleTaskGP: 43 | num_params /= 3 # divide by number of MCMC samples 44 | mll = compute_in_sample_model_fit_metric(model=model, criterion=MLL) 45 | aic = compute_in_sample_model_fit_metric(model=model, criterion=AIC) 46 | bic = compute_in_sample_model_fit_metric(model=model, criterion=BIC) 47 | self.assertEqual(aic, 2 * num_params - 2 * mll) 48 | self.assertEqual(bic, log(10) * num_params - 2 * mll) 49 | # test invalid criterion 50 | with self.assertRaisesRegex( 51 | ValueError, "Invalid evaluation criterion invalid." 52 | ): 53 | compute_in_sample_model_fit_metric(model=model, criterion="invalid") 54 | -------------------------------------------------------------------------------- /test/utils/test_multitask.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | 8 | import torch 9 | from botorch.utils.multitask import separate_mtmvn 10 | 11 | from botorch.utils.testing import BotorchTestCase 12 | from gpytorch.distributions import MultitaskMultivariateNormal 13 | from gpytorch.distributions.multivariate_normal import MultivariateNormal 14 | 15 | 16 | class TestSeparateMTMVN(BotorchTestCase): 17 | def _test_separate_mtmvn(self, interleaved=False): 18 | for dtype in (torch.float, torch.double): 19 | tkwargs = {"device": self.device, "dtype": dtype} 20 | mean = torch.rand(2, 2, **tkwargs) 21 | a = torch.rand(4, 4, **tkwargs) 22 | covar = a @ a.transpose(-1, -2) + torch.eye(4, **tkwargs) 23 | mvn = MultitaskMultivariateNormal( 24 | mean=mean, covariance_matrix=covar, interleaved=interleaved 25 | ) 26 | mtmvn_list = separate_mtmvn(mvn) 27 | 28 | mean_1 = mean[..., 0] 29 | mean_2 = mean[..., 1] 30 | if interleaved: 31 | covar_1 = covar[::2, ::2] 32 | covar_2 = covar[1::2, 1::2] 33 | else: 34 | covar_1 = covar[:2, :2] 35 | covar_2 = covar[2:, 2:] 36 | 37 | self.assertEqual(len(mtmvn_list), 2) 38 | for mvn_i, mean_i, covar_i in zip( 39 | mtmvn_list, (mean_1, mean_2), (covar_1, covar_2) 40 | ): 41 | self.assertIsInstance(mvn_i, MultivariateNormal) 42 | self.assertTrue(torch.equal(mvn_i.mean, mean_i)) 43 | self.assertAllClose(mvn_i.covariance_matrix, covar_i) 44 | 45 | def test_separate_mtmvn_interleaved(self) -> None: 46 | self._test_separate_mtmvn(interleaved=True) 47 | 48 | def test_separate_mtmvn_not_interleaved(self) -> None: 49 | self._test_separate_mtmvn(interleaved=False) 50 | -------------------------------------------------------------------------------- /test/utils/test_test_helpers.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | from unittest import mock 8 | 9 | from botorch.exceptions import UnsupportedError 10 | 11 | from botorch.utils.test_helpers import get_pvar_expected 12 | from botorch.utils.testing import BotorchTestCase 13 | 14 | 15 | class TestTestHelpers(BotorchTestCase): 16 | def test_get_pvar_expected(self): 17 | # The test helper is used throughout, veryfying that an error is raised 18 | # when it is used with an unsupported model. 19 | with self.assertRaisesRegex( 20 | UnsupportedError, 21 | "`get_pvar_expected` only supports `BatchedMultiOutputGPyTorchModel`s.", 22 | ): 23 | get_pvar_expected( 24 | posterior=mock.Mock(), model=mock.Mock(), X=mock.Mock(), m=2 25 | ) 26 | -------------------------------------------------------------------------------- /test/utils/test_testing.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import warnings 8 | 9 | import torch 10 | from botorch.exceptions.warnings import InputDataWarning 11 | from botorch.models.gp_regression import SingleTaskGP 12 | from botorch.utils.testing import BotorchTestCase, MockModel, MockPosterior 13 | 14 | 15 | class TestMockPosterior(BotorchTestCase): 16 | def test_basic_logic(self) -> None: 17 | mp = MockPosterior() 18 | self.assertEqual(mp.device.type, "cpu") 19 | self.assertEqual(mp.dtype, torch.float32) 20 | self.assertEqual(mp._extended_shape(), torch.Size()) 21 | self.assertEqual( 22 | MockPosterior(variance=torch.rand(2))._extended_shape(), torch.Size([2]) 23 | ) 24 | 25 | def test_passing_tensors(self) -> None: 26 | mean = torch.rand(2) 27 | variance = torch.eye(2) 28 | samples = torch.rand(1, 2) 29 | mp = MockPosterior(mean=mean, variance=variance, samples=samples) 30 | self.assertEqual(mp.device.type, "cpu") 31 | self.assertEqual(mp.dtype, torch.float32) 32 | self.assertTrue(torch.equal(mp.mean, mean)) 33 | self.assertTrue(torch.equal(mp.variance, variance)) 34 | self.assertTrue(torch.all(mp.rsample() == samples.unsqueeze(0))) 35 | self.assertTrue( 36 | torch.all(mp.rsample(torch.Size([2])) == samples.repeat(2, 1, 1)) 37 | ) 38 | 39 | def test_rsample_from_base_samples(self) -> None: 40 | mp = MockPosterior() 41 | with self.assertRaisesRegex( 42 | RuntimeError, "`sample_shape` disagrees with shape of `base_samples`." 43 | ): 44 | mp.rsample_from_base_samples(torch.zeros(2, 2), torch.zeros(3)) 45 | 46 | 47 | class TestMockModel(BotorchTestCase): 48 | def test_basic(self) -> None: 49 | mp = MockPosterior() 50 | mm = MockModel(mp) 51 | X = torch.empty(0) 52 | self.assertEqual(mm.posterior(X), mp) 53 | self.assertEqual(mm.num_outputs, 0) 54 | mm.state_dict() 55 | mm.load_state_dict() 56 | 57 | 58 | class TestMisc(BotorchTestCase): 59 | def test_warning_filtering(self) -> None: 60 | with warnings.catch_warnings(record=True) as ws: 61 | # Model with unstandardized float data, which would typically raise 62 | # multiple warnings. 63 | SingleTaskGP( 64 | train_X=torch.rand(5, 2, dtype=torch.float) * 10, 65 | train_Y=torch.rand(5, 1, dtype=torch.float) * 10, 66 | ) 67 | self.assertFalse(any(w.category == InputDataWarning for w in ws)) 68 | -------------------------------------------------------------------------------- /test_community/__init__.py: -------------------------------------------------------------------------------- 1 | # Copyright (c) Meta Platforms, Inc. and affiliates. 2 | # 3 | # This source code is licensed under the MIT license found in the 4 | # LICENSE file in the root directory of this source tree. 5 | 6 | """ 7 | Unit tests for BoTorch community contributions. 8 | """ 9 | -------------------------------------------------------------------------------- /test_community/acquisition/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/test_community/acquisition/__init__.py -------------------------------------------------------------------------------- /test_community/models/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/test_community/models/__init__.py -------------------------------------------------------------------------------- /test_community/models/test_example.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # Copyright (c) Meta Platforms, Inc. and affiliates. 3 | # 4 | # This source code is licensed under the MIT license found in the 5 | # LICENSE file in the root directory of this source tree. 6 | 7 | import torch 8 | from botorch.utils.testing import BotorchTestCase 9 | from botorch_community.models.example import ExampleModel 10 | from gpytorch.kernels import RBFKernel, ScaleKernel 11 | 12 | 13 | class TestExampleModel(BotorchTestCase): 14 | def test_example_gp(self) -> None: 15 | model = ExampleModel( 16 | train_X=torch.rand(2, 2), 17 | train_Y=torch.rand(2, 1), 18 | ) 19 | self.assertIsInstance(model.covar_module, ScaleKernel) 20 | self.assertIsInstance(model.covar_module.base_kernel, RBFKernel) 21 | -------------------------------------------------------------------------------- /tutorials/README.md: -------------------------------------------------------------------------------- 1 | This folder contains Jupyter tutorial notebooks. These notebooks are also 2 | parsed and embedded into the botorch website. 3 | -------------------------------------------------------------------------------- /tutorials/pretrained_models/mnist_cnn.pt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/tutorials/pretrained_models/mnist_cnn.pt -------------------------------------------------------------------------------- /tutorials/pretrained_models/mnist_vae.pt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/tutorials/pretrained_models/mnist_vae.pt -------------------------------------------------------------------------------- /website/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "scripts": { 3 | "docusaurus": "docusaurus", 4 | "start": "docusaurus start", 5 | "build": "docusaurus build", 6 | "swizzle": "docusaurus swizzle", 7 | "deploy": "docusaurus deploy", 8 | "clear": "docusaurus clear", 9 | "serve": "docusaurus serve", 10 | "write-translations": "docusaurus write-translations", 11 | "write-heading-ids": "docusaurus write-heading-ids" 12 | }, 13 | "devDependencies": { 14 | "@docusaurus/module-type-aliases": "3.6.3", 15 | "@docusaurus/types": "3.6.3" 16 | }, 17 | "dependencies": { 18 | "@docusaurus/core": "^3.6.3", 19 | "@docusaurus/preset-classic": "^3.6.3", 20 | "bl": "^6.0.0", 21 | "clsx": "^1.1.1", 22 | "plotly.js": "^2.8.1", 23 | "react": "^18.3.1", 24 | "react-dom": "^18.3.1", 25 | "react-plotly.js": "^2.5.1", 26 | "rehype-katex": "7", 27 | "remark-math": "6" 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /website/sidebars.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright (c) Meta Platforms, Inc. and affiliates. 3 | * 4 | * This source code is licensed under the MIT license found in the 5 | * LICENSE file in the root directory of this source tree. 6 | */ 7 | 8 | const tutorials = () => { 9 | const allTutorialMetadata = require('./tutorials.json'); 10 | const tutorialsSidebar = [{ 11 | type: 'category', 12 | label: 'Tutorials', 13 | collapsed: false, 14 | items: [ 15 | { 16 | type: 'doc', 17 | id: 'tutorials/index', 18 | label: 'Overview', 19 | }, 20 | ], 21 | },]; 22 | for (var category in allTutorialMetadata) { 23 | const categoryItems = allTutorialMetadata[category]; 24 | const items = []; 25 | categoryItems.map(item => { 26 | items.push({ 27 | type: 'doc', 28 | label: item.title, 29 | id: `tutorials/${item.id}/index`, 30 | }); 31 | }); 32 | 33 | tutorialsSidebar.push({ 34 | type: 'category', 35 | label: category, 36 | items: items, 37 | }); 38 | } 39 | return tutorialsSidebar; 40 | }; 41 | 42 | export default { 43 | "docs": { 44 | "About": ["introduction", "design_philosophy", "botorch_and_ax", "papers"], 45 | "General": ["getting_started"], 46 | "Basic Concepts": ["overview", "models", "posteriors", "acquisition", "optimization"], 47 | "Advanced Topics": ["constraints", "objectives", "batching", "samplers"], 48 | "Multi-Objective Optimization": ["multi_objective"] 49 | }, 50 | tutorials: tutorials(), 51 | } 52 | -------------------------------------------------------------------------------- /website/src/components/CellOutput.jsx: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright (c) Meta Platforms, Inc. and affiliates. 3 | * 4 | * This source code is licensed under the MIT license found in the 5 | * LICENSE file in the root directory of this source tree. 6 | */ 7 | 8 | import React from 'react'; 9 | import CodeBlock from '@theme/CodeBlock'; 10 | 11 | const CellOutput = (props) => { 12 | return ( 13 | 17 | {props.children} 18 | 19 | ) 20 | }; 21 | 22 | export default CellOutput; 23 | -------------------------------------------------------------------------------- /website/src/components/LinkButtons.jsx: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright (c) Meta Platforms, Inc. and affiliates. 3 | * 4 | * This source code is licensed under the MIT license found in the 5 | * LICENSE file in the root directory of this source tree. 6 | */ 7 | 8 | import React from 'react'; 9 | import Link from '@docusaurus/Link'; 10 | import IconExternalLink from '@theme/Icon/ExternalLink' 11 | 12 | const LinkButtons = ({githubUrl, colabUrl}) => { 13 | return ( 14 |
15 | 16 | Open in GitHub 17 | 18 | 19 | 20 | Run in Google Colab 21 | 22 | 23 |
24 | ); 25 | }; 26 | 27 | export default LinkButtons; 28 | -------------------------------------------------------------------------------- /website/src/components/Plotting.jsx: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright (c) Meta Platforms, Inc. and affiliates. 3 | * 4 | * This source code is licensed under the MIT license found in the 5 | * LICENSE file in the root directory of this source tree. 6 | */ 7 | 8 | import React from 'react'; 9 | import Loadable from 'react-loadable'; 10 | 11 | const Plotly = Loadable({ 12 | loader: () => import(`react-plotly.js`), 13 | loading: ({timedOut}) => 14 | timedOut ? ( 15 |
Error: Loading Plotly timed out.
16 | ) : ( 17 |
loading...
18 | ), 19 | timeout: 10000, 20 | }); 21 | 22 | export const PlotlyFigure = React.memo(({data}) => { 23 | return ( 24 |
25 | 26 |
27 | ); 28 | }); 29 | -------------------------------------------------------------------------------- /website/src/css/customTheme.css: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright (c) Meta Platforms, Inc. and affiliates. 3 | * 4 | * This source code is licensed under the MIT license found in the 5 | * LICENSE file in the root directory of this source tree. 6 | */ 7 | 8 | :root{ 9 | --ifm-color-primary-lightest: #F7C38B; 10 | --ifm-color-primary-lighter: #F5AE61; 11 | --ifm-color-primary-light: #F4A653; 12 | --ifm-color-primary: #F29837; 13 | --ifm-color-primary-dark: #F08A1B; 14 | --ifm-color-primary-darker: #ED820F; 15 | --ifm-color-primary-darkest: #C36B0D; 16 | } 17 | -------------------------------------------------------------------------------- /website/static/.nojekyll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/website/static/.nojekyll -------------------------------------------------------------------------------- /website/static/CNAME: -------------------------------------------------------------------------------- 1 | botorch.org 2 | -------------------------------------------------------------------------------- /website/static/css/code_block_buttons.css: -------------------------------------------------------------------------------- 1 | /* "Copy" code block button */ 2 | pre { 3 | position: relative; 4 | } 5 | 6 | pre .btnIcon { 7 | position: absolute; 8 | top: 4px; 9 | z-index: 2; 10 | cursor: pointer; 11 | border: 1px solid transparent; 12 | padding: 0; 13 | color: #000; 14 | background-color: transparent; 15 | height: 30px; 16 | transition: all .25s ease-out; 17 | } 18 | 19 | pre .btnIcon:hover { 20 | text-decoration: none; 21 | } 22 | 23 | .btnIcon__body { 24 | align-items: center; 25 | display: flex; 26 | } 27 | 28 | .btnIcon svg { 29 | fill: currentColor; 30 | margin-right: .4em; 31 | } 32 | 33 | .btnIcon__label { 34 | font-size: 11px; 35 | } 36 | 37 | .btnClipboard { 38 | right: 10px; 39 | } 40 | -------------------------------------------------------------------------------- /website/static/css/custom.css: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright (c) Meta Platforms, Inc. and affiliates. 3 | * 4 | * This source code is licensed under the MIT license found in the 5 | * LICENSE file in the root directory of this source tree. 6 | */ 7 | 8 | /* @import url('https://fonts.googleapis.com/css?family=Montserrat'); 9 | @import url('https://fonts.googleapis.com/css?family=IBM+Plex+Mono'); */ 10 | 11 | :root { 12 | /* --ifm-color-primary-lightest: #283442; 13 | --ifm-color-primary-lighter: #242E3B; 14 | --ifm-color-primary-light: #222C38; */ 15 | --ifm-color-primary: #f15a24; 16 | /* --ifm-color-primary-dark: #1C242E; 17 | --ifm-color-primary-darker: #1A222B; 18 | --ifm-color-primary-darkest: #161C24; */ 19 | } 20 | 21 | .homeContainer .button.button--secondary.button--outline:not(.button--active):not(:hover) { 22 | color: var(--ifm-color-secondary); 23 | } 24 | 25 | .homeContainer { 26 | background: rgb(2, 0, 36); 27 | background: linear-gradient(180deg, 28 | rgba(2, 0, 36, 1), 29 | rgba(34, 34, 34, 1) 0%, 30 | rgba(28, 96, 247, 1) 100%); 31 | padding: 30px 0px; 32 | } 33 | 34 | .header-github-link::before { 35 | content: ''; 36 | width: 24px; 37 | height: 24px; 38 | display: flex; 39 | background-color: var(--ifm-navbar-link-color); 40 | mask-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12'/%3E%3C/svg%3E"); 41 | transition: background-color var(--ifm-transition-fast) var(--ifm-transition-timing-default); 42 | } 43 | 44 | .header-github-link:hover::before { 45 | background-color: var(--ifm-navbar-link-hover-color); 46 | } 47 | -------------------------------------------------------------------------------- /website/static/img/botorch.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/website/static/img/botorch.ico -------------------------------------------------------------------------------- /website/static/img/botorch.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/website/static/img/botorch.png -------------------------------------------------------------------------------- /website/static/img/botorch_logo_lockup.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/website/static/img/botorch_logo_lockup.png -------------------------------------------------------------------------------- /website/static/img/botorch_logo_lockup_top.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/website/static/img/botorch_logo_lockup_top.png -------------------------------------------------------------------------------- /website/static/img/botorch_logo_lockup_white.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/website/static/img/botorch_logo_lockup_white.png -------------------------------------------------------------------------------- /website/static/img/expanding_arrows.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 8 | exp_arrows_grey 9 | 11 | 13 | 15 | 17 | 18 | -------------------------------------------------------------------------------- /website/static/img/oss_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pytorch/botorch/d247a33486c22bc5c6f16107db3e71f1e3bf3acd/website/static/img/oss_logo.png -------------------------------------------------------------------------------- /website/static/img/puzzle_pieces.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 8 | puzze_grey 9 | 13 | 17 | 21 | 22 | -------------------------------------------------------------------------------- /website/static/img/pytorch_logo.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 8 | pytorch_logo 9 | 11 | 13 | 14 | -------------------------------------------------------------------------------- /website/static/js/code_block_buttons.js: -------------------------------------------------------------------------------- 1 | // Turn off ESLint for this file because it's sent down to users as-is. 2 | /* eslint-disable */ 3 | window.addEventListener('load', function() { 4 | function button(label, ariaLabel, icon, className) { 5 | const btn = document.createElement('button'); 6 | btn.classList.add('btnIcon', className); 7 | btn.setAttribute('type', 'button'); 8 | btn.setAttribute('aria-label', ariaLabel); 9 | btn.innerHTML = 10 | '
' + 11 | icon + 12 | '' + 13 | label + 14 | '' + 15 | '
'; 16 | return btn; 17 | } 18 | 19 | function addButtons(codeBlockSelector, btn) { 20 | document.querySelectorAll(codeBlockSelector).forEach(function(code) { 21 | code.parentNode.appendChild(btn.cloneNode(true)); 22 | }); 23 | } 24 | 25 | const copyIcon = 26 | ''; 27 | 28 | addButtons( 29 | '.hljs', 30 | button('Copy', 'Copy code to clipboard', copyIcon, 'btnClipboard'), 31 | ); 32 | 33 | const clipboard = new ClipboardJS('.btnClipboard', { 34 | target: function(trigger) { 35 | return trigger.parentNode.querySelector('code'); 36 | }, 37 | }); 38 | 39 | clipboard.on('success', function(event) { 40 | event.clearSelection(); 41 | const textEl = event.trigger.querySelector('.btnIcon__label'); 42 | textEl.textContent = 'Copied'; 43 | setTimeout(function() { 44 | textEl.textContent = 'Copy'; 45 | }, 2000); 46 | }); 47 | }); 48 | --------------------------------------------------------------------------------