stbss | R Documentation |
For a given multivariate space-time dataset, stbss
estimates the realization of spatio-temporally uncorrelated random fields through a linear transformation which is defined by a so-called mixing matrix and a location vector. This is done assuming a spatio-temporal blind source separation model and simultaneously/jointly diagonalizing the sample covariance matrix and one/many local autocovariance matrices.
stbss(x, ...)
## Default S3 method:
stbss(x, coords, time, kernel_type,
kernel_parameters, lags, ordered = TRUE, kernel_list = NULL, ...)
## S3 method for class 'STFDF'
stbss(x, ...)
## S3 method for class 'STSDF'
stbss(x, ...)
## S3 method for class 'sftime'
stbss(x, ...)
x |
either a numeric matrix of dimension |
coords |
a numeric matrix of dimension |
time |
a numeric vector of length |
kernel_type |
either a string or a string vector of length |
kernel_parameters |
a numeric vector of length |
lags |
an integer vector of length |
ordered |
logical. If |
kernel_list |
a list of spatio-temporal kernel matrices with dimension |
... |
further arguments for the fast real joint diagonalization algorithm that jointly diagonalizes the local covariance matrices. See details and |
It is assumed that the p-variate space-time random field x(s,t)
is formed by
x(s,t) = A z(s,t) + b,
where z(s,t)
is the latent p-variate space-time random field, A
and b
are the mixing matrix and a location vector and s
and t
are the space and time coordinates. Furthermore, it is assumed that z(s,t)
is white and consists of space-time uncorrelated components. The goal is to reverse the linear form by estimating an unmixing matrix and the location vector. This is done by simultaneously/jointly diagonalizing local autocovariance matrices which are defined by
LACov(f) = 1/(n F_{f,n}) \sum_{i,j} f(s_i-s_j,t_i-t_j) (x(s_i,t_i)-\bar{x}) (x(s_j,t_j)-\bar{x})',
with
F^2_{f,n} = 1 / n \sum_{i,j} f^2(s_i-s_j,t_i-t_j).
Here, x(s_i,t_i)
are the p
random field values at location s_i,t_i
, \bar{x}
is the sample mean vector, and the space-time kernel function f
determines the locality. The following kernel functions are implemented and chosen with the argument kernel_type
:
'ring'
: the spatial parameters are inner radius r_i
and outer radius r_o
, with r_i < r_o
, and r_i, r_o \ge 0
, the temporal parameter is the temporal lag u
:
f(d_s,d_t) = I(r_i < d_s \le r_o)I(d_t = u)
'ball'
: the spatial parameter is the radius r
, with r \ge 0
, the temporal parameter is the temporal lag u
:
f(d_s,d_t) = I(d_s \le r)I(d_t = u)
'gauss'
: Gaussian function where 95% of the mass is inside the spatial parameter r
, with r \ge 0
, the temporal parameter is the temporal lag u
:
f(d_s,d_t) = exp(-0.5 (\Phi^{-1}(0.95) d_s/r)^2)I(d_t = u)
Above, I()
represents the indicator function. The argument kernel_type
determines the used kernel function as presented above, the argument lags
provides the used temporal lags for the kernel functions (u
in the above formulas) and the argument kernel_parameters
gives the spatial parameters for the kernel function. Each of the arguments kernel_type
, lags
and kernel_parameters
can be of length K
or 1
. Specifically, kernel_type
can be either one kernel, then each local autocovariance matrix use the same kernel type, or of length K
which leads to different kernel functions for the provided kernel parameters. lags
can be either one integer, then for each kernel the same temporal lag is used, or an integer vector of length K
which leads to different temporal lags. In the same fashion kernel_parameters
is a vector of length K
or 1
. If kernel_type
equals 'ball'
or 'gauss'
then the corresponding entry of kernel_parameters
gives the single spatial radius parameter. In contrast, if (at least one entry of) kernel_type
equals 'ring'
, then kernel_parameters
must be a list of length K
(or 1
) where each entry is a numeric vector of length 2
defining the inner and outer spatial radius.
Internally, stbss
calls stkmat
to compute a list of c(n,n)
kernel matrices based on the parameters given, where each entry of those matrices corresponds to f(s_i-s_j,t_i-t_j)
. Alternatively, such a list of kernel matrices can be given directly to the function stbss
through the kernel_list
argument. This is useful when stbss
is called numerous times with the same coordinates/kernel functions as the computation of the kernel matrices is then only done once prior the actual stbss
calls. For details see also lacov
.
If more than one local autocovariance matrix is used stbss
jointly diagonalizes these matrices with the function frjd
. ...
provides arguments for frjd
, useful arguments might be:
eps
: tolerance for convergence.
maxiter
: maximum number of iterations.
stbss
returns a list of class 'stbss'
with the following entries:
s |
object of |
coords |
coordinates of the observations. Is |
time |
time of the observations. Is |
w |
estimated unmixing matrix. |
w_inv |
inverse of the estimated unmixing matrix. |
pevals |
(pseudo-)eigenvalues for each latent field entry. |
d |
matrix of stacked (jointly) diagonalized local autocovariance matrices with dimension |
x_mu |
columnmeans of |
cov_inv_sqrt |
square root of the inverse sample covariance matrix of |
Muehlmann, C., De Iaco, S. and Nordhausen, K. (2023), Blind Recovery of Sources for Multivariate Space-Time Environmental Data. Stochastic and Environmental Research and Risk Assessment, 37, 1593–1613, <doi:10.1007/s00477-022-02348-2>.
stkmat
, frjd
# space and time coordinates
n_t <- 50
n_sp <- 10
st_coords <- as.matrix(expand.grid(1:n_sp, 1:n_sp, 1:n_t))
# simulate three latent white noise fields
field_1 <- rnorm(nrow(st_coords))
field_2 <- rnorm(nrow(st_coords))
field_3 <- rnorm(nrow(st_coords))
# compute the observed field
latent_field <- cbind(field_1, field_2, field_3)
mixing_matrix <- matrix(rnorm(9), 3, 3)
observed_field <- latent_field
# apply stbss with lag 1 and a ring kernel
stbss_res <- stbss(observed_field, coords = st_coords[, 1:2], time = st_coords[, 3],
kernel_type = 'ring', kernel_parameters = list(c(0, 1)), lags = 1)
# print object
print(stbss_res)
# unmixing matrix
w_unmix <- coef(stbss_res)
# apply the same stbss with a kernel list
kernel_list <- stkmat(coords = st_coords[, 1:2], time = st_coords[, 3],
kernel_type = 'ring', kernel_parameters = list(c(0, 1)), lags = 1)
stbss_res_k <- stbss(observed_field, kernel_list = kernel_list)
# apply stbss with three ball kernels
stbss_res_b <- stbss(observed_field, coords = st_coords[, 1:2], time = st_coords[, 3],
kernel_type = 'ball', kernel_parameters = 1:3, lags = 1:3)
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.