.. _sma-ex4:
Ex. 4: Uncertainty Quantification
---------------------------------
In this example, we will demonstrate the use of the surrogate modeling strategy
for forward propagating a set of model input uncertainties into model output
uncertainty. We will use a simple function as the full model, the
`Ishigami Function `_
.. math::
r = \sin(a) + 7.0 \sin(b)^2 + 0.1 c^4 \sin(a)
.. _sma-ex4-build:
Build the Surrogate
+++++++++++++++++++
In this section, we'll build a surrogate model of the Ishigami function which
will be used for forward propagation of hypothetical input uncertainties.
1. Click on the |wiz| to launch the wizard--we'll use many of the wizard defaults
to do most of the work setting up the surrogate model for the Ishigami function.
2. Click on the ``Forward Propagation`` tab and set the ``Function to be analyzed``
to ``Ishigami`` and the ``Method`` to ``surrogate``. The ``Number of dimensions``
should not be de-selected and constrained to ``3``.
3. Click ``Populate Nodes``
4. In the ``Design of Experiments`` node, click on the ``Design`` tab and set the
sampling ``Method`` to ``halton`` and click ``Build``. The sampling design can
be visualized in the ``Plot`` tab and saved if desired.
5. In the ``Response Surface`` node, click on the ``Model`` tab and set the
``Cross validation points`` to 0. Next check and highlight the ``gaussian process``
response surface model and reduce the ``nugget`` one order of magnitude to
``1e-06``. The rest of the surrogate modeling defaults are sufficient for this
example, but the user is certainly welcome to build a different, possibly better
surrogate of the Ishigami function.
6. Before constructing the surrogate, navigate to the ``Forward Propagation`` node
and set the Aleatory and Epistemic samples to low values, e.g., 3 each. We'll
define and propagate the input uncertainties after construction of the surrogate.
7. Press |play| and *voilĂ * a gaussian process surrogate model of the Ishigami
function is constructed.
The model can be viewed in the ``Plot`` tab of the ``Response Surface`` node. The
error plot should show local errors within +/- 0.01. Quantitatively, the surrogate
should have :math:`L_1`, :math:`L_2`, and :math:`L_\infty` norms of 4.1e-04, 4.5e-4
and 6.2e-4, respectively.
.. _sma-ex4-fprop:
Forward Propagation
+++++++++++++++++++
In this section, we'll select some hypothetical input uncertainties and propagate
them through the previously constructed surrogate model.
1. Select the ``a`` input variable from the table. Let's consider ``a`` an
aleatory ``Variable Type`` having a normal ``Distribution`` with a ``Mean``
of -1.0 and a ``Standard Deviation`` of 0.3.
2. Select ``b`` from the table and give it the same properties as ``a`` but
with a ``Mean`` of +1.0.
3. To test the mixed-UQ method, let's make ``c`` an epistemic ``Variable Type``
ranging ``From`` -1 ``To`` +1.
4. Make sure that the ``Epistemic Method`` above the table is set to latin hypercube.
5. With these settings, we can see from the example distribution function plots that
sampling outside bounds will be a very low probability event. Therefore, we can
simply re-draw the ``Samples outside range`` for this case.
6. Select a number of ``Aleatory samples`` and ``Epistemic samples``
7. Finally, click ``Calculate Propagation`` to forward propagate the designed input
uncertainty into an output uncertainty.
For the selected input uncertainties, we find that the output uncertainty is dominated
by the two aleatory uncertainties. This may not be so surprising given that the coefficient
of the third input variable in the Ishigami function is almost two orders of magnitude
lower than the second. Therefore, the size of the p-box will shrink with an increasing
number of aleatory samples. For 1000 ``Aleatory samples`` and 200 ``Epistemic samples``
we find that the 95th-percentile occurs at response between 5.94 to 6.12. The resultant
p-box for this case is provided below. Note that the exact same values may not be recovered
when repeating this example due to the random nature of the propagation sampling.
.. figure:: ./images/ex4_ishigami_pbox.png
:align: center
.. _sma-ex4-vv:
Verification
++++++++++++
.. figure:: ./images/ex4_ishigami_pbox_octave.png
:align: center
In practice, the model being replaced with a surrogate is expensive and, thus, direct
sampling of the full model to forward propagate the input uncertainty is not possible.
It is, however, for this simple demonstration problem. To validate Nodework's forward
propagation procedure, the previous example problem has been coded into a simple
`Matlab `_ or
`Octave `_ script which is provided below.
Running the script in one instance resulted in the p-box generated above. Qualitatively,
the output response propagated through the surrogate is very to the analogous output
uncertainty propagated directly through the full model. Quantitatively, we can see some
slight discrepancies. Again, considering the 95th-percentile as the decision quantity,
the direct p-box gives a response range of 5.9490 to 6.1417, slightly higher than reported
from the surrogate constructed p-box. Of course, some of the discrepancy is just due to
the randomization of sampling. However, reconstructing both the script (direct) and
Nodeworks (surrogate) p-boxes several times shows that the surrogate, while very
close, tends to give slightly lower responses at the 95th-percentile.
.. code-block:: matlab
%
% Ishigami function:
% r = sin(x1) + a*sin(x2)^2 + b*x3^4*sin(x1);
%
% Ref: see https://www.sfu.ca/~ssurjano/ishigami.html and refs therein.
%
clear all
close all
clc
%
% model constants
a = 7.0;
b = 0.1;
%
% input uncertainty properties for forward propagation UQ
x1o = -1.0;
sigma1 = 0.3;
x2o = 1.0;
sigma2 = 0.3;
x3a = -1.0;
x3b = 1.0;
%
% Num. of aleatory and epistemic samples
Na = 1000;
Ne = 200;
%
% direct sample the Ishigami function
r = zeros(Na,Ne);
for jj = 1:Ne
delx3 = (x3b - x3a)/double(Ne);
x3 = x3a + double(jj - 1)*delx3 + rand(1)*delx3;
for ii = 1:Na
x1 = x1o + sigma1*randn;
x2 = x2o + sigma2*randn;
r(ii,jj) = sin(x1) + a*sin(x2)^2 + b*x3^4*sin(x1);
end
end
%
% plot p-box
grey = [0.5 0.5 0.5];
p = linspace(1.0/double(Na),1.0,Na)';
figure;
hold on;
%
% sort each CDF and plot
rs = sort(r);
for jj = 1:Ne
plot(rs(:,jj),p,'-k', 'LineWidth', 0.2);
end
%
% highlight the p-box
pboxL = zeros(Na,1);
pboxR = zeros(Na,1);
for ii = 1:Na
pboxL(ii,1) = min(rs(ii,:));
pboxR(ii,1) = max(rs(ii,:));
end
plot(pboxL,p,'-r', 'LineWidth', 1.);
plot(pboxR,p,'-r', 'LineWidth', 1.);
%
% sort single CDF
rall = zeros(Na*Ne,1);
for jj = 1:Ne
ij = (jj-1)*Na;
rall(ij+1:ij+Na) = r(:,jj);
end
rall = sort(rall);
pall = linspace(1.0/double(Na*Ne),1.0,Na*Ne)';
plot(rall,pall,'-b', 'LineWidth', 1.);
%
% label axes and save
xlabel('Response');
ylabel('Cumulative Density Function');
print -dpng ishigami_pbox.png
%
% write out the 95%
msg = "\n\n The 95%% p-box range is:\t %12.4e \t to\t %12.4e \n";
tmp1 = pboxL(floor(0.95*Na));
tmp2 = pboxR(floor(0.95*Na));
printf(msg,tmp1,tmp2);
%
% exit if run in batch mode
%exit;
%
% EOF eof eor EOR
.. |play| image:: ../../../nodeworks/images/play.svg
.. |wiz| image:: ../../../nodeworks/images/wand.svg