| \"% __counter__+\n",
+ " \" | \"% __counter__+\n",
+ " \" |
| \"% __counter__+\n",
+ " \" | \"% __counter__+\n",
+ " \" |
\"% __counter__ ))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Suggested changes for user (6):\n",
+ "Change the prediction QoI map. Compare to the reference values."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "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.6.1"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/measure_methods/fromFile_ADCIRCMap/BET_Q_3D.py b/examples/measure_methods/fromFile_ADCIRCMap/BET_Q_3D.py
index 5171c89f..195a7e94 100644
--- a/examples/measure_methods/fromFile_ADCIRCMap/BET_Q_3D.py
+++ b/examples/measure_methods/fromFile_ADCIRCMap/BET_Q_3D.py
@@ -71,10 +71,10 @@ def postprocess(station_nums, ref_num):
postprocess(station_nums, ref_num)
-station_nums = [0, 8, 6] # 1, 5, 12
+station_nums = [0, 8, 6] # 1, 9, 7
postprocess(station_nums, ref_num)
-station_nums = [0, 8, 11] # 1, 5, 12
+station_nums = [0, 8, 11] # 1, 9, 12
postprocess(station_nums, ref_num)
"""
diff --git a/examples/measure_methods/fromFile_ADCIRCMap/BatchAdaptiveSampling-2to2.ipynb b/examples/measure_methods/fromFile_ADCIRCMap/BatchAdaptiveSampling-2to2.ipynb
new file mode 100644
index 00000000..481f3f36
--- /dev/null
+++ b/examples/measure_methods/fromFile_ADCIRCMap/BatchAdaptiveSampling-2to2.ipynb
@@ -0,0 +1,486 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Example: Batch Adaptive Sampling (2-to-2 example)\n",
+ "([From BET Documentation](http://ut-chg.github.io/BET/examples/example_rst_files/fromfile2D.html#fromfile2dexample))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ">**Note:**\n",
+ "*This example shows how to generate adaptive samples in a specific way by implicitly defining an input event of interest. It does NOT show how to solve the stochastic inverse problem using these samples, which can be found by reading other examples. Thus, we only present the first few steps involved in discretizing the parameter and data spaces using a specific type of adaptive sampling. The user is referred to some other examples for filling in the remaining steps for solving the stochastic inverse problem following the construction of the adaptive samples.*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We will walk through the following [example](fromFile2D.py) that uses a linear interpolant of a 2-dimensional QoI map used to define a 2-dimensional data space. The parameter space in this example is also 2-dimensional.\n",
+ "\n",
+ "This example specifically demonstrates the adaptive generation of samples using a goal-oriented adaptive sampling algorithm. This example is based upon the results shown in Section 8.5 of the manuscript [Definition and solution of a stochastic inverse problem for the Manning’s n parameter field in hydrodynamic models](http://dx.doi.org/10.1016/j.advwatres.2015.01.011) where the QoI map is given by $Q(\\lambda) = (q_1(\\lambda), q_6(\\lambda))$. We refer the reader to that example for more information about the physical interpretation of the parameter and data space, as well as the physical locations of the observation stations defining the QoI map."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ">**Note:**\n",
+ ">*In this example, we have used ADCIRC to generate data files based on a regular discretization of the parameter space whose sole purpose is to create an (accurate) surrogate QoI map defined as a piecewise linear interpolant. This is quite different from many of the other examples, but the use of the surrogate QoI map is immaterial. The user could also interface the sampler directly to ADCIRC, but this would require a copy of ADCIRC, the finite element mesh, and significant training on the use of this state-of-the-art shallow water equation code. The primary focus of this example is the generation of adaptive samples. If the user knows how to use the ADCIRC model, then the user may instead opt to significantly change Step (1) below to interface to ADCIRC instead of to our “model” defined in terms of the surrogate QoI map. Interfacing to ADCIRC directly would likely require the use of [PolyADCIRC](https://github.com/UT-CHG/PolyADCIRC).*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Generating a single set of adaptive samples"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Step (0): Setting up the environment\n",
+ "Import the necessary modules:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import bet.sampling.adaptiveSampling as asam\n",
+ "import bet.postProcess.plotDomains as pDom\n",
+ "import scipy.io as sio\n",
+ "from scipy.interpolate import griddata"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Step (1): Define the interface to the model and goal-oriented adaptive sampler\n",
+ "This is where we interface the adaptive sampler imported above to the model. In other examples, we have imported a Python interface to a computational model. In this example, we instead define the model as a (piecewise-defined) linear interpolant to the QoI map $Q(λ)=(q1(λ),q6(λ))Q(λ)=(q1(λ),q6(λ))$ using data read from a `.mat` [file](../matfiles/Q_2D.mat):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "station_nums = [0, 5] # 1, 6\n",
+ "mdat = sio.loadmat('../matfiles/Q_2D')\n",
+ "Q = mdat['Q']\n",
+ "Q = Q[:, station_nums]\n",
+ "# Create experiment model\n",
+ "points = mdat['points']\n",
+ "def model(inputs):\n",
+ " interp_values = np.empty((inputs.shape[0], Q.shape[1]))\n",
+ " for i in xrange(Q.shape[1]):\n",
+ " interp_values[:, i] = griddata(points.transpose(), Q[:, i],\n",
+ " inputs)\n",
+ " return interp_values"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this example, we use the adaptive sampler defined by `rhoD_kernel`, which requires an identification of a data distribution used to modify the transition kernel for input samples. The idea is to place more samples in the parameter space that correspond to a contour event of higher probability as specified by the data distribution `rho_D` shown below."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "First, we create the `transition_set` with an initial step size ratio of 0.5 and a minimum, maximum step size ratio of `.5**5` and 1.0 respectively. Note that this algorithm only generates samples inside the parameter domain, `lam_domain` (see Step (2) below):"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "# Create Transition Kernel\n",
+ "transition_set = asam.transition_set(.5, .5**5, 1.0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Here, we implicty designate a region of interest $\\Lambda_k = Q^{-1}(D_k)$ in $\\Lambda$ for some $D_k \\subset \\mathcal{D}$ through the use of the data distribution kernel. In this instance we choose our kernel $p_k(Q) = \\rho_\\mathcal{D}(Q)$, see `rhoD_kernel`.\n",
+ "\n",
+ "We choose some $\\lambda_{ref}$ and let $Q_{ref} = Q(\\lambda_{ref})$:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "Q_ref = mdat['Q_true']\n",
+ "Q_ref = Q_ref[15, station_nums] # 16th/20"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We define a rectangle, $R_{ref} \\subset \\mathcal{D}$ centered at $Q(\\lambda_{ref})$ with sides 15% the length of $q_1$ and $q_6$. Set $\\rho_\\mathcal{D}(q) = \\dfrac{\\mathbf{1}_{R_{ref}}(q)}{||\\mathbf{1}_{R_{ref}}||}$:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "bin_ratio = 0.15\n",
+ "bin_size = (np.max(Q, 0)-np.min(Q, 0))*bin_ratio\n",
+ "# Create kernel\n",
+ "maximum = 1/np.product(bin_size)\n",
+ "def rho_D(outputs):\n",
+ " rho_left = np.repeat([Q_ref-.5*bin_size], outputs.shape[0], 0)\n",
+ " rho_right = np.repeat([Q_ref+.5*bin_size], outputs.shape[0], 0)\n",
+ " rho_left = np.all(np.greater_equal(outputs, rho_left), axis=1)\n",
+ " rho_right = np.all(np.less_equal(outputs, rho_right),axis=1)\n",
+ " inside = np.logical_and(rho_left, rho_right)\n",
+ " max_values = np.repeat(maximum, outputs.shape[0], 0)\n",
+ " return inside.astype('float64')*max_values\n",
+ "\n",
+ "kernel_rD = asam.rhoD_kernel(maximum, rho_D)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The basic idea is that when the region of interest has been “found” by some sample in a chain, the transition set is modified by the adaptive sampler (it is made smaller) so that more samples are placed within this event of interest.\n",
+ "\n",
+ "Given a (M, mdim) data vector `rhoD_kernel` expects that `rho_D` will return a `ndarray` of shape (M,).\n",
+ "\n",
+ "Next, we create the `sampler`. This `sampler` will create 80 independent sampling chains that are each 125 samples long:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Create sampler\n",
+ "chain_length = 125\n",
+ "num_chains = 80\n",
+ "num_samples = chain_length*num_chains\n",
+ "sampler = asam.sampler(num_samples, chain_length, model)\n",
+ "sample_save_file = 'sandbox2d'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ">**Note:**\n",
+ "* *In the first line of code above change `chain_length` and `num_chains` to reduce the total number of forward solves.*\n",
+ "* *If `num_chains = 1` above, then this is no longer a “batch” sampling process where multiple chains are run simultaneously to “search for” the region of interest.*\n",
+ "* *Saves to `sandbox2d.mat`.*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Step (2) [and Step (3)]: Describe and (adaptively) sample the input (and output) space\n",
+ "The adaptive sampling of the input space requires feedback from the corresponding output samples, so the sets of samples are, in a sense, created simultaneously in order to define the discretization of the spaces used to solve the stochastic inverse problem. While this can always be the case, in other examples, we often sampled the input space completely in one step, and then propagated the samples through the model to generate the QoI samples in another step, and these two samples sets together were used to define the discretization object used to solve the stochastic inverse problem.\n",
+ "\n",
+ "The compact (bounded, finite-dimensional) paramter space for this example is:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "lam_domain = np.array([[.07, .15], [.1, .2]])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We choose an initial sample type to seed the sampling chains, which in this case comes from using Latin-Hypercube sampling:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "inital_sample_type = \"lhs\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Finally, we adaptively generate the samples using `generalized_chains()`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "(my_disc, all_step_ratios) = sampler.generalized_chains(lam_domain,\n",
+ " transition_set, kernel_rD, sample_save_file, inital_sample_type)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### [Optional]:\n",
+ "We may choose to visualize the results by executing the following code:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "# Read in points_ref and plot results\n",
+ "ref_sample = mdat['points_true']\n",
+ "ref_sample = ref_sample[5:7, 15]\n",
+ "\n",
+ "# Show the samples in the parameter space\n",
+ "pDom.scatter_rhoD(my_disc, rho_D=rho_D, ref_sample=ref_sample, io_flag='input')\n",
+ "# Show the corresponding samples in the data space\n",
+ "pDom.scatter_rhoD(my_disc, rho_D=rho_D, ref_sample=Q_ref, io_flag='output')\n",
+ "# Show the data domain that corresponds with the convex hull of samples in the\n",
+ "# parameter space\n",
+ "pDom.show_data_domain_2D(my_disc, Q_ref=Q_ref)\n",
+ "# Show multiple data domains that correspond with the convex hull of samples in\n",
+ "# the parameter space\n",
+ "pDom.show_data_domain_multi(my_disc, Q_ref=Q_ref, showdim='all')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# hack to refresh html after changes within notebook\n",
+ "import random\n",
+ "__counter__ = random.randint(0,2e9)\n",
+ "\n",
+ "# displays saved visualizations\n",
+ "from IPython.display import HTML, display\n",
+ "display(HTML(\" | \"% __counter__+\n",
+ " \" | |
| \"% __counter__+\n",
+ " \" | |
 | \"% __counter__+\n",
+ " \" | \"% __counter__+\n",
+ " \" |
 | \"% __counter__+\n",
+ " \" |
 | |
 | \"% __counter__+\n",
+ " \" |
 | |
 | \"% __counter__+\n",
+ " \" |
 | \"% __counter__+\n",
+ " \"
 | \"% __counter__+\n",
+ " \" |
 | \"% __counter__+\n",
+ " \" |
 | \"% __counter__+\n",
+ " \" |