small changes to docs

Author: jdjakem

pyapprox/surrogates/approximate.py

@@ -241,9 +241,7 @@ def adaptive_approximate_sparse_grid(
         if max_level_1d is None:
             msg = "max_level_1d must be set if config_var_trans is provided"
             #raise ValueError(msg)
-        print(max_level_1d)
         for ii, cv in enumerate(config_var_trans.config_values):
-            print(len(cv))
             if len(cv) <= max_level_1d[config_variables_idx+ii]:
                 msg = f"maxlevel_1d {max_level_1d} and "
                 msg += "config_var_trans.config_values with shapes {0}".format(

pyapprox/surrogates/interp/sparse_grid.py

@@ -846,7 +846,8 @@ def plot_sparse_grid_2d(samples, weights, poly_indices=None, subspace_indices=No
     return axs
 
 
-def plot_sparse_grid_3d(samples, weights, poly_indices=None, subspace_indices=None,
+def plot_sparse_grid_3d(samples, weights, poly_indices=None,
+                        subspace_indices=None,
                         active_samples=None, active_subspace_indices=None):
     from pyapprox.util.visualization import plot_3d_indices
     if samples.shape[0] != 3:

pyapprox/surrogates/interp/tensorprod.py

@@ -551,14 +551,14 @@ def plot_single_basis(self, ax, nodes_1d, ii, jj, nodes=None,
             single_basis_fun, plot_limits, num_pts_1d)
         if surface_cmap is not None:
             plot_surface(X, Y, Z, ax, axis_labels=None, limit_state=None,
-                         alpha=0.3, cmap="coolwarm", zorder=3, plot_axes=False)
+                         alpha=0.3, cmap=surface_cmap, zorder=3, plot_axes=False)
         if contour_cmap is not None:
             num_contour_levels = 30
             offset = -(Z.max()-Z.min())/2
             ax.contourf(
                 X, Y, Z, zdir='z', offset=offset,
                 levels=np.linspace(Z.min(), Z.max(), num_contour_levels),
-                cmap="gray", zorder=-1)
+                cmap=contour_cmap, zorder=-1)
 
         if nodes is None:
             return

tutorials/multi_fidelity/plot_multiindex_collocation.py

@@ -64,29 +64,29 @@ def build_tp(fun, max_level_1d):
 axs[0].plot(zz, funs[1](zz[None, :]), 'r', label=r"$f_1$")
 axs[0].plot(lf_approx.samples[0], lf_approx.values[:, 0], 'ko')
 axs[0].plot(zz, lf_approx(zz[None])[:, 0], 'g:', label=r"$f_{0,\mathcal{I}_0}$")
-axs[0].legend()
+axs[0].legend(fontsize=18)
 
 hf_approx = build_tp(funs[1], 1)
 axs[1].plot(zz, funs[1](zz[None, :]), 'r', label=r"$f_1$")
 axs[1].plot(hf_approx.samples[0], hf_approx.values[:, 0], 'ro')
 axs[1].plot(zz, hf_approx(zz[None])[:, 0], ':', color='gray',
             label=r"$f_{1,\mathcal{I}_1}$")
-axs[1].legend()
+axs[1].legend(fontsize=18)
 
 def discrepancy_fun(fun1, fun0, zz):
     return fun1(zz)-fun0(zz)
 
 discp_approx = build_tp(partial(discrepancy_fun, funs[1], lf_approx), 1)
 axs[2].plot(zz, funs[1](zz[None, :]), 'r', label=r"$f_1$")
 axs[2].plot(zz, funs[1](zz[None, :])-funs[0](zz[None, :]), 'k',
-            label=r"$f_1-f_0$")
+            label=r"$\delta=f_1-f_0$")
 axs[2].plot(discp_approx.samples[0], discp_approx.values[:, 0], 'ko')
 axs[2].plot(zz, discp_approx(zz[None, :]),
-            'g:', label=r"$f_{0,\mathcal{I}_0}+\delta_{\mathcal{I}_1}$")
+            'g:', label=r"$\delta_{\mathcal{I}_1}$")
 axs[2].plot(zz, lf_approx(zz[None])+discp_approx(zz[None, :]),
             'b:', label=r"$f_{0,\mathcal{I}_1}+\delta_{\mathcal{I}_1}$")
 [ax.set_xlabel(r"$z$") for ax in axs]
