├── .github
└── workflows
│ ├── deploy_docs.yml
│ ├── deploy_pypi.yml
│ └── python_package.yml
├── .gitignore
├── README.md
├── docs
└── sphinx
│ └── manual
│ ├── _static
│ └── logo.png
│ ├── _templates
│ └── versions.html
│ ├── en
│ ├── Makefile
│ └── source
│ │ ├── acknowledgement.rst
│ │ ├── algorithm.rst
│ │ ├── api
│ │ ├── modules.rst
│ │ ├── physbo.blm.basis.fourier.rst
│ │ ├── physbo.blm.basis.rst
│ │ ├── physbo.blm.core.model.rst
│ │ ├── physbo.blm.core.rst
│ │ ├── physbo.blm.inf.exact.rst
│ │ ├── physbo.blm.inf.rst
│ │ ├── physbo.blm.lik.gauss.rst
│ │ ├── physbo.blm.lik.linear.rst
│ │ ├── physbo.blm.lik.rst
│ │ ├── physbo.blm.predictor.rst
│ │ ├── physbo.blm.prior.gauss.rst
│ │ ├── physbo.blm.prior.rst
│ │ ├── physbo.blm.rst
│ │ ├── physbo.gp.core.learning.rst
│ │ ├── physbo.gp.core.model.rst
│ │ ├── physbo.gp.core.prior.rst
│ │ ├── physbo.gp.core.rst
│ │ ├── physbo.gp.cov.gauss.rst
│ │ ├── physbo.gp.cov.rst
│ │ ├── physbo.gp.inf.exact.rst
│ │ ├── physbo.gp.inf.rst
│ │ ├── physbo.gp.lik.gauss.rst
│ │ ├── physbo.gp.lik.rst
│ │ ├── physbo.gp.mean.const.rst
│ │ ├── physbo.gp.mean.rst
│ │ ├── physbo.gp.mean.zero.rst
│ │ ├── physbo.gp.predictor.rst
│ │ ├── physbo.gp.rst
│ │ ├── physbo.misc.centering.rst
│ │ ├── physbo.misc.gauss_elim.rst
│ │ ├── physbo.misc.rst
│ │ ├── physbo.misc.set_config.rst
│ │ ├── physbo.opt.adam.rst
│ │ ├── physbo.opt.rst
│ │ ├── physbo.predictor.rst
│ │ ├── physbo.rst
│ │ ├── physbo.search.discrete.policy.rst
│ │ ├── physbo.search.discrete.results.rst
│ │ ├── physbo.search.discrete.rst
│ │ ├── physbo.search.rst
│ │ ├── physbo.search.score.rst
│ │ ├── physbo.search.utility.rst
│ │ └── physbo.variable.rst
│ │ ├── conf.py
│ │ ├── contact.rst
│ │ ├── index.rst
│ │ ├── install.rst
│ │ ├── introduction.rst
│ │ └── notebook
│ │ ├── data
│ │ └── s5-210.csv
│ │ ├── index.rst
│ │ ├── tutorial_Gaussian_process.ipynb
│ │ ├── tutorial_basic.ipynb
│ │ ├── tutorial_basic_org.ipynb
│ │ ├── tutorial_interactive_mode.ipynb
│ │ ├── tutorial_multi_objective.ipynb
│ │ ├── tutorial_multi_probe.ipynb
│ │ └── tutorial_once_mode.ipynb
│ └── ja
│ ├── Makefile
│ ├── make.bat
│ ├── scan.sh
│ └── source
│ ├── .gitignore
│ ├── acknowledgement.rst
│ ├── algorithm.rst
│ ├── conf.py
│ ├── contact.rst
│ ├── index.rst
│ ├── install.rst
│ ├── introduction.rst
│ └── notebook
│ ├── data
│ └── s5-210.csv
│ ├── index.rst
│ ├── tutorial_Gaussian_process.ipynb
│ ├── tutorial_basic.ipynb
│ ├── tutorial_interactive_mode.ipynb
│ ├── tutorial_multi_objective.ipynb
│ ├── tutorial_multi_probe.ipynb
│ ├── tutorial_once_mode.ipynb
│ └── tutorial_simulator.ipynb
├── examples
├── grain_bound
│ ├── .gitignore
│ ├── data
│ │ └── s5-210.csv
│ ├── tutorial.ipynb
│ ├── tutorial_interactive_mode.ipynb
│ └── tutorial_multi_probe.ipynb
├── multiple.py
├── multiple_score.py
├── sfs.py
├── simple.py
├── simple_score.py
└── simple_time.py
├── make_wheels.sh
├── physbo
├── .gitignore
├── __init__.py
├── blm
│ ├── __init__.py
│ ├── basis
│ │ ├── __init__.py
│ │ └── fourier.py
│ ├── core
│ │ ├── __init__.py
│ │ └── model.py
│ ├── inf
│ │ ├── __init__.py
│ │ └── exact.py
│ ├── lik
│ │ ├── __init__.py
│ │ ├── _src
│ │ │ ├── __init__.py
│ │ │ └── cov.py
│ │ ├── gauss.py
│ │ └── linear.py
│ ├── predictor.py
│ └── prior
│ │ ├── __init__.py
│ │ └── gauss.py
├── gp
│ ├── __init__.py
│ ├── core
│ │ ├── __init__.py
│ │ ├── learning.py
│ │ ├── model.py
│ │ └── prior.py
│ ├── cov
│ │ ├── __init__.py
│ │ ├── _src
│ │ │ ├── __init__.py
│ │ │ └── enhance_gauss.pyx
│ │ └── gauss.py
│ ├── inf
│ │ ├── __init__.py
│ │ └── exact.py
│ ├── lik
│ │ ├── __init__.py
│ │ └── gauss.py
│ ├── mean
│ │ ├── __init__.py
│ │ ├── const.py
│ │ └── zero.py
│ └── predictor.py
├── misc
│ ├── __init__.py
│ ├── _src
│ │ ├── __init__.py
│ │ ├── cholupdate.pyx
│ │ ├── diagAB.pyx
│ │ ├── logsumexp.pyx
│ │ └── traceAB.pyx
│ ├── centering.py
│ ├── gauss_elim.py
│ └── set_config.py
├── opt
│ ├── __init__.py
│ └── adam.py
├── predictor.py
├── search
│ ├── __init__.py
│ ├── discrete
│ │ ├── __init__.py
│ │ ├── policy.py
│ │ └── results.py
│ ├── discrete_multi
│ │ ├── __init__.py
│ │ ├── policy.py
│ │ └── results.py
│ ├── pareto.py
│ ├── score.py
│ ├── score_multi.py
│ └── utility.py
└── variable.py
├── pyproject.toml
├── setup.cfg
├── setup.py
├── tests
├── README.md
├── integrated
│ ├── __init__.py
│ ├── test_gp.py
│ ├── test_interactive_example.py
│ ├── test_multi_objective.py
│ └── test_simple_example.py
└── unit
│ ├── __init__.py
│ ├── test_gp.py
│ ├── test_misc.py
│ ├── test_policy.py
│ ├── test_search.py
│ └── test_variable.py
└── tox.ini
/.github/workflows/deploy_docs.yml:
--------------------------------------------------------------------------------
1 | name: deploy
2 |
3 | on:
4 | push:
5 | branches:
6 | - master
7 | - develop
8 | - '!gh-pages'
9 | - changedocs
10 | tags: '*'
11 |
12 | jobs:
13 | deploy:
14 | runs-on: ubuntu-latest
15 | steps:
16 | - name: Inject slug/short variables
17 | uses: rlespinasse/github-slug-action@v4.x
18 |
19 | - name: Checkout
20 | uses: actions/checkout@v4
21 | with:
22 | path: main
23 | fetch-depth: 0
24 |
25 | - name: Checkout gh-pages
26 | uses: actions/checkout@v4
27 | with:
28 | ref: gh-pages
29 | path: gh-pages
30 |
31 | - name: Set up Python
32 | uses: actions/setup-python@v5
33 | with:
34 | python-version: '3.10'
35 |
36 | - name: Install dependencies
37 | run: |
38 | sudo apt update
39 | sudo apt install pandoc
40 | python -m pip install --upgrade pip setuptools wheel
41 | pip install tox tox-gh-actions
42 |
43 | - name: Build docs with tox
44 | env:
45 | TARGET_NAME: ${{ env.GITHUB_REF_SLUG }}
46 | run: |
47 | cd main
48 | tox run -e docs
49 | cd ../
50 |
51 | - name: Deploy Configuration
52 | run: |
53 | mkdir ~/.ssh
54 | ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts
55 | echo "${{ secrets.GH_ACTIONS_DEPLOY_KEY }}" > ~/.ssh/id_rsa
56 | chmod 400 ~/.ssh/id_rsa
57 |
58 | - name: Push
59 | env:
60 | GIT_USER: "PHYSBO Developers"
61 | GIT_EMAIL: "physbo-dev@issp.u-tokyo.ac.jp"
62 | TARGET_NAME: ${{ env.GITHUB_REF_SLUG }}
63 | run: |
64 | cd ${GITHUB_WORKSPACE}
65 | for lang in ja en; do
66 | rm -rf "gh-pages/manual/${TARGET_NAME}/${lang}"
67 | mkdir -p "gh-pages/manual/${TARGET_NAME}"
68 | cp -r "main/.tox/docs_out/manual/${lang}" "gh-pages/manual/${TARGET_NAME}/"
69 | done
70 | cd gh-pages
71 | git config --local user.name "${GIT_USER}"
72 | git config --local user.email "${GIT_EMAIL}"
73 | git remote set-url origin git@github.com:${GITHUB_REPOSITORY}.git
74 | git add manual
75 | if git commit -m "Deploy docs to ${TARGET_NAME} by GitHub Actions triggered by ${GITHUB_SHA}"
76 | then
77 | git push origin gh-pages
78 | else
79 | echo "Nothing to deploy"
80 | fi
81 |
--------------------------------------------------------------------------------
/.github/workflows/deploy_pypi.yml:
--------------------------------------------------------------------------------
1 | name: Deploy python package to PyPI
2 |
3 | on:
4 | push:
5 | tags: ['*']
6 |
7 | jobs:
8 | deploy:
9 | runs-on: ubuntu-latest
10 | environment:
11 | name: pypi
12 | url: https://pypi.org/p/physbo
13 | permissions:
14 | id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
15 | steps:
16 | - name: Checkout
17 | uses: actions/checkout@v4
18 |
19 | - name: Set up Python
20 | uses: actions/setup-python@v5
21 | with:
22 | python-version: '3.10'
23 |
24 | - name: Install dependencies
25 | run: |
26 | python -m pip install -U pip
27 | python -m pip install build
28 |
29 | - name: Build
30 | run: python -m build --sdist
31 |
32 | - name: Publish
33 | uses: pypa/gh-action-pypi-publish@release/v1
34 | with:
35 | skip-existing: true
36 |
--------------------------------------------------------------------------------
/.github/workflows/python_package.yml:
--------------------------------------------------------------------------------
1 | name: Test python package
2 |
3 | on:
4 | push:
5 | pull_request:
6 | schedule:
7 | - cron: '0 0 1,15 * *' # JST 9:00 AM, 1st and 15th of every month
8 |
9 | jobs:
10 | build:
11 | runs-on: ubuntu-22.04
12 | strategy:
13 | fail-fast: false
14 | max-parallel: 3
15 | matrix:
16 | python-version: ['3.8', '3.9', '3.10', '3.11']
17 |
18 | steps:
19 | - uses: actions/checkout@v4
20 | - name: Set up Python ${{ matrix.python-version }}
21 | uses: actions/setup-python@v5
22 | with:
23 | python-version: ${{ matrix.python-version }}
24 | - name: Install dependencies
25 | run: |
26 | python -m pip install --upgrade pip setuptools wheel
27 | pip install tox tox-gh-actions
28 | - name: Test with tox
29 | run: tox run
30 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # optimization tools for PHYsics based on Bayesian Optimization ( PHYSBO )
2 |
3 | Bayesian optimization has been proven as an effective tool in accelerating scientific discovery.
4 | A standard implementation (e.g., scikit-learn), however, can accommodate only small training data.
5 | PHYSBO is highly scalable due to an efficient protocol that employs Thompson sampling, random feature maps, one-rank Cholesky update and automatic hyperparameter tuning. Technical features are described in [COMBO's document](https://github.com/tsudalab/combo/blob/master/docs/combo_document.pdf) and [PHYSBO's report](https://doi.org/10.1016/j.cpc.2022.108405) (open access).
6 | PHYSBO was developed based on [COMBO](https://github.com/tsudalab/combo) for academic use.
7 |
8 | ## Documentation
9 |
10 | - Stable (master branch)
11 | - [English](https://issp-center-dev.github.io/PHYSBO/manual/master/en/index.html)
12 | - [日本語](https://issp-center-dev.github.io/PHYSBO/manual/master/ja/index.html)
13 | - Latest (develop branch)
14 | - [English](https://issp-center-dev.github.io/PHYSBO/manual/develop/en/index.html)
15 | - [日本語](https://issp-center-dev.github.io/PHYSBO/manual/develop/ja/index.html)
16 |
17 | ## Dependencies
18 |
19 | - Python >= 3.6
20 | - No longer tested with Python 3.6
21 | - NumPy < 2.0.0
22 | - SciPy
23 |
24 | ## Install
25 |
26 | - From PyPI (recommended)
27 |
28 | ```bash
29 | python3 -m pip install physbo
30 | ```
31 |
32 | - From source (for developers)
33 | 1. Update pip (>= 19.0)
34 |
35 | ```bash
36 | python3 -m pip install -U pip
37 | ```
38 |
39 | 1. Download or clone the github repository
40 |
41 | ```
42 | git clone https://github.com/issp-center-dev/PHYSBO
43 | ```
44 |
45 | 1. Install via pip
46 |
47 | ``` bash
48 | # ./PHYSBO is the root directory of PHYSBO
49 | # pip install options such as --user are avaiable
50 |
51 | python3 -m pip install ./PHYSBO
52 | ```
53 |
54 | 1. Note: Do not `import physbo` at the root directory of the repository because `import physbo` does not try to import the installed PHYSBO but one in the repository, which includes Cython codes not compiled.
55 |
56 | ## Uninstall
57 |
58 | ```bash
59 | python3 -m pip uninstall physbo
60 | ```
61 |
62 | ## Usage
63 |
64 | For an introductory tutorial please consult the documentation. ([English](https://issp-center-dev.github.io/PHYSBO/manual/master/en/notebook/tutorial_basic.html) / [日本語](https://issp-center-dev.github.io/PHYSBO/manual/develop/ja/install.html#id2))
65 |
66 | ['examples/simple.py'](./examples/simple.py) is a simple example.
67 |
68 | ## Data repository
69 |
70 | A tutorial and a dataset of a paper about PHYSBO can be found in [PHYSBO Gallery](http://isspns-container.issp.u-tokyo.ac.jp/repo/12).
71 |
72 | ## License
73 |
74 | PHYSBO was developed based on [COMBO](https://github.com/tsudalab/COMBO) for academic use.
75 | PHYSBO v2 is distributed under Mozilla Public License version 2.0 (MPL v2).
76 | We hope that you cite the following reference when you publish the results using PHYSBO:
77 |
78 | [“Bayesian optimization package: PHYSBO”, Yuichi Motoyama, Ryo Tamura, Kazuyoshi Yoshimi, Kei Terayama, Tsuyoshi Ueno, Koji Tsuda, Computer Physics Communications Volume 278, September 2022, 108405.](https://doi.org/10.1016/j.cpc.2022.108405)
79 |
80 | Bibtex
81 |
82 | ```
83 | @misc{@article{MOTOYAMA2022108405,
84 | title = {Bayesian optimization package: PHYSBO},
85 | journal = {Computer Physics Communications},
86 | volume = {278},
87 | pages = {108405},
88 | year = {2022},
89 | issn = {0010-4655},
90 | doi = {https://doi.org/10.1016/j.cpc.2022.108405},
91 | author = {Yuichi Motoyama and Ryo Tamura and Kazuyoshi Yoshimi and Kei Terayama and Tsuyoshi Ueno and Koji Tsuda},
92 | keywords = {Bayesian optimization, Multi-objective optimization, Materials screening, Effective model estimation}
93 | }
94 | ```
95 |
96 | ### Copyright
97 |
98 | © *2020- The University of Tokyo. All rights reserved.*
99 | This software was developed with the support of \"*Project for advancement of software usability in materials science*\" of The Institute for Solid State Physics, The University of Tokyo.
100 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/_static/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/issp-center-dev/PHYSBO/79ce6a2c012ae2e5a3384a295c381564feec1acd/docs/sphinx/manual/_static/logo.png
--------------------------------------------------------------------------------
/docs/sphinx/manual/_templates/versions.html:
--------------------------------------------------------------------------------
1 | {# The original version of this file is a part of sphinx_rtd_theme v0.5.0, which is distributed under the MIT license #}
2 | {# https://github.com/readthedocs/sphinx_rtd_theme #}
3 |
4 | {# Add rst-badge after rst-versions for small badge style. #}
5 | {% if ENABLE_VERSIONING == "true" %}
6 |
7 |
8 | Read the Docs
9 | v: {{ current_version }}
10 |
11 |
12 |
13 |
14 | - {{ _('Languages') }}
15 | {% for lang in languages %}
16 | {% set root_dir = pathto("../..", 1)%}
17 | -
18 | {% if lang == current_lang %}{% endif %}
19 | {{ lang }}
20 | {% if lang == current_lang %}{% endif %}
21 |
22 | {% endfor %}
23 |
24 | - {{ _('Branches') }}
25 | {% for name in branches %}
26 | {% set root_dir = pathto("../..", 1)%}
27 | -
28 | {% if name == current_version %}{% endif %}
29 | {{ name }}
30 | {% if name == current_version %}{% endif %}
31 |
32 | {% endfor %}
33 |
34 | - {{ _('Tags') }}
35 | {% for name in tags %}
36 | {% set root_dir = pathto("../..", 1)%}
37 | -
38 | {% if name == current_version %}{% endif %}
39 | {{ name }}
40 | {% if name == current_version %}{% endif %}
41 |
42 | {% endfor %}
43 |
44 |
45 |
46 |
47 | {% endif %} {# endif ENABLE_VERSIONING #}
48 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/Makefile:
--------------------------------------------------------------------------------
1 | # Minimal makefile for Sphinx documentation
2 | #
3 |
4 | # You can set these variables from the command line.
5 | SPHINXOPTS =
6 | SPHINXBUILD = python -msphinx
7 | SPHINXPROJ = pyMC
8 | SOURCEDIR = source
9 | BUILDDIR = build
10 |
11 | # Put it first so that "make" without argument is like "make help".
12 | help:
13 | @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
14 |
15 | .PHONY: help Makefile
16 |
17 | # Catch-all target: route all unknown targets to Sphinx using the new
18 | # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
19 | %: Makefile
20 | sh ./scan.sh
21 | @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) -t "tag-$@"
22 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/acknowledgement.rst:
--------------------------------------------------------------------------------
1 | ***************************
2 | Acknowledgement
3 | ***************************
4 | We would like to thank the support from “Project for advancement of software usability in materials science” by The Institute for Solid State Physics, The University of Tokyo, for development of PHYSBO.
5 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/modules.rst:
--------------------------------------------------------------------------------
1 | physbo
2 | ======
3 |
4 | .. toctree::
5 | :maxdepth: 4
6 |
7 | physbo
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.basis.fourier.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.basis.fourier module
2 | ===============================
3 |
4 | .. automodule:: physbo.blm.basis.fourier
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.basis.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.basis package
2 | ========================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.blm.basis.fourier
11 |
12 | Module contents
13 | ---------------
14 |
15 | .. automodule:: physbo.blm.basis
16 | :members:
17 | :undoc-members:
18 | :show-inheritance:
19 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.core.model.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.core.model module
2 | ============================
3 |
4 | .. automodule:: physbo.blm.core.model
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.core.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.core package
2 | =======================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.blm.core.model
11 |
12 | Module contents
13 | ---------------
14 |
15 | .. automodule:: physbo.blm.core
16 | :members:
17 | :undoc-members:
18 | :show-inheritance:
19 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.inf.exact.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.inf.exact module
2 | ===========================
3 |
4 | .. automodule:: physbo.blm.inf.exact
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.inf.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.inf package
2 | ======================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.blm.inf.exact
11 |
12 | Module contents
13 | ---------------
14 |
15 | .. automodule:: physbo.blm.inf
16 | :members:
17 | :undoc-members:
18 | :show-inheritance:
19 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.lik.gauss.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.lik.gauss module
2 | ===========================
3 |
4 | .. automodule:: physbo.blm.lik.gauss
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.lik.linear.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.lik.linear module
2 | ============================
3 |
4 | .. automodule:: physbo.blm.lik.linear
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.lik.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.lik package
2 | ======================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.blm.lik.gauss
11 | physbo.blm.lik.linear
12 |
13 | Module contents
14 | ---------------
15 |
16 | .. automodule:: physbo.blm.lik
17 | :members:
18 | :undoc-members:
19 | :show-inheritance:
20 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.predictor.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.predictor module
2 | ===========================
3 |
4 | .. automodule:: physbo.blm.predictor
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.prior.gauss.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.prior.gauss module
2 | =============================
3 |
4 | .. automodule:: physbo.blm.prior.gauss
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.prior.rst:
--------------------------------------------------------------------------------
1 | physbo.blm.prior package
2 | ========================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.blm.prior.gauss
11 |
12 | Module contents
13 | ---------------
14 |
15 | .. automodule:: physbo.blm.prior
16 | :members:
17 | :undoc-members:
18 | :show-inheritance:
19 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.blm.rst:
--------------------------------------------------------------------------------
1 | physbo.blm package
2 | ==================
3 |
4 | Subpackages
5 | -----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.blm.basis
11 | physbo.blm.core
12 | physbo.blm.inf
13 | physbo.blm.lik
14 | physbo.blm.prior
15 |
16 | Submodules
17 | ----------
18 |
19 | .. toctree::
20 | :maxdepth: 4
21 |
22 | physbo.blm.predictor
23 |
24 | Module contents
25 | ---------------
26 |
27 | .. automodule:: physbo.blm
28 | :members:
29 | :undoc-members:
30 | :show-inheritance:
31 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.core.learning.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.core.learning module
2 | ==============================
3 |
4 | .. automodule:: physbo.gp.core.learning
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.core.model.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.core.model module
2 | ===========================
3 |
4 | .. automodule:: physbo.gp.core.model
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.core.prior.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.core.prior module
2 | ===========================
3 |
4 | .. automodule:: physbo.gp.core.prior
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.core.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.core package
2 | ======================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.gp.core.learning
11 | physbo.gp.core.model
12 | physbo.gp.core.prior
13 |
14 | Module contents
15 | ---------------
16 |
17 | .. automodule:: physbo.gp.core
18 | :members:
19 | :undoc-members:
20 | :show-inheritance:
21 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.cov.gauss.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.cov.gauss module
2 | ==========================
3 |
4 | .. automodule:: physbo.gp.cov.gauss
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.cov.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.cov package
2 | =====================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.gp.cov.gauss
11 |
12 | Module contents
13 | ---------------
14 |
15 | .. automodule:: physbo.gp.cov
16 | :members:
17 | :undoc-members:
18 | :show-inheritance:
19 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.inf.exact.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.inf.exact module
2 | ==========================
3 |
4 | .. automodule:: physbo.gp.inf.exact
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.inf.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.inf package
2 | =====================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.gp.inf.exact
11 |
12 | Module contents
13 | ---------------
14 |
15 | .. automodule:: physbo.gp.inf
16 | :members:
17 | :undoc-members:
18 | :show-inheritance:
19 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.lik.gauss.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.lik.gauss module
2 | ==========================
3 |
4 | .. automodule:: physbo.gp.lik.gauss
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.lik.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.lik package
2 | =====================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.gp.lik.gauss
11 |
12 | Module contents
13 | ---------------
14 |
15 | .. automodule:: physbo.gp.lik
16 | :members:
17 | :undoc-members:
18 | :show-inheritance:
19 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.mean.const.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.mean.const module
2 | ===========================
3 |
4 | .. automodule:: physbo.gp.mean.const
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.mean.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.mean package
2 | ======================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.gp.mean.const
11 | physbo.gp.mean.zero
12 |
13 | Module contents
14 | ---------------
15 |
16 | .. automodule:: physbo.gp.mean
17 | :members:
18 | :undoc-members:
19 | :show-inheritance:
20 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.mean.zero.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.mean.zero module
2 | ==========================
3 |
4 | .. automodule:: physbo.gp.mean.zero
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.predictor.rst:
--------------------------------------------------------------------------------
1 | physbo.gp.predictor module
2 | ==========================
3 |
4 | .. automodule:: physbo.gp.predictor
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.gp.rst:
--------------------------------------------------------------------------------
1 | physbo.gp package
2 | =================
3 |
4 | Subpackages
5 | -----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.gp.core
11 | physbo.gp.cov
12 | physbo.gp.inf
13 | physbo.gp.lik
14 | physbo.gp.mean
15 |
16 | Submodules
17 | ----------
18 |
19 | .. toctree::
20 | :maxdepth: 4
21 |
22 | physbo.gp.predictor
23 |
24 | Module contents
25 | ---------------
26 |
27 | .. automodule:: physbo.gp
28 | :members:
29 | :undoc-members:
30 | :show-inheritance:
31 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.misc.centering.rst:
--------------------------------------------------------------------------------
1 | physbo.misc.centering module
2 | ============================
3 |
4 | .. automodule:: physbo.misc.centering
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.misc.gauss_elim.rst:
--------------------------------------------------------------------------------
1 | physbo.misc.gauss\_elim module
2 | ==============================
3 |
4 | .. automodule:: physbo.misc.gauss_elim
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.misc.rst:
--------------------------------------------------------------------------------
1 | physbo.misc package
2 | ===================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.misc.centering
11 | physbo.misc.gauss_elim
12 | physbo.misc.set_config
13 |
14 | Module contents
15 | ---------------
16 |
17 | .. automodule:: physbo.misc
18 | :members:
19 | :undoc-members:
20 | :show-inheritance:
21 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.misc.set_config.rst:
--------------------------------------------------------------------------------
1 | physbo.misc.set\_config module
2 | ==============================
3 |
4 | .. automodule:: physbo.misc.set_config
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.opt.adam.rst:
--------------------------------------------------------------------------------
1 | physbo.opt.adam module
2 | ======================
3 |
4 | .. automodule:: physbo.opt.adam
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.opt.rst:
--------------------------------------------------------------------------------
1 | physbo.opt package
2 | ==================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.opt.adam
11 |
12 | Module contents
13 | ---------------
14 |
15 | .. automodule:: physbo.opt
16 | :members:
17 | :undoc-members:
18 | :show-inheritance:
19 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.predictor.rst:
--------------------------------------------------------------------------------
1 | physbo.predictor module
2 | =======================
3 |
4 | .. automodule:: physbo.predictor
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.rst:
--------------------------------------------------------------------------------
1 | physbo package
2 | ==============
3 |
4 | Subpackages
5 | -----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.blm
11 | physbo.gp
12 | physbo.misc
13 | physbo.opt
14 | physbo.search
15 |
16 | Submodules
17 | ----------
18 |
19 | .. toctree::
20 | :maxdepth: 4
21 |
22 | physbo.predictor
23 | physbo.variable
24 |
25 | Module contents
26 | ---------------
27 |
28 | .. automodule:: physbo
29 | :members:
30 | :undoc-members:
31 | :show-inheritance:
32 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.search.discrete.policy.rst:
--------------------------------------------------------------------------------
1 | physbo.search.discrete.policy module
2 | ====================================
3 |
4 | .. automodule:: physbo.search.discrete.policy
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.search.discrete.results.rst:
--------------------------------------------------------------------------------
1 | physbo.search.discrete.results module
2 | =====================================
3 |
4 | .. automodule:: physbo.search.discrete.results
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.search.discrete.rst:
--------------------------------------------------------------------------------
1 | physbo.search.discrete package
2 | ==============================
3 |
4 | Submodules
5 | ----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.search.discrete.policy
11 | physbo.search.discrete.results
12 |
13 | Module contents
14 | ---------------
15 |
16 | .. automodule:: physbo.search.discrete
17 | :members:
18 | :undoc-members:
19 | :show-inheritance:
20 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.search.rst:
--------------------------------------------------------------------------------
1 | physbo.search package
2 | =====================
3 |
4 | Subpackages
5 | -----------
6 |
7 | .. toctree::
8 | :maxdepth: 4
9 |
10 | physbo.search.discrete
11 | physbo.search.discrete_multi
12 |
13 | Submodules
14 | ----------
15 |
16 | .. toctree::
17 | :maxdepth: 4
18 |
19 | physbo.search.pareto
20 | physbo.search.score
21 | physbo.search.score_multi
22 | physbo.search.utility
23 |
24 | Module contents
25 | ---------------
26 |
27 | .. automodule:: physbo.search
28 | :members:
29 | :undoc-members:
30 | :show-inheritance:
31 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.search.score.rst:
--------------------------------------------------------------------------------
1 | physbo.search.score module
2 | ==========================
3 |
4 | .. automodule:: physbo.search.score
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.search.utility.rst:
--------------------------------------------------------------------------------
1 | physbo.search.utility module
2 | ============================
3 |
4 | .. automodule:: physbo.search.utility
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/api/physbo.variable.rst:
--------------------------------------------------------------------------------
1 | physbo.variable module
2 | ======================
3 |
4 | .. automodule:: physbo.variable
5 | :members:
6 | :undoc-members:
7 | :show-inheritance:
8 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/contact.rst:
--------------------------------------------------------------------------------
1 | Contact
2 | =========================================
3 |
4 | - Bug Reports
5 |
6 | Please report all problems and bugs on the github `Issues `_ page.
7 |
8 | To resolve bugs early, follow these guidelines when reporting:
9 |
10 | 1. Please specify the version of PHYSBO you are using.
11 |
12 | 2. If there are problems for installation, please inform us about your operating system and the compiler.
13 |
14 | 3. If a problem occurs during execution, enter the input file used for execution and its output.
15 |
16 | Thank you for your cooperation.
17 |
18 | - Others
19 |
20 | If you have any questions about your research that are difficult to consult at Issues on GitHub, please send an e-mail to the following address:
21 |
22 | E-mail: ``physbo-dev__at__issp.u-tokyo.ac.jp`` (replace _at_ by @)
23 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/index.rst:
--------------------------------------------------------------------------------
1 | .. PHYSBO documentation master file, created by
2 | sphinx-quickstart on Tue May 26 18:44:52 2020.
3 | You can adapt this file completely to your liking, but it should at least
4 | contain the root `toctree` directive.
5 |
6 | Welcome to PHYSBO's documentation!
7 | ==================================
8 |
9 | .. toctree::
10 | :maxdepth: 2
11 | :caption: Contents:
12 |
13 | introduction
14 | install
15 | notebook/index
16 | algorithm
17 | API Reference
18 | acknowledgement
19 | contact
20 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/install.rst:
--------------------------------------------------------------------------------
1 | Basic usage
2 | =====================
3 |
4 | Install
5 | ---------------------
6 |
7 | Required Packages
8 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 |
10 | * Python >= 3.6
11 | * numpy < 2.0.0
12 | * scipy
13 |
14 | Download and Install
15 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
16 |
17 | - From ``PyPI`` (recommended) ::
18 |
19 | $ pip3 install physbo
20 |
21 | - Required packages such as NumPy will also be installed at the same time.
22 |
23 | - If you add the ``--user`` option, it will be installed under the user's home directory ::
24 |
25 | $ pip3 install --user physbo
26 |
27 |
28 | - From source (for developers)
29 |
30 | #. Download or clone the github repository
31 |
32 | $ git clone https://github.com/issp-center-dev/PHYSBO
33 |
34 | #. Update ``pip`` to 19.0 or higher ::
35 |
36 | $ pip3 install -U pip
37 |
38 | - If you don't have ``pip3``, you can install it with ``python3 -m ensurepip``.
39 |
40 | #. Install ::
41 |
42 | $ cd PHYSBO
43 | $ pip3 install --user ./
44 |
45 | Uninstall
46 | ~~~~~~~~~~~~~~~~~~~~~~~~
47 |
48 | #. Execute the following command. ::
49 |
50 | $ pip uninstall physbo
51 |
52 |
53 | Basic structures
54 | --------------------------
55 |
56 | PHYSBO has the following structure (shown up to the second level).
57 |
58 | ..
59 | |--physbo
60 | | |--blm
61 | | |--gp
62 | | |--misc
63 | | |--opt
64 | | |--search
65 | | |--predictor.py
66 | | |--variable.py
67 |
68 | Each module is created with the following structure.
69 |
70 | - ``blm`` :Module for Baysean linear model
71 | - ``gp`` :Module for Gaussian Process
72 | - ``opt`` :Module for optimazation
73 | - ``search`` :Module for searching for optimal solutions
74 | - ``predictor.py`` :Abstract class for predictors
75 | - ``variable.py`` :Class defined for variable associations used in physbo
76 | - ``misc`` : Others (e.g., modules for normalizing the search space)
77 |
78 | For more information about each module, please refer to the API reference.
79 |
80 | Calculation flow
81 | --------------------------
82 |
83 | Bayesian optimization is well suited for optimization problems such as complex simulations or real-world experimental tasks where the objective function is very costly to evaluate.
84 | In PHYSBO, the following steps are used to perform the optimization (please refer to the tutorial and API reference for details on each).
85 |
86 | 1. Defining the search space
87 |
88 | Define each parameter set (d-dimensional vector) as a search candidate, where N: the number of search candidates , d: the number of input parameter dimensions. The parameter set should list all the candidates.
89 |
90 | 2. Defining the simulator
91 |
92 | For searching candidates defined above, define a simulator that gives the objective function values (values to be optimized, such as material property values) for each search candidate. In PHYSBO, the direction of optimization is to maximize the objective function, so if you want to minimize the objective function, you can do so by applying a negative value to the value returned by the simulator.
93 |
94 | 3. Performing optimization
95 |
96 | First, set the optimization policy (the search space is passed to policy as an argument at this stage). You can choose between the following two optimization methods.
97 |
98 | - ``random_search``
99 | - ``bayes_search``
100 |
101 | In ``random_search``, we randomly select parameters from the search space and search for the largest objective function among them. It is used to prepare an initial set of parameters as a preprocessing step for Bayesian optimization. ``bayes_search`` performs Bayesian optimization. The type of score (acquisition function) in Bayesian optimization can be one of the following.
102 |
103 | - TS (Thompson Sampling): Sample one regression function from the posterior probability distribution of the learned Gaussian process, and select the point where the predicetd value becomes maximum as a next candidate.
104 | - EI (Expected Improvement): Select the point where the expected value of the difference between the predicted value by the Gaussian process and the maximum value in the current situation becomes the maximum as a next candidate.
105 | - PI (Probability of Improvement): Select the point with the highest probability of exceeding the current maximum of the current acquisition function as a next candidate.
106 |
107 | Details of Gaussian processes are described in :ref:`chap_algorithm` . For other details of each method, please see `this reference `_ .
108 | If you specify the simulator and the number of search steps in these methods, the following loop will rotate by the number of search steps.
109 |
110 | i). Select the next parameter to be executed from the list of candidate parameters.
111 |
112 | ii). Run the simulator with the selected parameters.
113 |
114 | The number of parameter returned in i) is one by default, but it is possible to return multiple parameters in one step. For more details, please refer to the "Exploring multiple candidates at once" section of the tutorial. Also, instead of running the above loop inside PHYSBO, it is possible to control i) and ii) separately from the outside. In other words, it is possible to propose the next parameter to be executed from PHYSBO, evaluate its objective function value in some way outside PHYSBO (e.g., by experiment rather than numerical calculation), and register the evaluated value in PHYSBO. For more details, please refer to the "Running Interactively" section of the tutorial.
115 |
116 | 4. Check numerical results
117 |
118 | The search result ``res`` is returned as an object of the ``history`` class ( ``physbo.search.discrete.results.history`` ). The following is a reference to the search results.
119 |
120 | - ``res.fx``: The logs of evaluation values for simulator (objective function) simulator.
121 | - ``res.chosen_actions``: The logs of the action ID (parameter) when the simulator has executed.
122 | - ``fbest, best_action= res.export_all_sequence_best_fx()``: The logs of the best values and their action IDs (parameters) at each step where the simulator has executed.
123 | - ``res.total_num_search``: Total number steps where the simulator has executed.
124 |
125 | The search results can be saved to an external file using the ``save`` method, and the output results can be loaded using the ``load`` method. See the tutorial for details on how to use it.
126 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/introduction.rst:
--------------------------------------------------------------------------------
1 | Introduction
2 | =====================
3 |
4 | About PHYSBO
5 | ----------------------
6 |
7 | PHYSBO (optimization tools for PHYSics based on Bayesian Optimization) is a Python library for fast and scalable Bayesian optimization. It is based on COMBO (Common Bayesian Optimization) and has been developed mainly for researchers in the materials science field. There are many attempts to accelerate scientific discovery through data-driven design-of-experiment algorithms in the fields of physics, chemistry, and materials. Bayesian optimization is an effective tool for accelerating these scientific discoveries. Bayesian optimization is a technique that can be used for complex simulations and real-world experimental tasks where the evaluation of objective function values (e.g., characteristic values) is very costly. In other words, the problem solved by Bayesian optimization is to find a parameter (e.g., material composition, structure, process and simulation parameters) with a better objective function value (e.g., material properties) in as few experiments and simulations as possible. In Bayesian optimization, the candidate parameters to be searched for are listed in advance, and the candidate with the largest objective function value is selected from among the candidates by making good use of machine learning (using Gaussian process regression) prediction. Experiments and simulations are performed on the candidates and the objective function values are evaluated. By repeating the process of selection by machine learning and evaluation by experimental simulation, we can reduce the number of times of optimization. On the other hand, Bayesian optimization is generally computationally expensive, and standard implementations such as scikit-learn are difficult to handle a large amount of data. PHYSBO achieves high scalability due to the following features
8 |
9 | - Thompson Sampling
10 | - random feature map
11 | - one-rank Cholesky update
12 | - automatic hyperparameter tuning
13 |
14 | Please see `this reference `_ for technical details.
15 |
16 | Citation
17 | ----------------------
18 |
19 | When citing PHYSBO, please cite the following reference:
20 |
21 | Yuichi Motoyama, Ryo Tamura, Kazuyoshi Yoshimi, Kei Terayama, Tsuyoshi Ueno, Koji Tsuda,
22 | Bayesian optimization package: PHYSBO,
23 | Computer Physics Communications Volume 278, September 2022, 108405. Available from https://www.sciencedirect.com/science/article/pii/S0010465522001242?via%3Dihub (open access).
24 |
25 | Bibtex is given as follows: ::
26 |
27 | @misc{@article{MOTOYAMA2022108405,
28 | title = {Bayesian optimization package: PHYSBO},
29 | journal = {Computer Physics Communications},
30 | volume = {278},
31 | pages = {108405},
32 | year = {2022},
33 | issn = {0010-4655},
34 | doi = {https://doi.org/10.1016/j.cpc.2022.108405},
35 | author = {Yuichi Motoyama and Ryo Tamura and Kazuyoshi Yoshimi and Kei Terayama and Tsuyoshi Ueno and Koji Tsuda},
36 | keywords = {Bayesian optimization, Multi-objective optimization, Materials screening, Effective model estimation}
37 | }
38 |
39 | Main Developers
40 | ----------------------
41 |
42 | - ver. 1.0-
43 |
44 | - Ryo Tamura (International Center for Materials Nanoarchitectonics, National Institute for Materials Science)
45 | - Tsuyoshi Ueno (Magne-Max Capital Management Company)
46 | - Kei Terayama (Graduate School of Medical Life Science, Yokohama City University)
47 | - Koji Tsuda (Graduate School of Frontier Sciences, The University of Tokyo)
48 | - Yuichi Motoyama (The Institute for Solid State Physics, The University of Tokyo)
49 | - Kazuyoshi Yoshimi (The Institute for Solid State Physics, The University of Tokyo)
50 | - Naoki Kawashima (The Institute for Solid State Physics, The University of Tokyo)
51 |
52 | License
53 | ----------------------
54 |
55 | PHYSBO v2 is distributed under `the Mozilla Public License version 2.0 (MPL v2) `_.
56 |
57 | Copyright (c) <2020-> The University of Tokyo. All rights reserved.
58 |
59 | Part of this software is developed under the support of "Project for advancement of software usability in materials science" by The Institute for Solid State Physics, The University of Tokyo.
60 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/notebook/index.rst:
--------------------------------------------------------------------------------
1 | Tutorials
2 | ==================================
3 | Here, the usage of PHYSBO is introduced through tutorials.
4 |
5 | .. toctree::
6 | :maxdepth: 2
7 | :caption: Contents:
8 |
9 | tutorial_basic
10 | tutorial_Gaussian_process
11 | tutorial_interactive_mode
12 | tutorial_once_mode
13 | tutorial_multi_probe
14 | tutorial_multi_objective
15 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/en/source/notebook/tutorial_once_mode.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Restart calculations by reading existing calculation results\n",
8 | "\n",
9 | "You can read existing action IDs (parameters) and their evaluation values and run PHYSBO in the following flow. \n",
10 | "\n",
11 | "1. Load an external file and read the existing action IDs (parameters) and their evaluation values. \n",
12 | "2. Register the action ID (parameter) and evaluation value to PHYSBO. \n",
13 | "3. Get the parameters for the next execution from PHYSBO.\n",
14 | "\n",
15 | "This can be used in cases where PHYSBO cannot be left open for a long time due to time constraints, and thus cannot be executed interactively.\n",
16 | "\n",
17 | "## Prepare the search candidate data\n",
18 | "\n",
19 | "As the previous tutorials, save the dataset file [s5-210.csv](https://raw.githubusercontent.com/issp-center-dev/PHYSBO/master/examples/grain_bound/data/s5-210.csv) into the subdirectory `data`, and load dataset from this file as the following:"
20 | ]
21 | },
22 | {
23 | "cell_type": "code",
24 | "execution_count": 2,
25 | "metadata": {
26 | "ExecuteTime": {
27 | "end_time": "2020-12-04T06:17:28.657314Z",
28 | "start_time": "2020-12-04T06:17:27.967614Z"
29 | }
30 | },
31 | "outputs": [],
32 | "source": [
33 | "import physbo\n",
34 | "\n",
35 | "import numpy as np\n",
36 | "\n",
37 | "\n",
38 | "def load_data():\n",
39 | " A = np.asarray(np.loadtxt('data/s5-210.csv',skiprows=1, delimiter=',') )\n",
40 | " X = A[:,0:3]\n",
41 | " t = -A[:,3]\n",
42 | " return X, t\n",
43 | "\n",
44 | "X, t = load_data()\n",
45 | "X = physbo.misc.centering(X)"
46 | ]
47 | },
48 | {
49 | "cell_type": "markdown",
50 | "metadata": {},
51 | "source": [
52 | "## Preparing the precomputed data\n",
53 | "\n",
54 | "In the `load_data` function above, all X and t are stored. Here, as precomputed, we get a random list of 20 actoin IDs and their evaluation values."
55 | ]
56 | },
57 | {
58 | "cell_type": "code",
59 | "execution_count": 4,
60 | "metadata": {},
61 | "outputs": [
62 | {
63 | "name": "stdout",
64 | "output_type": "stream",
65 | "text": [
66 | "[12623, 13781, 1326, 8484, 16753, 15922, 13268, 9938, 15617, 11732, 7157, 16537, 4563, 9235, 4579, 3107, 8208, 17451, 4815, 10162]\n"
67 | ]
68 | }
69 | ],
70 | "source": [
71 | "import random\n",
72 | "random.seed(0)\n",
73 | "calculated_ids = random.sample(range(t.size), 20)\n",
74 | "print(calculated_ids)\n",
75 | "t_initial = t[calculated_ids]"
76 | ]
77 | },
78 | {
79 | "cell_type": "markdown",
80 | "metadata": {},
81 | "source": [
82 | "## Register action ID (parameter) and evaluation value to PHYSBO.\n",
83 | "\n",
84 | "Register `calculated_ids` and `t[calculated_ids]` as a list in the initial variable `initial_data` of policy."
85 | ]
86 | },
87 | {
88 | "cell_type": "code",
89 | "execution_count": 5,
90 | "metadata": {},
91 | "outputs": [],
92 | "source": [
93 | "# set policy \n",
94 | "policy = physbo.search.discrete.policy(test_X=X, initial_data=[calculated_ids, t_initial])\n",
95 | "\n",
96 | "# set seed \n",
97 | "policy.set_seed( 0 )"
98 | ]
99 | },
100 | {
101 | "cell_type": "markdown",
102 | "metadata": {},
103 | "source": [
104 | "## Get the next parameter to be executed from PHYSBO\n",
105 | "\n",
106 | "Perform Bayesian optimization to obtain the next candidate point."
107 | ]
108 | },
109 | {
110 | "cell_type": "code",
111 | "execution_count": 6,
112 | "metadata": {
113 | "ExecuteTime": {
114 | "end_time": "2020-12-04T06:17:28.674407Z",
115 | "start_time": "2020-12-04T06:17:28.669875Z"
116 | }
117 | },
118 | "outputs": [
119 | {
120 | "name": "stdout",
121 | "output_type": "stream",
122 | "text": [
123 | "Start the initial hyper parameter searching ...\n",
124 | "Done\n",
125 | "\n",
126 | "Start the hyper parameter learning ...\n",
127 | "0 -th epoch marginal likelihood -20.09302189053099\n",
128 | "50 -th epoch marginal likelihood -23.11964735598211\n",
129 | "100 -th epoch marginal likelihood -24.83020118385076\n",
130 | "150 -th epoch marginal likelihood -25.817906570042602\n",
131 | "200 -th epoch marginal likelihood -26.42342027124426\n",
132 | "250 -th epoch marginal likelihood -26.822598600211865\n",
133 | "300 -th epoch marginal likelihood -27.10872736571494\n",
134 | "350 -th epoch marginal likelihood -27.331572599126865\n",
135 | "400 -th epoch marginal likelihood -27.517235815448124\n",
136 | "450 -th epoch marginal likelihood -27.67892333553869\n",
137 | "500 -th epoch marginal likelihood -27.82299469827059\n",
138 | "Done\n",
139 | "\n",
140 | "[73] [[-1.6680279 -1.46385011 1.68585446]]\n"
141 | ]
142 | }
143 | ],
144 | "source": [
145 | "actions = policy.bayes_search(max_num_probes=1, simulator=None, score=\"TS\", interval=0, num_rand_basis = 5000)\n",
146 | "print(actions, X[actions])"
147 | ]
148 | },
149 | {
150 | "cell_type": "markdown",
151 | "metadata": {},
152 | "source": [
153 | "Perform external calculations on the obtained candidate points, and register the actions and their scores in a file. The process of reading the file again, running the Bayesian optimization, and obtaining the next candidate point is repeated to advance the Bayesian optimization."
154 | ]
155 | }
156 | ],
157 | "metadata": {
158 | "kernelspec": {
159 | "display_name": "Python 3",
160 | "language": "python",
161 | "name": "python3"
162 | },
163 | "language_info": {
164 | "codemirror_mode": {
165 | "name": "ipython",
166 | "version": 3
167 | },
168 | "file_extension": ".py",
169 | "mimetype": "text/x-python",
170 | "name": "python",
171 | "nbconvert_exporter": "python",
172 | "pygments_lexer": "ipython3",
173 | "version": "3.8.5"
174 | }
175 | },
176 | "nbformat": 4,
177 | "nbformat_minor": 1
178 | }
179 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/Makefile:
--------------------------------------------------------------------------------
1 | # Minimal makefile for Sphinx documentation
2 | #
3 |
4 | # You can set these variables from the command line, and also
5 | # from the environment for the first two.
6 | SPHINXOPTS ?=
7 | SPHINXBUILD ?= sphinx-build
8 | SOURCEDIR = source
9 | BUILDDIR = build
10 |
11 | # Put it first so that "make" without argument is like "make help".
12 | help:
13 | @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
14 |
15 | .PHONY: help Makefile
16 |
17 | # Catch-all target: route all unknown targets to Sphinx using the new
18 | # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
19 | %: Makefile
20 | sh ./scan.sh
21 | @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" -t "tag-$@" $(SPHINXOPTS) $(O)
22 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/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% %O%
29 | goto end
30 |
31 | :help
32 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
33 |
34 | :end
35 | popd
36 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/scan.sh:
--------------------------------------------------------------------------------
1 | rm -rf source/api
2 | rm -rf build/doctrees
3 | sphinx-apidoc -f -e -o source/api ../../../../physbo
4 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/source/.gitignore:
--------------------------------------------------------------------------------
1 | api
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/source/acknowledgement.rst:
--------------------------------------------------------------------------------
1 | ***************************
2 | 謝辞
3 | ***************************
4 | PHYSBOは東京大学物性研究所 ソフトウェア高度化プロジェクト (2020 年度) の支援を受け開発されました。この場を借りて感謝します。
5 |
6 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/source/conf.py:
--------------------------------------------------------------------------------
1 | # Configuration file for the Sphinx documentation builder.
2 | #
3 | # This file only contains a selection of the most common options. For a full
4 | # list see the documentation:
5 | # https://www.sphinx-doc.org/en/master/usage/configuration.html
6 |
7 | # -- Path setup --------------------------------------------------------------
8 |
9 | # If extensions (or modules to document with autodoc) are in another directory,
10 | # add these directories to sys.path here. If the directory is relative to the
11 | # documentation root, use os.path.abspath to make it absolute, like shown here.
12 | #
13 | # import os
14 | # import sys
15 | # sys.path.insert(0, os.path.abspath('.'))
16 |
17 | import sys
18 | import os
19 |
20 | sys.path.insert(0, os.path.abspath("../../../../../physbo"))
21 |
22 | # -- Project information -----------------------------------------------------
23 |
24 | project = "PHYSBO"
25 | copyright = "2020-, PHYSBO developers"
26 | author = "PHYSBO developers"
27 |
28 | # The short X.Y version.
29 | version = "2.2"
30 | # The full version, including alpha/beta/rc tags.
31 | release = "2.2.0"
32 |
33 | # -- General configuration ---------------------------------------------------
34 |
35 | # Add any Sphinx extension module names here, as strings. They can be
36 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
37 | # ones.
38 | extensions = [
39 | "sphinx.ext.autodoc",
40 | "sphinx.ext.intersphinx",
41 | "sphinx.ext.todo",
42 | "sphinx.ext.coverage",
43 | "sphinx.ext.mathjax",
44 | "sphinx.ext.ifconfig",
45 | "sphinx.ext.viewcode",
46 | "sphinx.ext.napoleon",
47 | "nbsphinx",
48 | ]
49 |
50 | numfig = True
51 |
52 | # Add any paths that contain templates here, relative to this directory.
53 | templates_path = ["../../_templates"]
54 |
55 | # The language for content autogenerated by Sphinx. Refer to documentation
56 | # for a list of supported languages.
57 | #
58 | # This is also used if you do content translation via gettext catalogs.
59 | # Usually you set "language" from the command line for these cases.
60 | language = "ja"
61 |
62 | # List of patterns, relative to source directory, that match files and
63 | # directories to ignore when looking for source files.
64 | # This pattern also affects html_static_path and html_extra_path.
65 | exclude_patterns = ["_build", "**.ipynb_checkpoints"]
66 | for t in ("tag-latex", "tag-latexpdf", "tag-latexpdfja"):
67 | if t in tags:
68 | exclude_patterns.append("api")
69 |
70 | # The suffix of source filenames.
71 | source_suffix = [".rst", ".md"]
72 |
73 | from recommonmark.parser import CommonMarkParser
74 |
75 | source_parsers = {
76 | ".md": CommonMarkParser,
77 | }
78 |
79 | pygments_style = "sphinx"
80 |
81 | nbsphinx_execute = "never"
82 |
83 | # -- Options for HTML output -------------------------------------------------
84 |
85 | # The theme to use for HTML and HTML Help pages. See the documentation for
86 | # a list of builtin themes.
87 | #
88 | # html_theme = "alabaster"
89 | html_theme = "sphinx_rtd_theme"
90 | html_log = "logo.png"
91 | html_theme_options = {"logo_only": True}
92 |
93 | # Add any paths that contain custom static files (such as style sheets) here,
94 | # relative to this directory. They are copied after the builtin static files,
95 | # so a file named "default.css" will overwrite the builtin "default.css".
96 | html_static_path = ["../../_static"]
97 |
98 | master_doc = "index"
99 |
100 | # Grouping the document tree into LaTeX files. List of tuples
101 | # (source start file, target name, title,
102 | # author, documentclass [howto, manual, or own class]).
103 | latex_engine = 'uplatex'
104 | # latex_docclass = {"manual": "jsbook"}
105 | latex_logo = "../../_static/logo.png"
106 |
107 |
108 | # -- configuring _template/version.html -------------------------------------
109 |
110 | html_context = {}
111 |
112 | html_context["ENABLE_VERSIONING"] = os.environ.get("CI", "false")
113 |
114 | html_context["languages"] = [("en"), ("ja")]
115 | html_context["current_lang"] = language
116 |
117 | current_version = os.environ.get("TARGET_NAME", "")
118 | if not current_version:
119 | current_version = release
120 | html_context["current_version"] = current_version
121 |
122 | html_context["branches"] = ["develop", "master"]
123 | html_context["tags"] = []
124 | exclude_tags = ["v0.1.0", "v0.2.0", "v0.3.0"]
125 |
126 | try:
127 | import git
128 |
129 | repo = git.Repo(search_parent_directories=True)
130 | tags = list(map(str, repo.tags))
131 | tags.sort(reverse=True)
132 | for tag in tags:
133 | if tag not in exclude_tags:
134 | html_context["tags"].append(tag)
135 | except:
136 | pass
137 |
138 | if current_version not in html_context["branches"]:
139 | if current_version not in html_context["tags"]:
140 | html_context["branches"].append(current_version)
141 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/source/contact.rst:
--------------------------------------------------------------------------------
1 | お問い合わせ
2 | =========================================
3 |
4 | PHYSBO に関するお問い合わせはこちらにお寄せください。
5 |
6 | - バグ報告
7 |
8 | PHYSBO のバグ関連の報告は `GitHubのIssues `_ で受け付けています。
9 |
10 | バグを早期に解決するため、報告時には次のガイドラインに従ってください。
11 |
12 | - 使用している PHYSBO のバージョンを指定してください。
13 |
14 | - インストールに問題がある場合には、使用しているオペレーティングシステムとコンパイラの情報についてお知らせください。
15 |
16 | - 実行に問題が生じた場合は、実行に使用した入力ファイルとその出力を記載してください。
17 |
18 | - その他
19 |
20 | 研究に関連するトピックなどGitHubのIssuesで相談しづらいことを問い合わせる際には、以下の連絡先にコンタクトをしてください。
21 |
22 | E-mail: ``physbo-dev__at__issp.u-tokyo.ac.jp`` (_at_を@に変更してください)
23 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/source/index.rst:
--------------------------------------------------------------------------------
1 | .. PHYSBO documentation master file, created by
2 | sphinx-quickstart on Tue May 26 18:44:52 2020.
3 | You can adapt this file completely to your liking, but it should at least
4 | contain the root `toctree` directive.
5 |
6 | Welcome to PHYSBO's documentation!
7 | ==================================
8 |
9 | .. toctree::
10 | :maxdepth: 2
11 | :caption: Contents:
12 |
13 | introduction
14 | install
15 | notebook/index
16 | algorithm
17 | API Reference
18 | acknowledgement
19 | contact
20 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/source/install.rst:
--------------------------------------------------------------------------------
1 | 基本的な使用方法
2 | =====================
3 |
4 | インストール
5 | ---------------------
6 |
7 | 実行環境・必要なパッケージ
8 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 | PHYSBOの実行環境・必要なパッケージは以下の通りです。
10 |
11 | * Python >= 3.6
12 | * numpy < 2.0.0
13 | * scipy
14 |
15 |
16 | .. `Anaconda `_ 環境を利用すると、numpy, scipy, Cython がデフォルトでインストールされているため、COMBO をすぐに実行することが可能です。
17 | 依存パッケージを手動でインストールする場合は、以下の手順によりまとめてインストールすることができます。
18 |
19 | #. 以下をコピーして、'requirements.txt' というファイル名で保存します (setup.py と同じディレクトリ内に保存します) ::
20 |
21 | ## To install these requirements, run
22 | ## pip install -U -r requirements.txt
23 | ## (the -U option also upgrades packages; from the second time on,
24 | ## just run
25 | ## pip install -r requirements.txt
26 | ##
27 | ## NOTE: before running the command above, you need to install a recent version
28 | ## of pip from the website, and then possibly install/upgrade setuptools using
29 | ## sudo pip install --upgrade setuptools
30 | ## numpy
31 | numpy >=1.10
32 |
33 | ## scipy
34 | scipy >= 0.16
35 |
36 | ##
37 | Cython >= 0.22.1
38 |
39 | ## mpi4py
40 | mpi4py >= 2.0 (optional)
41 |
42 | #. 以下のコマンドを実行します。 ::
43 |
44 | > pip install -U -r requirements.txt
45 |
46 | ダウンロード・インストール
47 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
48 |
49 | - ``PyPI`` からのインストール(推奨) ::
50 |
51 | $ pip3 install physbo
52 |
53 | - NumPy などの依存パッケージも同時にインストールされます。
54 |
55 | - ``--user`` オプションを追加するとユーザのホームディレクトリ以下にインストールされます。 ::
56 |
57 | $ pip3 install --user physbo
58 |
59 |
60 | - ソースコードからのインストール(開発者向け)
61 |
62 | #. 本体のダウンロード
63 |
64 | ソースファイルをダウンロードするか、以下のように github レポジトリをクローンしてください。 ::
65 |
66 | $ git clone https://github.com/issp-center-dev/PHYSBO
67 |
68 | #. pip を 19.0 以上に更新 ::
69 |
70 | $ pip3 install -U pip
71 |
72 | - ここで ``pip3`` が入っていない場合には ``python3 -m ensurepip`` でインストール可能です
73 |
74 | #. インストール ::
75 |
76 | $ cd PHYSBO
77 | $ pip3 install --user ./
78 |
79 | アンインストール
80 | ~~~~~~~~~~~~~~~~~~~~~~~~
81 |
82 | #. 以下のコマンドを実行します。 ::
83 |
84 | $ pip uninstall physbo
85 |
86 |
87 | PHYSBOの基本構造
88 | --------------------------
89 |
90 | PHYSBOは以下のような構成になっています(第2階層まで表示)。
91 |
92 | ..
93 | |--physbo
94 | | |--blm
95 | | |--gp
96 | | |--misc
97 | | |--opt
98 | | |--search
99 | | |--predictor.py
100 | | |--variable.py
101 |
102 | 各モジュールは以下のような構成で作成されています。
103 |
104 | - ``blm`` :Baysean linear modelに関するモジュール
105 | - ``gp`` :Gaussian Processに関するモジュール
106 | - ``opt`` :最適化に関するモジュール
107 | - ``search`` :最適解を探索するためのモジュール
108 | - ``predictor.py`` :predictorの抽象クラス
109 | - ``variable.py`` :physboで用いる変数関連について定義されたクラス
110 | - ``misc`` : その他(探索空間を正規化するためのモジュールなど)
111 |
112 | 各モジュールの詳細についてはAPIリファレンスを参考にしてください。
113 |
114 | 計算の流れ
115 | --------------------------
116 |
117 | ベイズ最適化は、複雑なシミュレーションや、実世界における実験タスクなど、目的関数の評価に大きなコストがかかるような最適化問題に適しています。
118 | PHYSBO では以下の手順により最適化を実行します(それぞれの詳細はチュートリアルおよびAPIリファレンスを参考にしてください)。
119 |
120 | 1. 探索空間の定義
121 |
122 | N: 探索候補の数 , d: 入力パラメータの次元数 とした時、探索候補である各パラメータセット (d 次元のベクトル) を定義します。パラメータセットは全ての候補をリストアップしておく必要があります。
123 |
124 | 2. simulator の定義
125 |
126 | 上で定義した探索候補に対して、各探索候補の目的関数値(材料特性値など最適化したい値)を与えるsimulatorを定義します。PHYSBOでは、最適化の方向は「目的関数の最大化」になります。そのため,目的関数を最小化したい場合、simulatorから返す値にマイナスをかけることで実行できます。
127 |
128 | 3. 最適化の実行
129 |
130 | 最初に、最適化の policy をセットします(探索空間はこの段階で引数としてpolicyに渡されます)。最適化方法は、以下の2種類から選択します。
131 |
132 | - ``random_search``
133 | - ``bayes_search``
134 |
135 | ``random_search`` では、探索空間からランダムにパラメータを選び、その中で最大となる目的関数を探します。ベイズ最適化を行うための前処理として初期パラメータ群を用意するために使用します。 ``bayes_search`` は、ベイズ最適化を行います。ベイズ最適化でのscore: 獲得関数(acquisition function) の種類は、以下のいずれかから指定します。
136 |
137 | - TS (Thompson Sampling): 学習されたガウス過程の事後確率分布から回帰関数を1つサンプリングし、それを用いた予測が最大となる点を候補として選択します。
138 | - EI (Expected Improvement): ガウス過程による予測値と現状での最大値との差の期待値が最大となる点を候補として選択します。
139 | - PI (Probability of Improvement): 現状での最大値を超える確率が最大となる点を候補として選択します。
140 |
141 | ガウス過程に関する詳細については :ref:`chap_algorithm` に記載してあります。その他、各手法の詳細については、`こちらの文献 `_ およびその参考文献を参照して下さい。
142 |
143 | これらのメソッドに先ほど定義した simulator と探索ステップ数を指定すると、探索ステップ数だけ以下のループが回ります。
144 |
145 | i). パラメータ候補の中から次に実行するパラメータを選択
146 |
147 | ii). 選択されたパラメータで simulator を実行
148 |
149 | i)で返されるパラメータはデフォルトでは1つですが、1ステップで複数のパラメータを返すことも可能です。詳しくはチュートリアルの「複数候補を一度に探索する」の項目を参照してください。また、上記のループを PHYSBO の中で回すのではなく、i) と ii) を別個に外部から制御することも可能です。つまり、PHYSBO から次に実行するパラメータを提案し、その目的関数値をPHYSBOの外部で何らかの形で評価し(例えば、数値計算ではなく、実験による評価など)、それをPHYSBOの外部で何らかの形で提案し、評価値をPHYSBOに登録する、という手順が可能です。詳しくは、チュートリアルの「インタラクティブに実行する」の項目を参照してください。
150 |
151 |
152 | 4. 結果の確認
153 |
154 | 探索結果 res は history クラスのオブジェクト (physbo.search.discrete.results.history) として返されます。以下より探索結果を参照します。
155 |
156 | - res.fx : simulator (目的関数) の評価値の履歴。
157 | - res.chosen_actions: simulator を評価したときのaction ID(パラメータ)の履歴。
158 | - fbest, best_action= res.export_all_sequence_best_fx(): simulator を評価した全タイミングにおけるベスト値とそのaction ID(パラメータ)の履歴。
159 | - res.total_num_search: simulator のトータル評価数。
160 |
161 | また、探索結果は save メソッドにより外部ファイルに保存でき、load メソッドを用いて出力した結果をロードすることができます。使用方法の詳細はチュートリアルをご覧ください。
162 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/source/introduction.rst:
--------------------------------------------------------------------------------
1 | はじめに
2 | =====================
3 |
4 | PHYSBO とは
5 | ----------------------
6 |
7 | PHYSBO(optimization tool for PHYSics based on Bayesian Optimization)は、高速でスケーラブルなベイズ最適化 (Bayesian optimization) のためのPythonライブラリです。
8 | COMBO(COMmon Baysian Optimization)をもとに、主に物性分野の研究者をターゲットに開発されました。
9 | 物理、化学、材料分野において、データ駆動的な実験計画アルゴリズムによって科学的発見を加速する、という試みが多く行われています。
10 | ベイズ最適化は、このような科学的発見を加速するために有効なツールです。
11 | ベイズ最適化は、複雑なシミュレーションや、実世界における実験タスクなど、目的関数値(特性値など)の評価に大きなコストがかかるような場合に利用できる手法です。つまり、「できるだけ少ない実験・シミュレーション回数でより良い目的関数値(材料特性など)を持つパラメータ(材料の組成、構造、プロセスやシミュレーションパラメータなど)を見つけ出す」ことが、ベイズ最適化によって解かれる問題です。ベイズ最適化では、探索するパラメータの候補をあらかじめリストアップし、候補の中から目的関数値が最大と考えられる候補を機械学習(ガウス過程回帰を利用)による予測をうまく利用することで選定します。その候補に対して実験・シミュレーションを行い目的関数値を評価します。機械学習による選定・実験シミュレーションによる評価を繰り返すことにより、少ない回数での最適化が可能となります。
12 | 一方で、一般的にベイズ最適化は計算コストが高く、scikit-learn 等のスタンダードな実装では、多くのデータを扱うことが困難です。
13 | PHYSBOでは以下の特徴により、高いスケーラビリティを実現しています。
14 |
15 | * Thompson Sampling
16 | * random feature map
17 | * one-rank Cholesky update
18 | * automatic hyperparameter tuning
19 |
20 | 技術的な詳細については、`こちらの文献 `_ を参照して下さい。
21 |
22 |
23 | PHYSBO の引用
24 | ----------------------
25 |
26 | PHYSBOを引用する際には、以下の文献を引用してください、
27 |
28 |
29 | Yuichi Motoyama, Ryo Tamura, Kazuyoshi Yoshimi, Kei Terayama, Tsuyoshi Ueno, Koji Tsuda,
30 | Bayesian optimization package: PHYSBO,
31 | Computer Physics Communications Volume 278, September 2022, 108405. Available from https://www.sciencedirect.com/science/article/pii/S0010465522001242?via%3Dihub (open access).
32 |
33 | Bibtexは以下の通りです。 ::
34 |
35 | @misc{@article{MOTOYAMA2022108405,
36 | title = {Bayesian optimization package: PHYSBO},
37 | journal = {Computer Physics Communications},
38 | volume = {278},
39 | pages = {108405},
40 | year = {2022},
41 | issn = {0010-4655},
42 | doi = {https://doi.org/10.1016/j.cpc.2022.108405},
43 | author = {Yuichi Motoyama and Ryo Tamura and Kazuyoshi Yoshimi and Kei Terayama and Tsuyoshi Ueno and Koji Tsuda},
44 | keywords = {Bayesian optimization, Multi-objective optimization, Materials screening, Effective model estimation}
45 | }
46 |
47 | 主な開発者
48 | ----------------------
49 | - ver. 1.0-
50 |
51 | - 田村 亮 (物質・材料研究機構 国際ナノアーキテクトニクス研究拠点)
52 | - 寺山 慧 (横浜市立大学大学院 生命医科学研究科)
53 | - 津田 宏治 (東京大学大学院 新領域創成科学研究科)
54 | - 植野 剛 (株式会社 Magne-Max Capital Management)
55 | - 本山 裕一 (東京大学 物性研究所)
56 | - 吉見 一慶 (東京大学 物性研究所)
57 | - 川島 直輝 (東京大学 物性研究所)
58 |
59 |
60 | - ver. 0.1-0.3
61 |
62 | - 田村 亮 (物質・材料研究機構 国際ナノアーキテクトニクス研究拠点)
63 | - 寺山 慧 (横浜市立大学大学院 生命医科学研究科)
64 | - 津田 宏治 (東京大学大学院 新領域創成科学研究科)
65 | - 本山 裕一 (東京大学 物性研究所)
66 | - 吉見 一慶 (東京大学 物性研究所)
67 | - 川島 直輝 (東京大学 物性研究所)
68 |
69 | ライセンス
70 | ----------------------
71 |
72 | PHYSBO v2 のソースコードは `Mozilla Public License version 2.0(MPL v2) `_ (`日本語訳 `_) のもとで公開・頒布されています。
73 |
74 | Copyright (c) <2020-> The University of Tokyo. All rights reserved.
75 |
76 | 本ソフトウェアは2020年度 東京大学物性研究所 ソフトウェア高度化プロジェクトの支援を受け開発されました。
77 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/source/notebook/index.rst:
--------------------------------------------------------------------------------
1 | チュートリアル
2 | ==================================
3 | ここでは、PHYSBOのチュートリアルを通してその使用方法を紹介します。
4 |
5 |
6 | .. toctree::
7 | :maxdepth: 2
8 | :caption: Contents:
9 |
10 | tutorial_basic
11 | tutorial_Gaussian_process
12 | tutorial_interactive_mode
13 | tutorial_once_mode
14 | tutorial_multi_probe
15 | tutorial_multi_objective
16 |
17 |
--------------------------------------------------------------------------------
/docs/sphinx/manual/ja/source/notebook/tutorial_once_mode.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# 既存の計算結果を読み込んで実行する\n",
8 | "\n",
9 | "以下の流れで、既存のaction ID(パラメータ)とその評価値を読み込み、PHYSBO を実行することができます。\n",
10 | "\n",
11 | "1. 外部ファイルを読み込み、既存のaction ID(パラメータ)と評価値を読み込む。\n",
12 | "2. action ID(パラメータ)と評価値をPHYSBOに登録する。\n",
13 | "3. PHYSBO から次に実行するパラメータを得る。\n",
14 | "\n",
15 | "時間制限の関係上、PHYSBO をずっと開いたままにできないため、インタラクティブに実行できないといった場合に、利用することができます。\n",
16 | "\n",
17 | "## 探索候補データの準備\n",
18 | "\n",
19 | "これまでのチュートリアルと同様、データセットファイル [s5-210.csv](https://raw.githubusercontent.com/issp-center-dev/PHYSBO/master/examples/grain_bound/data/s5-210.csv) を `data` ディレクトリ以下に保存し、次のように読み出します。"
20 | ]
21 | },
22 | {
23 | "cell_type": "code",
24 | "execution_count": 1,
25 | "metadata": {
26 | "ExecuteTime": {
27 | "end_time": "2020-12-04T06:17:28.657314Z",
28 | "start_time": "2020-12-04T06:17:27.967614Z"
29 | }
30 | },
31 | "outputs": [],
32 | "source": [
33 | "import physbo\n",
34 | "\n",
35 | "import numpy as np\n",
36 | "\n",
37 | "\n",
38 | "def load_data():\n",
39 | " A = np.asarray(np.loadtxt('data/s5-210.csv',skiprows=1, delimiter=',') )\n",
40 | " X = A[:,0:3]\n",
41 | " t = -A[:,3]\n",
42 | " return X, t\n",
43 | "\n",
44 | "X, t = load_data()\n",
45 | "X = physbo.misc.centering(X)"
46 | ]
47 | },
48 | {
49 | "cell_type": "markdown",
50 | "metadata": {},
51 | "source": [
52 | "## 事前に計算したデータの用意\n",
53 | "\n",
54 | "上述の `load_data` 関数では全てのXとtが格納されています。ここでは事前に計算したとして、actoin IDのリストをランダムに20個取得し、その評価値を得ます。"
55 | ]
56 | },
57 | {
58 | "cell_type": "code",
59 | "execution_count": 2,
60 | "metadata": {},
61 | "outputs": [
62 | {
63 | "name": "stdout",
64 | "output_type": "stream",
65 | "text": [
66 | "[12623, 13781, 1326, 8484, 16753, 15922, 13268, 9938, 15617, 11732, 7157, 16537, 4563, 9235, 4579, 3107, 8208, 17451, 4815, 10162]\n"
67 | ]
68 | }
69 | ],
70 | "source": [
71 | "import random\n",
72 | "random.seed(0)\n",
73 | "calculated_ids = random.sample(range(t.size), 20)\n",
74 | "print(calculated_ids)\n",
75 | "t_initial = t[calculated_ids]"
76 | ]
77 | },
78 | {
79 | "cell_type": "markdown",
80 | "metadata": {},
81 | "source": [
82 | "## action ID(パラメータ)と評価値をPHYSBOに登録\n",
83 | "\n",
84 | "policyの初期変数 `initial_data` に `calculated_ids` と `t[calculated_ids]` をリストとして登録します。"
85 | ]
86 | },
87 | {
88 | "cell_type": "code",
89 | "execution_count": 3,
90 | "metadata": {},
91 | "outputs": [],
92 | "source": [
93 | "# policy のセット \n",
94 | "policy = physbo.search.discrete.policy(test_X=X, initial_data=[calculated_ids, t_initial])\n",
95 | "\n",
96 | "# シード値のセット \n",
97 | "policy.set_seed( 0 )"
98 | ]
99 | },
100 | {
101 | "cell_type": "markdown",
102 | "metadata": {},
103 | "source": [
104 | "## PHYSBO から次に実行するパラメータを取得\n",
105 | "\n",
106 | "ベイズ最適化を行い、次の候補点を得ます。"
107 | ]
108 | },
109 | {
110 | "cell_type": "code",
111 | "execution_count": 4,
112 | "metadata": {
113 | "ExecuteTime": {
114 | "end_time": "2020-12-04T06:17:28.674407Z",
115 | "start_time": "2020-12-04T06:17:28.669875Z"
116 | }
117 | },
118 | "outputs": [
119 | {
120 | "name": "stdout",
121 | "output_type": "stream",
122 | "text": [
123 | "Start the initial hyper parameter searching ...\n",
124 | "Done\n",
125 | "\n",
126 | "Start the hyper parameter learning ...\n",
127 | "0 -th epoch marginal likelihood -20.09302189053099\n",
128 | "50 -th epoch marginal likelihood -23.11964735598211\n",
129 | "100 -th epoch marginal likelihood -24.83020118385076\n",
130 | "150 -th epoch marginal likelihood -25.817906570042602\n",
131 | "200 -th epoch marginal likelihood -26.42342027124426\n",
132 | "250 -th epoch marginal likelihood -26.822598600211865\n",
133 | "300 -th epoch marginal likelihood -27.10872736571494\n",
134 | "350 -th epoch marginal likelihood -27.331572599126865\n",
135 | "400 -th epoch marginal likelihood -27.517235815448124\n",
136 | "450 -th epoch marginal likelihood -27.67892333553869\n",
137 | "500 -th epoch marginal likelihood -27.82299469827059\n",
138 | "Done\n",
139 | "\n",
140 | "[73] [[-1.6680279 -1.46385011 1.68585446]]\n"
141 | ]
142 | }
143 | ],
144 | "source": [
145 | "actions = policy.bayes_search(max_num_probes=1, simulator=None, score=\"TS\", interval=0, num_rand_basis = 5000)\n",
146 | "print(actions, X[actions])"
147 | ]
148 | },
149 | {
150 | "cell_type": "markdown",
151 | "metadata": {},
152 | "source": [
153 | "得られた候補点について外部で計算を行い、ファイルにactionsとそのスコアを登録する。再びファイルを読み込み、ベイズ最適化を実行し次の候補点を得るというプロセスを繰り返すことで、ベイズ最適化を進めることができます。"
154 | ]
155 | }
156 | ],
157 | "metadata": {
158 | "kernelspec": {
159 | "display_name": "Python 3",
160 | "language": "python",
161 | "name": "python3"
162 | },
163 | "language_info": {
164 | "codemirror_mode": {
165 | "name": "ipython",
166 | "version": 3
167 | },
168 | "file_extension": ".py",
169 | "mimetype": "text/x-python",
170 | "name": "python",
171 | "nbconvert_exporter": "python",
172 | "pygments_lexer": "ipython3",
173 | "version": "3.8.5"
174 | }
175 | },
176 | "nbformat": 4,
177 | "nbformat_minor": 1
178 | }
179 |
--------------------------------------------------------------------------------
/examples/grain_bound/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | *~
3 | build/
4 | installed
5 | .pyc
6 | .ipynb_checkpoints
7 | BLM_EI
8 | BLM_TS
9 | GP_EI
10 | random
11 | res
12 | data
13 | describe_graph.ipynb
14 | run_random.py
15 | script.py
16 | script_random.py
17 |
--------------------------------------------------------------------------------
/examples/multiple.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import itertools
9 |
10 | import numpy as np
11 | import physbo
12 |
13 | # Make a set of candidates, test_X
14 | D = 2 # The number of params (the dimension of parameter space)
15 | Nx = 11 # The number of candidates
16 | N = Nx * Nx
17 |
18 | # score = "HVPI"
19 | score = "EHVI"
20 |
21 | a = np.linspace(-2, 2, Nx)
22 | test_X = np.array(list(itertools.product(a, a)))
23 |
24 |
25 | def vlmop2_minus(x):
26 | n = x.shape[1]
27 | y1 = 1 - np.exp(-1 * np.sum((x - 1 / np.sqrt(n)) ** 2, axis=1))
28 | y2 = 1 - np.exp(-1 * np.sum((x + 1 / np.sqrt(n)) ** 2, axis=1))
29 |
30 | return np.c_[-y1, -y2]
31 |
32 |
33 | class simulator(object):
34 | def __init__(self, X):
35 | self.t = vlmop2_minus(X)
36 |
37 | def __call__(self, action):
38 | return self.t[action]
39 |
40 |
41 | sim = simulator(test_X)
42 |
43 | policy = physbo.search.discrete_multi.policy(test_X, num_objectives=2)
44 | policy.set_seed(0)
45 | # Random search (10 times)
46 | policy.random_search(max_num_probes=10, simulator=sim)
47 |
48 | # Bayesian search (40 times)
49 | # score function (acquition function): expectation of improvement (EI)
50 | policy.bayes_search(max_num_probes=40, simulator=sim, score=score, interval=0)
51 |
52 | print("Pareto fronts:")
53 | res = policy.history
54 | front, front_index = res.export_pareto_front()
55 | for fr, ifr in zip(front, front_index):
56 | print(" action: ", ifr)
57 | print(" X: ", test_X[ifr, :])
58 | print(" f: ", fr)
59 | print()
60 |
--------------------------------------------------------------------------------
/examples/multiple_score.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import itertools
9 |
10 | import numpy as np
11 | import physbo
12 |
13 | # Make a set of candidates, test_X
14 | D = 2 # The number of params (the dimension of parameter space)
15 | Nx = 11 # The number of candidates
16 | N = Nx * Nx
17 |
18 | # score = "HVPI"
19 | score = "EHVI"
20 |
21 | a = np.linspace(-2, 2, Nx)
22 | test_X = np.array(list(itertools.product(a, a)))
23 |
24 |
25 | def vlmop2_minus(x):
26 | n = x.shape[1]
27 | y1 = 1 - np.exp(-1 * np.sum((x - 1 / np.sqrt(n)) ** 2, axis=1))
28 | y2 = 1 - np.exp(-1 * np.sum((x + 1 / np.sqrt(n)) ** 2, axis=1))
29 |
30 | return np.c_[-y1, -y2]
31 |
32 |
33 | class simulator(object):
34 | def __init__(self, X):
35 | self.t = vlmop2_minus(X)
36 |
37 | def __call__(self, action):
38 | return self.t[action]
39 |
40 |
41 | sim = simulator(test_X)
42 |
43 | policy = physbo.search.discrete_multi.policy(test_X, num_objectives=2)
44 | policy.set_seed(0)
45 | # Random search (10 times)
46 | policy.random_search(max_num_probes=10, simulator=sim)
47 |
48 | # Bayesian search (40 times)
49 | # score function (acquisition function): expectation of improvement (EI)
50 | policy.bayes_search(max_num_probes=40, simulator=sim, score=score, interval=0)
51 |
52 | print("Mean values of prediction")
53 | scores = policy.get_post_fmean(xs=test_X)
54 | print(scores)
55 | print()
56 |
57 | print("Standard deviations of prediction")
58 | scores = policy.get_post_fcov(xs=test_X)
59 | print(np.sqrt(scores))
60 | print()
61 |
62 | print("Acquisition function")
63 | scores = policy.get_score(mode=score, xs=test_X)
64 | print(scores)
65 |
--------------------------------------------------------------------------------
/examples/sfs.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import physbo
3 | from physbo.misc import set_config
4 | from mlxtend.feature_selection import SequentialFeatureSelector as SFS
5 | import matplotlib.pyplot as plt
6 |
7 |
8 | # 1. Generate data
9 | def generate_data(n_samples=2000, n_features=5):
10 | """Generate artificial dataset"""
11 | # Generate features
12 | X = np.random.uniform(-10, 10, (n_samples, n_features))
13 |
14 | # Define objective function
15 | def target_function(x):
16 | # Function where x1, x2, x5 are important features
17 | return (
18 | (100 - x[4]) ** 2
19 | + (10 - x[0]) ** 2
20 | + (1 - x[1]) ** 2
21 | + x[3]
22 | + (1000 - x[0] * x[1])
23 | + np.random.normal(0, 1)
24 | )
25 |
26 | # Calculate target variable
27 | y = np.array([target_function(x) for x in X])
28 |
29 | return X, y
30 |
31 |
32 | # 2. GP model setup
33 | def setup_gp_model(input_dim):
34 | """Setup GP model"""
35 | # Set kernel (covariance function)
36 | cov = physbo.gp.cov.gauss(input_dim, ard=False)
37 |
38 | # Set mean function
39 | mean = physbo.gp.mean.const()
40 |
41 | # Set likelihood function
42 | lik = physbo.gp.lik.gauss()
43 |
44 | # Prepare configuration
45 | config = set_config()
46 |
47 | # Create GP model
48 | gp = physbo.gp.sfs(lik=lik, mean=mean, cov=cov, config=config)
49 |
50 | return gp
51 |
52 |
53 | def main():
54 | # 1. Generate data
55 | X, y = generate_data()
56 | print("Dataset shape:", X.shape)
57 |
58 | # 2. Setup GP model
59 | gp = setup_gp_model(X.shape[1])
60 |
61 | # 3. Configure Sequential Feature Selector
62 | sfs = SFS(
63 | estimator=gp,
64 | k_features=3, # Number of features to select
65 | forward=True, # Use forward selection
66 | floating=True, # Use Floating search
67 | scoring="r2", # Evaluation metric
68 | cv=3, # Number of cross-validation splits
69 | n_jobs=-1, # Number of parallel jobs
70 | )
71 |
72 | # 4. Execute feature selection
73 | sfs.fit(X, y)
74 |
75 | # 5. Display results
76 | print("\nSelected features:")
77 | print(sfs.subsets_)
78 |
79 | # 6. Visualize results
80 | plt.figure(figsize=(10, 6))
81 | from mlxtend.plotting import plot_sequential_feature_selection as plot_sfs
82 |
83 | fig = plot_sfs(sfs.get_metric_dict(), kind="std_err")
84 | plt.title("Sequential Forward Selection (w/ SFFS)")
85 | plt.grid()
86 | plt.show()
87 |
88 |
89 | if __name__ == "__main__":
90 | main()
91 |
--------------------------------------------------------------------------------
/examples/simple.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 | import physbo
10 |
11 | # Make a set of candidates, test_X
12 | D = 3 # The number of params (the dimension of parameter space)
13 | N = 1000 # The number of candidates
14 | test_X = np.random.randn(N, D) # Generated from Gaussian
15 | test_X[0, :] = 0.0 # true solution
16 |
17 |
18 | def simulator(actions: np.ndarray) -> np.ndarray:
19 | """Objective function
20 |
21 | Quadratic function, -Σ_i x_i^2
22 | Receives an array of actions (indices of candidates) and returns the corresponding results as an array
23 | """
24 | return -np.sum(test_X[actions, :] ** 2, axis=1)
25 |
26 |
27 | policy = physbo.search.discrete.policy(test_X)
28 | policy.set_seed(12345)
29 |
30 | # Random search (10 times)
31 | policy.random_search(max_num_probes=10, simulator=simulator)
32 |
33 | # Bayesian search (40 times)
34 | # score function (acquition function): expectation of improvement (EI)
35 | policy.bayes_search(max_num_probes=40, simulator=simulator, score="EI")
36 |
37 | # Print the best result
38 | # best_actions[i] and best_fx[i] stores the best action and value up to the i-th search (random + bayes)
39 | best_fx, best_actions = policy.history.export_sequence_best_fx()
40 | print(f"best_fx: {best_fx[-1]} at {test_X[best_actions[-1], :]}")
41 |
--------------------------------------------------------------------------------
/examples/simple_score.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 | import physbo
10 |
11 | # Make a set of candidates, test_X
12 | D = 3 # The number of params (the dimension of parameter space)
13 | N = 100 # The number of candidates
14 | test_X = np.random.randn(N, D) # Generated from Gaussian
15 | test_X[0, :] # true solution
16 | score = "EI"
17 |
18 |
19 | def simulator(actions: np.ndarray) -> np.ndarray:
20 | """Objective function
21 |
22 | Quadratic function, -Σ_i x_i^2
23 | Receives an array of actions (indices of candidates) and returns the corresponding results as an array
24 | """
25 | return -np.sum(test_X[actions, :] ** 2, axis=1)
26 |
27 |
28 | policy = physbo.search.discrete.policy(test_X)
29 | policy.set_seed(12345)
30 |
31 | # Random search (10 times)
32 | policy.random_search(max_num_probes=10, simulator=simulator)
33 |
34 | # Bayesian search (40 times)
35 | # score function (acquisition function): expectation of improvement (EI)
36 | policy.bayes_search(max_num_probes=40, simulator=simulator, score=score)
37 |
38 | print("Mean values of prediction")
39 | scores = policy.get_post_fmean(xs=test_X)
40 | print(scores)
41 | print()
42 |
43 | print("Standard deviations of prediction")
44 | scores = policy.get_post_fcov(xs=test_X)
45 | print(np.sqrt(scores))
46 | print()
47 |
48 | print("Acquisition function")
49 | scores = policy.get_score(mode=score, xs=test_X)
50 | print(scores)
51 |
--------------------------------------------------------------------------------
/examples/simple_time.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | ### This example describes how to save elapsed time
9 |
10 |
11 | import numpy as np
12 | import matplotlib.pyplot as plt
13 | import physbo
14 |
15 |
16 | # Make a set of candidates, test_X
17 | D = 3 # The number of params (the dimension of parameter space)
18 | N = 1000 # The number of candidates
19 | test_X = np.random.randn(N, D) # Generated from Gaussian
20 | test_X[0, :] = 0.0 # true solution
21 |
22 |
23 | def simulator(actions: np.ndarray) -> np.ndarray:
24 | """Objective function
25 |
26 | Quadratic function, -Σ_i x_i^2
27 | Receives an array of actions (indices of candidates) and returns the corresponding results as an array
28 | """
29 | return -np.sum(test_X[actions, :] ** 2, axis=1)
30 |
31 |
32 | policy = physbo.search.discrete.policy(test_X)
33 | policy.set_seed(12345)
34 |
35 | # Random search (10 times)
36 | policy.random_search(max_num_probes=10, simulator=simulator)
37 |
38 | # Bayesian search (40 times)
39 | # score function (acquition function): expectation of improvement (EI)
40 | policy.bayes_search(max_num_probes=40, simulator=simulator, score="EI")
41 |
42 | # Print the best result
43 | # best_actions[i] and best_fx[i] stores the best action and value up to the i-th search (random + bayes)
44 | best_fx, best_actions = policy.history.export_sequence_best_fx()
45 | print(f"best_fx: {best_fx[-1]} at {test_X[best_actions[-1], :]}")
46 |
47 | fig, ax = plt.subplots()
48 | ax.plot(policy.history.time_total, marker="o")
49 | fig.savefig("time_total.pdf")
50 | ax.clear()
51 |
52 | ax.plot(policy.history.time_update_predictor, marker="o")
53 | fig.savefig("time_update_predictor.pdf")
54 | ax.clear()
55 |
56 | ax.plot(policy.history.time_get_action, marker="o")
57 | fig.savefig("time_get_action.pdf")
58 | ax.clear()
59 |
60 | ax.plot(policy.history.time_run_simulator, marker="o")
61 | fig.savefig("time_run_simulator.pdf")
62 | ax.clear()
63 |
--------------------------------------------------------------------------------
/make_wheels.sh:
--------------------------------------------------------------------------------
1 | # This file is for the package maintainer
2 |
3 | rm -rf build dist *.egg-info
4 |
5 | ret=0
6 | python setup.py sdist || ret=$?
7 | echo
8 | echo
9 |
10 | if [ $ret -ne 0 ];then
11 | echo "Failed to make source distribution"
12 | exit 1
13 | fi
14 | python setup.py bdist_wheel || ret=$?
15 |
16 | echo
17 | echo
18 |
19 | if [ $ret -ne 0 ];then
20 | echo "Failed to make platform wheel"
21 | exit 1
22 | fi
23 |
24 | echo 'To upload to PyPI:'
25 | echo 'twine upload --repository pypi dist/*'
26 |
--------------------------------------------------------------------------------
/physbo/.gitignore:
--------------------------------------------------------------------------------
1 | *.c
2 | .idea
3 |
--------------------------------------------------------------------------------
/physbo/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from . import gp
9 | from . import opt
10 | from . import blm
11 | from . import misc
12 | from . import search
13 | from . import predictor
14 | from .predictor import base_predictor
15 | from .variable import variable
16 |
17 | __version__ = "2.2.0"
18 |
--------------------------------------------------------------------------------
/physbo/blm/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | """ Bayesian Linear Model
9 | """
10 |
11 | from . import basis
12 | from . import prior
13 | from . import lik
14 | from . import inf
15 |
16 | from .core import model
17 | from .predictor import predictor
18 |
--------------------------------------------------------------------------------
/physbo/blm/basis/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .fourier import fourier
9 |
--------------------------------------------------------------------------------
/physbo/blm/basis/fourier.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | # -*- coding:utf-8 -*-
9 | import numpy as np
10 |
11 |
12 | class fourier:
13 | """
14 | random feature maps
15 | ``Psi(X; W,b) = cos[X * Wt + b] * alpha``
16 | where
17 |
18 | - X: input, N-by-d matrix
19 | - W: weight, l-by-d matrix
20 | - Wt: transpose of W
21 | - b: bias, 1-by-l matrix
22 | - alpha: coefficient
23 |
24 | and
25 |
26 | - N: number of data
27 | - d: dimension of input
28 | - l: number of basis
29 |
30 | Attributes
31 | ==========
32 | params: Tuple
33 | W, b, alpha
34 | nbasis: int
35 | number of basis
36 |
37 | References
38 | ==========
39 | A. Rahimi and B. Recht, "Random features for large-scale kernel machines,"
40 | in "Advances in neural information processing systems," 2007, pp. 1177-1184.
41 | """
42 |
43 | def __init__(self, params):
44 | """
45 | Parameters
46 | ----------
47 | params: Tuple
48 | W, b, alpha
49 | """
50 | self._check_params(params)
51 | self._check_len_params(params)
52 | self.params = params
53 | self.nbasis = self.params[1].shape[0]
54 |
55 | def get_basis(self, X, params=None):
56 | """
57 | compute the value of basis
58 |
59 | Parameters
60 | ==========
61 | X: numpy.ndarray
62 | input
63 | params: Tuple
64 | W, b, alpha
65 | (default: self.params)
66 |
67 | Returns
68 | =======
69 | Psi(X; W,b): numpy.ndarray
70 | N-by-l matrix
71 |
72 | ``cos[X * Wt + b] * alpha``
73 |
74 | where ``Wt`` is the transpose of ``W``.
75 | """
76 | if params is None:
77 | params = self.params
78 |
79 | self._check_params(params)
80 | self._check_len_params(params)
81 |
82 | return np.cos(np.dot(X, params[0].transpose()) + params[1]) * params[2]
83 |
84 | def set_params(self, params):
85 | """
86 | update basis parameters
87 |
88 | Parameters
89 | ==========
90 | params: tuple
91 | W, b, alpha
92 |
93 | """
94 | self._check_params(params)
95 | self._check_len_params(params)
96 | self.params = params
97 |
98 | def show(self):
99 | """
100 | print parameters
101 | """
102 | print("W = ", self.params[0])
103 | print("b = ", self.params[1])
104 | print("alpha = ", self.params[2])
105 |
106 | def _check_params(self, params):
107 | """
108 | Parameters
109 | ==========
110 | params: tuple
111 | W, b, alpha
112 |
113 | Raises
114 | ======
115 | ValueError
116 | if ``params`` is not a 3-dimensional tuple
117 | """
118 | if not isinstance(params, tuple):
119 | raise ValueError("The variable < params > must be a tuple.")
120 |
121 | if len(params) != 3:
122 | raise ValueError("The variable < params > must be 3-dimensional tuple.")
123 |
124 | def _check_len_params(self, params):
125 | """
126 | Parameters
127 | ==========
128 | params: tuple
129 | W, b, alpha
130 |
131 |
132 | Raises
133 | ======
134 | ValueError
135 | when dim of W and b are mismatch
136 | or alpha is not a scalar
137 | """
138 | if params[0].shape[0] != params[1].shape[0]:
139 | raise ValueError(
140 | "The length of 0-axis of W must be same as the length of b."
141 | )
142 |
143 | if hasattr(params[2], "__len__"):
144 | if len(params[2]) != 1:
145 | raise ValueError("The third entry of must be a scalar.")
146 | else:
147 | if isinstance(params[2], str):
148 | raise ValueError("The third entry of must be a scalar.")
149 |
--------------------------------------------------------------------------------
/physbo/blm/core/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .model import model
9 |
--------------------------------------------------------------------------------
/physbo/blm/inf/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from . import exact
9 |
--------------------------------------------------------------------------------
/physbo/blm/inf/exact.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 | import scipy
10 |
11 | import physbo.misc as misc
12 |
13 |
14 | def prepare(blm, X, t, Psi=None):
15 | """
16 | initializes auxiaialy parameters for quick sampling
17 |
18 | ``blm.stats`` will be updated.
19 |
20 | Parameters
21 | ==========
22 | blm: physbo.blm.core.model
23 | model
24 | X: numpy.ndarray
25 | inputs
26 | t: numpy.ndarray
27 | target (label)
28 | Psi:
29 | feature maps (default: blm.lik.get_basis(X))
30 | """
31 | if Psi is None:
32 | Psi = blm.lik.get_basis(X)
33 | PsiT = Psi.transpose()
34 | G = np.dot(PsiT, Psi) * blm.lik.cov.prec
35 | A = G + blm.prior.get_prec()
36 | U = scipy.linalg.cholesky(A, check_finite=False)
37 | b = PsiT.dot(t - blm.lik.linear.bias)
38 | alpha = misc.gauss_elim(U, b)
39 | blm.stats = (U, b, alpha)
40 |
41 |
42 | def update_stats(blm, x, t, psi=None):
43 | """
44 | calculates new auxiaialy parameters for quick sampling by fast-update
45 |
46 | Parameters
47 | ==========
48 | blm: physbo.blm.core.model
49 | model
50 | x: numpy.ndarray
51 | input
52 | t: numpy.ndarray
53 | target (label)
54 | psi:
55 | feature map (default: blm.lik.get_basis(X))
56 |
57 | Returns
58 | =======
59 | (U, b, alpha): Tuple
60 | new auxially parameters
61 |
62 | Notes
63 | =====
64 | ``blm.stats[0]`` (U) will be mutated while the others not.
65 | """
66 | if psi is None:
67 | psi = blm.lik.get_basis(x)
68 | U = blm.stats[0]
69 | b = blm.stats[1] + (t - blm.lik.linear.bias) * psi
70 | misc.cholupdate(U, psi * np.sqrt(blm.lik.cov.prec))
71 | alpha = misc.gauss_elim(U, b)
72 | return (U, b, alpha)
73 |
74 |
75 | def sampling(blm, w_mu=None, N=1, alpha=1.0):
76 | """
77 | draws samples of weights
78 |
79 | Parameters
80 | ==========
81 | blm: physbo.blm.core.model
82 | model
83 | w_mu: numpy.ndarray
84 | mean of weight
85 | N: int
86 | the number of samples
87 | (default: 1)
88 | alpha: float
89 | noise for sampling source
90 | (default: 1.0)
91 |
92 | Returns
93 | =======
94 | numpy.ndarray
95 | samples of weights
96 | """
97 | if w_mu is None:
98 | w_mu = get_post_params_mean(blm)
99 | if N == 1:
100 | z = np.random.randn(blm.nbasis) * alpha
101 | else:
102 | z = np.random.randn(blm.nbasis, N) * alpha
103 |
104 | U = blm.stats[0]
105 | invUz = scipy.linalg.solve_triangular(
106 | U, z, lower=False, overwrite_b=False, check_finite=False
107 | )
108 | return (invUz.transpose() + w_mu).transpose()
109 |
110 |
111 | def get_post_params_mean(blm):
112 | """
113 | calculates mean of weight
114 |
115 | Parameters
116 | ==========
117 | blm: physbo.blm.core.model
118 |
119 | Returns
120 | =======
121 | numpy.ndarray
122 | """
123 | return blm.stats[2] * blm.lik.cov.prec
124 |
125 |
126 | def get_post_fmean(blm, X, Psi=None, w=None):
127 | """
128 | calculates posterior mean of model
129 |
130 | Parameters
131 | ==========
132 | blm: physbo.blm.core.model
133 | X: numpy.ndarray
134 | inputs
135 | Psi: numpy.ndarray
136 | feature maps
137 | (default: blm.lik.linear.basis.get_basis(X))
138 | w: numpy.ndarray
139 | weights
140 | (default: get_post_params_mean(blm))
141 |
142 | Returns
143 | =======
144 | numpy.ndarray
145 | """
146 | if Psi is None:
147 | Psi = blm.lik.linear.basis.get_basis(X)
148 |
149 | if w is None:
150 | w = get_post_params_mean(blm)
151 | return Psi.dot(w) + blm.lik.linear.bias
152 |
153 |
154 | def get_post_fcov(blm, X, Psi=None, diag=True):
155 | """
156 | calculates posterior covariance of model
157 |
158 | Parameters
159 | ==========
160 | blm: physbo.blm.core.model
161 | X: numpy.ndarray
162 | inputs
163 | Psi: numpy.ndarray
164 | feature maps
165 | (default: blm.lik.linear.basis.get_basis(X))
166 | diag: bool
167 | if True, returns only variances as a diagonal matrix
168 | (default: True)
169 |
170 | Returns
171 | =======
172 | numpy.ndarray
173 | Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
174 | where num_points is the number of points in X.
175 | """
176 | if Psi is None:
177 | Psi = blm.lik.linear.basis.get_basis(X)
178 |
179 | U = blm.stats[0]
180 | R = scipy.linalg.solve_triangular(
181 | U.transpose(),
182 | Psi.transpose(),
183 | lower=True,
184 | overwrite_b=False,
185 | check_finite=False,
186 | )
187 | RT = R.transpose()
188 |
189 | if diag is True:
190 | fcov = misc.diagAB(RT, R)
191 | else:
192 | fcov = np.dot(RT, R)
193 |
194 | return fcov
195 |
--------------------------------------------------------------------------------
/physbo/blm/lik/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from ._src import cov
9 | from .linear import linear
10 | from .gauss import gauss
11 |
--------------------------------------------------------------------------------
/physbo/blm/lik/_src/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .cov import cov
9 |
--------------------------------------------------------------------------------
/physbo/blm/lik/_src/cov.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | class cov:
12 | """
13 | Covariance
14 |
15 | Attributes
16 | ==========
17 | params: float
18 | half of log of variance
19 | nparams: int
20 | number of parameters
21 | sigma2: float
22 | variance
23 | prec: float
24 | inv. of variance
25 | """
26 |
27 | def __init__(self, params=None):
28 | self.params = params
29 | if self.params is None:
30 | self.params = np.log(1)
31 | self.nparams = 1
32 | self.sigma2, self.prec = self._trans_params(params)
33 |
34 | def get_cov(self, N, params=None):
35 | """
36 | compute the covariance of prior
37 |
38 | Parameters
39 | ==========
40 | N: int
41 | dimension
42 | params:
43 | half of log of variance
44 | (default: self.params)
45 |
46 | Returns
47 | =======
48 | numpy.ndarray
49 | NxN covariance matrix
50 | """
51 | if params is None:
52 | params = self.params
53 |
54 | sigma2, prec = self._trans_params(params)
55 | return np.identity(N) * sigma2
56 |
57 | def get_prec(self, N, params=None):
58 | """
59 | compute the precision of prior
60 |
61 | Parameters
62 | ==========
63 | N: int
64 | dimension
65 | params:
66 | half of log of variance
67 | (default: self.params)
68 |
69 | Returns
70 | =======
71 | numpy.ndarray
72 | inverse of covariance matrix
73 | """
74 | if params is None:
75 | params = self.params
76 | sigma2, prec = self._trans_params(params)
77 | return np.identity(N) * prec
78 |
79 | def set_params(self, params):
80 | """
81 | set the parameter
82 |
83 | Parameters
84 | ==========
85 | params: float
86 | half of log of variance
87 | """
88 | self.params = params
89 | self.sigma2, self.prec = self._trans_params(params)
90 |
91 | def _trans_params(self, params=None):
92 | """
93 | transform the parameter into variance and precision
94 |
95 | Parameters
96 | ==========
97 | params: float
98 | half of log of variance
99 | (default: self.params)
100 |
101 | Returns
102 | =======
103 | sigma2: float
104 | variance
105 | prec: float
106 | precision (inv. of variance)
107 | """
108 | if params is None:
109 | params = np.copy(self.params)
110 |
111 | sigma2 = np.exp(2 * params)
112 | prec = 1 / sigma2
113 | return sigma2, prec
114 |
--------------------------------------------------------------------------------
/physbo/blm/lik/gauss.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | class gauss:
12 | """
13 | Gaussian
14 |
15 | Attributes
16 | ==========
17 | linear
18 | cov: blm.lik.cov
19 | covariance
20 | stats
21 | """
22 |
23 | def __init__(self, linear, cov):
24 | self.linear = linear
25 | self.cov = cov
26 | self.stats = ()
27 |
28 | def get_cov(self, N, params=None):
29 | """
30 | Returns covariance matrix
31 |
32 | Parameters
33 | ==========
34 | N: int
35 | dimension
36 | params: float
37 | half of log of variance
38 | (default: self.cov.params)
39 |
40 | Returns
41 | =======
42 | numpy.ndarray
43 | NxN covariance matrix
44 | """
45 | if params is None:
46 | params = np.copy(self.cov.params)
47 |
48 | return self.cov.get_cov(N, params)
49 |
50 | def get_prec(self, N, params=None):
51 | """
52 | Returns precision matrix
53 |
54 | Parameters
55 | ==========
56 | N: int
57 | dimension
58 | params: float
59 | half of log of variance
60 | (default: self.cov.params)
61 |
62 | Returns
63 | =======
64 | numpy.ndarray
65 | NxN precision matrix
66 | """
67 |
68 | if params is None:
69 | params = np.copy(self.cov.params)
70 |
71 | return self.cov.get_cov(N, params)
72 |
73 | def get_basis(self, X):
74 | """
75 | calculates value of basis function at input
76 |
77 | Parameters
78 | ==========
79 | X: numpy.ndarray
80 | input
81 |
82 | See also
83 | ========
84 | blm.basis.fourier.get_basis
85 | """
86 | return self.linear.basis.get_basis(X)
87 |
88 | def get_mean(self, X, Psi=None, params=None, bias=None):
89 | """
90 | calculates mean value
91 |
92 | Parameters
93 | ==========
94 | X: numpy.ndarray
95 | raw input
96 | Psi: numpy.ndarray
97 | value of feature maps
98 | params: numpy.ndarray
99 | weight
100 | bias: float
101 | bias
102 |
103 | See also
104 | ========
105 | blm.basis.fourier.get_mean
106 | """
107 | return self.linear.get_mean(X, Psi, params, bias)
108 |
109 | def set_params(self, params):
110 | """
111 | sets parameters
112 | """
113 | self.linear.set_params(params)
114 |
115 | def set_bias(self, bias):
116 | """
117 | sets bias
118 | """
119 | self.linear.set_bias(bias)
120 |
121 | def sampling(self, fmean):
122 | """
123 | draws samples
124 |
125 | Parameters
126 | ==========
127 | fmean: numpy.ndarray
128 | means of samples
129 |
130 | Returns
131 | =======
132 | samples: numpy.ndarray
133 | """
134 | num_data = fmean.shape[0]
135 | eps = np.sqrt(self.cov.sigma2) * np.random.randn(num_data)
136 | return fmean + eps
137 |
--------------------------------------------------------------------------------
/physbo/blm/lik/linear.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | class linear:
12 | """
13 |
14 | Attributes
15 | ==========
16 | basis:
17 | basis for random feature map
18 | nbasis: int
19 | number of basis
20 | bias:
21 | params:
22 | _init_params:
23 | initial value of the parameter
24 | """
25 |
26 | def __init__(self, basis, params=None, bias=None):
27 | self.basis = basis
28 | self.nbasis = basis.nbasis
29 | self._init_params = params
30 | self.bias = bias
31 | self.params = params
32 |
33 | if params is None:
34 | self.params = np.zeros(self.nbasis)
35 | self.nparams = self.nbasis
36 |
37 | def get_mean(self, X, Psi=None, params=None, bias=None):
38 | """
39 | calculate mean values
40 |
41 | Parameters
42 | ==========
43 | X: numpy.ndarray
44 | input as an N-by-d matrix
45 | Psi: numpy.ndarray
46 | feature maps ``Psi(X)`` as an N-by-l matrix
47 | (default: self.get_basis(X))
48 | params: numpy.ndarray
49 | weight as a vector with size l
50 | (default: self.params)
51 | bias: float
52 | (default: self.bias)
53 |
54 | Returns
55 | =======
56 | numpy.ndarray
57 | Psi * params + bias
58 |
59 | """
60 | if params is None:
61 | params = np.copy(self.params)
62 |
63 | if bias is None:
64 | bias = np.copy(self.bias)
65 |
66 | if Psi is None:
67 | Psi = self.get_basis(X)
68 |
69 | return Psi.dot(params) + bias
70 |
71 | def set_params(self, params):
72 | """
73 | set parameters
74 |
75 | Parameters
76 | ==========
77 | params: np.ndarray
78 | """
79 | self.params = params
80 |
81 | def set_bias(self, bias):
82 | """
83 | set bias
84 |
85 | Parameters
86 | ==========
87 | bias: float
88 | """
89 | self.bias = bias
90 |
91 | def _init_params(self, params):
92 | """
93 | initialize parameters
94 |
95 | Parameters
96 | ==========
97 | params: np.ndarray
98 | (default: numpy.zeros(self.nbasis))
99 | """
100 | if params is None:
101 | self.params = np.zeros(self.nbasis)
102 |
103 | self.params = params
104 |
105 | def _init_bias(self, bias):
106 | """
107 | initialize bias
108 |
109 | Parameters
110 | ==========
111 | bias: float
112 | (default: 0)
113 | """
114 | if bias is None:
115 | self.bias = 0
116 |
117 | self.bias = bias
118 |
--------------------------------------------------------------------------------
/physbo/blm/prior/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .gauss import gauss
9 |
--------------------------------------------------------------------------------
/physbo/blm/prior/gauss.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | class cov_const:
12 | """
13 | isotropic variance-covariance
14 |
15 | All elements have the same variance and are independent with each other
16 |
17 | Attributes
18 | ==========
19 | params: float
20 | half of log of covariance
21 | sigma2: float
22 | covariance
23 | prec: float
24 | precision (= inv. of covariance)
25 | """
26 |
27 | def __init__(self, params=None):
28 | """
29 | Parameters
30 | ==========
31 | params: float
32 | half of log of covariance
33 | (default: numpy.log(1))
34 | """
35 | if params is None:
36 | self.params = np.log(1)
37 | self.sigma2, self.prec = self._trans_params(params)
38 |
39 | def get_cov(self, nbasis, params=None):
40 | """
41 | computes the covariance
42 |
43 | Parameters
44 | ==========
45 | nbasis: int
46 | the number of components
47 | params: float
48 | half of log of variance
49 | (default: self.params)
50 |
51 | Returns
52 | =======
53 | numpy.ndarray
54 | nbasis-by-n-basis covariance matrix
55 | """
56 | if params is None:
57 | params = self.params
58 | sigma2, prec = self._trans_params(params)
59 | return np.identity(nbasis) * sigma2
60 |
61 | def get_prec(self, nbasis, params=None):
62 | """
63 | computes the precision
64 |
65 | Parameters
66 | ==========
67 | nbasis: int
68 | the number of components
69 | params: float
70 | half of log of variance
71 | (default: self.params)
72 |
73 | Returns
74 | =======
75 | numpy.ndarray
76 | nbasis-by-n-basis precision matrix
77 | """
78 | if params is None:
79 | params = self.params
80 | sigma2, prec = self._trans_params(params)
81 | return np.identity(nbasis) * prec
82 |
83 | def set_params(self, params):
84 | """
85 | sets params
86 |
87 | Parameters
88 | ==========
89 | params: float
90 | half of log of variance
91 | """
92 | self.params = params
93 | self.sigma2, self.prec = self._trans_params(params)
94 |
95 | def _trans_params(self, params=None):
96 | """
97 | calculates variance and precise from params
98 |
99 | Parameters
100 | ==========
101 | params: float
102 | half of log of variance
103 | (default: self.params)
104 |
105 | Returns
106 | =======
107 | sigma2: float
108 | variance
109 | prec: float
110 | precise (= inv. of variance)
111 | """
112 | if params is None:
113 | params = self.params
114 |
115 | sigma2 = np.exp(2 * params)
116 | prec = 1 / sigma2
117 |
118 | return sigma2, prec
119 |
120 |
121 | class gauss:
122 | """
123 | Gaussian prior
124 |
125 | Attributes
126 | ==========
127 | nbasis: int
128 | number of components
129 | cov: cov_const
130 | covariance
131 | """
132 |
133 | def __init__(self, nbasis, cov=None):
134 | """
135 | Parameters
136 | ==========
137 | nbasis: int
138 | number of components
139 | cov: cov_const
140 | (default: cov_const())
141 | """
142 | self._init_cov(cov)
143 | self.nbasis = nbasis
144 |
145 | def get_mean(self, params=None):
146 | """
147 | calculates the mean value of priors
148 |
149 | Parameters
150 | ==========
151 | params: float
152 | half of log of variance
153 | (not used)
154 |
155 | Returns
156 | =======
157 | numpy.ndarray
158 | """
159 | return np.zeros(self.nbasis)
160 |
161 | def get_cov(self, params=None):
162 | """
163 | calculates the variance-covariance matrix of priors
164 |
165 | Parameters
166 | ==========
167 | params: float
168 | half of log of variance
169 | (default: self.cov.params)
170 |
171 | Returns
172 | =======
173 | numpy.ndarray
174 | """
175 | return self.cov.get_cov(self.nbasis, params)
176 |
177 | def get_prec(self, params=None):
178 | """
179 | calculates the precise matrix of priors
180 |
181 | Parameters
182 | ==========
183 | params: float
184 | half of log of variance
185 | (default: self.cov.params)
186 |
187 | Returns
188 | =======
189 | numpy.ndarray
190 | """
191 | return self.cov.get_prec(self.nbasis, params)
192 |
193 | def set_params(self, params):
194 | """
195 | sets params
196 |
197 | Parameters
198 | ==========
199 | params: float
200 | half of log of variance
201 | """
202 | self.cov.set_params(params)
203 |
204 | def _init_cov(self, cov):
205 | """
206 | initialize covariance
207 |
208 | Parameters
209 | ==========
210 | cov: cov_const
211 | default: ``cov_const()``
212 | """
213 | self.cov = cov
214 | if cov is None:
215 | self.cov = cov_const()
216 |
--------------------------------------------------------------------------------
/physbo/gp/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from . import cov
9 | from . import mean
10 | from . import lik
11 |
12 | from .core import prior
13 | from .core import model
14 | from .core import sfs
15 | from .core import learning
16 | from .predictor import predictor
17 |
--------------------------------------------------------------------------------
/physbo/gp/core/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .prior import prior
9 | from .model import model
10 | from .model import sfs
11 |
12 | # from predictor import predictor
13 |
--------------------------------------------------------------------------------
/physbo/gp/core/prior.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 | import scipy
10 |
11 |
12 | class prior:
13 | """prior of gaussian process"""
14 |
15 | def __init__(self, mean, cov):
16 | """
17 |
18 | Parameters
19 | ----------
20 | mean: numpy.ndarray
21 | mean values of prior
22 | cov: physbo.gp.cov.gauss
23 | covariance matrix of priors
24 | """
25 | self.mean = mean
26 | self.cov = cov
27 | self.num_params = self.cov.num_params + self.mean.num_params
28 | self.params = self.cat_params(self.mean.params, self.cov.params)
29 |
30 | def cat_params(self, mean_params, cov_params):
31 | """
32 |
33 | Parameters
34 | ----------
35 | mean_params: numpy.ndarray
36 | Mean values of parameters
37 | cov_params: numpy.ndarray
38 | Covariance matrix of parameters
39 | Returns
40 | -------
41 | numpy.ndarray
42 | """
43 | return np.append(mean_params, cov_params)
44 |
45 | def decomp_params(self, params):
46 | """
47 | decomposing the parameters to those of mean values and covariance matrix for priors
48 |
49 | Parameters
50 | ----------
51 | params: numpy.ndarray
52 | parameters
53 |
54 | Returns
55 | -------
56 | mean_params: numpy.ndarray
57 | cov_params: numpy.ndarray
58 | """
59 | if params is None:
60 | params = np.copy(self.params)
61 |
62 | mean_params = params[0 : self.mean.num_params]
63 | cov_params = params[self.mean.num_params :]
64 | return mean_params, cov_params
65 |
66 | def get_mean(self, num_data, params=None):
67 | """
68 | Calculating the mean value of priors
69 |
70 | Parameters
71 | ----------
72 | num_data: int
73 | Total number of data
74 | params: numpy.ndarray
75 | Parameters
76 | Returns
77 | -------
78 | float
79 | """
80 | if params is None:
81 | params = np.copy(self.params)
82 | return self.mean.get_mean(num_data, params[0 : self.mean.num_params])
83 |
84 | def get_cov(self, X, Z=None, params=None, diag=False):
85 | """
86 | Calculating the variance-covariance matrix of priors
87 |
88 | Parameters
89 | ----------
90 | X: numpy.ndarray
91 | N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of search candidate.
92 | Z: numpy.ndarray
93 | N x d dimensional matrix. Each row of Z denotes the d-dimensional feature vector of tests.
94 | params: numpy.ndarray
95 | Parameters.
96 | diag: bool
97 | If true, only variances (diagonal elements) are returned.
98 |
99 | Returns
100 | -------
101 | numpy.ndarray
102 | Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
103 | where num_points is the number of points in X.
104 | """
105 | if params is None:
106 | params = np.copy(self.params)
107 |
108 | return self.cov.get_cov(X, Z, params=params[self.mean.num_params :], diag=diag)
109 |
110 | def get_grad_mean(self, num_data, params=None):
111 | """
112 | Calculating the gradiant of mean values of priors
113 |
114 | Parameters
115 | ----------
116 | num_data: int
117 | Total number of data
118 | params: numpy.ndarray
119 | Parameters
120 |
121 | Returns
122 | -------
123 | numpy.ndarray
124 |
125 | """
126 | if params is None:
127 | params = np.copy(self.params)
128 |
129 | mean_params, cov_params = self.decomp_params(params)
130 | return self.mean.get_grad(num_data, params=mean_params)
131 |
132 | def get_grad_cov(self, X, params=None):
133 | """
134 | Calculating the covariance matrix priors
135 |
136 | Parameters
137 | ----------
138 | X: numpy.ndarray
139 | N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of search candidate.
140 | params: numpy.ndarray
141 | Parameters.
142 |
143 | Returns
144 | -------
145 | numpy.ndarray
146 |
147 | """
148 | if params is None:
149 | params = np.copy(self.params)
150 | mean_params, cov_params = self.decomp_params(params)
151 | return self.cov.get_grad(X, params=cov_params)
152 |
153 | def set_params(self, params):
154 | """
155 | Setting parameters
156 |
157 | Parameters
158 | ----------
159 | params: numpy.ndarray
160 | Parameters.
161 | """
162 | mean_params, cov_params = self.decomp_params(params)
163 | self.set_mean_params(mean_params)
164 | self.set_cov_params(cov_params)
165 |
166 | def set_mean_params(self, params):
167 | """
168 | Setting parameters for mean values of priors
169 |
170 | Parameters
171 | ----------
172 | params: numpy.ndarray
173 | Parameters
174 | """
175 | if self.mean.num_params != 0:
176 | self.params[0 : self.mean.num_params] = params
177 | self.mean.set_params(params)
178 |
179 | def set_cov_params(self, params):
180 | """
181 | Setting parameters for covariance matrix of priors
182 |
183 | Parameters
184 | ----------
185 | params: numpy.ndarray
186 | Parameters
187 | """
188 | self.params[self.mean.num_params :] = params
189 | self.cov.set_params(params)
190 |
191 | def sampling(self, X, N=1):
192 | """
193 | Sampling from GP prior
194 |
195 | Parameters
196 | ----------
197 | X: numpy.ndarray
198 | N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of search candidate.
199 | N: int
200 |
201 | Returns
202 | -------
203 | float
204 |
205 | """
206 | num_data = X.shape[0]
207 | G = self.get_cov(X) + 1e-8 * np.identity(num_data)
208 | U = scipy.linalg.cholesky(G, check_finite=False)
209 | Z = np.random.randn(N, num_data)
210 | return np.dot(Z, U) + self.get_mean(num_data)
211 |
--------------------------------------------------------------------------------
/physbo/gp/cov/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .gauss import gauss
9 |
--------------------------------------------------------------------------------
/physbo/gp/cov/_src/__init__.py:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/physbo/gp/cov/_src/enhance_gauss.pyx:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 | cimport numpy as np
10 | import cython
11 | cimport cython
12 | from libc.math cimport exp
13 |
14 | DTYPE64 = np.float64
15 | ctypedef np.float64_t DTYPE64_t
16 | DTYPE32 = np.float32
17 | ctypedef np.float32_t DTYPE32_t
18 |
19 | @cython.boundscheck( False )
20 | @cython.wraparound( False )
21 | @cython.nonecheck( False )
22 |
23 | def grad_width64( np.ndarray[DTYPE64_t, ndim = 2] X, np.ndarray[DTYPE64_t, ndim = 1] width, np.ndarray[DTYPE64_t, ndim = 2] G ):
24 | """
25 | Gradiant along width direction (64bit).
26 |
27 | Parameters
28 | ----------
29 | X: numpy.ndarray[numpy.float64_t, ndim = 2]
30 |
31 | width: numpy.ndarray[numpy.float64_t, ndim = 1]
32 | The grid width
33 | G: numpy.ndarray[numpy.float64_t, ndim = 2]
34 | The gram matrix
35 | Returns
36 | -------
37 | numpy.ndarray
38 | """
39 | cdef int N = X.shape[0]
40 | cdef int D = X.shape[1]
41 |
42 | cdef np.ndarray[DTYPE64_t, ndim = 3] gradG = np.zeros([D,N,N], dtype = DTYPE64 )
43 | cdef int i, j, d
44 |
45 | for d in xrange( D ):
46 | for i in xrange( N ):
47 | for j in xrange( i+1, N ):
48 | gradG[d,i,j]= ( X[i,d] - X[j,d] )/width[d]
49 | gradG[d,i,j]= gradG[d,i,j]**2 * G[i,j]
50 | gradG[ d, j, i ] = gradG[ d, i, j ]
51 | return gradG
52 |
53 | @cython.boundscheck( False )
54 | @cython.wraparound( False )
55 | @cython.nonecheck( False )
56 |
57 | def grad_width32( np.ndarray[DTYPE32_t, ndim = 2] X, np.ndarray[DTYPE32_t, ndim = 1] width, np.ndarray[DTYPE32_t, ndim = 2] G ):
58 | """
59 |
60 | Gradiant along width direction (32bit).
61 |
62 | Parameters
63 | ----------
64 | X: numpy.ndarray[numpy.float32_t, ndim = 2]
65 |
66 | width: numpy.ndarray[numpy.float32_t, ndim = 1]
67 | The grid width
68 | G: numpy.ndarray[numpy.float32_t, ndim = 2]
69 | The gram matrix
70 | Returns
71 | -------
72 | numpy.ndarray
73 | """
74 | cdef int N = X.shape[0]
75 | cdef int D = X.shape[1]
76 |
77 | cdef np.ndarray[DTYPE32_t, ndim = 3] gradG = np.zeros([D,N,N], dtype = DTYPE32 )
78 | cdef int i, j, d
79 |
80 | for d in xrange( D ):
81 | for i in xrange( N ):
82 | for j in xrange( i+1, N ):
83 | gradG[d,i,j]= ( X[i,d] - X[j,d] )/width[d]
84 | gradG[d,i,j]= gradG[d,i,j]**2 * G[i,j]
85 | gradG[ d, j, i ] = gradG[ d, i, j ]
86 | return gradG
87 |
--------------------------------------------------------------------------------
/physbo/gp/inf/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from . import exact
9 |
--------------------------------------------------------------------------------
/physbo/gp/lik/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .gauss import gauss
9 |
--------------------------------------------------------------------------------
/physbo/gp/lik/gauss.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | class gauss:
12 | """Gaussian likelihood function"""
13 |
14 | def __init__(self, std=1, max_params=1e6, min_params=1e-6):
15 | """
16 |
17 | Parameters
18 | ----------
19 | std: numpy.ndarray or float
20 | standard deviation.
21 | max_params: float
22 | The maximum value of the parameter.
23 | If the parameter is greater than this value, it will be replaced by this value.
24 | min_params: float
25 | The minimum value of the parameter.
26 | If the parameter is less than this value, it will be replaced by this value.
27 | """
28 | self.min_params = np.log(min_params)
29 | self.max_params = np.log(max_params)
30 | self.num_params = 1
31 | self.std = std
32 | self.params = np.log(std)
33 | self.set_params(self.params)
34 |
35 | def supp_params(self, params=None):
36 | """
37 | Set maximum (minimum) values for parameters when the parameter is greater(less) than this value.
38 |
39 | Parameters
40 | ----------
41 | params: numpy.ndarray
42 | Parameters for optimization.
43 | Array of real elements of size (n,), where ‘n’ is the number of independent variables.
44 | Returns
45 | -------
46 |
47 | """
48 | if params is None:
49 | params = np.copy(params)
50 |
51 | if params > self.max_params:
52 | params = self.max_params
53 |
54 | if params < self.min_params:
55 | params = self.min_params
56 |
57 | return params
58 |
59 | def trans_params(self, params=None):
60 | """
61 | Get exp[params].
62 |
63 | Parameters
64 | ----------
65 | params: numpy.ndarray
66 | Parameters for optimization.
67 | Array of real elements of size (n,), where ‘n’ is the number of independent variables.
68 |
69 | Returns
70 | -------
71 | std: numpy.ndarray
72 | """
73 | if params is None:
74 | params = np.copy(self.params)
75 |
76 | std = np.exp(params)
77 | return std
78 |
79 | def get_params_bound(self):
80 | """
81 | Get boundary array.
82 |
83 | Returns
84 | -------
85 | bound: list
86 | A num_params-dimensional array with the tuple (min_params, max_params).
87 | """
88 | bound = [(self.min_params, self.max_params) for i in range(0, self.num_params)]
89 | return bound
90 |
91 | def get_cov(self, num_data, params=None):
92 | """
93 | Get a covariance matrix
94 |
95 | Parameters
96 | ----------
97 | num_data: int
98 | params: numpy.ndarray
99 | Parameters for optimization.
100 | Array of real elements of size (n,), where ‘n’ is the number of independent variables.
101 |
102 | Returns
103 | -------
104 | numpy.ndarray
105 | Diagonal element matrix of exp(2.0*params)
106 | """
107 | std = self.trans_params(params)
108 | var = std**2
109 | return var * np.identity(num_data)
110 |
111 | def get_grad(self, num_data, params=None):
112 | """
113 | Get a gradient matrix
114 |
115 | Parameters
116 | ----------
117 | num_data: int
118 | params: numpy.ndarray
119 | Parameters for optimization.
120 | Array of real elements of size (n,), where ‘n’ is the number of independent variables.
121 |
122 | Returns
123 | -------
124 | numpy.ndarray
125 | Diagonal element matrix of 2.0 * exp(2.0*params)
126 | """
127 | std = self.trans_params(params)
128 | var = std**2
129 | return var * np.identity(num_data) * 2
130 |
131 | def set_params(self, params):
132 | """
133 | Set parameters.
134 |
135 | Parameters
136 | ----------
137 | params: numpy.ndarray
138 | Parameters for optimization.
139 | Array of real elements of size (n,), where ‘n’ is the number of independent variables.
140 |
141 | Returns
142 | -------
143 |
144 | """
145 | self.params = self.supp_params(params)
146 | self.std = self.trans_params(params)
147 |
148 | def get_cand_params(self, t):
149 | """
150 | Getting candidate parameters.
151 |
152 | Parameters
153 | ----------
154 | t: numpy.ndarray
155 | N dimensional array. The negative energy of each search candidate (value of the objective function to be optimized).
156 |
157 | Returns
158 | -------
159 | numpy.ndarray
160 | log[ standard deviation of t] - log 10.0
161 | """
162 | return np.log(np.std(t) / 10)
163 |
164 | # [TODO] Check: This function seems not to be used.
165 | def sampling(self, fmean):
166 | """
167 | Sampling by adding noise
168 |
169 | Parameters
170 | ----------
171 | fmean: numpy.ndarray
172 |
173 | Returns
174 | -------
175 |
176 | """
177 | num_data = fmean.shape[0]
178 | eps = self.std * np.random.randn(num_data)
179 | return fmean + eps
180 |
--------------------------------------------------------------------------------
/physbo/gp/mean/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .zero import zero
9 | from .const import const
10 |
--------------------------------------------------------------------------------
/physbo/gp/mean/const.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | class const:
12 | """constant"""
13 |
14 | def __init__(self, params=None, max_params=1e12, min_params=-1e12):
15 | """
16 |
17 | Parameters
18 | ----------
19 | params: numpy.ndarray
20 | Parameters
21 | max_params: float
22 | Threshold value for specifying the maximum value of the parameter
23 | min_params: float
24 | Threshold value for specifying the minimum value of the parameter
25 |
26 | """
27 | self.max_params = max_params
28 | self.min_params = min_params
29 | self.init_params(params)
30 | self.num_params = 1
31 |
32 | def supp_params(self, params):
33 | """
34 | Setting maximum and minimum value of parameters.
35 |
36 | Parameters
37 | ----------
38 | params: numpy.ndarray
39 | parameters
40 |
41 | Returns
42 | -------
43 | numpy.ndarray
44 | """
45 | if params > self.max_params:
46 | params = self.max_params
47 |
48 | if params < self.min_params:
49 | params = self.min_params
50 |
51 | return params
52 |
53 | def get_params_bound(self):
54 | """
55 | Getting the boundary list for parameters
56 |
57 | Returns
58 | -------
59 | bound: list
60 | num_params array with the tupple (min_param, max_params)
61 |
62 | """
63 | bound = [(self.min_params, self.max_params) for i in range(0, self.num_params)]
64 | return bound
65 |
66 | def get_mean(self, num_data, params=None):
67 | """
68 |
69 | Parameters
70 | ----------
71 | num_data: int
72 | total number of data
73 | params: numpy.ndarray
74 | parameters
75 |
76 | Returns
77 | -------
78 | numpy.ndarray
79 | """
80 | if params is None:
81 | params = np.copy(self.params)
82 | return params * np.ones(num_data)
83 |
84 | def get_grad(self, num_data, params=None):
85 | """
86 | Returning a new array of (num_data), filled with ones.
87 |
88 | Parameters
89 | ----------
90 | num_data: int
91 | total number of data
92 | params: object
93 | not used
94 |
95 | Returns
96 | -------
97 | numpy.ndarray
98 | """
99 | return np.ones(num_data)
100 |
101 | def set_params(self, params):
102 | """
103 | Setting parameters defined in const class.
104 |
105 | Parameters
106 | ----------
107 | params: numpy.ndarray
108 | parameters
109 |
110 | Returns
111 | -------
112 | numpy.ndarray
113 | """
114 | self.params = params
115 |
116 | def init_params(self, params):
117 | """
118 | Initializing parameters
119 |
120 | Parameters
121 | ----------
122 | params: numpy.ndarray
123 | parameters
124 |
125 | Returns
126 | -------
127 | params: numpy.ndarray
128 | initialized parameters
129 | """
130 | if params is None:
131 | self.params = 0
132 | else:
133 | self.params = self.supp_params(params)
134 |
135 | def get_cand_params(self, t):
136 | """
137 | Getting the median array of candidates.
138 |
139 | Parameters
140 | ----------
141 | t: array_like
142 | Input array or object that can be converted to an array
143 |
144 | Returns
145 | -------
146 | median: numpy.ndarray
147 | A new array holding the result.
148 |
149 | """
150 | return np.median(t)
151 |
--------------------------------------------------------------------------------
/physbo/gp/mean/zero.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | class zero:
12 | """zero"""
13 |
14 | def __init__(self):
15 | self.num_params = 0
16 | self.params = np.array([])
17 |
18 | def get_mean(self, num_data, params=None):
19 | """
20 | Returning numpy.zeros(num_data)
21 |
22 | Parameters
23 | ----------
24 | num_data: int
25 | dimension of numpy.zeros
26 | params: object
27 | not used
28 |
29 | Returns
30 | -------
31 | numpy.ndarray
32 |
33 | """
34 | return np.zeros(num_data)
35 |
36 | def get_grad(self, num_data, params=None):
37 | """
38 | Returning empty numpy.ndarray
39 |
40 | Parameters
41 | ----------
42 | num_data: int
43 | not used
44 | params: object
45 | not used
46 |
47 | Returns
48 | -------
49 | numpy.ndarray
50 |
51 | """
52 | return np.array([])
53 |
54 | def set_params(self, params):
55 | """
56 | Not defined
57 |
58 | Parameters
59 | ----------
60 | params
61 |
62 | Returns
63 | -------
64 |
65 | """
66 | pass
67 |
--------------------------------------------------------------------------------
/physbo/gp/predictor.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import physbo.predictor
9 |
10 |
11 | class predictor(physbo.predictor.base_predictor):
12 | """predictor"""
13 |
14 | def __init__(self, config, model=None):
15 | """
16 |
17 | Parameters
18 | ----------
19 | config: physbo.misc.set_config
20 | configuration
21 | model: physbo.gp.core.model
22 | """
23 | super(predictor, self).__init__(config, model)
24 |
25 | def fit(self, training, num_basis=None):
26 | """
27 | Fitting model to training dataset
28 |
29 | Parameters
30 | ----------
31 | training: physbo.variable
32 | dataset for training
33 | num_basis: int
34 | the number of basis (default: self.config.predict.num_basis)
35 | """
36 | if self.model.prior.cov.num_dim is None:
37 | self.model.prior.cov.num_dim = training.X.shape[1]
38 | self.model.fit(training.X, training.t, self.config)
39 | self.delete_stats()
40 |
41 | def get_basis(self, *args, **kwds):
42 | """
43 |
44 | Parameters
45 | ----------
46 | args
47 | kwds
48 |
49 | Returns
50 | -------
51 |
52 | """
53 | pass
54 |
55 | def get_post_params(self, *args, **kwds):
56 | """
57 |
58 | Parameters
59 | ----------
60 | args
61 | kwds
62 |
63 | Returns
64 | -------
65 |
66 | """
67 | pass
68 |
69 | def update(self, training, test):
70 | self.prepare(training)
71 |
72 | def prepare(self, training):
73 | """
74 | Initializing model by using training data set
75 |
76 | Parameters
77 | ----------
78 | training: physbo.variable
79 | dataset for training
80 |
81 | """
82 | self.model.prepare(training.X, training.t)
83 |
84 | def delete_stats(self):
85 | self.model.stats = None
86 |
87 | def get_post_fmean(self, training, test):
88 | """
89 | Calculating posterior mean value of model
90 |
91 | Parameters
92 | ----------
93 | training: physbo.variable
94 | training dataset. If already trained, the model does not use this.
95 | test: physbo.variable
96 | inputs
97 |
98 | Returns
99 | -------
100 | numpy.ndarray
101 |
102 | """
103 | if self.model.stats is None:
104 | self.prepare(training)
105 | return self.model.get_post_fmean(training.X, test.X)
106 |
107 | def get_post_fcov(self, training, test, diag=True):
108 | """
109 | Calculating posterior variance-covariance matrix of model
110 |
111 | Parameters
112 | ----------
113 | training: physbo.variable
114 | training dataset. If already trained, the model does not use this.
115 | test: physbo.variable
116 | inputs
117 | diag: bool
118 | If true, only variances (diagonal elements) are returned.
119 |
120 | Returns
121 | -------
122 | numpy.ndarray
123 | Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
124 | where num_points is the number of points in test.
125 |
126 | """
127 | if self.model.stats is None:
128 | self.prepare(training)
129 | return self.model.get_post_fcov(training.X, test.X, diag=diag)
130 |
131 | def get_post_samples(self, training, test, alpha=1):
132 | """
133 | Drawing samples of mean values of model
134 |
135 | Parameters
136 | ----------
137 | training: physbo.variable
138 | training dataset. If already trained, the model does not use this.
139 | test: physbo.variable
140 | inputs (not used)
141 | alpha: float
142 | tuning parameter of the covariance by multiplying alpha**2 for np.random.multivariate_normal.
143 | Returns
144 | -------
145 | numpy.ndarray
146 |
147 | """
148 | if self.model.stats is None:
149 | self.prepare(training)
150 | return self.model.post_sampling(training.X, test.X, alpha=alpha)
151 |
152 | def get_predict_samples(self, training, test, N=1):
153 | """
154 | Drawing samples of values of model
155 |
156 | Parameters
157 | ----------
158 | training: physbo.variable
159 | training dataset. If already trained, the model does not use this.
160 | test: physbo.variable
161 | inputs
162 | N: int
163 | number of samples
164 | (default: 1)
165 |
166 | Returns
167 | -------
168 | numpy.ndarray (N x len(test))
169 |
170 | """
171 | if self.model.stats is None:
172 | self.prepare(training)
173 | return self.model.predict_sampling(training.X, test.X, N=N)
174 |
--------------------------------------------------------------------------------
/physbo/misc/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .centering import centering
9 | from .gauss_elim import gauss_elim
10 | from .set_config import set_config
11 | from ._src.diagAB import diagAB_64 as diagAB
12 | from ._src.traceAB import traceAB2_64 as traceAB2
13 | from ._src.traceAB import traceAB3_64 as traceAB3
14 | from ._src.cholupdate import cholupdate64 as cholupdate
15 | from ._src.logsumexp import logsumexp64
16 |
--------------------------------------------------------------------------------
/physbo/misc/_src/__init__.py:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/physbo/misc/_src/cholupdate.pyx:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from libc.math cimport sqrt
9 | from libc.math cimport abs as cabs
10 | import numpy as np
11 | cimport numpy as np
12 | import cython
13 | cimport cython
14 |
15 | DTYPE = np.float64
16 | ctypedef np.float64_t DTYPE_t
17 |
18 | @cython.boundscheck( False )
19 | @cython.wraparound( False )
20 | @cython.nonecheck( False )
21 | cdef inline double hypot(double x, double y):
22 | cdef double t
23 | x = cabs(x)
24 | y = cabs(y)
25 | t = x if x < y else y
26 | x = x if x > y else y
27 | t = t/x
28 | return x*sqrt(1+t*t)
29 |
30 | @cython.boundscheck( False )
31 | @cython.wraparound( False )
32 | @cython.nonecheck( False )
33 | def cholupdate64( np.ndarray[DTYPE_t, ndim = 2] L, np.ndarray[DTYPE_t, ndim = 1] x ):
34 | cdef int N = x.shape[0]
35 | cdef double c, r, s, eps
36 | cdef int k, i
37 | cdef np.ndarray[DTYPE_t, ndim = 1] x2 = x
38 |
39 | for k in xrange( 0, N ):
40 | r = hypot(L[k,k], x2[k])
41 | c = r / L[ k, k ]
42 | s = x2[ k ] / L[ k, k ]
43 | L[ k, k ] = r
44 |
45 | for i in xrange( k+1, N ):
46 | L[ k, i ] = ( L[ k, i ] + s * x2[ i ] ) / c
47 | x2[ i ] = c * x2[ i ] - s * L[ k, i ]
48 |
--------------------------------------------------------------------------------
/physbo/misc/_src/diagAB.pyx:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 | cimport numpy as np
10 | import cython
11 | cimport cython
12 |
13 | DTYPE = np.float64
14 | ctypedef np.float64_t DTYPE_t
15 |
16 | @cython.boundscheck( False )
17 | @cython.wraparound( False )
18 | @cython.nonecheck( False )
19 | def diagAB_64( np.ndarray[DTYPE_t, ndim = 2] A, np.ndarray[DTYPE_t, ndim = 2] B ):
20 | """ Return diagonal part of AB
21 |
22 | Parameters
23 | ==========
24 | A: np.ndarray
25 | NxM matrix
26 | B: np.ndarray
27 | MxN matrix
28 |
29 | Returns
30 | =======
31 | d: np.ndarray
32 | Diagonal part of the matrix AB
33 | """
34 | cdef int N = A.shape[0]
35 | cdef int M = A.shape[1]
36 |
37 | cdef np.ndarray[DTYPE_t, ndim = 1] diagAB = np.zeros( N, dtype=DTYPE )
38 | cdef int i, j
39 |
40 | for i in xrange( N ):
41 | for j in xrange( M ):
42 | diagAB[i] += A[i,j]*B[j,i]
43 |
44 | return diagAB
45 |
--------------------------------------------------------------------------------
/physbo/misc/_src/logsumexp.pyx:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from libc.math cimport exp, log
9 | import numpy as np
10 | cimport numpy as np
11 | import cython
12 | cimport cython
13 |
14 | DTYPE = np.float64
15 | ctypedef np.float64_t DTYPE_t
16 |
17 | @cython.boundscheck( False )
18 | @cython.wraparound( False )
19 | @cython.nonecheck( False )
20 |
21 | def logsumexp64( np.ndarray[DTYPE_t, ndim = 1] x ):
22 | """ Calculate log(sum(exp(x)))
23 |
24 | Parameters
25 | ==========
26 | x: np.ndarray
27 | """
28 | cdef int N = x.shape[0]
29 | cdef int i
30 | cdef double xmax
31 | cdef double tmp = 0
32 | cdef double output
33 |
34 | xmax = np.max(x)
35 |
36 | for i in xrange(0,N):
37 | tmp += exp( x[i] - xmax )
38 |
39 | return log(tmp) + xmax
40 |
--------------------------------------------------------------------------------
/physbo/misc/_src/traceAB.pyx:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 | cimport numpy as np
10 | import cython
11 | cimport cython
12 |
13 | DTYPE = np.float64
14 | ctypedef np.float64_t DTYPE_t
15 |
16 |
17 | @cython.boundscheck( False )
18 | @cython.wraparound( False )
19 | @cython.nonecheck( False )
20 | def traceAB3_64( np.ndarray[DTYPE_t, ndim = 2] A, np.ndarray[DTYPE_t, ndim = 3] B ):
21 | """ Calculates vector of trace of AB[i], where i is the first axis of 3-rank tensor B
22 |
23 | Parameters
24 | ==========
25 | A: np.ndarray
26 | NxM matrix
27 | B: np.ndarray
28 | dxMxN tensor
29 |
30 | Returns
31 | =======
32 | traceAB: np.ndarray
33 | """
34 | cdef int N = A.shape[0]
35 | cdef int M = A.shape[1]
36 | cdef int D = B.shape[0]
37 |
38 | cdef np.ndarray[DTYPE_t, ndim = 1] traceAB = np.zeros( D, dtype = DTYPE )
39 | cdef int i, j, d
40 |
41 | for d in xrange( D ):
42 | traceAB[d] = 0
43 | for i in xrange( N ):
44 | for j in xrange( M ):
45 | traceAB[d] += A[i,j]*B[d,j,i]
46 | return traceAB
47 |
48 | @cython.boundscheck( False )
49 | @cython.wraparound( False )
50 | @cython.nonecheck( False )
51 | def traceAB2_64( np.ndarray[DTYPE_t, ndim = 2] A, np.ndarray[DTYPE_t, ndim = 2] B ):
52 | """ Calculates trace of AB
53 |
54 | Parameters
55 | ==========
56 | A: np.ndarray
57 | NxM matrix
58 | B: np.ndarray
59 | MxN matrix
60 |
61 | Returns
62 | =======
63 | traceAB: float
64 | trace of the matrix AB
65 | """
66 | cdef int N = A.shape[0]
67 | cdef int M = A.shape[1]
68 |
69 | cdef DTYPE_t traceAB = 0
70 | cdef int i, j, d
71 |
72 | for i in xrange( N ):
73 | for j in xrange( M ):
74 | traceAB += A[i,j]*B[j,i]
75 | return traceAB
76 |
--------------------------------------------------------------------------------
/physbo/misc/centering.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | def centering(X):
12 | """
13 | Normalize the mean and standard deviation along the each column of X to 0 and 1, respectively
14 |
15 | Parameters
16 | ----------
17 | X: numpy array
18 | N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of search candidate.
19 |
20 | Returns
21 | -------
22 | X_normalized: numpy array
23 | normalized N x d dimensional matrix.
24 | """
25 | stdX = np.std(X, 0)
26 | index = np.where(stdX != 0)
27 | X_normalized = (X[:, index[0]] - np.mean(X[:, index[0]], 0)) / stdX[index[0]]
28 | return X_normalized
29 |
--------------------------------------------------------------------------------
/physbo/misc/gauss_elim.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 | import scipy
10 |
11 |
12 | def gauss_elim(U, t):
13 | """
14 | Calculate alpha using scipy.linalg.solve_triangular.
15 | alpha = (U^T U)^-1 t = U^-1 [(U^T)-1 t]
16 |
17 | Parameters
18 | ----------
19 | U: (M, M) array_like
20 | A triangular matrix
21 | t: (M,) or (M, N) array_like
22 |
23 | Returns
24 | -------
25 | alpha: numpy.ndarray
26 | Solution to the system L^T alpha = t. Shape of return matches t.
27 | """
28 | alpha = scipy.linalg.solve_triangular(
29 | U.transpose(), t, lower=True, overwrite_b=False, check_finite=False
30 | )
31 |
32 | alpha = scipy.linalg.solve_triangular(
33 | U, alpha, lower=False, overwrite_b=False, check_finite=False
34 | )
35 | return alpha
36 |
--------------------------------------------------------------------------------
/physbo/opt/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .adam import adam
9 |
--------------------------------------------------------------------------------
/physbo/opt/adam.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | class adam:
12 | """
13 | Optimizer of f(x) with the adam method
14 |
15 | Attributes
16 | ==========
17 | params: numpy.ndarray
18 | current input, x
19 | nparams: int
20 | dimension
21 | grad: function
22 | gradient function, g(x) = f'(x)
23 | m: numpy.ndarray
24 | v: numpy.ndarray
25 | epoch: int
26 | the number of update already done
27 | max_epoch: int
28 | the maximum number of update
29 | alpha: float
30 | beta: float
31 | gamma: float
32 | epsilon: float
33 | """
34 |
35 | def __init__(self, params, grad, options={}):
36 | """
37 |
38 | Parameters
39 | ==========
40 | params:
41 | grad:
42 | options: dict
43 | Hyperparameters for the adam method
44 |
45 | - "alpha" (default: 0.001)
46 | - "beta" (default: 0.9)
47 | - "gamma" (default: 0.9999)
48 | - "epsilon" (default: 1e-8)
49 | - "max_epoch" (default: 4000)
50 | """
51 | self.grad = grad
52 | self.params = params
53 | self.nparams = params.shape[0]
54 | self._set_options(options)
55 | self.m = np.zeros(self.nparams)
56 | self.v = np.zeros(self.nparams)
57 | self.epoch = 0
58 |
59 | def set_params(self, params):
60 | self.params = params
61 |
62 | def update(self, params, *args, **kwargs):
63 | """
64 | calculates the updates of params
65 |
66 | Parameters
67 | ==========
68 | params: numpy.ndarray
69 | input
70 | args:
71 | will be passed to self.grad
72 | kwargs:
73 | will be passed to self.grad
74 |
75 | Returns
76 | =======
77 | numpy.ndarray
78 | update of params
79 | """
80 | g = self.grad(params, *args, **kwargs)
81 | self.m = self.m * self.beta + g * (1 - self.beta)
82 | self.v = self.v * self.gamma + g**2 * (1 - self.gamma)
83 | hat_m = self.m / (1 - self.beta ** (self.epoch + 1))
84 | hat_v = self.v / (1 - self.gamma ** (self.epoch + 1))
85 | self.epoch += 1
86 | return -self.alpha * hat_m / (np.sqrt(hat_v) + self.epsilon)
87 |
88 | def run(self, *args, **kwargs):
89 | params = self.params
90 | for epoch in range(self.max_epoch):
91 | update = self.update(params, *args, **kwargs)
92 | params += update
93 |
94 | def _set_options(self, options):
95 | """
96 | set hyperparameters for the method
97 |
98 | Parameters
99 | ==========
100 | options: dict
101 |
102 | """
103 | self.alpha = options.get("alpha", 0.001)
104 | self.beta = options.get("beta", 0.9)
105 | self.gamma = options.get("gamma", 0.9999)
106 | self.epsilon = options.get("epsilon", 1e-8)
107 | self.max_epoch = options.get("max_epoch", 4000)
108 |
--------------------------------------------------------------------------------
/physbo/predictor.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import pickle as pickle
9 | import numpy as np
10 | from physbo import gp
11 |
12 |
13 | class base_predictor(object):
14 | """
15 | Base predictor is defined in this class.
16 |
17 | """
18 |
19 | def __init__(self, config, model=None):
20 | """
21 |
22 | Parameters
23 | ----------
24 | config: set_config object (physbo.misc.set_config)
25 | model: model object
26 | A default model is set as gp.core.model
27 | """
28 |
29 | self.config = config
30 | self.model = model
31 | if self.model is None:
32 | self.model = gp.core.model(
33 | cov=gp.cov.gauss(num_dim=None, ard=False),
34 | mean=gp.mean.const(),
35 | lik=gp.lik.gauss(),
36 | )
37 |
38 | def fit(self, *args, **kwds):
39 | """
40 |
41 | Default fit function.
42 | This function must be overwritten in each model.
43 |
44 | Parameters
45 | ----------
46 | args
47 | kwds
48 |
49 | Returns
50 | -------
51 |
52 | """
53 | raise NotImplementedError
54 |
55 | def prepare(self, *args, **kwds):
56 | """
57 |
58 | Default prepare function.
59 | This function must be overwritten in each model.
60 |
61 | Parameters
62 | ----------
63 | args
64 | kwds
65 |
66 | Returns
67 | -------
68 |
69 | """
70 | raise NotImplementedError
71 |
72 | def delete_stats(self, *args, **kwds):
73 | """
74 |
75 | Default function to delete status.
76 | This function must be overwritten in each model.
77 |
78 | Parameters
79 | ----------
80 | args
81 | kwds
82 |
83 | Returns
84 | -------
85 |
86 | """
87 | raise NotImplementedError
88 |
89 | def get_basis(self, *args, **kwds):
90 | """
91 |
92 | Default function to get basis
93 | This function must be overwritten in each model.
94 |
95 | Parameters
96 | ----------
97 | args
98 | kwds
99 |
100 | Returns
101 | -------
102 |
103 | """
104 | raise NotImplementedError
105 |
106 | def get_post_fmean(self, *args, **kwds):
107 | """
108 |
109 | Default function to get a mean value of the score.
110 | This function must be overwritten in each model.
111 |
112 | Parameters
113 | ----------
114 | args
115 | kwds
116 |
117 | Returns
118 | -------
119 |
120 | """
121 | raise NotImplementedError
122 |
123 | def get_post_fcov(self, *args, **kwds):
124 | """
125 |
126 | Default function to get a covariance of the score.
127 | This function must be overwritten in each model.
128 |
129 | Parameters
130 | ----------
131 | args
132 | kwds
133 |
134 | Returns
135 | -------
136 |
137 | """
138 | raise NotImplementedError
139 |
140 | def get_post_params(self, *args, **kwds):
141 | """
142 |
143 | Default function to get parameters.
144 | This function must be overwritten in each model.
145 |
146 | Parameters
147 | ----------
148 | args
149 | kwds
150 |
151 | Returns
152 | -------
153 |
154 | """
155 | raise NotImplementedError
156 |
157 | def get_post_samples(self, *args, **kwds):
158 | """
159 |
160 | Default function to get samples.
161 | This function must be overwritten in each model.
162 |
163 | Parameters
164 | ----------
165 | args
166 | kwds
167 |
168 | Returns
169 | -------
170 |
171 | """
172 | raise NotImplementedError
173 |
174 | def get_predict_samples(self, *args, **kwds):
175 | """
176 |
177 | Default function to get prediction variables of samples.
178 | This function must be overwritten in each model.
179 |
180 | Parameters
181 | ----------
182 | args
183 | kwds
184 |
185 | Returns
186 | -------
187 |
188 | """
189 | raise NotImplementedError
190 |
191 | def get_post_params_samples(self, *args, **kwds):
192 | """
193 |
194 | Default function to get parameters of samples.
195 | This function must be overwritten in each model.
196 |
197 | Parameters
198 | ----------
199 | args
200 | kwds
201 |
202 | Returns
203 | -------
204 |
205 | """
206 | raise NotImplementedError
207 |
208 | def update(self, *args, **kwds):
209 | """
210 |
211 | Default function to update variables.
212 | This function must be overwritten in each model.
213 |
214 | Parameters
215 | ----------
216 | args
217 | kwds
218 |
219 | Returns
220 | -------
221 |
222 | """
223 | raise NotImplementedError
224 |
225 | def save(self, file_name):
226 | """
227 |
228 | Default function to save information by using pickle.dump function.
229 | The protocol version is set as 3.
230 |
231 | Parameters
232 | ----------
233 | file_name: str
234 | A file name to save self.__dict__ object.
235 |
236 | Returns
237 | -------
238 |
239 | """
240 | with open(file_name, "wb") as f:
241 | pickle.dump(self.__dict__, f, 4)
242 |
243 | def load(self, file_name):
244 | """
245 |
246 | Default function to load variables.
247 | The information is updated using self.update function.
248 |
249 | Parameters
250 | ----------
251 | file_name: str
252 | A file name to load variables from the file.
253 |
254 | Returns
255 | -------
256 |
257 | """
258 | with open(file_name, "rb") as f:
259 | tmp_dict = pickle.load(f)
260 | self.config = tmp_dict["config"]
261 | self.model = tmp_dict["model"]
262 |
--------------------------------------------------------------------------------
/physbo/search/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from . import score
9 | from . import discrete
10 | from . import score_multi
11 | from . import discrete_multi
12 |
--------------------------------------------------------------------------------
/physbo/search/discrete/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .policy import policy
9 | from .results import history
10 |
11 | # __all__ = ["policy", "history"]
12 |
--------------------------------------------------------------------------------
/physbo/search/discrete_multi/__init__.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from .policy import policy
9 | from .results import history
10 |
11 | # __all__ = ["policy", "history"]
12 |
--------------------------------------------------------------------------------
/physbo/search/discrete_multi/results.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 | import pickle
10 | import copy
11 |
12 | from .. import pareto
13 |
14 | MAX_SEARCH = int(30000)
15 |
16 |
17 | class history(object):
18 | def __init__(self, num_objectives):
19 | self.num_objectives = num_objectives
20 | self.pareto = pareto.Pareto(num_objectives=self.num_objectives)
21 |
22 | self.num_runs = int(0)
23 | self.total_num_search = int(0)
24 | self.fx = np.zeros((MAX_SEARCH, self.num_objectives), dtype=float)
25 | self.chosen_actions = np.zeros(MAX_SEARCH, dtype=int)
26 | self.terminal_num_run = np.zeros(MAX_SEARCH, dtype=int)
27 |
28 | self._time_total = np.zeros(MAX_SEARCH, dtype=float)
29 | self._time_update_predictor = np.zeros(MAX_SEARCH, dtype=float)
30 | self._time_get_action = np.zeros(MAX_SEARCH, dtype=float)
31 | self._time_run_simulator = np.zeros(MAX_SEARCH, dtype=float)
32 |
33 | @property
34 | def time_total(self):
35 | return copy.copy(self._time_total[0 : self.num_runs])
36 |
37 | @property
38 | def time_update_predictor(self):
39 | return copy.copy(self._time_update_predictor[0 : self.num_runs])
40 |
41 | @property
42 | def time_get_action(self):
43 | return copy.copy(self._time_get_action[0 : self.num_runs])
44 |
45 | @property
46 | def time_run_simulator(self):
47 | return copy.copy(self._time_run_simulator[0 : self.num_runs])
48 |
49 | def write(
50 | self,
51 | t,
52 | action,
53 | time_total=None,
54 | time_update_predictor=None,
55 | time_get_action=None,
56 | time_run_simulator=None,
57 | ):
58 | t = np.array(t)
59 | action = np.array(action)
60 |
61 | if t.ndim == 1:
62 | N = 1
63 | if len(t) != self.num_objectives:
64 | raise ValueError("t does not match the number of objectives")
65 | else:
66 | N = t.shape[0]
67 | if t.shape[1] != self.num_objectives:
68 | raise ValueError("t does not match the number of objectives")
69 |
70 | st = self.total_num_search
71 | en = st + N
72 |
73 | self.terminal_num_run[self.num_runs] = en
74 | self.fx[st:en] = t
75 | self.chosen_actions[st:en] = action
76 | self.num_runs += 1
77 | self.total_num_search += N
78 |
79 | # update Pareto set
80 | self.pareto.update_front(t)
81 |
82 | if time_total is None:
83 | time_total = np.zeros(N, dtype=float)
84 | self._time_total[st:en] = time_total
85 |
86 | if time_update_predictor is None:
87 | time_update_predictor = np.zeros(N, dtype=float)
88 | self._time_update_predictor[st:en] = time_update_predictor
89 |
90 | if time_get_action is None:
91 | time_get_action = np.zeros(N, dtype=float)
92 | self._time_get_action[st:en] = time_get_action
93 |
94 | if time_run_simulator is None:
95 | time_run_simulator = np.zeros(N, dtype=float)
96 | self._time_run_simulator[st:en] = time_run_simulator
97 |
98 | def export_pareto_front(self):
99 | return self.pareto.export_front()
100 |
101 | def save(self, filename):
102 | N = self.total_num_search
103 | M = self.num_runs
104 |
105 | obj = {
106 | "num_runs": M,
107 | "total_num_search": N,
108 | "fx": self.fx[0:N],
109 | "chosen_actions": self.chosen_actions[0:N],
110 | "terminal_num_run": self.terminal_num_run[0:M],
111 | "pareto": self.pareto,
112 | }
113 |
114 | with open(filename, "wb") as f:
115 | pickle.dump(obj, f)
116 |
117 | def load(self, filename):
118 | with open(filename, "rb") as f:
119 | data = pickle.load(f)
120 |
121 | M = int(data["num_runs"])
122 | N = int(data["total_num_search"])
123 | self.num_runs = M
124 | self.total_num_search = N
125 | self.fx[0:N] = data["fx"]
126 | self.chosen_actions[0:N] = data["chosen_actions"]
127 | self.terminal_num_run[0:M] = data["terminal_num_run"]
128 | self.pareto = data["pareto"]
129 |
--------------------------------------------------------------------------------
/physbo/search/score.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 | import scipy.stats
10 |
11 |
12 | def score(mode, predictor, test, training=None, **kwargs):
13 | """
14 | Calculate scores (acquisition function) for test data.
15 |
16 | Parameters
17 | ----------
18 | mode: str
19 | Kind of score.
20 |
21 | "EI", "PI", and "TS" are available.
22 |
23 | predictor: predictor object
24 | Base class is defined in physbo.predictor.
25 |
26 | training: physbo.variable
27 | Training dataset.
28 | If the predictor is not trained, use this for training.
29 |
30 | test: physbo.variable
31 | Inputs
32 |
33 | Other Parameters
34 | ----------------
35 | fmax: float
36 | Max value of mean of posterior probability distribution.
37 | If not set, the maximum value of posterior mean for training is used.
38 | Used only for mode == "EI" and "PI"
39 |
40 | alpha: float
41 | noise for sampling source (default: 1.0)
42 | Used only for mode == "TS"
43 |
44 | Returns
45 | -------
46 | score: numpy.ndarray
47 |
48 | Raises
49 | ------
50 | NotImplementedError
51 | If unknown mode is given
52 | """
53 |
54 | if test.X.shape[0] == 0:
55 | return np.zeros(0)
56 |
57 | if mode == "EI":
58 | fmax = kwargs.get("fmax", None)
59 | return EI(predictor, training, test, fmax)
60 | elif mode == "PI":
61 | fmax = kwargs.get("fmax", None)
62 | return PI(predictor, training, test, fmax)
63 | elif mode == "TS":
64 | alpha = kwargs.get("alpha", 1.0)
65 | return TS(predictor, training, test, alpha)
66 | else:
67 | raise NotImplementedError("ERROR: mode must be EI, PI or TS.")
68 |
69 |
70 | def EI(predictor, training, test, fmax=None):
71 | """
72 | Maximum expected improvement.
73 |
74 | Parameters
75 | ----------
76 | predictor: predictor object
77 | Base class is defined in physbo.predictor.
78 | training: physbo.variable
79 | Training dataset.
80 | If the predictor is not trained, use this for training.
81 | test: physbo.variable
82 | Inputs
83 | fmax: float
84 | Max value of posterior probability distribution.
85 | If not set, the maximum value of posterior mean for training is used.
86 | Returns
87 | -------
88 | score: numpy.ndarray
89 | """
90 | fmean = predictor.get_post_fmean(training, test)
91 | fcov = predictor.get_post_fcov(training, test)
92 | fstd = np.sqrt(fcov)
93 |
94 | if fmax is None:
95 | fmax = np.max(predictor.get_post_fmean(training, training))
96 |
97 | temp1 = fmean - fmax
98 | temp2 = temp1 / fstd
99 | score = temp1 * scipy.stats.norm.cdf(temp2) + fstd * scipy.stats.norm.pdf(temp2)
100 | return score
101 |
102 |
103 | def PI(predictor, training, test, fmax=None):
104 | """
105 | Maximum probability of improvement.
106 |
107 | Parameters
108 | ----------
109 | predictor: predictor object
110 | Base class is defined in physbo.predictor.
111 | training: physbo.variable
112 | Training dataset.
113 | If the predictor is not trained, use this for training.
114 | test: physbo.variable
115 | Inputs
116 | fmax: float
117 | Max value of posterior probability distribution.
118 | If not set, the maximum value of posterior mean for training is used.
119 | Returns
120 | -------
121 | score: numpy.ndarray
122 | """
123 | fmean = predictor.get_post_fmean(training, test)
124 | fcov = predictor.get_post_fcov(training, test)
125 | fstd = np.sqrt(fcov)
126 |
127 | if fmax is None:
128 | fmax = np.max(predictor.get_post_fmean(training, training))
129 |
130 | temp = (fmean - fmax) / fstd
131 | score = scipy.stats.norm.cdf(temp)
132 | return score
133 |
134 |
135 | def TS(predictor, training, test, alpha=1):
136 | """
137 | Thompson sampling (See Sec. 2.1 in Materials Discovery Volume 4, June 2016, Pages 18-21)
138 |
139 | Parameters
140 | ----------
141 | predictor: predictor object
142 | Base class is defined in physbo.predictor.
143 | training: physbo.variable
144 | Training dataset.
145 | If the predictor is not trained, use this for training.
146 | test: physbo.variable
147 | Inputs
148 | alpha: float
149 | noise for sampling source
150 | (default: 1.0)
151 | Returns
152 | -------
153 | score: numpy.ndarray
154 | """
155 | return (predictor.get_post_samples(training, test, alpha=alpha)).flatten()
156 |
--------------------------------------------------------------------------------
/physbo/search/utility.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | def show_search_results(history, N):
12 | n = history.total_num_search
13 | index = np.argmax(history.fx[0:n])
14 |
15 | if N == 1:
16 | print(
17 | "%04d-th step: f(x) = %f (action=%d)"
18 | % (n, history.fx[n - 1], history.chosen_actions[n - 1])
19 | )
20 | print(
21 | " current best f(x) = %f (best action=%d) \n"
22 | % (history.fx[index], history.chosen_actions[index])
23 | )
24 | else:
25 | print(
26 | "current best f(x) = %f (best action = %d) "
27 | % (history.fx[index], history.chosen_actions[index])
28 | )
29 |
30 | print("list of simulation results")
31 | st = history.total_num_search - N
32 | en = history.total_num_search
33 | for n in range(st, en):
34 | print("f(x)=%f (action = %d)" % (history.fx[n], history.chosen_actions[n]))
35 | print("\n")
36 |
37 |
38 | def show_search_results_mo(history, N, disp_pareto_set=False):
39 | n = history.total_num_search
40 | pset, step = history.pareto.export_front()
41 |
42 | def msg_pareto_set_updated(indent=False):
43 | prefix = " " if indent else ""
44 | if history.pareto.front_updated:
45 | print(prefix + "Pareto set updated.")
46 | if disp_pareto_set:
47 | print(
48 | prefix
49 | + "current Pareto set = %s (steps = %s) \n"
50 | % (str(pset), str(step + 1))
51 | )
52 | else:
53 | print(
54 | prefix + "the number of Pareto frontiers = %s \n" % str(len(step))
55 | )
56 |
57 | if N == 1:
58 | print(
59 | "%04d-th step: f(x) = %s (action = %d)"
60 | % (n, str(history.fx[n - 1]), history.chosen_actions[n - 1])
61 | )
62 |
63 | msg_pareto_set_updated(indent=True)
64 |
65 | else:
66 | msg_pareto_set_updated()
67 |
68 | print("list of simulation results")
69 | st = history.total_num_search - N
70 | en = history.total_num_search
71 | for n in range(st, en):
72 | print(
73 | "f(x) = %s (action = %d)"
74 | % (str(history.fx[n]), history.chosen_actions[n])
75 | )
76 | print("\n")
77 |
78 |
79 | def show_start_message_multi_search(N, score=None):
80 | if score is None:
81 | score = "random"
82 | print(f"{N+1:04}-th multiple probe search ({score})")
83 |
84 |
85 | def show_interactive_mode(simulator, history):
86 | if simulator is None and history.total_num_search == 0:
87 | print("interactive mode starts ... \n ")
88 |
89 |
90 | def length_vector(t):
91 | N = len(t) if hasattr(t, "__len__") else 1
92 | return N
93 |
94 |
95 | def is_learning(n, interval):
96 | if interval == 0:
97 | return n == 0
98 | elif interval > 0:
99 | return np.mod(n, interval) == 0
100 | else:
101 | return False
102 |
--------------------------------------------------------------------------------
/physbo/variable.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import numpy as np
9 |
10 |
11 | class variable(object):
12 | def __init__(self, X=None, t=None, Z=None):
13 | """
14 |
15 | Parameters
16 | ----------
17 | X: numpy array
18 | N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of each search candidate.
19 | t: numpy array
20 | N dimensional array. The negative energy of each search candidate (value of the objective function to be optimized).
21 | Z:
22 |
23 | """
24 | self.X = X
25 | self.Z = Z
26 | self.t = t
27 |
28 | def get_subset(self, index):
29 | """
30 | Getting subset of variables.
31 |
32 | Parameters
33 | ----------
34 | index: int or array of int
35 | Index of selected action.
36 | Returns
37 | -------
38 | variable: physbo.variable
39 | """
40 | temp_X = self.X[index, :] if self.X is not None else None
41 | temp_t = self.t[index] if self.t is not None else None
42 | temp_Z = self.Z[index, :] if self.Z is not None else None
43 |
44 | return variable(X=temp_X, t=temp_t, Z=temp_Z)
45 |
46 | def delete(self, num_row):
47 | """
48 | Deleting variables of X, t, Z whose indexes are specified by num_row.
49 |
50 | Parameters
51 | ----------
52 | num_row: numpy array
53 | Index array to be deleted.
54 |
55 | Returns
56 | -------
57 |
58 | """
59 | self.delete_X(num_row)
60 | self.delete_t(num_row)
61 | self.delete_Z(num_row)
62 |
63 | def add(self, X=None, t=None, Z=None):
64 | """
65 | Adding variables of X, t, Z.
66 |
67 | Parameters
68 | ----------
69 | X: numpy array
70 | N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of each search candidate.
71 | t: numpy array
72 | N dimensional array. The negative energy of each search candidate (value of the objective function to be optimized).
73 | Z
74 |
75 | Returns
76 | -------
77 |
78 | """
79 | self.add_X(X)
80 | self.add_t(t)
81 | self.add_Z(Z)
82 |
83 | def delete_X(self, num_row):
84 | """
85 | Deleting variables of X whose indexes are specified by num_row.
86 |
87 |
88 | Parameters
89 | ----------
90 | num_row: numpy array
91 | Index array to be deleted.
92 |
93 | Returns
94 | -------
95 |
96 | """
97 | if self.X is not None:
98 | self.X = np.delete(self.X, num_row, 0)
99 |
100 | def delete_t(self, num_row):
101 | """
102 | Deleting variables of t whose indexes are specified by num_row.
103 |
104 | Parameters
105 | ----------
106 | num_row: numpy array
107 | Index array to be deleted.
108 |
109 | Returns
110 | -------
111 |
112 | """
113 | if self.t is not None:
114 | self.t = np.delete(self.t, num_row)
115 |
116 | def delete_Z(self, num_row):
117 | """
118 | Deleting variables of Z whose indexes are specified by num_row.
119 |
120 | Parameters
121 | ----------
122 | num_row: numpy array
123 | Index array to be deleted.
124 |
125 | Returns
126 | -------
127 |
128 | """
129 | if self.Z is not None:
130 | self.Z = np.delete(self.Z, num_row, 0)
131 |
132 | def add_X(self, X=None):
133 | """
134 | Adding variable X. If self.X is None, self.X is set as X.
135 |
136 | Parameters
137 | ----------
138 | X: numpy array
139 | N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of each search candidate.
140 |
141 | Returns
142 | -------
143 |
144 | """
145 | if X is not None:
146 | if self.X is not None:
147 | self.X = np.vstack((self.X, X))
148 | else:
149 | self.X = X
150 |
151 | def add_t(self, t=None):
152 | """
153 | Adding variable t. If self.t is None, self.t is set as t.
154 |
155 | Parameters
156 | ----------
157 | t: numpy array
158 | N dimensional array. The negative energy of each search candidate (value of the objective function to be optimized).
159 |
160 | Returns
161 | -------
162 |
163 | """
164 | if not isinstance(t, np.ndarray):
165 | t = np.array([t])
166 |
167 | if t is not None:
168 | if self.t is not None:
169 | self.t = np.hstack((self.t, t))
170 | else:
171 | self.t = t
172 |
173 | def add_Z(self, Z=None):
174 | """
175 | Adding variable Z. If self.Z is None, self.Z is set as Z.
176 |
177 | Parameters
178 | ----------
179 | Z
180 |
181 | Returns
182 | -------
183 |
184 | """
185 | if Z is not None:
186 | if self.Z is None:
187 | self.Z = Z
188 | else:
189 | self.Z = np.vstack((self.Z, Z))
190 |
191 | def save(self, file_name):
192 | """
193 | Saving variables X, t, Z to the file.
194 |
195 | Parameters
196 | ----------
197 | file_name: str
198 | A file name for saving variables X, t, Z using numpy.savez_compressed.
199 |
200 | Returns
201 | -------
202 |
203 | """
204 | np.savez_compressed(file_name, X=self.X, t=self.t, Z=self.Z)
205 |
206 | def load(self, file_name):
207 | """
208 | Loading variables X, t, Z from the file.
209 |
210 | Parameters
211 | ----------
212 | file_name: str
213 | A file name for loading variables X, t, Z using numpy.load.
214 |
215 | Returns
216 | -------
217 |
218 | """
219 | data = np.load(file_name, allow_pickle=True)
220 | self.X = data["X"]
221 | self.t = data["t"]
222 | self.Z = data["Z"]
223 |
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | [build-system]
2 | requires = ["setuptools", "wheel", "cython", "numpy<2.0"]
3 | build-backend = "setuptools.build_meta"
4 |
--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [metadata]
2 | name = physbo
3 | version = 2.2.0
4 | description = optimization tool for PHYSics based on Bayesian Optimization
5 | long_description = file: README.md
6 | long_description_content_type = text/markdown
7 | url = https://github.com/issp-center-dev/PHYSBO
8 | license = MPLv2
9 | author = PHYSBO developers
10 | author_email = physbo-dev@issp.u-tokyo.ac.jp
11 |
12 | [options]
13 | packages = find:
14 | zip_safe = False
15 | python_requires= >=3.6
16 | install_requires =
17 | numpy < 2.0
18 | scipy
19 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from Cython.Build import cythonize
9 | from Cython.Distutils import build_ext
10 | from setuptools import setup, Extension
11 |
12 | import numpy
13 |
14 | compile_flags = [
15 | "-O3",
16 | ]
17 | ext_mods = [
18 | Extension(
19 | name="physbo.misc._src.traceAB",
20 | sources=["physbo/misc/_src/traceAB.pyx"],
21 | include_dirs=[numpy.get_include()],
22 | extra_compile_args=compile_flags,
23 | ),
24 | Extension(
25 | name="physbo.misc._src.cholupdate",
26 | sources=["physbo/misc/_src/cholupdate.pyx"],
27 | include_dirs=[numpy.get_include()],
28 | extra_compile_args=compile_flags,
29 | ),
30 | Extension(
31 | name="physbo.misc._src.diagAB",
32 | sources=["physbo/misc/_src/diagAB.pyx"],
33 | include_dirs=[numpy.get_include()],
34 | extra_compile_args=compile_flags,
35 | ),
36 | Extension(
37 | name="physbo.gp.cov._src.enhance_gauss",
38 | sources=["physbo/gp/cov/_src/enhance_gauss.pyx"],
39 | include_dirs=[numpy.get_include()],
40 | extra_compile_args=compile_flags,
41 | ),
42 | Extension(
43 | name="physbo.misc._src.logsumexp",
44 | sources=["physbo/misc/_src/logsumexp.pyx"],
45 | include_dirs=[numpy.get_include()],
46 | extra_compile_args=compile_flags,
47 | ),
48 | ]
49 | setup(
50 | package_dir={"physbo": "physbo"},
51 | cmdclass={"build_ext": build_ext},
52 | ext_modules=ext_mods,
53 | )
54 |
--------------------------------------------------------------------------------
/tests/README.md:
--------------------------------------------------------------------------------
1 | To test not the *local* package but the *installed* package, do NOT make `__init__.py` in this directory.
2 |
--------------------------------------------------------------------------------
/tests/integrated/__init__.py:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/tests/integrated/test_gp.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from __future__ import print_function
9 |
10 | from itertools import product
11 |
12 | import numpy as np
13 | import pytest
14 |
15 | physbo = pytest.importorskip("physbo")
16 |
17 |
18 | def f(x):
19 | return -np.sum((x - 0.5) ** 2)
20 |
21 |
22 | class simulator:
23 | def __init__(self, noise=1.0e-5):
24 | np.random.seed(12345)
25 | self.nslice = 11
26 | self.dim = 2
27 | self.N = self.nslice**self.dim
28 | self.X = np.zeros((self.N, self.dim))
29 | self.t = np.zeros(self.N)
30 | for i, x in enumerate(
31 | product(np.linspace(0.0, 1.0, self.nslice), repeat=self.dim)
32 | ):
33 | lx = list(x)
34 | self.X[i, :] = lx
35 | self.t[i] = f(self.X[i, :]) + noise * np.random.randn()
36 |
37 |
38 | def test_gp():
39 | sim = simulator()
40 | X = sim.X
41 | t = sim.t
42 | X = physbo.misc.centering(X)
43 |
44 | np.random.seed(12345)
45 | N = len(t)
46 | Ntrain = int(N * 0.8)
47 | Ntest = N - Ntrain
48 | id_all = np.random.choice(len(t), len(t), replace=False)
49 | id_train = id_all[0:Ntrain]
50 | id_test = id_all[Ntrain:N]
51 |
52 | X_train = X[id_train]
53 | X_test = X[id_test]
54 |
55 | t_train = t[id_train]
56 | t_test = t[id_test]
57 |
58 | cov = physbo.gp.cov.gauss(X_train.shape[1], ard=False)
59 | mean = physbo.gp.mean.const()
60 | lik = physbo.gp.lik.gauss()
61 |
62 | gp = physbo.gp.model(lik=lik, mean=mean, cov=cov)
63 | config = physbo.misc.set_config()
64 |
65 | gp.fit(X_train, t_train, config)
66 | gp.print_params()
67 |
68 | gp.prepare(X_train, t_train)
69 | fmean = gp.get_post_fmean(X_train, X_test)
70 | _ = gp.get_post_fcov(X_train, X_test)
71 |
72 | res = np.mean((fmean - t_test) ** 2)
73 | ref = 1.0891454518475606e-05
74 | assert res == pytest.approx(ref, rel=1e-3)
75 |
76 | # restart
77 | cov = physbo.gp.cov.gauss(X_train.shape[1], ard=False)
78 | mean = physbo.gp.mean.const()
79 | lik = physbo.gp.lik.gauss()
80 | gp2 = physbo.gp.model(lik=lik, mean=mean, cov=cov)
81 | gp_params = np.append(
82 | np.append(gp.lik.params, gp.prior.mean.params), gp.prior.cov.params
83 | )
84 | gp2.set_params(gp_params)
85 | gp2.prepare(X_train, t_train)
86 | fmean = gp2.get_post_fmean(X_train, X_test)
87 | _ = gp2.get_post_fcov(X_train, X_test)
88 |
89 | res2 = np.mean((fmean - t_test) ** 2)
90 | assert res == res2
91 |
--------------------------------------------------------------------------------
/tests/integrated/test_interactive_example.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from __future__ import print_function
9 |
10 | from itertools import product
11 |
12 | import numpy as np
13 | import pytest
14 |
15 | physbo = pytest.importorskip("physbo")
16 |
17 |
18 | def f(x):
19 | return -np.sum((x - 0.5) ** 2)
20 |
21 |
22 | class simulator:
23 | def __init__(self):
24 | self.nslice = 11
25 | self.dim = 2
26 | self.N = self.nslice**self.dim
27 | self.X = np.zeros((self.N, self.dim))
28 | for i, x in enumerate(
29 | product(np.linspace(0.0, 1.0, self.nslice), repeat=self.dim)
30 | ):
31 | self.X[i, :] = list(x)
32 |
33 | def __call__(self, actions):
34 | return np.array([f(self.X[action, :]) for action in actions])
35 |
36 |
37 | def test_interactive():
38 | sim = simulator()
39 | nrand = 10
40 | nsearch = 5
41 | policy = physbo.search.discrete.policy(test_X=sim.X)
42 | policy.set_seed(12345)
43 |
44 | actions = policy.random_search(
45 | max_num_probes=1, num_search_each_probe=nrand, simulator=None
46 | )
47 | targets = sim(actions)
48 | print(actions)
49 | print(targets)
50 | policy.write(actions, targets)
51 | physbo.search.utility.show_search_results(policy.history, nrand)
52 |
53 | actions = policy.bayes_search(
54 | max_num_probes=1, num_search_each_probe=nsearch, simulator=None, score="TS"
55 | )
56 | targets = sim(actions)
57 | print(actions)
58 | print(targets)
59 | policy.write(actions, targets)
60 | physbo.search.utility.show_search_results(policy.history, nsearch)
61 |
62 | res = policy.history
63 | best_fx, best_action = res.export_all_sequence_best_fx()
64 | print(best_fx)
65 | print(best_action)
66 | assert best_fx[-1] == pytest.approx(0.0, abs=0.001)
67 | assert best_action[-1] == 60
68 |
--------------------------------------------------------------------------------
/tests/integrated/test_multi_objective.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from __future__ import print_function
9 |
10 | from itertools import product
11 |
12 | import numpy as np
13 | import pytest
14 |
15 | physbo = pytest.importorskip("physbo")
16 |
17 |
18 | def vlmop2_minus(x):
19 | n = x.shape[1]
20 | y1 = 1 - np.exp(-1 * np.sum((x - 1 / np.sqrt(n)) ** 2, axis=1))
21 | y2 = 1 - np.exp(-1 * np.sum((x + 1 / np.sqrt(n)) ** 2, axis=1))
22 |
23 | return np.c_[-y1, -y2]
24 |
25 |
26 | class simulator:
27 | def __init__(self):
28 | a = np.linspace(-2, 2, 11)
29 | self.X = np.array(list(product(a, a)))
30 | self.t = vlmop2_minus(self.X)
31 |
32 | def __call__(self, action):
33 | return self.t[action]
34 |
35 |
36 | def test_multi_objective_EHVI():
37 | sim = simulator()
38 | nrand = 10
39 | nsearch = 5
40 | policy = physbo.search.discrete_multi.policy(test_X=sim.X, num_objectives=2)
41 | policy.set_seed(12345)
42 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
43 | res = policy.bayes_search(max_num_probes=nsearch, simulator=sim, score="EHVI")
44 | vid = res.pareto.volume_in_dominance([-1, -1], [0, 0])
45 | vid_ref = 0.2392468337984477
46 | assert vid == pytest.approx(vid_ref, rel=1e-3)
47 | policy.get_score("EHVI", xs=sim.X)
48 |
49 |
50 | def test_multi_objective_HVPI():
51 | sim = simulator()
52 | nrand = 10
53 | nsearch = 5
54 | policy = physbo.search.discrete_multi.policy(test_X=sim.X, num_objectives=2)
55 | policy.set_seed(12345)
56 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
57 | res = policy.bayes_search(max_num_probes=nsearch, simulator=sim, score="HVPI")
58 | vid = res.pareto.volume_in_dominance([-1, -1], [0, 0])
59 | vid_ref = 0.25322554948754283
60 | assert vid == pytest.approx(vid_ref, rel=1e-3)
61 | policy.get_score("HVPI", xs=sim.X)
62 |
63 |
64 | def test_multi_objective_TS():
65 | sim = simulator()
66 | nrand = 10
67 | nsearch = 5
68 | policy = physbo.search.discrete_multi.policy(test_X=sim.X, num_objectives=2)
69 | policy.set_seed(12345)
70 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
71 | res = policy.bayes_search(max_num_probes=nsearch, simulator=sim, score="TS")
72 | vid = res.pareto.volume_in_dominance([-1, -1], [0, 0])
73 | vid_ref = 0.17724278568874974
74 | assert vid == pytest.approx(vid_ref, rel=1e-3)
75 | policy.get_score("TS", xs=sim.X)
76 |
77 |
78 | def test_multi_objective_EHVI_rand():
79 | sim = simulator()
80 | nrand = 10
81 | nsearch = 5
82 | policy = physbo.search.discrete_multi.policy(test_X=sim.X, num_objectives=2)
83 | policy.set_seed(12345)
84 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
85 | res = policy.bayes_search(
86 | max_num_probes=nsearch, simulator=sim, score="EHVI", num_rand_basis=100
87 | )
88 | vid = res.pareto.volume_in_dominance([-1, -1], [0, 0])
89 | vid_ref = 0.08400891973743863
90 | assert vid == pytest.approx(vid_ref, rel=1e-3)
91 | policy.get_score("EHVI", xs=sim.X)
92 |
93 |
94 | def test_multi_objective_HVPI_rand():
95 | sim = simulator()
96 | nrand = 10
97 | nsearch = 5
98 | policy = physbo.search.discrete_multi.policy(test_X=sim.X, num_objectives=2)
99 | policy.set_seed(12345)
100 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
101 | res = policy.bayes_search(
102 | max_num_probes=nsearch, simulator=sim, score="HVPI", num_rand_basis=100
103 | )
104 | vid = res.pareto.volume_in_dominance([-1, -1], [0, 0])
105 | vid_ref = 0.13374086517165518
106 | assert vid == pytest.approx(vid_ref, rel=1e-3)
107 | policy.get_score("HVPI", xs=sim.X)
108 |
109 |
110 | def test_multi_objective_TS_rand():
111 | sim = simulator()
112 | nrand = 10
113 | nsearch = 5
114 | policy = physbo.search.discrete_multi.policy(test_X=sim.X, num_objectives=2)
115 | policy.set_seed(12345)
116 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
117 | res = policy.bayes_search(
118 | max_num_probes=nsearch, simulator=sim, score="TS", num_rand_basis=100
119 | )
120 | vid = res.pareto.volume_in_dominance([-1, -1], [0, 0])
121 | vid_ref = 0.134435814966692
122 | assert vid == pytest.approx(vid_ref, rel=1e-3)
123 | policy.get_score("TS", xs=sim.X)
124 |
--------------------------------------------------------------------------------
/tests/integrated/test_simple_example.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from __future__ import print_function
9 |
10 | from itertools import product
11 |
12 | import numpy as np
13 | import pytest
14 |
15 | physbo = pytest.importorskip("physbo")
16 |
17 |
18 | def f(x):
19 | return -np.sum((x - 0.5) ** 2)
20 |
21 |
22 | class simulator:
23 | def __init__(self):
24 | self.nslice = 11
25 | self.dim = 2
26 | self.N = self.nslice**self.dim
27 | self.X = np.zeros((self.N, self.dim))
28 | for i, x in enumerate(
29 | product(np.linspace(0.0, 1.0, self.nslice), repeat=self.dim)
30 | ):
31 | self.X[i, :] = list(x)
32 |
33 | def __call__(self, action):
34 | return f(self.X[action, :])
35 |
36 |
37 | def test_random_search():
38 | sim = simulator()
39 | policy = physbo.search.discrete.policy(test_X=sim.X)
40 | policy.set_seed(12345)
41 | nsearch = 20
42 | res = policy.random_search(max_num_probes=nsearch, simulator=sim)
43 | best_fx, best_action = res.export_all_sequence_best_fx()
44 | print(best_fx[-1])
45 | print(best_action[-1])
46 | assert best_fx[-1] == pytest.approx(-0.01, abs=0.001)
47 | assert best_action[-1] == 61
48 |
49 |
50 | def test_bayes_search_EI():
51 | sim = simulator()
52 | nrand = 10
53 | nsearch = 5
54 | policy = physbo.search.discrete.policy(test_X=sim.X)
55 | policy.set_seed(12345)
56 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
57 | res = policy.bayes_search(max_num_probes=nsearch, simulator=sim, score="EI")
58 | best_fx, best_action = res.export_all_sequence_best_fx()
59 | print(best_fx)
60 | print(best_action)
61 | assert best_fx[-1] == pytest.approx(0.0, abs=0.001)
62 | assert best_action[-1] == 60
63 | policy.get_score("EI", xs=sim.X)
64 |
65 |
66 | def test_bayes_search_EI_rand():
67 | sim = simulator()
68 | nrand = 10
69 | nsearch = 5
70 | policy = physbo.search.discrete.policy(test_X=sim.X)
71 | policy.set_seed(12345)
72 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
73 | res = policy.bayes_search(
74 | max_num_probes=nsearch, simulator=sim, score="EI", num_rand_basis=100
75 | )
76 | best_fx, best_action = res.export_all_sequence_best_fx()
77 | print(best_fx)
78 | print(best_action)
79 | assert best_fx[-1] == pytest.approx(0.0, abs=0.001)
80 | assert best_action[-1] == 60
81 | policy.get_score("EI", xs=sim.X)
82 |
83 |
84 | def test_bayes_search_PI():
85 | sim = simulator()
86 | nrand = 10
87 | nsearch = 5
88 | policy = physbo.search.discrete.policy(test_X=sim.X)
89 | policy.set_seed(12345)
90 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
91 | res = policy.bayes_search(max_num_probes=nsearch, simulator=sim, score="PI")
92 | best_fx, best_action = res.export_all_sequence_best_fx()
93 | print(best_fx)
94 | print(best_action)
95 | assert best_fx[-1] == pytest.approx(0.0, abs=0.001)
96 | assert best_action[-1] == 60
97 | policy.get_score("PI", xs=sim.X)
98 |
99 |
100 | def test_bayes_search_PI_rand():
101 | sim = simulator()
102 | nrand = 10
103 | nsearch = 5
104 | policy = physbo.search.discrete.policy(test_X=sim.X)
105 | policy.set_seed(12345)
106 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
107 | res = policy.bayes_search(
108 | max_num_probes=nsearch, simulator=sim, score="PI", num_rand_basis=100
109 | )
110 | best_fx, best_action = res.export_all_sequence_best_fx()
111 | print(best_fx)
112 | print(best_action)
113 | assert best_fx[-1] == pytest.approx(0.0, abs=0.001)
114 | assert best_action[-1] == 60
115 | policy.get_score("PI", xs=sim.X)
116 |
117 |
118 | def test_bayes_search_TS():
119 | sim = simulator()
120 | nrand = 10
121 | nsearch = 5
122 | policy = physbo.search.discrete.policy(test_X=sim.X)
123 | policy.set_seed(12345)
124 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
125 | res = policy.bayes_search(max_num_probes=nsearch, simulator=sim, score="TS")
126 | best_fx, best_action = res.export_all_sequence_best_fx()
127 | print(best_fx)
128 | print(best_action)
129 | assert best_fx[-1] == pytest.approx(0.0, abs=0.001)
130 | assert best_action[-1] == 60
131 | policy.get_score("TS", xs=sim.X)
132 |
133 |
134 | def test_bayes_search_TS_rand():
135 | sim = simulator()
136 | nrand = 10
137 | nsearch = 5
138 | policy = physbo.search.discrete.policy(test_X=sim.X)
139 | policy.set_seed(12345)
140 | res = policy.random_search(max_num_probes=nrand, simulator=sim)
141 | res = policy.bayes_search(
142 | max_num_probes=nsearch, simulator=sim, score="TS", num_rand_basis=100
143 | )
144 | best_fx, best_action = res.export_all_sequence_best_fx()
145 | print(best_fx)
146 | print(best_action)
147 | assert best_fx[-1] == pytest.approx(0.0, abs=0.001)
148 | assert best_action[-1] == 60
149 | policy.get_score("TS", xs=sim.X)
150 |
--------------------------------------------------------------------------------
/tests/unit/__init__.py:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/tests/unit/test_gp.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from __future__ import print_function
9 |
10 | import pytest
11 | import numpy as np
12 | import numpy.random as random
13 |
14 | physbo = pytest.importorskip("physbo")
15 |
16 |
17 | def get_post_fmean(training, test):
18 | print(test)
19 | N = test.shape[0]
20 | return random.randn(N, 1)
21 |
22 |
23 | def get_post_fcov(training, test):
24 | print(test)
25 | N = test.shape[0]
26 | return np.ones((N, 1))
27 |
28 |
29 | def get_post_samples(training, test, alpha=1.0):
30 | print(test)
31 | N = test.shape[0]
32 | return random.randn(N, 1)
33 |
34 |
35 | @pytest.fixture
36 | def predictor(mocker):
37 | p = mocker.MagicMock()
38 | p.get_post_fmean = mocker.MagicMock(side_effect=get_post_fmean)
39 | p.get_post_fcov = mocker.MagicMock(side_effect=get_post_fcov)
40 | p.get_post_samples = mocker.MagicMock(side_effect=get_post_samples)
41 | return p
42 |
43 |
44 | @pytest.fixture
45 | def X():
46 | return np.array(
47 | [
48 | [0.0, 0.0, 0.0],
49 | [1.0, 1.0, 1.0],
50 | [2.0, 2.0, 2.0],
51 | [3.0, 3.0, 3.0],
52 | [4.0, 4.0, 4.0],
53 | [5.0, 5.0, 5.0],
54 | ]
55 | )
56 |
57 |
58 | @pytest.fixture
59 | def Y():
60 | return np.array(
61 | [
62 | [0.0, 0.0, 0.0],
63 | [1.0, 1.0, 1.0],
64 | [2.0, 2.0, 2.0],
65 | [3.0, 3.0, 3.0],
66 | ]
67 | )
68 |
69 |
70 | @pytest.fixture
71 | def t():
72 | return np.array([0.0, 1.0, 2.0, 3.0])
73 |
74 |
75 | def test_gp(predictor, X, t, mocker):
76 | X = physbo.misc.centering(X)
77 | np.random.seed(12345)
78 | N = len(t)
79 | Ntrain = N - 1
80 | Ntest = N - Ntrain
81 | id_all = np.random.choice(len(t), len(t), replace=False)
82 | id_train = id_all[0:Ntrain]
83 | id_test = id_all[Ntrain:N]
84 |
85 | X_train = X[id_train]
86 | X_test = X[id_test]
87 |
88 | t_train = t[id_train]
89 | t_test = t[id_test]
90 |
91 | cov = physbo.gp.cov.gauss(X_train.shape[1], ard=False)
92 | mean = physbo.gp.mean.const()
93 | lik = physbo.gp.lik.gauss()
94 |
95 | adam_run_spy = mocker.spy(physbo.gp.core.learning.adam, "run")
96 | model_set_params_spy = mocker.spy(physbo.gp.core.model, "set_params")
97 |
98 | gp = physbo.gp.model(lik=lik, mean=mean, cov=cov)
99 | config = physbo.misc.set_config()
100 | gp.fit(X_train, t_train, config)
101 |
102 | adam_run_spy.assert_called()
103 | model_set_params_spy.assert_called()
104 |
105 | inf_prepare_spy = mocker.spy(physbo.gp.inf.exact, "prepare")
106 | gp.prepare(X_train, t_train)
107 | fmean = gp.get_post_fmean(X_train, X_test)
108 | inf_prepare_spy.assert_called()
109 | _ = gp.get_post_fcov(X_train, X_test)
110 |
--------------------------------------------------------------------------------
/tests/unit/test_misc.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import sys
9 |
10 | import pytest
11 | import numpy as np
12 |
13 | physbo = pytest.importorskip("physbo")
14 |
15 |
16 | @pytest.fixture
17 | def X():
18 | return np.array(
19 | [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0], [2.0, 2.0, 2.0], [3.0, 3.0, 3.0]]
20 | )
21 |
22 |
23 | # @pytest.mark.parametrize("index", [2, [0, 1]])
24 | def test_centering(X):
25 | dim = X.shape[1]
26 | centered = physbo.misc.centering(X)
27 | assert np.array_equal(centered.mean(axis=0), np.zeros(dim))
28 | assert np.array_equal(centered.std(axis=0), np.ones(dim))
29 |
30 |
31 | def test_gauss_elim():
32 | np.random.seed(12345)
33 | N = 5
34 | U = np.random.randn(N, N)
35 | for i in range(N):
36 | for j in range(i):
37 | U[i, j] = 0.0
38 | ref = np.random.randn(N)
39 | t = np.dot(U, ref)
40 | t = np.dot(U.transpose(), t)
41 | res = physbo.misc.gauss_elim(U, t)
42 | np.testing.assert_array_almost_equal(res, ref)
43 |
44 |
45 | @pytest.mark.parametrize("NM", [(3, 5), (5, 3), (5, 5)])
46 | def test_diagAB(NM):
47 | np.random.seed(12345)
48 | N = NM[0]
49 | M = NM[1]
50 | A = np.random.randn(N, M)
51 | B = np.random.randn(M, N)
52 | ref = np.dot(A, B).diagonal()
53 | res = physbo.misc.diagAB(A, B)
54 | np.testing.assert_array_almost_equal(res, ref)
55 |
56 |
57 | # Now work only for diagnal matrices
58 | @pytest.mark.parametrize("NM", [(3, 5), (5, 3), (5, 5)])
59 | def test_traceAB2(NM):
60 | np.random.seed(12345)
61 | N = NM[0]
62 | M = NM[1]
63 | A = np.random.randn(N, M)
64 | B = np.random.randn(M, N)
65 | ref = np.dot(A, B).trace()
66 | res = physbo.misc.traceAB2(A, B)
67 | assert res == pytest.approx(ref)
68 |
69 |
70 | # Now work only for diagnal matrices
71 | @pytest.mark.parametrize("NM", [(3, 5), (5, 3), (5, 5)])
72 | def test_traceAB3(NM):
73 | np.random.seed(12345)
74 | d = 2
75 | N = NM[0]
76 | M = NM[1]
77 | A = np.random.randn(N, M)
78 | B = np.random.randn(d, M, N)
79 | ref = [np.dot(A, B[i, :, :]).trace() for i in range(d)]
80 | res = physbo.misc.traceAB3(A, B)
81 | np.testing.assert_array_almost_equal(res, ref)
82 |
83 |
84 | def test_logsumexp64():
85 | np.random.seed(12345)
86 | N = 10
87 | xs = np.random.randn(N)
88 | ref = np.log(sum(np.exp(xs)))
89 | res = physbo.misc.logsumexp64(xs)
90 | assert res == pytest.approx(ref)
91 |
--------------------------------------------------------------------------------
/tests/unit/test_policy.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from __future__ import print_function
9 |
10 | import os
11 | import pickle
12 | import shutil
13 | import tempfile
14 |
15 | import pytest
16 | import numpy as np
17 | import numpy.testing
18 |
19 |
20 | physbo = pytest.importorskip("physbo")
21 |
22 |
23 | @pytest.fixture
24 | def X():
25 | return np.array(
26 | [
27 | [0.0, 0.0, 0.0],
28 | [1.0, 1.0, 1.0],
29 | [2.0, 2.0, 2.0],
30 | [3.0, 3.0, 3.0],
31 | [4.0, 4.0, 4.0],
32 | [5.0, 5.0, 5.0],
33 | ]
34 | )
35 |
36 |
37 | @pytest.fixture
38 | def policy():
39 | X = np.array(
40 | [
41 | [0.0, 0.0, 0.0],
42 | [1.0, 1.0, 1.0],
43 | [2.0, 2.0, 2.0],
44 | [3.0, 3.0, 3.0],
45 | [4.0, 4.0, 4.0],
46 | [5.0, 5.0, 5.0],
47 | ]
48 | )
49 | return physbo.search.discrete.policy(test_X=X)
50 |
51 |
52 | def test_write(policy, X):
53 | simulator = lambda x: 1.0
54 | ACTIONS = np.array([0, 1], np.int32)
55 |
56 | policy.write(ACTIONS, np.apply_along_axis(simulator, 1, X[ACTIONS]))
57 | numpy.testing.assert_array_equal(
58 | ACTIONS, policy.history.chosen_actions[: len(ACTIONS)]
59 | )
60 | assert len(X) - len(ACTIONS) == len(policy.actions)
61 |
62 |
63 | def test_randomsearch(policy, mocker):
64 | simulator = mocker.MagicMock(return_value=1.0)
65 | write_spy = mocker.spy(physbo.search.discrete.policy, "write")
66 |
67 | N = 2
68 |
69 | # No simulator is passed: only returns candidates
70 | res = policy.random_search(1, num_search_each_probe=N)
71 | assert len(res) == N
72 | assert policy.history.num_runs == 0
73 | write_spy.assert_not_called()
74 | assert simulator.call_count == 0
75 |
76 | # A simulator is passed: N pairs of action and score are registered
77 | history = policy.random_search(N, simulator=simulator)
78 | assert history.num_runs == N
79 | write_spy.assert_called()
80 | assert simulator.call_count == N
81 |
82 |
83 | def test_bayes_search(policy, mocker):
84 | simulator = mocker.MagicMock(side_effect=lambda x: x)
85 | write_spy = mocker.spy(physbo.search.discrete.policy, "write")
86 | get_actions_spy = mocker.spy(physbo.search.discrete.policy, "_get_actions")
87 |
88 | N = 2
89 |
90 | # initial training
91 | policy.random_search(N, simulator=simulator)
92 |
93 | res = policy.bayes_search(max_num_probes=N, simulator=simulator, score="TS")
94 | assert res.num_runs == N + N
95 | assert write_spy.call_count == N + N
96 | assert simulator.call_count == N + N
97 | assert get_actions_spy.call_count == N
98 |
99 |
100 | def test_saveload(policy, X):
101 | simulator = lambda x: x
102 |
103 | N = 2
104 | policy.random_search(N, simulator=simulator)
105 | policy.bayes_search(max_num_probes=N, simulator=simulator, score="TS")
106 |
107 | with tempfile.TemporaryDirectory() as tempdir:
108 | policy.save(
109 | file_history=os.path.join(tempdir, "history.npz"),
110 | file_training=os.path.join(tempdir, "training.npz"),
111 | file_predictor=os.path.join(tempdir, "predictor.dump"),
112 | )
113 |
114 | policy2 = physbo.search.discrete.policy(test_X=X)
115 | policy2.load(
116 | file_history=os.path.join(tempdir, "history.npz"),
117 | file_training=os.path.join(tempdir, "training.npz"),
118 | file_predictor=os.path.join(tempdir, "predictor.dump"),
119 | )
120 | numpy.testing.assert_array_equal(policy.actions, policy2.actions)
121 | assert policy.history.num_runs == policy2.history.num_runs
122 |
123 |
124 | def test_get_score(policy, mocker, X):
125 | simulator = mocker.MagicMock(return_value=1.0)
126 | policy.random_search(2, simulator=simulator)
127 | policy.set_seed(137)
128 |
129 | res = policy.get_score("EI", xs=X)
130 | ref = np.array(
131 | [
132 | 3.98940120e-07,
133 | 3.98934542e-07,
134 | 3.98924610e-07,
135 | 3.98914969e-07,
136 | 3.98911183e-07,
137 | 3.98914969e-07,
138 | ]
139 | )
140 | numpy.testing.assert_allclose(res, ref)
141 |
142 | res = policy.get_score("PI", xs=X)
143 | print(res)
144 | ref = np.array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5])
145 | numpy.testing.assert_allclose(res, ref)
146 |
147 | res = policy.get_score("TS", xs=X)
148 | ref = np.array(
149 | [1.00000021, 0.99999978, 0.9999993, 0.9999991, 0.99999905, 0.99999888]
150 | )
151 | numpy.testing.assert_allclose(res, ref)
152 |
153 | with pytest.raises(NotImplementedError):
154 | policy.get_score("XX")
155 |
--------------------------------------------------------------------------------
/tests/unit/test_search.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | from __future__ import print_function
9 |
10 | import pytest
11 | import numpy as np
12 | import numpy.random as random
13 |
14 | physbo = pytest.importorskip("physbo")
15 |
16 |
17 | def get_post_fmean(training, test):
18 | print(test)
19 | N = test.shape[0]
20 | return random.randn(N, 1)
21 |
22 |
23 | def get_post_fcov(training, test):
24 | print(test)
25 | N = test.shape[0]
26 | return np.ones((N, 1))
27 |
28 |
29 | def get_post_samples(training, test, alpha=1.0):
30 | print(test)
31 | N = test.shape[0]
32 | return random.randn(N, 1)
33 |
34 |
35 | @pytest.fixture
36 | def predictor(mocker):
37 | p = mocker.MagicMock()
38 | p.get_post_fmean = mocker.MagicMock(side_effect=get_post_fmean)
39 | p.get_post_fcov = mocker.MagicMock(side_effect=get_post_fcov)
40 | p.get_post_samples = mocker.MagicMock(side_effect=get_post_samples)
41 | return p
42 |
43 |
44 | @pytest.fixture
45 | def X():
46 | return np.array(
47 | [
48 | [0.0, 0.0, 0.0],
49 | [1.0, 1.0, 1.0],
50 | [2.0, 2.0, 2.0],
51 | [3.0, 3.0, 3.0],
52 | [4.0, 4.0, 4.0],
53 | [5.0, 5.0, 5.0],
54 | ]
55 | )
56 |
57 |
58 | @pytest.fixture
59 | def Y():
60 | return np.array(
61 | [
62 | [0.0, 0.0, 0.0],
63 | [1.0, 1.0, 1.0],
64 | [2.0, 2.0, 2.0],
65 | [3.0, 3.0, 3.0],
66 | ]
67 | )
68 |
69 |
70 | def test_EI(predictor, X, Y):
71 | N = Y.shape[0]
72 | score = physbo.search.score.EI(predictor, X, Y)
73 | assert score.shape[0] == N
74 | predictor.get_post_fmean.assert_any_call(X, Y)
75 | predictor.get_post_fcov.assert_called_once_with(X, Y)
76 | predictor.get_post_samples.assert_not_called()
77 |
78 | predictor.get_post_fmean.reset_mock()
79 | predictor.get_post_fcov.reset_mock()
80 | predictor.get_post_samples.reset_mock()
81 |
82 | score = physbo.search.score.EI(predictor, X, Y, fmax=1.0)
83 | assert score.shape[0] == N
84 | predictor.get_post_fmean.assert_called_once_with(X, Y)
85 | predictor.get_post_fcov.assert_called_once_with(X, Y)
86 | predictor.get_post_samples.assert_not_called()
87 |
88 |
89 | def test_PI(predictor, X, Y):
90 | N = Y.shape[0]
91 | score = physbo.search.score.PI(predictor, X, Y)
92 | assert score.shape[0] == N
93 | predictor.get_post_fmean.assert_any_call(X, Y)
94 | predictor.get_post_fcov.assert_called_once_with(X, Y)
95 | predictor.get_post_samples.assert_not_called()
96 |
97 | predictor.get_post_fmean.reset_mock()
98 | predictor.get_post_fcov.reset_mock()
99 | predictor.get_post_samples.reset_mock()
100 |
101 | score = physbo.search.score.EI(predictor, X, Y, fmax=1.0)
102 | assert score.shape[0] == N
103 | predictor.get_post_fmean.assert_called_once_with(X, Y)
104 | predictor.get_post_fcov.assert_called_once_with(X, Y)
105 | predictor.get_post_samples.assert_not_called()
106 |
107 |
108 | def test_TS(predictor, X, Y):
109 | N = Y.shape[0]
110 | alpha = 1.0
111 | score = physbo.search.score.TS(predictor, X, Y, alpha=alpha)
112 | assert score.shape[0] == N
113 | predictor.get_post_fmean.assert_not_called()
114 | predictor.get_post_fcov.assert_not_called()
115 | predictor.get_post_samples.assert_called_once_with(X, Y, alpha=alpha)
116 |
--------------------------------------------------------------------------------
/tests/unit/test_variable.py:
--------------------------------------------------------------------------------
1 | # SPDX-License-Identifier: MPL-2.0
2 | # Copyright (C) 2020- The University of Tokyo
3 | #
4 | # This Source Code Form is subject to the terms of the Mozilla Public
5 | # License, v. 2.0. If a copy of the MPL was not distributed with this
6 | # file, You can obtain one at https://mozilla.org/MPL/2.0/.
7 |
8 | import sys
9 |
10 | import pytest
11 | import numpy as np
12 |
13 | physbo = pytest.importorskip("physbo")
14 |
15 |
16 | @pytest.fixture
17 | def X():
18 | return np.array(
19 | [[0.0, 0.0, 0.0], [1.0, 1.0, 1.0], [2.0, 2.0, 2.0], [3.0, 3.0, 3.0]]
20 | )
21 |
22 |
23 | @pytest.fixture
24 | def t():
25 | return np.array([0.0, 1.0, 2.0, 3.0])
26 |
27 |
28 | @pytest.fixture
29 | def Z():
30 | return np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 2.0], [3.0, 3.0]])
31 |
32 |
33 | @pytest.fixture
34 | def variable(X, t, Z):
35 | return physbo.variable(X=X, t=t, Z=Z)
36 |
37 |
38 | @pytest.mark.parametrize("index", [2, [0, 1]])
39 | def test_get_subset(variable, X, t, Z, index):
40 | var2 = variable.get_subset(index)
41 | assert np.array_equal(var2.X, X[index, :])
42 | assert np.array_equal(var2.t, t[index])
43 | assert np.array_equal(var2.Z, Z[index, :])
44 |
45 |
46 |
47 | @pytest.mark.parametrize("index", [2, [0, 1]])
48 | def test_delete_X(variable, X, index):
49 | variable.delete_X(index)
50 | ref = np.delete(X, index, 0)
51 | assert np.array_equal(variable.X, ref)
52 |
53 |
54 | @pytest.mark.parametrize("index", [2, [0, 1]])
55 | def test_delete_t(variable, t, index):
56 | variable.delete_t(index)
57 | ref = np.delete(t, index)
58 | assert np.array_equal(variable.t, ref)
59 |
60 |
61 | @pytest.mark.parametrize("index", [2, [0, 1]])
62 | def test_delete_Z(variable, Z, index):
63 | variable.delete_Z(index)
64 | ref = np.delete(Z, index, 0)
65 | assert np.array_equal(variable.Z, ref)
66 |
67 |
68 | def test_add(variable, X, t, Z, mocker):
69 | variable.add(X, t, Z)
70 | assert np.array_equal(variable.X, np.vstack((X,X)))
71 | assert np.array_equal(variable.t, np.hstack((t,t)))
72 | assert np.array_equal(variable.Z, np.vstack((Z,Z)))
73 |
74 |
75 | def test_add_X(variable, X):
76 | n = X.shape[0]
77 | variable.add_X(X)
78 | assert np.array_equal(variable.X[n : 2 * n, :], X)
79 |
80 |
81 | def test_add_t(variable, t):
82 | n = t.shape[0]
83 | variable.add_t(t)
84 | assert np.array_equal(variable.t[n : 2 * n], t)
85 |
86 |
87 | def test_add_Z(variable, Z):
88 | n = Z.shape[0]
89 | variable.add_Z(Z)
90 | assert np.array_equal(variable.Z[n : 2 * n, :], Z)
91 |
92 |
93 | def test_save_load(variable, tmpdir):
94 | tmpfile = tmpdir.join("tmpfile.npz")
95 | filename = str(tmpfile)
96 | variable.save(filename)
97 | var2 = physbo.variable()
98 | var2.load(filename)
99 | assert np.array_equal(variable.X, var2.X)
100 | assert np.array_equal(variable.t, var2.t)
101 | assert np.array_equal(variable.Z, var2.Z)
102 |
103 | variable.Z = None
104 | variable.save(filename)
105 | var2 = physbo.variable()
106 | var2.load(filename)
107 | assert np.array_equal(variable.X, var2.X)
108 | assert np.array_equal(variable.t, var2.t)
109 | assert np.array_equal(variable.Z, var2.Z)
110 | tmpfile.remove()
111 |
--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
1 | [tox]
2 | requires = tox>=4
3 | envlist = py37, py38, py39, py310, py311, docs
4 | isolated_build = true
5 |
6 | [gh-actions]
7 | python =
8 | '3.7': py37
9 | '3.8': py38
10 | '3.9': py39
11 | '3.10': py310
12 | '3.11': py311
13 |
14 | [testenv]
15 | deps =
16 | pytest
17 | pytest-mock
18 |
19 | commands =
20 | pytest --capture=sys
21 |
22 | [testenv:docs]
23 | description = invoke sphinx-build to build the HTML docs
24 | basepython = python3.10
25 | deps =
26 | sphinx
27 | sphinx_rtd_theme
28 | recommonmark
29 | ipykernel
30 | nbsphinx
31 | pybtex
32 | ipython_genutils
33 | numpy
34 | scipy
35 | allowlist_externals = rm
36 | passenv = CI, TARGET_NAME
37 |
38 | commands =
39 | rm -rf docs/sphinx/manual/ja/source/api
40 | rm -rf docs/sphinx/manual/en/source/api
41 | sphinx-apidoc -f -e -o docs/sphinx/manual/ja/source/api physbo
42 | sphinx-apidoc -f -e -o docs/sphinx/manual/en/source/api physbo
43 | sphinx-build -d "{toxworkdir}/docs_out/doctree/ja" docs/sphinx/manual/ja/source "{toxworkdir}/docs_out/manual/ja" --color -bhtml {posargs}
44 | sphinx-build -d "{toxworkdir}/docs_out/doctree/en" docs/sphinx/manual/en/source "{toxworkdir}/docs_out/manual/en" --color -bhtml {posargs}
45 |
--------------------------------------------------------------------------------