diff --git a/.github/workflows/build_docs.yml b/.github/workflows/build_docs.yml index c50ad5a..c2c6d88 100644 --- a/.github/workflows/build_docs.yml +++ b/.github/workflows/build_docs.yml @@ -21,7 +21,7 @@ jobs: # We would like to use 3.12, but this presently fails. - name: Set up Python - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: "3.11" diff --git a/.github/workflows/check_spelling.yml b/.github/workflows/check_spelling.yml index 4fd8e0d..d2e830b 100644 --- a/.github/workflows/check_spelling.yml +++ b/.github/workflows/check_spelling.yml @@ -18,6 +18,6 @@ jobs: - name: Checkout OpenBT repository uses: actions/checkout@v7 - name: Spell Check Repo - uses: crate-ci/typos@v1.47.2 + uses: crate-ci/typos@v1.48.0 with: config: ${{ env.TYPOS_CFG }} diff --git a/.github/workflows/measure_coverage.yml b/.github/workflows/measure_coverage.yml index bdd7603..c8aca60 100644 --- a/.github/workflows/measure_coverage.yml +++ b/.github/workflows/measure_coverage.yml @@ -27,7 +27,7 @@ jobs: sudo apt-get update sudo apt-get -y install openmpi-bin libopenmpi-dev - name: Set up Python - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: "3.14" - name: Setup Python dependencies diff --git a/.github/workflows/test_CLTs.yml b/.github/workflows/test_CLTs.yml index c04e561..7bca0cc 100644 --- a/.github/workflows/test_CLTs.yml +++ b/.github/workflows/test_CLTs.yml @@ -51,7 +51,7 @@ jobs: fi fi - name: Set up Python - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: "3.14" - name: Install Meson build system diff --git a/.github/workflows/test_py_devmode.yml b/.github/workflows/test_py_devmode.yml index 7028701..2602513 100644 --- a/.github/workflows/test_py_devmode.yml +++ b/.github/workflows/test_py_devmode.yml @@ -28,7 +28,7 @@ jobs: - name: Checkout OpenBT uses: actions/checkout@v7 - name: Set up Python - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: "3.14" - name: Setup Python dependencies diff --git a/.github/workflows/test_py_sdist.yml b/.github/workflows/test_py_sdist.yml index 4fcb14a..ff75445 100644 --- a/.github/workflows/test_py_sdist.yml +++ b/.github/workflows/test_py_sdist.yml @@ -26,7 +26,7 @@ jobs: steps: - uses: actions/checkout@v7 - name: Setup Python - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: "3.14" - name: Setup base Python environment @@ -103,7 +103,7 @@ jobs: fi fi - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v6 + uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} - name: Setup Python dependencies diff --git a/.gitignore b/.gitignore index 11f91bc..6ff199f 100644 --- a/.gitignore +++ b/.gitignore @@ -34,6 +34,9 @@ openbt_pypkg/coverage.xml openbt_pypkg/htmlcov openbt_pypkg/src/openbt.egg-info openbt_pypkg/src/openbt/_version.py +openbt_pypkg/src/openbt/include/ +openbt_pypkg/src/openbt/lib/ + # Other files -.DS_Store +.DS_Store \ No newline at end of file diff --git a/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb b/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb index c72962d..c6f40b6 100644 --- a/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb +++ b/Examples/BART_BMM_Technometrics_2024/BART_BMM_Technometrics.ipynb @@ -1,847 +1,678 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## BART-BMM Examples\n", + "\n", + "This notebook reproduces the BART-BMM examples shown in [\"Model Mixing Using Bayesian Additive Regression Trees\"](https://www.tandfonline.com/doi/full/10.1080/00401706.2023.2257765).\n", + "\n", + "### **Installation Step**\n", + "\n", + "This notebook uses the OpenBT Python package from this repository (`openbt_pypkg`), which wraps the OpenBT C++ command line tools.\n", + "\n", + "See the \"Getting Started with Python\" section of the [OpenBT User Guide](https://openbt.readthedocs.io) for full dependency and installation details.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SqKKvc8ZS8d7" + }, + "source": [ + "### **Python Setup**\n", + "Next, import the required python libraries." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "ZuRGYOA8VBYC" + }, + "outputs": [], + "source": [ + "# Required Imports\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as ticker\n", + "from scipy.stats import norm\n", + "from scipy.special import gamma\n", + "import sys\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The BART-BMM mixing model is provided directly by the `openbt` package's `Openbtmix` class (`openbt.openbtmixing`), which wraps the `openbtcli`, `openbtpred`, and `openbtmixingwts` command line tools built during installation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we load the data required to reproduce these examples. The training/test data live in the `Data/` folder next to this notebook, and the Honda EFT model definitions live in `eft_models.py` in this same folder." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### **EFT Setup**\n", + "\n", + "The following lines of code import the `sin_cos_exp` Taylor-series model class bundled with `openbt` (used in Example 2) and the Honda EFT model functions from `eft_models.py` (used in Examples 1a/1b). Additionally, the EFT model wrapper class is created (`honda_models`)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# openbt imports\n", + "from openbt import Openbtmix\n", + "from openbt.tests.polynomial_models import sin_exp, cos_exp, sin_cos_exp" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "x0Bi_I8kI6uP" + }, + "outputs": [], + "source": [ + "import eft_models as eft" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Wrap honda models\n", + "class honda_models:\n", + " def __init__(self, sg = True, N = 2):\n", + " self.N = N\n", + " self.sg = sg\n", + "\n", + " def evaluate(self, x):\n", + " if isinstance(x, list):\n", + " x = np.array(x)\n", + " if self.sg:\n", + " m = eft.fsg(x,self.N)\n", + " s = eft.dsg(x,self.N)\n", + " else:\n", + " m = eft.flg(x,self.N)\n", + " s = eft.dlg(x,self.N)\n", + " if len(m.shape) == 1:\n", + " m = m.reshape(m.shape[0],1)\n", + " s = s.reshape(s.shape[0],1)\n", + " return m,s" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TFQuzuJPJHSs" + }, + "source": [ + "### **Example 1a:**\n", + "\n", + "This section provides the code to reproduce the BART-BMM results for the first EFT example in the manuscript." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The BART-BMM model is trained using the following steps.\n", + "\n", + "1. Define the model set using the two lines of code shown below, each of which creates a class instance for one of the EFT models." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the models\n", + "fs2 = honda_models(True,2)\n", + "fl4 = honda_models(False,4)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Format training and test data\n", + "x_train = np.linspace(0.03,0.5,num = 20)\n", + "x_test = np.linspace(0.03,0.5,num = 200)\n", + "y_train = np.loadtxt(\"Data/honda_y_train.txt\")\n", + "\n", + "y_train = y_train.reshape(20,1)\n", + "x_train = x_train.reshape(20,1)\n", + "x_test = x_test.reshape(200,1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Define the class instance of the BART-BMM model using the `Openbtmix` class. For this example, the class instance is called `mix`.\n", + "\n", + "3. Set the prior information using the `set_prior()` method.\n", + "\n", + "4. Fit the model using `train()`. This requires the user to pass in the data, the evaluated model set (`f_train`), the informative-prior standard deviations (`s_train`), and relevant MCMC arguments." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('numcut', 300)\n", + "Running model...\n" + ] } + ], + "source": [ + "# Fit the BMM Model\n", + "# Evaluate the model set at the training inputs\n", + "f_train = np.concatenate([fs2.evaluate(x_train)[0], fl4.evaluate(x_train)[0]], axis=1)\n", + "s_train = np.concatenate([fs2.evaluate(x_train)[1], fl4.evaluate(x_train)[1]], axis=1)\n", + "\n", + "# Initialize the Openbtmix class instance\n", + "mix = Openbtmix()\n", + "\n", + "# Set prior information\n", + "mix.set_prior(k=5.5,ntree=10,nu=5,sighat=0.01,inform_prior=True)\n", + "\n", + "# Train the model\n", + "fit = mix.train(x_train=x_train, y_train=y_train, f_train=f_train, s_train=s_train,\n", + " ndpost = 20000, nadapt = 5000, nskip = 2000, adaptevery = 500, minnumbot = 3,\n", + " tc = 2,numcut = 300)" + ] }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "## BART-BMM Examples\n", - "\n", - "This notebook reproduces the BART-BMM examples shown in \"Model Mixing Using Bayesian Additive Regression Trees.\" Each code cell can be executed by clicking the \"play\" button, which is found on the lefthand side of the cell. Alternatively, one can click inside the cell and use the command `shift + enter`.\n", - "\n", - "\n", - "### **Installation Step**\n", - "\n", - "The first set of code cells will pull the openbt package from its github repository. It will then be installed in this ***virtual environment***." - ], - "metadata": { - "id": "QzzGbACrSTz6" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "FBoGbNpBsvE6" - }, - "outputs": [], - "source": [ - "!wget -q https://github.com/jcyannotty/OpenBT/raw/main/openbt_mixing0.current_amd64-MPI_Ubuntu_20.04.deb" - ] - }, - { - "cell_type": "code", - "source": [ - "!dpkg -i openbt_mixing0.current_amd64-MPI_Ubuntu_20.04.deb" - ], - "metadata": { - "id": "cVLMD7wAtS5s", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "924136a8-9f20-4455-f618-acae41392d1b" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Selecting previously unselected package openbt.\n", - "(Reading database ... 120500 files and directories currently installed.)\n", - "Preparing to unpack openbt_mixing0.current_amd64-MPI_Ubuntu_20.04.deb ...\n", - "Unpacking openbt (0.current-MPI) ...\n", - "Setting up openbt (0.current-MPI) ...\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "!ldconfig" - ], - "metadata": { - "id": "klEsFy2xt0ZN" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### **Python Setup**\n", - "Next, import the required python libraries." - ], - "metadata": { - "id": "SqKKvc8ZS8d7" - } - }, - { - "cell_type": "code", - "source": [ - "# Required Imports\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib.ticker as ticker\n", - "from scipy.stats import norm\n", - "from scipy.special import gamma\n", - "import sys\n", - "import os" - ], - "metadata": { - "id": "ZuRGYOA8VBYC" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "The BART-BMM software is included in the Taweret python package. This package includes model mixing methodology developed by the Bayesian Analysis of Nuclear Dynamics (BAND) collaboration. It will be publicly released in the coming months." - ], - "metadata": { - "id": "n3AzVUdMTMVQ" - } - }, - { - "cell_type": "code", - "source": [ - "# Clone the Taweret Repo\n", - "!git clone https://github.com/jcyannotty/Taweret.git\n", - "!cd Taweret && git checkout develop" - ], - "metadata": { - "id": "Gnn6RcAcVcw_", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "4b773298-c7b3-44e5-f780-1d686f45a830" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Cloning into 'Taweret'...\n", - "remote: Enumerating objects: 2200, done.\u001b[K\n", - "remote: Counting objects: 100% (520/520), done.\u001b[K\n", - "remote: Compressing objects: 100% (126/126), done.\u001b[K\n", - "remote: Total 2200 (delta 434), reused 445 (delta 393), pack-reused 1680\u001b[K\n", - "Receiving objects: 100% (2200/2200), 77.19 MiB | 23.70 MiB/s, done.\n", - "Resolving deltas: 100% (1176/1176), done.\n", - "Branch 'develop' set up to track remote branch 'develop' from 'origin'.\n", - "Switched to a new branch 'develop'\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "sys.path.insert(0,'/content/Taweret')" - ], - "metadata": { - "id": "tIRQ34KbUIo9" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "Next, we can pull data required to reproduce these examples." - ], - "metadata": { - "id": "tyjbqQJWTtNV" - } - }, - { - "cell_type": "code", - "source": [ - "!wget -q https://github.com/jcyannotty/OpenBT/raw/main/Python/eft_models.py" - ], - "metadata": { - "id": "lb2b067Y1NO0" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "!wget -q https://github.com/jcyannotty/OpenBT/raw/main/Examples/Data/honda_y_train.txt\n", - "!wget -q https://github.com/jcyannotty/OpenBT/raw/main/Examples/Data/2d_x_train.txt\n", - "!wget -q https://github.com/jcyannotty/OpenBT/raw/main/Examples/Data/2d_y_train.txt" - ], - "metadata": { - "id": "edyzQNUh20b3" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### **Taweret and EFT Setup**\n", - "\n", - "The following lines of code import specific modules from Taweret which are required to reproduce these examples. Additionally, the EFT model class is created (honda_models)." - ], - "metadata": { - "id": "-y74jgN-T2Rg" - } - }, - { - "cell_type": "code", - "source": [ - "# Taweret Imports\n", - "from Taweret.models.polynomial_models import sin_exp, cos_exp, sin_cos_exp\n", - "from Taweret.mix.trees import Trees\n", - "from Taweret.core.base_model import BaseModel" - ], - "metadata": { - "id": "iPvragCRVgpL" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "import eft_models as eft" - ], - "metadata": { - "id": "x0Bi_I8kI6uP" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Wrap honda models\n", - "class honda_models(BaseModel):\n", - " def __init__(self,sg = True, N = 2):\n", - " self.N = N\n", - " self.sg = sg\n", - "\n", - " def evaluate(self, x):\n", - " if isinstance(x, list):\n", - " x = np.array(x)\n", - " if self.sg:\n", - " m = eft.fsg(x,self.N)\n", - " s = eft.dsg(x,self.N)\n", - " else:\n", - " m = eft.flg(x,self.N)\n", - " s = eft.dlg(x,self.N)\n", - " if len(m.shape) == 1:\n", - " m = m.reshape(m.shape[0],1)\n", - " s = s.reshape(s.shape[0],1)\n", - " return m,s\n", - "\n", - " def set_prior(self):\n", - " return super().set_prior()\n", - "\n", - " def log_likelihood_elementwise(self):\n", - " return super().log_likelihood_elementwise()\n" - ], - "metadata": { - "id": "fw3J1Dhcy_q-" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "### **Example 1a:**\n", - "\n", - "This section provides the code to reproduce the BART-BMM results for the first EFT example in the manuscript." - ], - "metadata": { - "id": "TFQuzuJPJHSs" - } - }, - { - "cell_type": "markdown", - "source": [ - "The BART-BMM model is trained using the following steps.\n", - "\n", - "1. Define the model set using the three lines of code shown below. The first two lines define a class instance for each EFT model. The third line of code defines the model set. " - ], - "metadata": { - "id": "4HCBcf99VMWs" - } - }, - { - "cell_type": "code", - "source": [ - "# Load the models, create the model set\n", - "fs2 = honda_models(True,2)\n", - "fl4 = honda_models(False,4)\n", - "model_dict = {\"model1\":fs2,\"model2\":fl4}" - ], - "metadata": { - "id": "i81g7jbAJbqi" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Format training and test data\n", - "x_train = np.linspace(0.03,0.5,num = 20)\n", - "x_test = np.linspace(0.03,0.5,num = 200)\n", - "y_train = np.loadtxt(\"honda_y_train.txt\")\n", - "\n", - "y_train = y_train.reshape(20,1)\n", - "x_train = x_train.reshape(20,1)\n", - "x_test = x_test.reshape(200,1)\n" - ], - "metadata": { - "id": "TZ4NBUpeJnsV" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "2. Define the class instance of the BART-BMM model using the `Trees` class. For this example, the class instance is called `mix`.\n", - "\n", - "3. Set the prior information using the `set_prior()` method.\n", - "\n", - "4. Fit the model using the `train()`. This requires the user to pass in the data and relevant MCMC arguments. " - ], - "metadata": { - "id": "w4mwJ3yxVa_u" - } - }, - { - "cell_type": "code", - "source": [ - "# Fit the BMM Model\n", - "# Initialize the Trees class instance\n", - "mix = Trees(model_dict = model_dict, google_colab = True)\n", - "\n", - "# Set prior information\n", - "mix.set_prior(k=5.5,ntree=10,overallnu=5,overallsd=0.01,inform_prior=True)\n", - "\n", - "# Train the model\n", - "fit = mix.train(X=x_train, y=y_train, ndpost = 20000, nadapt = 5000, nskip = 2000, adaptevery = 500, minnumbot = 3,\n", - " tc = 2,numcut = 300)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "7XFXprPL46At", - "outputId": "dafa231d-1fc9-42e6-eb28-0ea764d62bb2" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Results stored in temporary path: /tmp/openbtpy_g53ic6t1\n", - "Running model...\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. Both methods require an array of test points and a confidence level." - ], - "metadata": { - "id": "Njm7D2mQVofQ" - } - }, - { - "cell_type": "code", - "source": [ - "# Get predictions\n", - "ppost, pmean, pci, pstd = mix.predict(X = x_test, ci = 0.95)\n", - "wpost, wmean, wci, wstd = mix.predict_weights(X = x_test, ci = 0.95)\n" - ], - "metadata": { - "id": "twbkYZMI83VU" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "6. Plot the resulting predictions and weight functions." - ], - "metadata": { - "id": "bCoZw9zDVrII" - } - }, - { - "cell_type": "code", - "source": [ - "# Predictions - Upper and Lower ci bounds\n", - "plower = pci[0]\n", - "pupper = pci[1]\n", - "\n", - "# Weight Functions - Upper and Lower ci bounds\n", - "wlower = wci[0]\n", - "wupper = wci[1]\n", - "\n", - "# EFT predictions at test points\n", - "f_test = [fs2.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]\n", - "\n", - "# Define the underlying true model\n", - "fdagger = eft.f_dagger(x_test)" - ], - "metadata": { - "id": "_XdK7S0w-AxU" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Plot the predictions and weight functions\n", - "col_list = ['red','blue','green','purple','orange']\n", - "\n", - "fig, ax = plt.subplots(1,2,figsize=(12,5))\n", - "ax[0].plot(x_test, fdagger, color = 'black')\n", - "ax[0].plot(x_test, pmean, color = 'purple')\n", - "for i in range(2):\n", - " ax[0].plot(x_test, f_test[i], color = col_list[i], linestyle = 'dotted')\n", - "ax[0].scatter(x_train ,y_train,c=\"black\")\n", - "ax[0].set_title(\"Posterior Mean Prediction\")\n", - "ax[0].set_xlabel(\"X\")\n", - "ax[0].set_ylabel(\"F(X)\")\n", - "ax[0].set_ylim(1.8,2.8)\n", - "ax[0].fill_between(x_test.reshape(200,), plower, pupper, facecolor='purple', alpha=0.3)\n", - "ax[0].grid(True, color='lightgrey')\n", - "\n", - "\n", - "for i in range(2):\n", - " ax[1].plot(x_test, wmean[:,i], color = col_list[i])\n", - " ax[1].fill_between(x_test.reshape(200,), wlower[:,i], wupper[:,i], color = col_list[i], alpha = 0.3)\n", - "ax[1].set_title(\"Posterior Weight Functions\")\n", - "ax[1].set_xlabel(\"X\")\n", - "ax[1].set_ylabel(\"W(X)\")\n", - "ax[1].grid(True, color='lightgrey')\n", - "\n", - "\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 487 - }, - "id": "xhw8PPAd89qi", - "outputId": "6de8b8bf-b3e1-417f-bad0-223d262be62e" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "### **Example 1b:**\n", - "\n", - "This section provides the code to reproduce the BART-BMM results for example 1b in the manuscript." - ], - "metadata": { - "id": "lDJp2kAYJMeF" - } - }, - { - "cell_type": "markdown", - "source": [ - "The BART-BMM model is trained using the following steps.\n", - "\n", - "1. Define the model set using the three lines of code shown below. The first two lines define a class instance for each EFT model. The third line of code defines the model set. " - ], - "metadata": { - "id": "NvszngrcV2bl" - } - }, - { - "cell_type": "code", - "source": [ - "# Redefine the model set\n", - "fs4 = honda_models(True,4)\n", - "model_dict = {\"model1\":fs4,\"model2\":fl4}" - ], - "metadata": { - "id": "YMVfKwJzJPT8" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "2. Define the class instance of the BART-BMM model using the `Trees` class. For this example, the class instance is called `mix`.\n", - "\n", - "3. Set the prior information using the `set_prior()` method.\n", - "\n", - "4. Fit the model using the `train()`. This requires the user to pass in the data and relevant MCMC arguments. " - ], - "metadata": { - "id": "H_JYLHFMV6a_" - } - }, - { - "cell_type": "code", - "source": [ - "# Fit the BMM Model\n", - "# Initialize the Trees class instance\n", - "mix = Trees(model_dict = model_dict, google_colab = True)\n", - "\n", - "# Set prior information\n", - "mix.set_prior(k=5.0,ntree=10,overallnu=5,overallsd=0.01,inform_prior=True)\n", - "\n", - "# Train the model\n", - "fit = mix.train(X=x_train, y=y_train, ndpost = 20000, nadapt = 5000, nskip = 2000, adaptevery = 500, minnumbot = 3,\n", - " tc = 2,numcut = 300)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "P5rtbhRNJZiA", - "outputId": "5095861c-d060-43a2-da0c-30c4f1147f99" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Results stored in temporary path: /tmp/openbtpy_ya3zown0\n", - "Running model...\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. Both methods require an array of test points and a confidence level." - ], - "metadata": { - "id": "pJdmM4kVV-D1" - } - }, - { - "cell_type": "code", - "source": [ - "# Get predictions\n", - "ppost, pmean, pci, pstd = mix.predict(X = x_test, ci = 0.95)\n", - "wpost, wmean, wci, wstd = mix.predict_weights(X = x_test, ci = 0.95)\n" - ], - "metadata": { - "id": "HBJ61xMxJdLc" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "6. Plot the predictions and weight functions." - ], - "metadata": { - "id": "_0Ch2Z5bV_X9" - } - }, - { - "cell_type": "code", - "source": [ - "# Predcition upper and lower bounds\n", - "plower = pci[0]\n", - "pupper = pci[1]\n", - "\n", - "# Weight Functions upper and lower bounds\n", - "wlower = wci[0]\n", - "wupper = wci[1]\n", - "\n", - "# F test data\n", - "f_test = [fs4.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]" - ], - "metadata": { - "id": "OdW84RzBJgO6" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Plot the predictions and weight functions\n", - "col_list = ['red','blue','green','purple','orange']\n", - "\n", - "fig, ax = plt.subplots(1,2,figsize=(12,5))\n", - "ax[0].plot(x_test, fdagger, color = 'black')\n", - "ax[0].plot(x_test, pmean, color = 'purple')\n", - "for i in range(2):\n", - " ax[0].plot(x_test, f_test[i], color = col_list[i], linestyle = 'dotted')\n", - "ax[0].scatter(x_train ,y_train,c=\"black\")\n", - "ax[0].set_title(\"Posterior Mean Prediction\")\n", - "ax[0].set_xlabel(\"X\") # Update Label\n", - "ax[0].set_ylabel(\"F(X)\") # Update Label\n", - "ax[0].set_ylim(1.8,2.8)\n", - "ax[0].fill_between(x_test.reshape(200,), plower, pupper, facecolor='purple', alpha=0.3)\n", - "ax[0].grid(True, color='lightgrey')\n", - "\n", - "\n", - "for i in range(2):\n", - " ax[1].plot(x_test, wmean[:,i], color = col_list[i])\n", - " ax[1].fill_between(x_test.reshape(200,), wlower[:,i], wupper[:,i], color = col_list[i], alpha = 0.3)\n", - "ax[1].set_title(\"Posterior Weight Functions\")\n", - "ax[1].set_xlabel(\"X\")\n", - "ax[1].set_ylabel(\"W(X)\")\n", - "ax[1].grid(True, color='lightgrey')\n", - "\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 487 - }, - "id": "I-f8MkmmJnqq", - "outputId": "df0d0dbd-7bd4-45cb-e63f-3225bed0a677" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. `predict()` requires the test inputs, the evaluated model set at those inputs, and a confidence level; `predict_weights()` requires just the test inputs and a confidence level." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Evaluate the model set at the test inputs\n", + "f_test_arr = np.concatenate([fs2.evaluate(x_test)[0], fl4.evaluate(x_test)[0]], axis=1)\n", + "\n", + "# Get predictions\n", + "pred = mix.predict(x_test=x_test, f_test=f_test_arr, ci=0.95)\n", + "wts = mix.predict_weights(x_test=x_test, ci=0.95)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bCoZw9zDVrII" + }, + "source": [ + "6. Plot the resulting predictions and weight functions." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Predictions - Upper and Lower ci bounds\n", + "pmean = pred[\"pred\"][\"mean\"]\n", + "plower = pred[\"pred\"][\"lb\"]\n", + "pupper = pred[\"pred\"][\"ub\"]\n", + "\n", + "# Weight Functions - Upper and Lower ci bounds\n", + "wmean = wts[\"wts\"][\"mean\"]\n", + "wlower = wts[\"wts\"][\"lb\"]\n", + "wupper = wts[\"wts\"][\"ub\"]\n", + "\n", + "# EFT predictions at test points\n", + "f_test = [fs2.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]\n", + "\n", + "# Define the underlying true model\n", + "fdagger = eft.f_dagger(x_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "xhw8PPAd89qi", + "outputId": "6de8b8bf-b3e1-417f-bad0-223d262be62e" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, - { - "cell_type": "markdown", - "source": [ - "## **Example 2**\n", - "\n", - "The BART-BMM model is trained using the following steps.\n", - "\n", - "1. Define the model set using the three lines of code shown below. The first two lines define a class instance for each Taylor series expansion. The third line of code defines the model set. " - ], - "metadata": { - "id": "T6o6fkY6WA5L" - } - }, - { - "cell_type": "code", - "source": [ - "# Define the model set\n", - "f1 = sin_cos_exp(7,10,np.pi,np.pi) # 7th order sin(x1) + 10th order cos(x2)\n", - "f2 = sin_cos_exp(13,6,-np.pi,-np.pi) # 13th order sin(x1) + 6th order cos(x2)\n", - "model_dict = {'model1':f1, 'model2':f2}\n", - "\n", - "# Get train data\n", - "x_train = np.loadtxt(\"2d_x_train.txt\").reshape(80,2)\n", - "x_train = x_train.reshape(2,80).transpose()\n", - "\n", - "y_train = np.loadtxt(\"2d_y_train.txt\").reshape(80,1)\n", - "\n", - "# Get test data\n", - "n_test = 30\n", - "x1_test = np.outer(np.linspace(-np.pi, np.pi, n_test), np.ones(n_test))\n", - "x2_test = x1_test.copy().transpose()\n", - "f0_test = (np.sin(x1_test) + np.cos(x2_test))\n", - "x_test = np.array([x1_test.reshape(x1_test.size,),x2_test.reshape(x1_test.size,)]).transpose()\n" - ], - "metadata": { - "id": "WUnzkJlVWFtM" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "2. Define the class instance of the BART-BMM model using the `Trees` class. For this example, the class instance is called `mix`.\n", - "\n", - "3. Set the prior information using the `set_prior()` method.\n", - "\n", - "4. Fit the model using the `train()`. This requires the user to pass in the data and relevant MCMC arguments. " - ], - "metadata": { - "id": "JdUjxZV2YMqn" - } - }, - { - "cell_type": "code", - "source": [ - "# Fit the BMM Model\n", - "# Initialize the Trees class instance\n", - "mix = Trees(model_dict = model_dict, google_colab = True)\n", - "\n", - "# Set prior information\n", - "mix.set_prior(k=2.0,ntree=30,overallnu=5,overallsd=0.01,inform_prior=False)\n", - "\n", - "# Train the model\n", - "fit = mix.train(X=x_train, y=y_train, ndpost = 5000, nadapt = 2000, nskip = 1000, adaptevery = 200, minnumbot = 4, tc = 2)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "gd981k7zYUWP", - "outputId": "ce1c8242-e358-42eb-b6bd-65d03b020c82" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Results stored in temporary path: /tmp/openbtpy_k074kw9y\n", - "Running model...\n" - ] - } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the predictions and weight functions\n", + "col_list = ['red','blue','green','purple','orange']\n", + "\n", + "fig, ax = plt.subplots(1,2,figsize=(12,5))\n", + "ax[0].plot(x_test, fdagger, color = 'black')\n", + "ax[0].plot(x_test, pmean, color = 'purple')\n", + "for i in range(2):\n", + " ax[0].plot(x_test, f_test[i], color = col_list[i], linestyle = 'dotted')\n", + "ax[0].scatter(x_train ,y_train,c=\"black\")\n", + "ax[0].set_title(\"Posterior Mean Prediction\")\n", + "ax[0].set_xlabel(\"X\")\n", + "ax[0].set_ylabel(\"F(X)\")\n", + "ax[0].set_ylim(1.8,2.8)\n", + "ax[0].fill_between(x_test.reshape(200,), plower, pupper, facecolor='purple', alpha=0.3)\n", + "ax[0].grid(True, color='lightgrey')\n", + "\n", + "for i in range(2):\n", + " ax[1].plot(x_test, wmean[:,i], color = col_list[i])\n", + " ax[1].fill_between(x_test.reshape(200,), wlower[:,i], wupper[:,i], color = col_list[i], alpha = 0.3)\n", + "ax[1].set_title(\"Posterior Weight Functions\")\n", + "ax[1].set_xlabel(\"X\")\n", + "ax[1].set_ylabel(\"W(X)\")\n", + "ax[1].grid(True, color='lightgrey')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lDJp2kAYJMeF" + }, + "source": [ + "### **Example 1b:**\n", + "\n", + "This section provides the code to reproduce the BART-BMM results for example 1b in the manuscript." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The BART-BMM model is trained using the following steps.\n", + "\n", + "1. Define the model set using the line of code shown below, which creates a class instance for the new EFT model. The other EFT model, `fl4`, is reused from Example 1a." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Redefine the model set\n", + "fs4 = honda_models(True,4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Define the class instance of the BART-BMM model using the `Openbtmix` class. For this example, the class instance is called `mix`.\n", + "\n", + "3. Set the prior information using the `set_prior()` method.\n", + "\n", + "4. Fit the model using `train()`. This requires the user to pass in the data, the evaluated model set (`f_train`), the informative-prior standard deviations (`s_train`), and relevant MCMC arguments." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('numcut', 300)\n", + "Running model...\n" + ] + } + ], + "source": [ + "# Fit the BMM Model\n", + "# Evaluate the model set at the training inputs\n", + "f_train = np.concatenate([fs4.evaluate(x_train)[0], fl4.evaluate(x_train)[0]], axis=1)\n", + "s_train = np.concatenate([fs4.evaluate(x_train)[1], fl4.evaluate(x_train)[1]], axis=1)\n", + "\n", + "# Initialize the Openbtmix class instance\n", + "mix = Openbtmix()\n", + "\n", + "# Set prior information\n", + "mix.set_prior(k=5.0,ntree=10,nu=5,sighat=0.01,inform_prior=True)\n", + "\n", + "# Train the model\n", + "fit = mix.train(x_train=x_train, y_train=y_train, f_train=f_train, s_train=s_train,\n", + " ndpost = 20000, nadapt = 5000, nskip = 2000, adaptevery = 500, minnumbot = 3,\n", + " tc = 2,numcut = 300)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. `predict()` requires the test inputs, the evaluated model set at those inputs, and a confidence level; `predict_weights()` requires just the test inputs and a confidence level." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Evaluate the model set at the test inputs\n", + "f_test_arr = np.concatenate([fs4.evaluate(x_test)[0], fl4.evaluate(x_test)[0]], axis=1)\n", + "\n", + "# Get predictions\n", + "pred = mix.predict(x_test=x_test, f_test=f_test_arr, ci=0.95)\n", + "wts = mix.predict_weights(x_test=x_test, ci=0.95)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_0Ch2Z5bV_X9" + }, + "source": [ + "6. Plot the predictions and weight functions." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Predcition upper and lower bounds\n", + "pmean = pred[\"pred\"][\"mean\"]\n", + "plower = pred[\"pred\"][\"lb\"]\n", + "pupper = pred[\"pred\"][\"ub\"]\n", + "\n", + "# Weight Functions upper and lower bounds\n", + "wmean = wts[\"wts\"][\"mean\"]\n", + "wlower = wts[\"wts\"][\"lb\"]\n", + "wupper = wts[\"wts\"][\"ub\"]\n", + "\n", + "# F test data\n", + "f_test = [fs4.evaluate(x_test)[0],fl4.evaluate(x_test)[0]]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "I-f8MkmmJnqq", + "outputId": "df0d0dbd-7bd4-45cb-e63f-3225bed0a677" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, - { - "cell_type": "markdown", - "source": [ - "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. Both methods require an array of test points and a confidence level." - ], - "metadata": { - "id": "ss60BLXDYXSF" - } - }, - { - "cell_type": "code", - "source": [ - "# Get predictions\n", - "ppost, pmean, pci, pstd = mix.predict(X = x_test, ci = 0.95)\n", - "wpost, wmean, wci, wstd = mix.predict_weights(X = x_test, ci = 0.95)\n" - ], - "metadata": { - "id": "P9aVdBgrYg_-" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# The posterior mean weight functions\n", - "cmap_hot = plt.get_cmap('hot')\n", - "w1 = wmean.transpose()[0]\n", - "w2 = wmean.transpose()[1]\n", - "\n", - "w1_mean = wmean.transpose()[0]\n", - "w1_mean = w1_mean.reshape(x1_test.shape).transpose()\n", - "\n", - "w2_mean = wmean.transpose()[1]\n", - "w2_mean = w2_mean.reshape(x1_test.shape).transpose()\n", - "\n", - "w_sum = w1_mean + w2_mean\n", - "\n", - "# Posterior Mean resiudals\n", - "cmap_rb = plt.get_cmap(\"RdBu\")\n", - "fig, ax = plt.subplots(1,3, figsize = (24,6))\n", - "\n", - "pcm1 = ax[0].pcolormesh((f0_test - pmean.reshape(x1_test.shape)).transpose(),cmap = cmap_rb, vmin = -2.5, vmax = 2.5)\n", - "ax[0].set_title(\"Posterior Mean Residuals\", size = 16)\n", - "ax[0].set(xlabel = \"$x_1$\", ylabel = \"$x_2$\")\n", - "ax[0].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[0].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "ax[0].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[0].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "\n", - "fig.colorbar(pcm1,ax = ax[0])\n", - "\n", - "pcm0 = ax[1].pcolormesh(w1_mean,cmap = cmap_hot, vmin = -0.05, vmax = 1.05)\n", - "ax[1].set_title(\"Posterior Mean of $w_1(x)$\", size = 16)\n", - "ax[1].set(xlabel = \"$x_1$\", ylabel = \"$x_2\")\n", - "ax[1].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[1].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "ax[1].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[1].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "fig.colorbar(pcm0,ax = ax[1])\n", - "\n", - "pcm2 = ax[2].pcolormesh(w2_mean,cmap = cmap_hot, vmin = -0.05, vmax = 1.05)\n", - "ax[2].set_title(\"Posterior Mean of $w_2(x)$\", size = 16)\n", - "ax[2].set(xlabel = \"$x_1$\", ylabel = \"$x_2$\")\n", - "ax[2].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[2].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "ax[2].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", - "ax[2].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", - "fig.colorbar(pcm2,ax = ax[2])\n", - "fig.suptitle(\"Posterior Mean Residuals and Weight Functions\", size = 18)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 412 - }, - "id": "meVGDrOAZp5w", - "outputId": "831c346f-95af-47f6-8783-094f81317f36" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Text(0.5, 0.98, 'Posterior Mean Residuals and Weight Functions')" - ] - }, - "metadata": {}, - "execution_count": 15 - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the predictions and weight functions\n", + "col_list = ['red','blue','green','purple','orange']\n", + "\n", + "fig, ax = plt.subplots(1,2,figsize=(12,5))\n", + "ax[0].plot(x_test, fdagger, color = 'black')\n", + "ax[0].plot(x_test, pmean, color = 'purple')\n", + "for i in range(2):\n", + " ax[0].plot(x_test, f_test[i], color = col_list[i], linestyle = 'dotted')\n", + "ax[0].scatter(x_train ,y_train,c=\"black\")\n", + "ax[0].set_title(\"Posterior Mean Prediction\")\n", + "ax[0].set_xlabel(\"X\") # Update Label\n", + "ax[0].set_ylabel(\"F(X)\") # Update Label\n", + "ax[0].set_ylim(1.8,2.8)\n", + "ax[0].fill_between(x_test.reshape(200,), plower, pupper, facecolor='purple', alpha=0.3)\n", + "ax[0].grid(True, color='lightgrey')\n", + "\n", + "\n", + "for i in range(2):\n", + " ax[1].plot(x_test, wmean[:,i], color = col_list[i])\n", + " ax[1].fill_between(x_test.reshape(200,), wlower[:,i], wupper[:,i], color = col_list[i], alpha = 0.3)\n", + "ax[1].set_title(\"Posterior Weight Functions\")\n", + "ax[1].set_xlabel(\"X\")\n", + "ax[1].set_ylabel(\"W(X)\")\n", + "ax[1].grid(True, color='lightgrey')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Example 2**\n", + "\n", + "The BART-BMM model is trained using the following steps.\n", + "\n", + "1. Define the model set using the two lines of code shown below, each of which creates a class instance for a Taylor series expansion." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Define the model set\n", + "f1 = sin_cos_exp(7,10,np.pi,np.pi) # 7th order sin(x1) + 10th order cos(x2)\n", + "f2 = sin_cos_exp(13,6,-np.pi,-np.pi) # 13th order sin(x1) + 6th order cos(x2)\n", + "\n", + "# Get train data\n", + "x_train = np.loadtxt(\"Data/2d_x_train.txt\").reshape(80,2)\n", + "x_train = x_train.reshape(2,80).transpose()\n", + "\n", + "y_train = np.loadtxt(\"Data/2d_y_train.txt\").reshape(80,1)\n", + "\n", + "# Get test data\n", + "n_test = 30\n", + "x1_test = np.outer(np.linspace(-np.pi, np.pi, n_test), np.ones(n_test))\n", + "x2_test = x1_test.copy().transpose()\n", + "f0_test = (np.sin(x1_test) + np.cos(x2_test))\n", + "x_test = np.array([x1_test.reshape(x1_test.size,),x2_test.reshape(x1_test.size,)]).transpose()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Define the class instance of the BART-BMM model using the `Openbtmix` class. For this example, the class instance is called `mix`.\n", + "\n", + "3. Set the prior information using the `set_prior()` method.\n", + "\n", + "4. Fit the model using `train()`. This requires the user to pass in the data, the evaluated model set (`f_train`), and relevant MCMC arguments." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running model...\n" + ] + } + ], + "source": [ + "# Fit the BMM Model\n", + "# Evaluate the model set at the training inputs\n", + "f_train = np.concatenate([f1.evaluate(x_train)[0], f2.evaluate(x_train)[0]], axis=1)\n", + "\n", + "# Initialize the Openbtmix class instance\n", + "mix = Openbtmix()\n", + "\n", + "# Set prior information\n", + "mix.set_prior(k=2.0,ntree=30,nu=5,sighat=0.01,inform_prior=False)\n", + "\n", + "# Train the model\n", + "fit = mix.train(x_train=x_train, y_train=y_train, f_train=f_train,\n", + " ndpost = 5000, nadapt = 2000, nskip = 1000, adaptevery = 200, minnumbot = 4, tc = 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Obtain the predictions from the mixed function and the corresponding weight functions using the methods `predict()` and `predict_weights()`, respectively. `predict()` requires the test inputs, the evaluated model set at those inputs, and a confidence level; `predict_weights()` requires just the test inputs and a confidence level." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Evaluate the model set at the test inputs\n", + "f_test = np.concatenate([f1.evaluate(x_test)[0], f2.evaluate(x_test)[0]], axis=1)\n", + "\n", + "# Get predictions\n", + "pred = mix.predict(x_test=x_test, f_test=f_test, ci=0.95)\n", + "wts = mix.predict_weights(x_test=x_test, ci=0.95)\n", + "\n", + "pmean = pred[\"pred\"][\"mean\"]\n", + "wmean = wts[\"wts\"][\"mean\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 412 + }, + "id": "meVGDrOAZp5w", + "outputId": "831c346f-95af-47f6-8783-094f81317f36" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" } - ] -} \ No newline at end of file + ], + "source": [ + "# The posterior mean weight functions\n", + "cmap_hot = plt.get_cmap('hot')\n", + "w1 = wmean.transpose()[0]\n", + "w2 = wmean.transpose()[1]\n", + "\n", + "w1_mean = wmean.transpose()[0]\n", + "w1_mean = w1_mean.reshape(x1_test.shape).transpose()\n", + "\n", + "w2_mean = wmean.transpose()[1]\n", + "w2_mean = w2_mean.reshape(x1_test.shape).transpose()\n", + "\n", + "w_sum = w1_mean + w2_mean\n", + "\n", + "# Posterior Mean resiudals\n", + "cmap_rb = plt.get_cmap(\"RdBu\")\n", + "fig, ax = plt.subplots(1,3, figsize = (24,6))\n", + "\n", + "pcm1 = ax[0].pcolormesh((f0_test - pmean.reshape(x1_test.shape)).transpose(),cmap = cmap_rb, vmin = -2.5, vmax = 2.5)\n", + "ax[0].set_title(\"Posterior Mean Residuals\", size = 16)\n", + "ax[0].set(xlabel = \"$x_1$\", ylabel = \"$x_2$\")\n", + "ax[0].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[0].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "ax[0].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[0].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "\n", + "fig.colorbar(pcm1,ax = ax[0])\n", + "\n", + "pcm0 = ax[1].pcolormesh(w1_mean,cmap = cmap_hot, vmin = -0.05, vmax = 1.05)\n", + "ax[1].set_title(\"Posterior Mean of $w_1(x)$\", size = 16)\n", + "ax[1].set(xlabel = \"$x_1$\", ylabel = \"$x_2\")\n", + "ax[1].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[1].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "ax[1].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[1].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "fig.colorbar(pcm0,ax = ax[1])\n", + "\n", + "pcm2 = ax[2].pcolormesh(w2_mean,cmap = cmap_hot, vmin = -0.05, vmax = 1.05)\n", + "ax[2].set_title(\"Posterior Mean of $w_2(x)$\", size = 16)\n", + "ax[2].set(xlabel = \"$x_1$\", ylabel = \"$x_2$\")\n", + "ax[2].xaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[2].xaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "ax[2].yaxis.set_major_locator(ticker.FixedLocator(np.round(np.linspace(0, n_test, 6),3)))\n", + "ax[2].yaxis.set_major_formatter(ticker.FixedFormatter(np.round(np.linspace(-np.pi, np.pi, 6),3)))\n", + "fig.colorbar(pcm2,ax = ax[2])\n", + "_ = fig.suptitle(\"Posterior Mean Residuals and Weight Functions\", size = 18)" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/bibliography_cpp.rst b/docs/bibliography_cpp.rst deleted file mode 100644 index 203aa7f..0000000 --- a/docs/bibliography_cpp.rst +++ /dev/null @@ -1,13 +0,0 @@ -.. raw:: latex - - \cleardoublepage - \begingroup - \renewcommand\chapter[1]{\endgroup} - \phantomsection - -Bibliography -============ - -.. bibliography:: references.bib - :style: plain - :keyprefix: cpp- diff --git a/docs/developer_environment.rst b/docs/developer_environment.rst new file mode 100644 index 0000000..6cbb816 --- /dev/null +++ b/docs/developer_environment.rst @@ -0,0 +1,236 @@ +.. _developer_env: + +Developer Environment +===================== + +This section is a repository of information that might be potentially useful to +developers. Note that information regarding intermediate files/caches that are +created automatically, which might cause issues during development and testing, +is split across sections. + +Eigen +----- +.. _Eigen: https://gitlab.com/libeigen/eigen + +Eigen_ is a header-only C++ template library for linear algebra. Being +header-only means there is no compiled library to link against, it is used +purely by including its headers directly into source files. + +Installation +~~~~~~~~~~~~ + +The |openbt| Meson build system satisfies the Eigen dependence automatically. +First, Meson uses different techniques to search for an existing Eigen +installation. If found, that installation is used for the build. If not found, +Meson falls back to the ``subprojects/eigen.wrap`` file, which instructs it to +download a pinned Eigen version automatically from Eigen's repository and use it +internally for that build. As a result, Eigen is always available to the build +regardless of whether it is preinstalled on the system. + +Developers using macOS who need to test the build system or who prefer to have a +system-wide installation can install Eigen |via| Homebrew: + +.. code-block:: console + + $ brew install eigen + +Meson Build +----------- +.. _Meson: https://mesonbuild.com +.. _ninja: https://ninja-build.org + +The |openbt| Python package uses the Meson_ build system together with its +ninja_ backend to compile the C++ command line tools during installation. +Please refer to the relevant installation instructions to determine if manual +installation of these tools is required for a particular task. + +Please refer to the documentation in ``tools/build_openbt_clt.sh`` for +information about using that tool, for an example of how to configure and use +the Meson build system, and for potential build difficulties (|eg| due to +intermediate and cached files). + +Build Process with Python +~~~~~~~~~~~~~~~~~~~~~~~~~ + +The Meson build is not invoked directly by developers working on or testing the +Python package. The build is triggered automatically when the |openbt| Python +package is installed |via| + +.. code-block:: console + + $ cd /path/to/OpenBT/openbt_pypkg + $ python -m pip install . + +or in editable mode |via| + +.. code-block:: console + + $ python -m pip install -e . + +It is also invoked automatically to build wheels. We generally refer to this +automated process as a "package build." + +Internally, ``setup.py`` defines a custom ``build_clt`` command that wipes and +rebuilds the Meson build directory ``openbt_pypkg/cpp/builddir`` from scratch on +every package build, forcing Meson to re-detect the compiler, MPI, and Eigen +installations rather than reusing stale detection results. Developers who need +the exact Meson invocation can inspect ``build_clt`` in ``setup.py`` directly. + +A successful package build creates the following files and directories: + +* ``openbt_pypkg/cpp/builddir/`` — Meson's working build directory. Build + output including object files are stored here. Since this directory is wiped + and recreated on every package build, it can be deleted safely at any time. + +* ``openbt_pypkg/src/openbt/_version.py`` — Written by ``setuptools_scm`` + from the current git tag, not by Meson. + +Note that while ``openbt_pypkg/cpp`` officially contains the package's C++ +source code and Meson build system, its contents simply alias the actual code +and build system defined at the root of the repository. Therefore, for example, +all intermediate and cached issues associated with the base folder also exist +for package builds. + +Editable Python package installations install build products, such as the +command line tools, directly in a developer's clone rather than inside the +Python execution environment (|eg| within the ``site-packages`` folder of a +virtual environment). These cached files, which can occasionally cause issues, +are + +* ``openbt_pypkg/src/openbt/{bin,include,lib}/`` — The install destination + populated by ``meson install``. This is the most problematic caching layer: + ``meson install`` overlays new files onto these directories but never removes + stale ones. If a binary is renamed, a tool is removed from the build, or + Eigen headers change, the old files persist silently. Consider deleting these + if the build produces unexpected behaviour. Note that, of these contents, + only a subset of the command line tools in ``bin`` is included in a package + build. See ``meson.build`` for the current list of built tools. + +* ``openbt_pypkg/src/openbt/include/eigen3/`` — Eigen headers installed + under the package prefix as a side effect of Eigen's own Meson install step, + regardless of whether Eigen came from the system or the bundled + ``subprojects/eigen.wrap``. These files are unimportant once the command + line tools are built and are not included in package distributions. + +* ``openbt_pypkg/src/openbt/lib/pkgconfig/eigen3.pc`` — A ``pkg-config`` + file for the installed Eigen, with its ``prefix`` pointing into + ``src/openbt/``, that is installed as a side effect. This file is unimportant + and is not included in package distributions. + + +Tox +--- +.. _tox setup: https://tox.wiki/en/latest/index.html + +Developers are free to setup whatever environment that they may need to +facilitate their work with the Python package. However, the package includes a +`tox setup`_, which developers can also use to automatically setup and manage +dedicated virtual environments for different predefined development tasks. Some +tasks are more broadly useful at the level of the whole repository since they +can, for instance, build the User Guides for all |openbt| tools. + +Development with |tox| +~~~~~~~~~~~~~~~~~~~~~~ + +The following is a rough guide to help install |tox| as a command line tool in +a dedicated, minimal virtual environment. |tox| is made available with +no need to manually activate its virtual environment. + +.. note:: + Developers that would like to use |tox| should, at the very least, learn + enough about it that they understand the difference between running ``tox`` + and ``tox -r``. Some potential issues are highlighted below. + +.. code-block:: console + + $ cd $HOME/local/venv + $ deactivate + $ /path/to/desired/python --version + $ /path/to/desired/python -m venv $HOME/local/venv/.toxbase + $ ./.toxbase/bin/python -m pip list + $ ./.toxbase/bin/python -m pip install --upgrade pip setuptools + $ ./.toxbase/bin/python -m pip install tox + $ ./.toxbase/bin/python -m pip list + $ ./.toxbase/bin/tox --version + +To avoid having to activate ``.toxbase`` every time we would like to work with +|tox|, we setup |tox| in ``PATH``. Note that developers can use this single +|tox| installation for multiple projects. Please replace ``.bash_profile`` +with the appropriate shell configuration file and tailor the following to your +needs. + +.. code-block:: console + + $ mkdir -p $HOME/local/bin + $ ln -s $HOME/local/venv/.toxbase/bin/tox $HOME/local/bin/tox + $ vi $HOME/.bash_profile (add $HOME/local/bin to PATH) + $ . $HOME/.bash_profile + $ which tox + $ tox --version + +No work will be carried out by default with the calls ``tox`` and ``tox -r``. + +Run the following from the directory hierarchy that contains the |openbt| +|tox| configuration file ``/path/to/OpenBT/openbt_pypkg/tox.ini`` to see the +full list of available environments and what each one does: + +.. code-block:: console + + $ tox list -v + +Two or more tasks can be executed in a single invocation, (|eg| ``tox -r -e +report,coverage``). Users needing ``pdf`` should note that |tox| does not +install ``make`` or a LaTeX distribution; those must be installed separately. + +The |tox| tool caches all of its virtual environments in ``openbt_pypkg/.tox/``. +Running ``tox -r -e `` forces a clean environment rebuild including +installation of (potentially more modern) dependencies and a full package build +from scratch. Happily, developers can activate and work directly in |tox|'s +cached virtual environments. + +Direct use of |tox| virtual environments +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Many of the |tox| tasks will build the |openbt| binary automatically each time +they are run, which can significantly slow development work. In such cases, +developer productivity can benefit from creating a clean virtual environment for +their task using ``tox -r -e `` and subsequently loading and working in that +virtual environment directly. + +Developers can inspect ``tox.ini`` to see what commands are run by their task +and adapt these for their work. + +The following example shows how to run only a single test case using the +``coverage`` virtual environment setup by |tox|. + +.. code-block:: console + + $ cd /path/to/OpenBT/openbt_pypkg + $ tox -r -e coverage + $ . ./.tox/coverage/bin/activate + $ which python + $ python --version + $ python -m pip list + $ python -m pytest --pyargs openbt.tests.test_mixing + +Note that using the ``coverage`` virtual environment directly can be +particularly useful since the package is installed in editable mode and +therefore facilitates interactive development and testing of the Python code. + +The ``html`` environment can be activated directly in the same way to rebuild +documentation iteratively without paying the cost of a full package rebuild each +time: + +.. code-block:: console + + $ cd /path/to/OpenBT/openbt_pypkg + $ tox -r -e html + $ . ./.tox/html/bin/activate + $ which sphinx-build + $ sphinx-build -W -E -b html ../docs ../docs/build_html + +Caching +~~~~~~~ +As noted above, some |tox| tasks build the |openbt| package in editable mode. +They, therefore, can suffer from the potential caching issues mentioned above +for direct editable installations of the package. diff --git a/docs/examples_r.rst b/docs/examples_r.rst new file mode 100644 index 0000000..c78dea0 --- /dev/null +++ b/docs/examples_r.rst @@ -0,0 +1,93 @@ +Examples +======== +.. _Branin: https://www.sfu.ca/~ssurjano/branin.html + +To use |openbt| in R, install ``Ropenbt`` as described in :doc:`get_started_r`. +This example assumes that the command line tools were built with MPI support. + +Let's create a test function. A popular one is the Branin_ function: + +.. code-block:: r + + # Test Branin function, rescaled + braninsc <- function(xx) + { + x1 <- xx[1] + x2 <- xx[2] + + x1bar <- 15*x1 - 5 + x2bar <- 15 * x2 + + term1 <- x2bar - 5.1*x1bar^2/(4*pi^2) + 5*x1bar/pi - 6 + term2 <- (10 - 10/(8*pi)) * cos(x1bar) + + y <- (term1^2 + term2 - 44.81) / 51.95 + return(y) + } + + + # Simulate Branin data for testing + set.seed(99) + n=500 + p=2 + x = matrix(runif(n*p),ncol=p) + y=rep(0,n) + for(i in 1:n) y[i] = braninsc(x[i,]) + +And then we can load the ``Ropenbt`` package and fit a BART model. Here we set +the model type as ``model="bart"``, which ensures that we fit a homoscedastic BART +model. The number of MPI processes to use is specified as ``tc=4``. For a list +of all optional parameters, see ``args(openbt)``. + +.. code-block:: r + + library(Ropenbt) + fit=openbt(x,y,tc=4,model="bart",modelname="branin") + +Next we can construct predictions and make a simple plot. Here, we are +calculating the in-sample predictions since we passed the same ``x`` matrix to +the ``predict.openbt()`` function. + +.. code-block:: r + + # Calculate in-sample predictions + fitp=predict.openbt(fit,x,tc=4) + + # Make a simple plot + plot(y,fitp$mmean,xlab="observed",ylab="fitted") + abline(0,1) + +To save the model, use the ``openbt.save()`` function. Similarly, load the +model using ``openbt.load()``. Because the posterior can be large in +sample-based models such as these, the fitted model is saved in a compressed +file format with the extension ``.obt``. + +.. code-block:: r + + # Save fitted model as test.obt in the working directory + openbt.save(fit,"test") + + # Load fitted model to a new object. + fit2=openbt.load("test") + +The standard variable activity information, calculated as the proportion of +splitting rules involving each variable, can be computed using the +``vartivity.openbt()`` function. + +.. code-block:: r + + # Calculate variable activity information + fitv=vartivity.openbt(fit2) + + # Plot variable activity + plot(fitv) + +A more accurate alternative is to calculate the Sobol' indices. + +.. code-block:: r + + # Calculate Sobol' indices + fits=sobol.openbt(fit2) + fits$msi + fits$mtsi + fits$msij diff --git a/docs/get_started_r.rst b/docs/get_started_r.rst new file mode 100644 index 0000000..5ccc551 --- /dev/null +++ b/docs/get_started_r.rst @@ -0,0 +1,39 @@ +Getting Started with R +======================= +.. _remotes: https://remotes.r-lib.org + +Installed versions of the |openbt| R package, ``Ropenbt``, provide a front-end R +interface that wraps a dedicated set of |openbt| C++ command line tools. The +package locates and calls the already-built command line tools (such as +``openbtcli``) by first searching the folders specified in ``PATH``. If they +are not found, it searches the current working directory as a fallback. + +Follow the :doc:`get_started_cpp` guide to build, install, and test the tools +before continuing. + +Install Ropenbt +------------------------- +With the command line tools built, install the +``Ropenbt`` R interface directly from GitHub using the remotes_ package. First, make sure +``remotes`` is installed: + +.. code-block:: r + + install.packages("remotes") + +Now install ``Ropenbt`` directly from the codebase: + +.. code-block:: r + + remotes::install_github('https://github.com/bandframework/OpenBT', subdir='Ropenbt') + +Note that some ``Ropenbt`` package dependencies may also be installed. Since +``Ropenbt`` itself needs no compilation, this step is quick regardless of +platform. + +Testing +------- +The ``Ropenbt`` package does not currently ship a dedicated automated test suite +of its own. However, executing the full set of steps detailed in +:doc:`examples_r` is a reasonable smoke test that your installation is working +end to end. diff --git a/docs/git_workflow.rst b/docs/git_workflow.rst index e46a2b0..60c3fcd 100644 --- a/docs/git_workflow.rst +++ b/docs/git_workflow.rst @@ -1,7 +1,5 @@ Git Workflow ============ -Since we are currently standing this repository up, we are working with an -informal git workflow. A minimal set of rules are .. note:: @@ -10,6 +8,9 @@ informal git workflow. A minimal set of rules are which might result in unwanted side effects. Rather, a gatekeeper should resolve the conflicts in a local clone, merge locally, and push. +Since we are currently standing this repository up, we are working with an +informal git workflow. A minimal set of rules are + #. No one should make direct commits to the ``main`` branch. #. Each addition and change should be made on a dedicated feature branch that is based off of the latest commit on the ``main`` branch. Try to group related @@ -39,3 +40,58 @@ informal git workflow. A minimal set of rules are Developers are encouraged to create PRs early during branch development to begin and record a dialogue with potential reviewers in the PR. + +GitHub Actions +-------------- + +All of the following actions run automatically on every push and pull request to +``main``. A merge should only proceed once all actions pass. + +Documentation +~~~~~~~~~~~~~ + +* **Check Spelling** — Checks all files in the repository + for typographic errors using the ``typos`` tool with the ``typos.toml`` + configuration file. + +* **Check Links** — Checks all ``.rst`` and ``.md`` files for broken URLs using + the ``lychee`` tool. In addition to running on push and pull request, this + action runs on a regular schedule to catch links that break between + contributions. + +* **Build Sphinx Docs** — Builds the |openbt| documentation in both HTML and + PDF format using |tox|. The built documents are uploaded as a downloadable + artifact so that contributors can review rendered documentation without + needing a local build environment. + +Python Package Testing +~~~~~~~~~~~~~~~~~~~~~~ + +* **Test** |openbt| **Python Source Distribution** — The primary test action. Builds + a Python source distribution and tests it across a matrix of operating + systems, MPI implementations, and Python versions to validate broad + compatibility. This action additionally runs on published releases so that + the source distribution built and tested by the action, which is stored as an + artifact, can be manually uploaded to PyPI as the official release + distribution. + +* **Test** |openbt| **Developer-mode Installation** — Tests the editable installation + (``pip install -e .``) on a reduced matrix. MPI is intentionally installed + |via| |pip| rather than a system package manager to confirm that pip-installed + MPI implementations work correctly. + +* **Test** |openbt| **in Anaconda** — Tests installation inside a conda environment + across a matrix of operating systems and installs |via| |pip| a prebuilt + Open MPI installation included in a Python package. + +* **Measure** |openbt| **Python Coverage** — Runs the full Python test suite with + coverage measurement using |tox| and uploads the raw coverage file, XML + report, and HTML report as artifacts. + +C++ Tools Testing +~~~~~~~~~~~~~~~~~ + +* **Test** |openbt| **C++ Command Line Tools** — Builds and tests the C++ command + line tools directly across a matrix of operating systems and MPI implementations, independently of the Python package. Prints dynamic library + linkage information for each built binary so that developers can verify the + correct MPI implementation was linked. diff --git a/docs/index.rst b/docs/index.rst index fc41f5e..f9ddb99 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -3,11 +3,9 @@ Welcome to |openbt|'s Documentation! .. _Open MPI: https://www.open-mpi.org .. _MPICH: https://www.mpich.org .. _framework: https://bandframework.github.io -.. _Issue 35: https://github.com/bandframework/OpenBT/issues/35 .. _OpenBT repository: https://bitbucket.org/mpratola/openbt/src/master .. _OpenBTMixing repository: https://github.com/jcyannotty/OpenBT - .. image:: images/openbt_logo_rect.png :align: center :alt: OpenBT @@ -29,7 +27,7 @@ it can be built with MPI installed on a laptop using the system's package manager or with MPI installations on leadership class platforms and clusters that were installed by experts and optimized for their specific platform. -This repository was established by merging the contents of the original Bitbucket +This project was established by merging the contents of the original Bitbucket `OpenBT repository`_ with the `OpenBTMixing repository`_, which was based off of the former. It, therefore, will supersede those two repositories, which will be frozen. @@ -37,18 +35,20 @@ frozen. This repository and its contents are being established and developed as part of |band| framework_. -.. note:: - While an R wrapper does exist for the original |openbt| and |openbtmixing| - repositories, that functionality has not yet been included in this new, - combined repository (`Issue 35`_). - .. toctree:: :numbered: :maxdepth: 1 :caption: C++ User Guide: get_started_cpp - bibliography_cpp + +.. toctree:: + :numbered: + :maxdepth: 1 + :caption: R User Guide: + + get_started_r + examples_r .. toctree:: :numbered: @@ -67,6 +67,6 @@ This repository and its contents are being established and developed as part of contributing git_workflow documentation - tox_usage + developer_environment versioning release_procedure diff --git a/docs/tox_usage.rst b/docs/tox_usage.rst deleted file mode 100644 index 5e0a259..0000000 --- a/docs/tox_usage.rst +++ /dev/null @@ -1,8 +0,0 @@ -.. _developer_env: - -Developer Environment -===================== -.. _tox: https://tox.wiki/en/latest/index.html - -.. todo:: - Sarthak to write this diff --git a/openbt_pypkg/tox.ini b/openbt_pypkg/tox.ini index 60ca6f3..0f9f69e 100644 --- a/openbt_pypkg/tox.ini +++ b/openbt_pypkg/tox.ini @@ -8,7 +8,9 @@ requires = tox>=4 env_list = [testenv] -description = Run OpenBT's full test suite with or without coverage +description = + coverage: Run OpenBT's full test suite with coverage + nocoverage: Run OpenBT's full test suite without coverage passenv = COVERAGE_HTML COVERAGE_XML @@ -28,7 +30,10 @@ commands = coverage: coverage run --rcfile={toxinidir}/.coveragerc --data-file={env:COV_FILE} -m pytest ./src/openbt/tests [testenv:report] -description = Generate XML and HTML format coverage reports +description = Write coverage results to stdout as well as generate XML and HTML + format coverage reports. This is typically run after or at the same time as + the coverage task. See tox.ini for information on env vars that control + where the reports are written. depends = coverage deps = coverage skip_install = true @@ -38,8 +43,7 @@ commands = coverage report --data-file={env:COV_FILE} [testenv:check] -# The work done in this task does not alter any files. -description = Check code against typical Python standards +description = Check code against typical Python standards. This task does not alter any files. deps = setuptools flake8 @@ -54,8 +58,12 @@ deps = sphinx sphinxcontrib-bibtex sphinx_rtd_theme + # Uncomment the following dependence if optional live-reloading will be used in this task + #sphinx-autobuild commands = sphinx-build -W -E -b html {env:DOC_ROOT} {env:DOC_ROOT}/build_html + # The command below is for live-reloading of the documentation during development. Uncomment it if you want to use it. + #sphinx-autobuild -W -E -b html {env:DOC_ROOT} {env:DOC_ROOT}/build_html [testenv:pdf] description = Generate OpenBT PDF-format documentation diff --git a/tools/build_openbt_clt.sh b/tools/build_openbt_clt.sh index b5a58c3..e1292aa 100755 --- a/tools/build_openbt_clt.sh +++ b/tools/build_openbt_clt.sh @@ -12,6 +12,24 @@ # This script returns exit codes that should make it compatible with use in CI # build processes. # +# Intermediate & cached files +# --------------------------- +# This script has Meson create and use the /path/to/OpenBT/builddir folder for +# the build. Developers can use this script to create that folder and then use +# Meson manually with that folder to develop and test the code. Users could +# similarly use the contents of the script to guide custom builds. The Meson +# setup, compile, and install commands in the script might provide a good +# starting point for such efforts. +# +# While the /path/to/OpenBT/subprojects folder does contain necessary files +# under version control, it can also contain cached third-party dependencies +# such as Eigen's source code. The subprojects/packagecache folder can also +# contain cached files such as third-party dependence tarballs and patches. +# Please note that setting up the Meson build directory with the --clearcache +# flag does **not** remove such files. Rather, they intentionally persist +# across builds. Consider reviewing those contents if Meson uses Eigen versions +# or installations different from those intended. +# #####----- HARDCODED VALUES use_mpi=true