Finalmente, reviso la serie “Escobar, el patrón del mal” Caracol Televisión de 2012, dirigida por Carlos Moreno, esta serie busca recrear aspectos de la vida de Pablo

input points can be given, and the hierarchical emulator will use each of the terms to predict the outputs of the simpler and extended simulators, and the difference between them. Because the structure is object-oriented, the information for each stage (data organisation, emulator building and prediction) is stored as separate objects. The structure of the objects and methods ensures that the process is rigidly organised, and no necessary information lost.

5.3

Comparing the hierarchical emulator with the

‘standard’

In order to see whether hierarchical emulation is worth pursuing, we must compare it to the status quo. Questions we must therefore ask are:

1. What tasks are we asking the hierarchical emulator to perform?

2. What are the ‘standard’ emulators against which we will compare it?

These issues are explored below, before comparing different emulation strategies using two versions of HadOCC.

5.3.1

Tasks for comparison

Predicting s0(x) output

When the hierarchical emulator is used to emulate s0(x), all terms apart from the

first are ‘switched off’, and we are left with an emulator of s0(x). Therefore the

standard and hierarchical emulators of s0(x) should perform identically.

Predicting s1(x, v, w) output

Unlike any standard method, the hierarchical emulator for s1(x, v, w) is built from

several terms, each of which is a separate emulator. Apart from the s0(x) term,

each of these is multiplied by vectors g (v), and there is potential for this to disrupt things. Because of the separability property established by the prior specification, the variance of the hierarchical emulator’s prediction is the sum of the variances

5.3. Comparing the hierarchical emulator with the ‘standard’ 79

of the individual terms, and this has potential to become large as the hierarchical variables increase.

Predicting s1(x, v, w) output is useful in its own right, and in a situation where

s0(x) is much cheaper to run than s1(x, v, w), building a hierarchical emulator by

using many runs from s0(x) and fewer from s1(x, v, w) could be an attractive option.

Predicting some measure of the difference between s0 and s1

In comparing the two simulators, being able to reliably predict the difference between them in some way will be a tremendous help. It may also enable us to discern the circumstances in which the two simulators are very different, and when they behave similarly. The prediction variable will be the difference

s1(x, v, w) − s0(x)

or, if the logs of the outputs are used, the ratio s1(x, v, w)

s0(x)

,

so long as both functions are positive. Which of these is predicted by the hierarchical emulator will depend on whether the simulator output or its logarithm is chosen.

Predicting s1 output ‘near’ s0

A key concern is how the emulators’ predictions and variances depend on the values of the hierarchical inputs v. This may reveal features of the emulation models that are not appropriate. In particular, it may be interesting to compare predictions of the more complex simulator’s behaviour when it is very near to the simpler simulator, that is when the v are very close to v∗.

5.3.2

Standard emulators

By ‘standard’ emulators, here we refer to those built using the methods in Chapter 3, where the emulator is the sum of one regression surface and one correlated error term. Therefore in these terms, a hierarchical emulator is a linear combination of standard emulators. In either setting there are choices of prior distribution, regression surface

5.3. Comparing the hierarchical emulator with the ‘standard’ 80

and correlation function, and while these are important they are not the focus of this chapter. In building any sort of emulator they should be made to best cater to the simulator at hand. In this chapter, the default choice will be to use the weak prior p βi, σi2
∝ 1 σ2 i ,

include all input variables as active, include either all first order or all first and second order terms in the regression surface, and model the error by a stationary, isotropic Gaussian process, whose correlation length is the maximum likelihood estimator. We will check that these choices are appropriate before continuing.

In comparing the hierarchical emulator with the standard approach, we focus here particularly on the choice of independent variable and the use of training data, and will try to make the other emulation choices comparable where possible. Having determined the tasks set for the emulators, the set of ‘standard’ emulators against which we are to compare the hierarchical emulators should include the choices that intuitively best suit those tasks.

Emulators of s1

Firstly, we can build a standard emulator of s1(x, v, w). This emulator can be used

to predict both s1(˜x, ˜v, ˜w) and s0(˜x). If the inputs are all processed together, as a

data frame containing (˜x, ˜v, ˜w) and (˜x, v∗, w) then the covariance matrix will also enable us to calculate var [s1(˜x, ˜v, ˜w) − s0(˜x)]. This emulator can therefore be used

to achieve each of the chosen tasks.

An emulator of s1(·) can be built using either only the data where v 6= v∗, or all

the simulator data available, including data from lower down in the hierarchy. The examples Section 5.5 will include both.

Separate emulators of s0 and s1

Instead of using an emulator of s1(·) only, one could build separate emulators of

s1(x, v, w) and s0(x), then use these to predict s1(˜x, ˜v, ˜w) and s0(˜x). These can be

5.3. Comparing the hierarchical emulator with the ‘standard’ 81

for each input point can be calculated using the Cauchy-Schwarz inequality, but the exact value var [s1(˜x, ˜v, ˜w) − s0(˜x)] cannot.

Emulating the difference

So long as the training data is set up in the correct way, the difference can be calculated exactly, then emulated using standard methods. Intuitively, this should produce the best prediction of the difference. It doesn’t, however, provide a way to see the difference relative to the values of each output, and so can only really be useful when combined with an emulator of s0(·) or s1(·).

A truly comparable standard emulator

In comparing the performance of the hierarchical emulator with that of the standard method, it seems appropriate, as far as possible, to include the same information in both emulators. In terms of input data, this can be achieved by using the same training data. However, the very structure of the hierarchical emulator includes the information that

s1(x, v∗, w) = s0(x) for all x, w, (5.16)

because of the g (·) functions which switch off terms as necessary. A fair question to ask then is, can this same information be included in a standard emulator?

A crucial aspect of this information is that when v = v∗, the value of w doesn’t affect the value of s1(·). This information could be incorporated into a regression

function, simply by making sure that all terms involving w also involved v in such a way that this was achieved. However, for Equation 5.16 to hold in the correlated error term, the correlation structure would have to be drastically changed. One method would be to have correlation lengths for w that are a function of v, such that when v = v∗ the extra inputs w add no variance.

This seems a sufficiently serious deviation from standard emulation for us to be able to compare the hierarchical emulator with those in Section 5.3.2, and to think of the capacity to include the information in Equation (5.16) as a benefit, rather than an unfair advantage, of hierarchical emulation.