-_ = axs[2].legend()
+_ = axs[2].legend(fontsize=18)
 
 #%%
 #The left plot shows that using 5 samples of the low-fidelity model produces an accurate approximation of the low-fidelity model, but it will be a poor approximation of the high fidelity model in the limit of infinite low-fidelity data. The middle plot shows three samples of the high-fidelity model also produces a poor approximation, but if more samples were added the approximation would coverge to the high-fidelity model. In contrast the right plot shows that 5 samples of the low-fideliy model plus three samples of the high-fidelity model produces a good approximation of the high-fidelity model.
@@ -143,7 +143,7 @@ def setup_model(config_values):
         tp_approx.samples_1d, tp_approx.config_variables_idx)
     ax.plot(zz, subspace_approx_vals, '--', color=approx_colors[kk],
             label=r"$f_{%d,%d}$" % (kk, jj))
-    ax.legend()
+    ax.legend(fontsize=18)
 _ = [[ax.set_ylim([-1, 1]), ax.set_xlabel(r"$z$")] for ax in axs.flatten()]
 
 #%%
@@ -228,21 +228,36 @@ def __call__(self, approx):
     {"refinement_indicator": variance_refinement_indicator,
      "max_level_1d": [10,  len(config_values[0])-1],
      "univariate_quad_rule_info": None,
-     "max_level": np.inf, "max_nsamples": 50,
+     "max_level": np.inf, "max_nsamples": 80,
      "config_variables_idx": nvars,
      "config_var_trans": config_var_trans,
      "cost_function": cost_function,
      "callback": adaptive_callback}).approx
 
+from pyapprox.interface.wrappers import SingleFidelityWrapper
+hf_model = SingleFidelityWrapper(mi_model, config_values[0][2:3])
+mf_model = SingleFidelityWrapper(mi_model, config_values[0][1:2])
+lf_model = SingleFidelityWrapper(mi_model, config_values[0][:1])
+
 #%%
 #Now plot the adaptive algorithm
-fig, axs = plt.subplots(1, 2, sharey=False, figsize=(16, 6))
+fig, axs = plt.subplots(1, 3, sharey=False, figsize=(3*8, 6))
+plot_xx = np.linspace(-1, 1, 101)
 def animate(ii):
     [ax.clear() for ax in axs]
     sg = adaptive_callback.sparse_grids[ii]
     plot_adaptive_sparse_grid_2d(sg, axs=axs[:2])
     axs[0].set_xlim([0, 10])
     axs[0].set_ylim([0, len(config_values[0])-1])
