Density Forecasting

Abstract

This chapter reviews different methods to construct density forecasts and to aggregate forecasts from many sources. Density evaluation tools to measure the accuracy of density forecasts are reviewed and calibration methods for improving the accuracy of forecasts are presented. The manuscript provides some numerical simulation tools to approximate predictive densities with a focus on parallel computing on graphical process units. Some simple examples are proposed to illustrate the methods.

Appendix

There is little difference between a CPU and a GPU MATLAB code as Listings 15.1 and 15.2, for example, show. The pseudo code, reported in the listings, generates random variables Y  and X and estimates the linear regression model Y = Xβ + 𝜖, on CPU and GPU, respectively.

The GPU code, Listing 15.2, uses the command gpuArray.randn to generate a matrix of normal random numbers. The build-in function is handled by the NVIDIA plug-in that generates the random number with an underline raw CUDA code. Once the variables vY and mX are created and saved in the GPU memory all the related calculations are automatically executed on the GPU, e.g., inv is executed directly on the GPU. This is completely transparent to the user.

If further calculations are needed on the CPU then the command gather transfers the data from GPU to the CPU, see line 5 of Listing 15.2. There exist already a lot of supported functions and this number continuously increases with new releases.⁴

Listing 15.1 MATLAB CPU code that generate random numbers and estimate a linear regression model

1    iRows  =  1000; iColumns  =   5;   % number  of  rows and columns

2     mX   =  randn (iRows ,  iColumns ) ;   % generate random numbers

3     vY  =  randn (iRows ,  1) ;

4    vBeta  =  inv ( mX   ’ * mX) * mX’ * vY;

Listing 15.2 MATLAB GPU code that generate random numbers and estimate a linear regression model

1    iRows  =  1000; iColumns  =   5;   % number  of  rows and columns

2     mX   =  gpuArray . randn (iRows ,  iColumns ) ;   % generate random numbers

3     vY  =  gpuArray . randn (iRows ,  1) ;

4    vBeta  =  inv ( mX   ’ * mX) * mX’ * vY;

5    vBeta  =  gather ( vBeta ) ;   %  transfer  data to CPU

As further examples in Listings 15.3 and 15.4 we show the GPU implementation of the accept/reject and the importance sampling algorithms presented in Sect. 15.5.

Listing 15.3 Accept/reject MATLAB GPU code

1 sampsize  =  1000000; % sample  s i z e  to use  for  examples

2  sig   =   1;                  % standard  deviation   of  the instrumental  density

3 samp  =  gpuArray . randn ( sampsize ,  1)  .*   sig ;   % step 1 in the A/R algorithm

4 ys  =  exp((− samp .ˆ2) /2)   .*  ( sin (6 * samp) .ˆ2   +  3  *(( cos (samp) .ˆ2) .*( sin (4*samp) .ˆ2) )  +  1) ;

5 wts  =  (1/ sqrt (2* pi ) )  .*  exp (− samp .ˆ2/2) ;

6 samp2  =  gpuArray . rand ( sampsize ,  1) ;

7 dens  =  samp(samp2<=(ys ) ./ wts ) ;     % step 2 in the A/R algorithm

8  target   =  gather ( dens ) ;             % step 3 in the A/R algorithm

Listing 15.4 Importance sampling GPU code

1 nIS  =  10000; nu  =  gpuArray (12) ;  nustar  =  gpuArray (7) ; % number  of   simulations ;  degree  of  freedom  of  the  target   density ;  degree  of  freedom  of  the proposal

2 muIS  =  gpuArray . nan( nIS ,  2) ;

3 wIS  =  gpuArray . nan( nIS ,  2) ;

4 x1  =  rant_GPU( nIS ,  nustar ) ;                      % Student t  proposals

5 x2  =   tan (( gpuArray . rand ( nIS ,  1) −   0.5)   *   pi ) ;   % Cauchy  proposals

6 wIS ( : ,  1)  =   w1_GPU(x1 ,  nu ,  nustar ) ;              % Importance weights

7 wIS ( : ,  2)  =   w3_GPU(x2 ,  nu) ;                      % Importance weights

8 muIS ( : ,  1)  =   sqrt ( abs (x1 ./(1− x1 ) ) ) ;

9 muIS ( : ,  2)  =   sqrt ( abs (x2 ./(1− x2 ) ) ) ;

10 muIScum ( : , 1 )= cumsum(muIS ( : , 1 ) .* wIS ( : , 1 ) ) . / ( 1 : nIS ) ’;

11 muIScum ( : , 2 )= cumsum(muIS ( : , 2 ) .* wIS ( : , 2 ) ) . / ( 1 : nIS ) ’;

12  %

13  % Additional  functions

14 function   w   =   w1_GPU(x , nu , nustar )      % Student ’ s t weights

15     w   =  tpdf_GPU(x ,  nu) ./ tpdf_GPU(x ,  nustar ) ;

16 end

17 function   w = w3_GPU(x , nu)               % Cauchy weights

18      w   =  tpdf_GPU(x ,  nu) ./  pdfcauchy_GPU(x ,  0 , 1) ;

19 end

20 function   f   =  tpdf_GPU(x , v)            % Student ’ s t GPU pdf

21 k  =   find (v>0  &  v <Inf ) ;

22      i f  any(k)

23         term  =  exp (gammaln(( v(k)  +  1) / 2) −   gammaln ( v ( k ) /2) ) ;

24         f (k)  =  term  ./  ( sqrt (v(k)* pi )  .*  (1  +  (x(k)  .ˆ  2)  ./  v(k) )  .ˆ   (( v(k)  +  1) /2) ) ;

25     end

26 end

27 function   f   =  pdfcauchy_GPU(x ,  a ,  b)   % Cauchy GPU pdf

28          f   =   1./( pi  .*  b  .*  (1  +   (( x −   a ) ./ b ) .ˆ2) ) ;

29 end