+    axs[1].set_ylim([0, len(config_values[0])-1])
+    axs[1].set_ylabel(r"$\alpha_1$")
+    axs[2].plot(plot_xx, lf_model(plot_xx[None, :]), 'r', label=r"$f_0(z_1)$")
+    axs[2].plot(plot_xx, mf_model(plot_xx[None, :]), 'g', label=r"$f_1(z_1)$")
+    axs[2].plot(plot_xx, hf_model(plot_xx[None, :]), 'k', label=r"$f_2(z_1)$")
+    axs[2].plot(plot_xx, sg(plot_xx[None, :]), '--b', label=r"$f_{I}(z_1)$")
+    axs[2].set_xlabel(r"$z_1$")
+    axs[2].legend(fontsize=18)
+
 
 import matplotlib.animation as animation
 ani = animation.FuncAnimation(

tutorials/multi_fidelity/plot_multioutput_acv.py

@@ -3,6 +3,8 @@
 ========================================
 
 This tutorial demonstrates how computing statistics for multiple outputs simultaneoulsy can improve the accuracy of ACV estimates of individual statistics when compared to ACV applied to each output separately.
+
+The optimal control variate weights are obtained by minimizing the estimator covariance [RM1985]_.
 """
 import numpy as np
 import matplotlib.pyplot as plt
@@ -53,3 +55,9 @@ def __call__(self, est_covariance, est):
 ax = plt.subplots(1, 1, figsize=(8, 6))[1]
 _ = mf.plot_estimator_variance_reductions(
     [est, est_0], est_labels, ax, criteria=CustomComparisionCriteria())
+
+
+#%%
+#References
+#----------
+#[RM1985] `Reuven Y. Rubinstein and Ruth Marcus. Efficiency of multivariate control variates in monte carlo simulation. Operations Research, 33(3):661–677, 1985. <https://doi.org/10.48550/arXiv.2310.00125>`_

tutorials/surrogates/plot_sparse_grids.py

@@ -318,7 +318,7 @@ def __call__(self, approx):
 fig, axs = plt.subplots(1, 3, sharey=False, figsize=(3*8, 6))
 ranges = benchmark.variable.get_statistics("interval", 1.0).flatten()
 data = [get_meshgrid_function_data(sg, ranges, 51)
-        for sg in  adaptive_callback.sparse_grids]
+        for sg in adaptive_callback.sparse_grids]
 Z_min = np.min([d[2] for d in data])
 Z_max = np.max([d[2] for d in data])
 levels = np.linspace(Z_min, Z_max, 21)

tutorials/surrogates/plot_univariate_interpolation.py

@@ -67,10 +67,12 @@
 lagrange_basis = UnivariateLagrangeBasis()
 lagrange_basis_vals = lagrange_basis(cheby_nodes, samples)
 ax[0].plot(samples, lagrange_basis_vals)
+ax[0].plot(cheby_nodes, cheby_nodes*0, 'ko')
 equidistant_nodes = np.linspace(-1, 1, nnodes)
 quadratic_basis = UnivariatePiecewiseQuadraticBasis()
 piecewise_basis_vals = quadratic_basis(equidistant_nodes, samples)
 _ = ax[1].plot(samples, piecewise_basis_vals)
+_ = ax[1].plot(equidistant_nodes, equidistant_nodes*0, 'ko')
 
 #%%
 #Notice that the unlike the lagrange basis the picewise polynomial basis is non-zero only on a local region of the input space.
@@ -160,7 +162,7 @@ def fun(samples):
 ax = plt.subplots(1, 1, figsize=(8, 6))[1]
 plot_xx = np.linspace(0, 1, 101)
 true_vals = benchmark.fun(plot_xx[None, :])
-pbwt = "w"
+pbwt = r"\pi"
 ax.plot(plot_xx, true_vals, '-r', label=r'$f(z)$')
 ax.plot(plot_xx, interp(plot_xx[None, :]), ':k', label=r'$f_M^\nu$')
 ax.plot(train_samples[0], train_values[:, 0], 'ko', ms=10,
@@ -176,7 +178,8 @@ def fun(samples):
     plot_xx, ax.get_ylim()[0], pdf_vals+ax.get_ylim()[0],
     alpha=0.3, visible=True,
     label=r'$%s(z)$' % pbwt)
-_ = ax.legend()
+ax.set_xlabel(r'$M$', fontsize=24)
+_ = ax.legend(fontsize=18, loc="upper right")
 
 #%%
 #As you can see the approximation that targets the uniform norm is "more accurate" on average over the domain, but the interpolant that directly targets accuracy with respect to the desired Beta distribution is more accurate in the regions of non-negligible probability.
@@ -237,6 +240,11 @@ def compute_L2_error(interp, validation_samples, validation_values):
     ax.semilogy(ntrain_samples_list, results,
                 label="{0:1.2f}".format(density_ratio))
 
-ax.set_xlabel(r'$M$')
-ax.set_ylabel(r'$\| f-f_M^\nu\|_{L^2_%s}$' % pbwt)
+ax.set_xlabel(r'$M$', fontsize=24)
+ax.set_ylabel(r'$\| f-f_M^\nu\|_{L^2_%s}$' % pbwt, fontsize=24)
 _ = ax.legend(ncol=2)
+
+#%%
+#References
+#----------
+#.. [XJD2013] `Chen Xiaoxiao, Park Eun-Jae, Xiu Dongbin. A flexible numerical approach for quantification of epistemic uncertainty. J. Comput. Phys., 240 (2013), pp. 211-224 <https://doi.org/10.1016/j.jcp.2013.01.018>`_