Package 'fsemipar'

Estimation, Variable Selection and Prediction for Functional Semiparametric Models

Description

This package is dedicated to the estimation and simultaneous estimation and variable selection in several functional semiparametric models with scalar response. These include the functional single-index model, the semi-functional partial linear model, and the semi-functional partial linear single-index model. Additionally, it encompasses algorithms for addressing estimation and variable selection in linear models and bi-functional partial linear models when the scalar covariates with linear effects are derived from the discretisation of a curve. Furthermore, the package offers routines for kernel- and kNN-based estimation using Nadaraya-Watson weights in models with a nonparametric or semiparametric component. It also includes S3 methods (predict, plot, print, summary) to facilitate statistical analysis across all the considered models and estimation procedures.

Details

The package can be divided into several thematic sections:

1. Estimation of the functional single-index model.

   • projec.

   • semimetric.projec.

   • fsim.kernel.fit and fsim.kNN.fit.

   • fsim.kernel.fit.optim and fsim.kNN.fit.optim

   • fsim.kernel.test and fsim.kNN.test.

   • predict, plot, summary and print methods for fsim.kernel and fsim.kNN classes.

2. Simultaneous estimation and variable selection in linear and semi-functional partial linear models.

   1. Linear model

      • lm.pels.fit.

      • predict, summary, plot and print methods for lm.pels class.

   2. Semi-functional partial linear model.

      • sfpl.kernel.fit and sfpl.kNN.fit.

      • predict, summary, plot and print methods for sfpl.kernel and sfpl.kNN classes.

   3. Semi-functional partial linear single-index model.

      • sfplsim.kernel.fit and sfplsim.kNN.fit.

      • predict, summary, plot and print methods for sfplsim.kernel and sfplsim.kNN classes.

3. Algorithms for impact point selection in models with covariates derived from the discretisation of a curve.

   1. Linear model

      • PVS.fit.

      • predict, summary, plot and print methods for PVS class.

   2. Bi-functional partial linear model.

      • PVS.kernel.fit and PVS.kNN.fit.

      • predict, summary, plot and print methods for PVS.kernel and PVS.kNN classes.

   3. Bi-functional partial linear single-index model.

      • FASSMR.kernel.fit and FASSMR.kNN.fit.

      • IASSMR.kernel.fit and IASSMR.kNN.fit.

      • predict, summary, plot and print methods for FASSMR.kernel, FASSMR.kNN, IASSMR.kernel and IASSMR.kNN classes.

4. Two datasets: Tecator and Sugar.

Author(s)

German Aneiros [aut], Silvia Novo [aut, cre]

Maintainer: Silvia Novo <[email protected]>

References

Aneiros, G. and Vieu, P., (2014) Variable selection in infinite-dimensional problems, Statistics and Probability Letters, 94, 12–20. doi:10.1016/j.spl.2014.06.025.

Aneiros, G., Ferraty, F., and Vieu, P., (2015) Variable selection in partial linear regression with functional covariate, Statistics, 49 1322–1347, doi:10.1080/02331888.2014.998675.

Aneiros, G., and Vieu, P., (2015) Partial linear modelling with multi-functional covariates. Computational Statistics, 30, 647–671. doi:10.1007/s00180-015-0568-8.

Novo S., Aneiros, G., and Vieu, P., (2019) Automatic and location-adaptive estimation in functional single-index regression, Journal of Nonparametric Statistics, 31(2), 364–392, doi:10.1080/10485252.2019.1567726.

Novo, S., Aneiros, G., and Vieu, P., (2021) Sparse semiparametric regression when predictors are mixture of functional and high-dimensional variables, TEST, 30, 481–504, doi:10.1007/s11749-020-00728-w.

Novo, S., Aneiros, G., and Vieu, P., (2021) A kNN procedure in semiparametric functional data analysis, Statistics and Probability Letters, 171, 109028, doi:10.1016/j.spl.2020.109028.

Novo, S., Vieu, P., and Aneiros, G., (2021) Fast and efficient algorithms for sparse semiparametric bi-functional regression, Australian and New Zealand Journal of Statistics, 63, 606–638, doi:10.1111/anzs.12355.

---

Impact point selection with FASSMR and kernel estimation

Description

This function implements the Fast Algorithm for Sparse Semiparametric Multi-functional Regression (FASSMR) with kernel estimation. This algorithm is specifically designed for estimating multi-functional partial linear single-index models, which incorporate multiple scalar variables and a functional covariate as predictors. These scalar variables are derived from the discretisation of a curve and have linear effect while the functional covariate exhibits a single-index effect.

FASSMR selects the impact points of the discretised curve and estimates the model. The algorithm employs a penalised least-squares regularisation procedure, integrated with kernel estimation using Nadaraya-Watson weights. It uses B-spline expansions to represent curves and eligible functional indexes. Additionally, it utilises an objective criterion (criterion) to determine the initial number of covariates in the reduced model (w.opt), the bandwidth (h.opt), and the penalisation parameter (lambda.opt).

Usage

FASSMR.kernel.fit(x, z, y, seed.coeff = c(-1, 0, 1), order.Bspline = 3, 
nknot.theta = 3,  min.q.h = 0.05, max.q.h = 0.5, h.seq = NULL, num.h = 10,  
kind.of.kernel = "quad",range.grid = NULL, nknot = NULL, lambda.min = NULL, 
lambda.min.h = NULL, lambda.min.l = NULL, factor.pn = 1, nlambda = 100, 
vn = ncol(z), nfolds = 10, seed = 123, wn = c(10, 15, 20), criterion = "GCV", 
penalty = "grSCAD", max.iter = 1000, n.core = NULL)

Arguments

x	Matrix containing the observations of the functional covariate collected by row (functional single-index component).
z	Matrix containing the observations of the functional covariate that is discretised collected by row (linear component).
y	Vector containing the scalar response.
seed.coeff	Vector of initial values used to build the set $\Theta_n$ (see section Details). The coefficients for the B-spline representation of each eligible functional index $\theta \in \Theta_n$ are obtained from seed.coeff. The default is c(-1,0,1).
order.Bspline	Positive integer giving the order of the B-spline basis functions. This is the number of coefficients in each piecewise polynomial segment. The default is 3.
nknot.theta	Positive integer indicating the number of regularly spaced interior knots in the B-spline expansion of $\theta_0$. The default is 3.
min.q.h	Minimum quantile order of the distances between curves, which are computed using the projection semi-metric. This value determines the lower endpoint of the range from which the bandwidth is selected. The default is 0.05.
max.q.h	Maximum quantile order of the distances between curves, which are computed using the projection semi-metric. This value determines the upper endpoint of the range from which the bandwidth is selected. The default is 0.5.
h.seq	Vector containing the sequence of bandwidths. The default is a sequence of num.h equispaced bandwidths in the range constructed using min.q.h and max.q.h.
num.h	Positive integer indicating the number of bandwidths in the grid. The default is 10.
kind.of.kernel	The type of kernel function used. Currently, only Epanechnikov kernel ("quad") is available.
range.grid	Vector of length 2 containing the endpoints of the grid at which the observations of the functional covariate x are evaluated (i.e. the range of the discretisation). If range.grid=NULL, then range.grid=c(1,p) is considered, where p is the discretisation size of x (i.e. ncol(x)).
nknot	Positive integer indicating the number of interior knots for the B-spline expansion of the functional covariate. The default value is (p - order.Bspline - 1)%/%2.
lambda.min	The smallest value for lambda (i. e., the lower endpoint of the sequence in which lambda.opt is selected), as fraction of lambda.max. The defaults is lambda.min.l if the sample size is larger than factor.pn times the number of linear covariates and lambda.min.h otherwise.
lambda.min.h	The lower endpoint of the sequence in which lambda.opt is selected if the sample size is smaller than factor.pn times the number of linear covariates. The default is 0.05.
lambda.min.l	The lower endpoint of the sequence in which lambda.opt is selected if the sample size is larger than factor.pn times the number of linear covariates. The default is 0.0001.
factor.pn	Positive integer used to set lambda.min. The default value is 1.
nlambda	Positive integer indicating the number of values in the sequence from which lambda.opt is selected. The default is 100.
vn	Positive integer or vector of positive integers indicating the number of groups of consecutive variables to be penalised together. The default value is vn=ncol(z), resulting in the individual penalization of each scalar covariate.
nfolds	Positive integer indicating the number of cross-validation folds (used when criterion="k-fold-CV"). Default is 10.
seed	You may set the seed for the random number generator to ensure reproducible results (applicable when criterion="k-fold-CV" is used). The default seed value is 123.
wn	A vector of positive integers indicating the eligible number of covariates in the reduced model. For more information, refer to the section Details. The default is c(10,15,20).
criterion	The criterion used to select the tuning and regularisation parameters: wn.opt, lambda.opt and h.opt (also vn.opt if needed). Options include "GCV", "BIC", "AIC", or "k-fold-CV". The default setting is "GCV".
penalty	The penalty function applied in the penalised least-squares procedure. Currently, only "grLasso" and "grSCAD" are implemented. The default is "grSCAD".
max.iter	Maximum number of iterations allowed across the entire path. The default value is 1000.
n.core	Number of CPU cores designated for parallel execution. The default is n.core<-availableCores(omit=1).

Details

The multi-functional partial linear single-index model (MFPLSIM) is given by the expression

$Y_i=\sum_{j=1}^{p_n}\beta_{0j}\zeta_i(t_j)+r\left(\left<\theta_0,X_i\right>\right)+\varepsilon_i,\ \ \ (i=1,\dots,n),$

where:

• $Y_i$ is a real random response and $X_i$ denotes a random element belonging to some separable Hilbert space $\mathcal{H}$ with inner product denoted by $\left\langle\cdot,\cdot\right\rangle$. The second functional predictor $\zeta_i$ is assumed to be a curve defined on some interval $[a,b]$ which is observed at the points $a\leq t_1<\dots<t_{p_n}\leq b$.

• $\mathbf{\beta}_0=(\beta_{01},\dots,\beta_{0p_n})^{\top}$ is a vector of unknown real coefficients and $r(\cdot)$ denotes a smooth unknown link function. In addition, $\theta_0$ is an unknown functional direction in $\mathcal{H}$.

• $\varepsilon_i$ denotes the random error.

In the MFPLSIM, we assume that only a few scalar variables from the set $\{\zeta(t_1),\dots,\zeta(t_{p_n})\}$ form part of the model. Therefore, we must select the relevant variables in the linear component (the impact points of the curve $\zeta$ on the response) and estimate the model.

In this function, the MFPLSIM is fitted using the FASSMR algorithm. The main idea of this algorithm is to consider a reduced model, with only some (very few) linear covariates (but covering the entire discretization interval of $\zeta$), and discarding directly the other linear covariates (since it is expected that they contain very similar information about the response).

To explain the algorithm, we assume, without loss of generality, that the number $p_n$ of linear covariates can be expressed as follows: $p_n=q_nw_n$ with $q_n$ and $w_n$ integers. This consideration allows us to build a subset of the initial $p_n$ linear covariates, containging only $w_n$ equally spaced discretised observations of $\zeta$ covering the entire interval $[a,b]$. This subset is the following:

$\mathcal{R}_n^{\mathbf{1}}=\left\{\zeta\left(t_k^{\mathbf{1}}\right),\ \ k=1,\dots,w_n\right\},$

where $t_k^{\mathbf{1}}=t_{\left[(2k-1)q_n/2\right]}$ and $\left[z\right]$ denotes the smallest integer not less than the real number $z$.

We consider the following reduced model, which involves only the linear covariates belonging to $\mathcal{R}_n^{\mathbf{1}}$:

$Y_i=\sum_{k=1}^{w_n}\beta_{0k}^{\mathbf{1}}\zeta_i(t_k^{\mathbf{1}})+r^{\mathbf{1}}\left(\left<\theta_0^{\mathbf{1}},\mathcal{X}_i\right>\right)+\varepsilon_i^{\mathbf{1}}.$

The program receives the eligible numbers of linear covariates for building the reduced model through the argument wn. Then, the penalised least-squares variable selection procedure, with kernel estimation, is applied to the reduced model. This is done using the function sfplsim.kernel.fit, which requires the remaining arguments (for details, see the documentation of the function sfplsim.kernel.fit). The estimates obtained are the outputs of the FASSMR algorithm. For further details on this algorithm, see Novo et al. (2021).

Remark: If the condition $p_n=w_n q_n$ is not met (then $p_n/w_n$ is not an integer number), the function considers variable $q_n=q_{n,k}$ values $k=1,\dots,w_n$. Specifically:

$q_{n,k}= \left\{\begin{array}{ll} [p_n/w_n]+1 & k\in\{1,\dots,p_n-w_n[p_n/w_n]\},\\ {[p_n/w_n]} & k\in\{p_n-w_n[p_n/w_n]+1,\dots,w_n\}, \end{array} \right.$

where $[z]$ denotes the integer part of the real number $z$.

The function supports parallel computation. To avoid it, we can set n.core=1.

Value

call	The matched call.
fitted.values	Estimated scalar response.
residuals	Differences between y and the fitted.values.
beta.est	$\hat{\mathbf{\beta}}$ (i.e. estimate of $\mathbf{\beta}_0$ when the optimal tuning parameters w.opt, lambda.opt, h.opt and vn.opt are used).
beta.red	Estimate of $\beta_0^{\mathbf{1}}$ in the reduced model when the optimal tuning parameters w.opt, lambda.opt, h.opt and vn.opt are used.
theta.est	Coefficients of $\hat{\theta}$ in the B-spline basis (i.e. estimate of $\theta_0$ when the optimal tuning parameters w.opt, lambda.opt, h.opt and vn.opt are used): a vector of length(order.Bspline+nknot.theta).
indexes.beta.nonnull	Indexes of the non-zero $\hat{\beta_{j}}$.
h.opt	Selected bandwidth (when w.opt is considered).
w.opt	Selected size for $\mathcal{R}_n^{\mathbf{1}}$.
lambda.opt	Selected value for the penalisation parameter (when w.opt is considered).
IC	Value of the criterion function considered to select w.opt, lambda.opt, h.opt and vn.opt.
vn.opt	Selected value of vn (when w.opt is considered).
beta.w	Estimate of $\beta_0^{\mathbf{1}}$ for each value of the sequence wn.
theta.w	Estimate of $\theta_0^{\mathbf{1}}$ for each value of the sequence wn (i.e. its coefficients in the B-spline basis).
IC.w	Value of the criterion function for each value of the sequence wn.
indexes.beta.nonnull.w	Indexes of the non-zero linear coefficients for each value of the sequence wn.
lambda.w	Selected value of penalisation parameter for each value of the sequence wn.
h.w	Selected bandwidth for each value of the sequence wn.
index01	Indexes of the covariates (in the entire set of $p_n$) used to build $\mathcal{R}_n^{\mathbf{1}}$ for each value of the sequence wn.
...

Author(s)

German Aneiros Perez [email protected]

Silvia Novo Diaz [email protected]

References

Novo, S., Vieu, P., and Aneiros, G., (2021) Fast and efficient algorithms for sparse semiparametric bi-functional regression. Australian and New Zealand Journal of Statistics, 63, 606–638, doi:10.1111/anzs.12355.

See Also

See also sfplsim.kernel.fit, predict.FASSMR.kernel, plot.FASSMR.kernel and IASSMR.kernel.fit.

Alternative method FASSMR.kNN.fit.

Examples

data(Sugar)

y<-Sugar$ash
x<-Sugar$wave.290
z<-Sugar$wave.240

#Outliers
index.y.25 <- y > 25
index.atip <- index.y.25
(1:268)[index.atip]


#Dataset to model
x.sug <- x[!index.atip,]
z.sug<- z[!index.atip,]
y.sug <- y[!index.atip]

train<-1:216

ptm=proc.time()
fit <- FASSMR.kernel.fit(x=x.sug[train,],z=z.sug[train,], y=y.sug[train], 
        nknot.theta=2, lambda.min.l=0.03,
        max.q.h=0.35, nknot=20,criterion="BIC", 
        max.iter=5000)
proc.time()-ptm

---

Impact point selection with FASSMR and kNN estimation

Description

This function implements the Fast Algorithm for Sparse Semiparametric Multi-functional Regression (FASSMR) with kNN estimation. This algorithm is specifically designed for estimating multi-functional partial linear single-index models, which incorporate multiple scalar variables and a functional covariate as predictors. These scalar variables are derived from the discretisation of a curve and have linear effect while the functional covariate exhibits a single-index effect.

FASSMR selects the impact points of the discretised curve and estimates the model. The algorithm employs a penalised least-squares regularisation procedure, integrated with kNN estimation using Nadaraya-Watson weights. It uses B-spline expansions to represent curves and eligible functional indexes. Additionally, it utilises an objective criterion (criterion) to determine the initial number of covariates in the reduced model (w.opt), the number of neighbours (k.opt), and the penalisation parameter (lambda.opt).

Usage

FASSMR.kNN.fit(x, z, y, seed.coeff = c(-1, 0, 1), order.Bspline = 3, 
nknot.theta = 3,  knearest = NULL, min.knn = 2, max.knn = NULL, step = NULL,  
kind.of.kernel = "quad",range.grid = NULL, nknot = NULL, lambda.min = NULL, 
lambda.min.h = NULL, lambda.min.l = NULL, factor.pn = 1, nlambda = 100, 
vn = ncol(z), nfolds = 10, seed = 123, wn = c(10, 15, 20), criterion = "GCV", 
penalty = "grSCAD", max.iter = 1000, n.core = NULL)

Arguments

x	Matrix containing the observations of the functional covariate collected by row (functional single-index component).
z	Matrix containing the observations of the functional covariate that is discretised collected by row (linear component).
y	Vector containing the scalar response.
seed.coeff	Vector of initial values used to build the set $\Theta_n$ (see section Details). The coefficients for the B-spline representation of each eligible functional index $\theta \in \Theta_n$ are obtained from seed.coeff. The default is c(-1,0,1).
order.Bspline	Positive integer giving the order of the B-spline basis functions. This is the number of coefficients in each piecewise polynomial segment. The default is 3.
nknot.theta	Positive integer indicating the number of regularly spaced interior knots in the B-spline expansion of $\theta_0$. The default is 3.
knearest	Vector of positive integers containing the sequence in which the number of nearest neighbours k.opt is selected. If knearest=NULL, then knearest <- seq(from =min.knn, to = max.knn, by = step).
min.knn	A positive integer that represents the minimum value in the sequence for selecting the number of nearest neighbours k.opt. This value should be less than the sample size. The default is 2.
max.knn	A positive integer that represents the maximum value in the sequence for selecting number of nearest neighbours k.opt. This value should be less than the sample size. The default is max.knn <- n%/%5.
step	A positive integer used to construct the sequence of k-nearest neighbours as follows: min.knn, min.knn + step, min.knn + 2*step, min.knn + 3*step,.... The default value for step is step<-ceiling(n/100).
kind.of.kernel	The type of kernel function used. Currently, only Epanechnikov kernel ("quad") is available.
range.grid	Vector of length 2 containing the endpoints of the grid at which the observations of the functional covariate x are evaluated (i.e. the range of the discretisation). If range.grid=NULL, then range.grid=c(1,p) is considered, where p is the discretisation size of x (i.e. ncol(x)).
nknot	Positive integer indicating the number of interior knots for the B-spline expansion of the functional covariate. The default value is (p - order.Bspline - 1)%/%2.
lambda.min	The smallest value for lambda (i. e., the lower endpoint of the sequence in which lambda.opt is selected), as fraction of lambda.max. The defaults is lambda.min.l if the sample size is larger than factor.pn times the number of linear covariates and lambda.min.h otherwise.
lambda.min.h	The lower endpoint of the sequence in which lambda.opt is selected if the sample size is smaller than factor.pn times the number of linear covariates. The default is 0.05.
lambda.min.l	The lower endpoint of the sequence in which lambda.opt is selected if the sample size is larger than factor.pn times the number of linear covariates. The default is 0.0001.
factor.pn	Positive integer used to set lambda.min. The default value is 1.
nlambda	Positive integer indicating the number of values in the sequence from which lambda.opt is selected. The default is 100.
vn	Positive integer or vector of positive integers indicating the number of groups of consecutive variables to be penalised together. The default value is vn=ncol(z), resulting in the individual penalization of each scalar covariate.
nfolds	Positive integer indicating the number of cross-validation folds (used when criterion="k-fold-CV"). Default is 10.
seed	You may set the seed for the random number generator to ensure reproducible results (applicable when criterion="k-fold-CV" is used). The default seed value is 123.
wn	A vector of positive integers indicating the eligible number of covariates in the reduced model. For more information, refer to the section Details. The default is c(10,15,20).
criterion	The criterion used to select the tuning and regularisation parameters: wn.opt, k.opt and lambda.opt (also vn.opt if needed). Options include "GCV", "BIC", "AIC", or "k-fold-CV". The default setting is "GCV".
penalty	The penalty function applied in the penalised least-squares procedure. Currently, only "grLasso" and "grSCAD" are implemented. The default is "grSCAD".
max.iter	Maximum number of iterations allowed across the entire path. The default value is 1000.
n.core	Number of CPU cores designated for parallel execution. The default is n.core<-availableCores(omit=1).

Details

The multi-functional partial linear single-index model (MFPLSIM) is given by the expression

$Y_i=\sum_{j=1}^{p_n}\beta_{0j}\zeta_i(t_j)+r\left(\left<\theta_0,X_i\right>\right)+\varepsilon_i,\ \ \ (i=1,\dots,n),$

where:

• $Y_i$ is a real random response and $X_i$ denotes a random element belonging to some separable Hilbert space $\mathcal{H}$ with inner product denoted by $\left\langle\cdot,\cdot\right\rangle$. The second functional predictor $\zeta_i$ is assumed to be a curve defined on some interval $[a,b]$ which is observed at the points $a\leq t_1<\dots<t_{p_n}\leq b$.

• $\mathbf{\beta}_0=(\beta_{01},\dots,\beta_{0p_n})^{\top}$ is a vector of unknown real coefficients and $r(\cdot)$ denotes a smooth unknown link function. In addition, $\theta_0$ is an unknown functional direction in $\mathcal{H}$.

• $\varepsilon_i$ denotes the random error.

In the MFPLSIM, we assume that only a few scalar variables from the set $\{\zeta(t_1),\dots,\zeta(t_{p_n})\}$ form part of the model. Therefore, we must select the relevant variables in the linear component (the impact points of the curve $\zeta$ on the response) and estimate the model.

In this function, the MFPLSIM is fitted using the FASSMR algorithm. The main idea of this algorithm is to consider a reduced model, with only some (very few) linear covariates (but covering the entire discretization interval of $\zeta$), and discarding directly the other linear covariates (since it is expected that they contain very similar information about the response).

To explain the algorithm, we assume, without loss of generality, that the number $p_n$ of linear covariates can be expressed as follows: $p_n=q_nw_n$ with $q_n$ and $w_n$ integers. This consideration allows us to build a subset of the initial $p_n$ linear covariates, containging only $w_n$ equally spaced discretised observations of $\zeta$ covering the entire interval $[a,b]$. This subset is the following:

$\mathcal{R}_n^{\mathbf{1}}=\left\{\zeta\left(t_k^{\mathbf{1}}\right),\ \ k=1,\dots,w_n\right\},$

where $t_k^{\mathbf{1}}=t_{\left[(2k-1)q_n/2\right]}$ and $\left[z\right]$ denotes the smallest integer not less than the real number $z$.

We consider the following reduced model, which involves only the linear covariates belonging to $\mathcal{R}_n^{\mathbf{1}}$:

$Y_i=\sum_{k=1}^{w_n}\beta_{0k}^{\mathbf{1}}\zeta_i(t_k^{\mathbf{1}})+r^{\mathbf{1}}\left(\left<\theta_0^{\mathbf{1}},\mathcal{X}_i\right>\right)+\varepsilon_i^{\mathbf{1}}.$

The program receives the eligible numbers of linear covariates for building the reduced model through the argument wn. Then, the penalised least-squares variable selection procedure, with kNN estimation, is applied to the reduced model. This is done using the function sfplsim.kNN.fit, which requires the remaining arguments (for details, see the documentation of the function sfplsim.kNN.fit). The estimates obtained are the outputs of the FASSMR algorithm. For further details on this algorithm, see Novo et al. (2021).

Remark: If the condition $p_n=w_n q_n$ is not met (then $p_n/w_n$ is not an integer number), the function considers variable $q_n=q_{n,k}$ values $k=1,\dots,w_n$. Specifically:

$q_{n,k}= \left\{\begin{array}{ll} [p_n/w_n]+1 & k\in\{1,\dots,p_n-w_n[p_n/w_n]\},\\ {[p_n/w_n]} & k\in\{p_n-w_n[p_n/w_n]+1,\dots,w_n\}, \end{array} \right.$

where $[z]$ denotes the integer part of the real number $z$.

The function supports parallel computation. To avoid it, we can set n.core=1.

Value

call	The matched call.
fitted.values	Estimated scalar response.
residuals	Differences between y and the fitted.values.
beta.est	$\hat{\mathbf{\beta}}$ (i.e. estimate of $\mathbf{\beta}_0$ when the optimal tuning parameters w.opt, lambda.opt, k.opt and vn.opt are used).
beta.red	Estimate of $\beta_0^{\mathbf{1}}$ in the reduced model when the optimal tuning parameters w.opt, lambda.opt, k.opt and vn.opt are used.
theta.est	Coefficients of $\hat{\theta}$ in the B-spline basis (i.e. estimate of $\theta_0$ when the optimal tuning parameters w.opt, lambda.opt, k.opt and vn.opt are used): a vector of length(order.Bspline+nknot.theta).
indexes.beta.nonnull	Indexes of the non-zero $\hat{\beta_{j}}$.
k.opt	Selected number of nearest neighbours (when w.opt is considered).
w.opt	Selected size for $\mathcal{R}_n^{\mathbf{1}}$.
lambda.opt	Selected value for the penalisation parameter (when w.opt is considered).
IC	Value of the criterion function considered to select w.opt, lambda.opt, k.opt and vn.opt.
vn.opt	Selected value of vn (when w.opt is considered).
beta.w	Estimate of $\beta_0^{\mathbf{1}}$ for each value of the sequence wn (i.e. for each number of covariates in the reduced model).
theta.w	Estimate of $\theta_0^{\mathbf{1}}$ for each value of the sequence wn (i.e. its coefficients in the B-spline basis).
IC.w	Value of the criterion function for each value of the sequence wn.
indexes.beta.nonnull.w	Indexes of the non-zero linear coefficients for each value of the sequence wn.
lambda.w	Selected value of penalisation parameter for each value of the sequence wn.
k.w	Selected number of neighbours for each value of the sequence wn.
index01	Indexes of the covariates (in the entire set of $p_n$) used to build $\mathcal{R}_n^{\mathbf{1}}$ for each value of the sequence wn.
...

Author(s)

German Aneiros Perez [email protected]

Silvia Novo Diaz [email protected]

References

Novo, S., Vieu, P., and Aneiros, G., (2021) Fast and efficient algorithms for sparse semiparametric bi-functional regression. Australian and New Zealand Journal of Statistics, 63, 606–638, doi:10.1111/anzs.12355.

See Also

See also sfplsim.kNN.fit, predict.FASSMR.kNN, plot.FASSMR.kNN and IASSMR.kNN.fit.

Alternative method FASSMR.kernel.fit

Examples

data(Sugar)


y<-Sugar$ash
x<-Sugar$wave.290
z<-Sugar$wave.240

#Outliers
index.y.25 <- y > 25
index.atip <- index.y.25
(1:268)[index.atip]


#Dataset to model
x.sug <- x[!index.atip,]
z.sug<- z[!index.atip,]
y.sug <- y[!index.atip]

train<-1:216
ptm=proc.time()
fit<- FASSMR.kNN.fit(x=x.sug[train,],z=z.sug[train,], y=y.sug[train], 
        nknot.theta=2, lambda.min.l=0.03, max.knn=20,nknot=20,criterion="BIC",
        max.iter=5000)
proc.time()-ptm

fit
names(fit)

---

Package fsemipar internal functions

Description

The package includes the following internal functions, based on the code by F. Ferraty, which is available on his website at https://www.math.univ-toulouse.fr/~ferraty/SOFTWARES/NPFDA/index.html.

Details

• approx.spline.deriv

• Bspline.ini

• fnp.kernel.fit

• fnp.kernel.fit.test

• fnp.kernel.test

• fnp.kNN.fit

• fnp.kNN.fit.test

• fnp.kNN.fit.test.loc

• fnp.kNN.GCV

• fnp.kNN.test

• fsim.kernel.fit.fixedtheta

• fsim.kNN.fit.fixedtheta

• fun.kernel

• fun.kernel.fixedtheta

• fun.kNN

• fun.kNN.fixedtheta

• funopare.kNN

• H.fnp.kernel

• H.fnp.kNN

• H.fsim.kernel

• H.fsim.kNN

• interp.spline.deriv

• quad

• semimetric.deriv

• semimetric.interv

• semimetric.pca

• sfplsim.kernel.fit.fixedtheta

• sfplsim.kNN.fit.fixedtheta

• Splinemlf

• symsolve

---

Functional single-index model fit using kernel estimation and joint LOOCV minimisation

Description

This function fits a functional single-index model (FSIM) between a functional covariate and a scalar response. It employs kernel estimation with Nadaraya-Watson weights and uses B-spline expansions to represent curves and eligible functional indexes.

The function also utilises the leave-one-out cross-validation (LOOCV) criterion to select the bandwidth (h.opt) and the coefficients of the functional index in the spline basis (theta.est). It performs a joint minimisation of the LOOCV objective function in both the bandwidth and the functional index.

Usage

fsim.kernel.fit(x, y, seed.coeff = c(-1, 0, 1), order.Bspline = 3, 
nknot.theta = 3,  min.q.h = 0.05, max.q.h = 0.5, h.seq = NULL, num.h = 10, 
kind.of.kernel = "quad", range.grid = NULL, nknot = NULL, n.core = NULL)

Arguments

x	Matrix containing the observations of the functional covariate (i.e. curves) collected by row.
y	Vector containing the scalar response.
seed.coeff	Vector of initial values used to build the set $\Theta_n$ (see section Details). The coefficients for the B-spline representation of each eligible functional index $\theta \in \Theta_n$ are obtained from seed.coeff. The default is c(-1,0,1).
order.Bspline	Positive integer giving the order of the B-spline basis functions. This is the number of coefficients in each piecewise polynomial segment. The default is 3
nknot.theta	Positive integer indicating the number of regularly spaced interior knots in the B-spline expansion of $\theta_0$. The default is 3.
min.q.h	Minimum quantile order of the distances between curves, which are computed using the projection semi-metric. This value determines the lower endpoint of the range from which the bandwidth is selected. The default is 0.05.
max.q.h	Maximum quantile order of the distances between curves, which are computed using the projection semi-metric. This value determines the upper endpoint of the range from which the bandwidth is selected. The default is 0.5.
h.seq	Vector containing the sequence of bandwidths. The default is a sequence of num.h equispaced bandwidths in the range constructed using min.q.h and max.q.h.
num.h	Positive integer indicating the number of bandwidths in the grid. The default is 10.
kind.of.kernel	The type of kernel function used. Currently, only Epanechnikov kernel ("quad") is available.
range.grid	Vector of length 2 containing the endpoints of the grid at which the observations of the functional covariate x are evaluated (i.e. the range of the discretisation). If range.grid=NULL, then range.grid=c(1,p) is considered, where p is the discretisation size of x (i.e. ncol(x)).
nknot	Positive integer indicating the number of interior knots for the B-spline expansion of the functional covariate. The default value is (p - order.Bspline - 1)%/%2.
n.core	Number of CPU cores designated for parallel execution.The default is n.core<-availableCores(omit=1).

Details

The functional single-index model (FSIM) is given by the expression:

$Y_i=r(\langle\theta_0,X_i\rangle)+\varepsilon_i, \quad i=1,\dots,n,$

where $Y_i$ denotes a scalar response, $X_i$ is a functional covariate valued in a separable Hilbert space $\mathcal{H}$ with an inner product $\langle \cdot, \cdot\rangle$. The term $\varepsilon$ denotes the random error, $\theta_0 \in \mathcal{H}$ is the unknown functional index and $r(\cdot)$ denotes the unknown smooth link function.

The FSIM is fitted using the kernel estimator

$\widehat{r}_{h,\hat{\theta}}(x)=\sum_{i=1}^nw_{n,h,\hat{\theta}}(x,X_i)Y_i, \quad \forall x\in\mathcal{H},$

with Nadaraya-Watson weights

$w_{n,h,\hat{\theta}}(x,X_i)=\frac{K\left(h^{-1}d_{\hat{\theta}}\left(X_i,x\right)\right)}{\sum_{i=1}^nK\left(h^{-1}d_{\hat{\theta}}\left(X_i,x\right)\right)},$

where

• the real positive number $h$ is the bandwidth.

• $K$ is a kernel function (see the argument kind.of.kernel).

• $d_{\hat{\theta}}(x_1,x_2)=|\langle\hat{\theta},x_1-x_2\rangle|$ is the projection semi-metric, and $\hat{\theta}$ is an estimate of $\theta_0$.

The procedure requires the estimation of the function-parameter $\theta_0$. Therefore, we use B-spline expansions to represent curves (dimension nknot+order.Bspline) and eligible functional indexes (dimension nknot.theta+order.Bspline). Then, we build a set $\Theta_n$ of eligible functional indexes by calibrating (to ensure the identifiability of the model) the set of initial coefficients given in seed.coeff. The larger this set is, the greater the size of $\Theta_n$. Since our approach requires intensive computation, a trade-off between the size of $\Theta_n$ and the performance of the estimator is necessary. For that, Ait-Saidi et al. (2008) suggested considering order.Bspline=3 and seed.coeff=c(-1,0,1). For details on the construction of $\Theta_n$, see Novo et al. (2019).

We obtain the estimated coefficients of $\theta_0$ in the spline basis (theta.est) and the selected bandwidth (h.opt) by minimising the LOOCV criterion. This function performs a joint minimisation in both parameters, the bandwidth and the functional index, and supports parallel computation. To avoid parallel computation, we can set n.core=1.

Value

call	The matched call.
fitted.values	Estimated scalar response.
residuals	Differences between y and the fitted.values.
theta.est	Coefficients of $\hat{\theta}$ in the B-spline basis: a vector of length(order.Bspline+nknot.theta).
h.opt	Selected bandwidth.
r.squared	Coefficient of determination.
var.res	Redidual variance.
df	Residual degrees of freedom.
yhat.cv	Predicted values for the scalar response using leave-one-out samples.
CV.opt	Minimum value of the CV function, i.e. the value of CV for theta.est and h.opt.
CV.values	Vector containing CV values for each functional index in $\Theta_n$ and the value of $h$ that minimises the CV for such index (i.e. CV.values[j] contains the value of the CV function corresponding to theta.seq.norm[j,] and the best value of the h.seq for this functional index according to the CV criterion).
H	Hat matrix.
m.opt	Index of $\hat{\theta}$ in the set $\Theta_n$.
theta.seq.norm	The vector theta.seq.norm[j,] contains the coefficientes in the B-spline basis of the jth functional index in $\Theta_n$.
h.seq	Sequence of eligible values for $h$.
...

Author(s)

German Aneiros Perez [email protected]

Silvia Novo Diaz [email protected]

References

Ait-Saidi, A., Ferraty, F., Kassa, R., and Vieu, P. (2008) Cross-validated estimations in the single-functional index model. Statistics, 42(6), 475–494, doi:10.1080/02331880801980377.

Novo S., Aneiros, G., and Vieu, P., (2019) Automatic and location-adaptive estimation in functional single–index regression. Journal of Nonparametric Statistics, 31(2), 364–392, doi:10.1080/10485252.2019.1567726.

See Also

See also fsim.kernel.test, predict.fsim.kernel, plot.fsim.kernel.

Alternative procedure fsim.kNN.fit.

Examples

data(Tecator)
y<-Tecator$fat
X<-Tecator$absor.spectra2

#FSIM fit.
ptm<-proc.time()
fit<-fsim.kernel.fit(y[1:160],x=X[1:160,],max.q.h=0.35, nknot=20,
range.grid=c(850,1050),nknot.theta=4)
proc.time()-ptm
fit
names(fit)

---

Functional single-index model fit using kernel estimation and iterative LOOCV minimisation

Description

This function fits a functional single-index model (FSIM) between a functional covariate and a scalar response. It employs kernel estimation with Nadaraya-Watson weights and uses B-spline expansions to represent curves and eligible functional indexes.

The function also utilises the leave-one-out cross-validation (LOOCV) criterion to select the bandwidth (h.opt) and the coefficients of the functional index in the spline basis (theta.est). It performs an iterative minimisation of the LOOCV objective function, starting from an initial set of coefficients (gamma) for the functional index.

Usage

fsim.kernel.fit.optim(x, y, nknot.theta = 3, order.Bspline = 3, gamma = NULL, 
min.q.h = 0.05, max.q.h = 0.5, h.seq = NULL, num.h = 10,
kind.of.kernel = "quad", range.grid = NULL, nknot = NULL, threshold = 0.005)

Arguments

x	Matrix containing the observations of the functional covariate (i.e. curves) collected by row.
y	Vector containing the scalar response.
order.Bspline	Positive integer giving the order of the B-spline basis functions. This is the number of coefficients in each piecewise polynomial segment. The default is 3
nknot.theta	Positive integer indicating the number of regularly spaced interior knots in the B-spline expansion of $\theta_0$. The default is 3.
gamma	Vector indicating the initial coefficients for the functional index used in the iterative procedure. By default, it is a vector of ones. The size of the vector is determined by the sum nknot.theta+order.Bspline.
min.q.h	Minimum quantile order of the distances between curves, which are computed using the projection semi-metric. This value determines the lower endpoint of the range from which the bandwidth is selected. The default is 0.05.
max.q.h	Maximum quantile order of the distances between curves, which are computed using the projection semi-metric. This value determines the upper endpoint of the range from which the bandwidth is selected. The default is 0.5.
h.seq	Vector containing the sequence of bandwidths. The default is a sequence of num.h equispaced bandwidths in the range constructed using min.q.h and max.q.h.
num.h	Positive integer indicating the number of bandwidths in the grid. The default is 10.
kind.of.kernel	The type of kernel function used. Currently, only Epanechnikov kernel ("quad") is available.
range.grid	Vector of length 2 containing the endpoints of the grid at which the observations of the functional covariate x are evaluated (i.e. the range of the discretisation). If range.grid=NULL, then range.grid=c(1,p) is considered, where p is the discretisation size of x (i.e. ncol(x)).
nknot	Positive integer indicating the number of regularly spaced interior knots for the B-spline expansion of the functional covariate. The default value is (p - order.Bspline - 1)%/%2.
threshold	The convergence threshold for the LOOCV function (scaled by the variance of the response). The default is 5e-3.

Details

The functional single-index model (FSIM) is given by the expression:

$Y_i=r(\langle\theta_0,X_i\rangle)+\varepsilon_i, \quad i=1,\dots,n,$

where $Y_i$ denotes a scalar response, $X_i$ is a functional covariate valued in a separable Hilbert space $\mathcal{H}$ with an inner product $\langle \cdot, \cdot\rangle$. The term $\varepsilon$ denotes the random error, $\theta_0 \in \mathcal{H}$ is the unknown functional index and $r(\cdot)$ denotes the unknown smooth link function.

The FSIM is fitted using the kernel estimator

$\widehat{r}_{h,\hat{\theta}}(x)=\sum_{i=1}^nw_{n,h,\hat{\theta}}(x,X_i)Y_i, \quad \forall x\in\mathcal{H},$

with Nadaraya-Watson weights

$w_{n,h,\hat{\theta}}(x,X_i)=\frac{K\left(h^{-1}d_{\hat{\theta}}\left(X_i,x\right)\right)}{\sum_{i=1}^nK\left(h^{-1}d_{\hat{\theta}}\left(X_i,x\right)\right)},$

where

• the real positive number $h$ is the bandwidth.

• $K$ is a kernel function (see the argument kind.of.kernel).

• $d_{\hat{\theta}}(x_1,x_2)=|\langle\hat{\theta},x_1-x_2\rangle|$ is the projection semi-metric, and $\hat{\theta}$ is an estimate of $\theta_0$.

The procedure requires the estimation of the function-parameter $\theta_0$. Therefore, we use B-spline expansions to represent curves (dimension nknot+order.Bspline) and eligible functional indexes (dimension nknot.theta+order.Bspline). We obtain the estimated coefficients of $\theta_0$ in the spline basis (theta.est) and the selected bandwidth (h.opt) by minimising the LOOCV criterion. This function performs an iterative minimisation procedure, starting from an initial set of coefficients (gamma) for the functional index. Given a functional index, the optimal bandwidth according to the LOOCV criterion is selected. For a given bandwidth, the minimisation in the functional index is performed using the R function optim. The procedure is iterated until convergence. For details, see Ferraty et al. (2013).

Value

call	The matched call.
fitted.values	Estimated scalar response.
residuals	Differences between y and the fitted.values.
theta.est	Coefficients of $\hat{\theta}$ in the B-spline basis: a vector of length(order.Bspline+nknot.theta).
h.opt	Selected bandwidth.
r.squared	Coefficient of determination.
var.res	Redidual variance.
df	Residual degrees of freedom.
CV.opt	Minimum value of the LOOCV function, i.e. the value of LOOCV for theta.est and h.opt.
err	Value of the LOOCV function divided by var(y) for each interaction.
H	Hat matrix.
h.seq	Sequence of eligible values for the bandwidth.
CV.hseq	CV values for each h.
...

Author(s)

German Aneiros Perez [email protected]

Silvia Novo Diaz [email protected]

References

Ferraty, F., Goia, A., Salinelli, E., and Vieu, P. (2013) Functional projection pursuit regression. Test, 22, 293–320, doi:10.1007/s11749-012-0306-2.

Novo S., Aneiros, G., and Vieu, P., (2019) Automatic and location-adaptive estimation in functional single–index regression. Journal of Nonparametric Statistics, 31(2), 364–392, doi:10.1080/10485252.2019.1567726.

See Also

See also predict.fsim.kernel and plot.fsim.kernel.

Alternative procedures fsim.kNN.fit.optim, fsim.kernel.fit and fsim.kNN.fit.

Examples

data(Tecator)
y<-Tecator$fat
X<-Tecator$absor.spectra2

#FSIM fit.
ptm<-proc.time()
fit<-fsim.kernel.fit.optim(y[1:160],x=X[1:160,],max.q.h=0.35, nknot=20,
range.grid=c(850,1050),nknot.theta=4)
proc.time()-ptm
fit
names(fit)

---

Functional single-index kernel predictor

Description

This function computes predictions for a functional single-index model (FSIM) with a scalar response, which is estimated using the Nadaraya-Watson kernel estimator. It requires a functional index ($\theta$), a global bandwidth (h), and the new observations of the functional covariate (x.test) as inputs.

Usage

fsim.kernel.test(x, y, x.test, y.test=NULL, theta, nknot.theta = 3, 
order.Bspline = 3, h = 0.5, kind.of.kernel = "quad", range.grid = NULL,
nknot = NULL)

Arguments

x	Matrix containing the observations of the functional covariate in the training sample, collected by row.
y	Vector containing the scalar responses in the training sample.
x.test	Matrix containing the observations of the functional covariate in the the testing sample, collected by row.
y.test	(optional) Vector or matrix containing the scalar responses in the testing sample.
theta	Vector containing the coefficients of $\theta$ in a B-spline basis, such that length(theta)=order.Bspline+nknot.theta
nknot.theta	Number of regularly spaced interior knots in the B-spline expansion of $\theta_0$. The default is 3.
order.Bspline	Order of the B-spline basis functions. This is the number of coefficients in each piecewise polynomial segment. The default is 3
h	The global bandwidth. The default if 0.5.
kind.of.kernel	The type of kernel function used. Currently, only Epanechnikov kernel ("quad") is available.
range.grid	Vector of length 2 containing the endpoints of the grid at which the observations of the functional covariate x are evaluated (i.e. the range of the discretisation). If range.grid=NULL, then range.grid=c(1,p) is considered, where p is the discretisation size of x (i.e. ncol(x)).
nknot	Number of regularly spaced interior knots for the B-spline expansion of the functional covariate. The default value is (p - order.Bspline - 1)%/%2.

Details

The functional single-index model (FSIM) is given by the expression:

$Y_i=r(\langle\theta_0,X_i\rangle)+\varepsilon_i, \quad i=1,\dots,n,$

where $Y_i$ denotes a scalar response, $X_i$ is a functional covariate valued in a separable Hilbert space $\mathcal{H}$ with an inner product $\langle \cdot, \cdot\rangle$. The term $\varepsilon$ denotes the random error, $\theta_0 \in \mathcal{H}$ is the unknown functional index and $r(\cdot)$ denotes the unknown smooth link function; $n$ is the training sample size.

Given $\theta \in \mathcal{H}$, $h>0$ and a testing sample {$X_j,\ j=1,\dots,n_{test}$}, the predicted responses (see the value y.estimated.test) can be computed using the kernel procedure using

$\widehat{r}_{h,\theta}(X_j)=\sum_{i=1}^nw_{n,h,\theta}(X_j,X_i)Y_i,\quad j=1,\dots,n_{test},$

with Nadaraya-Watson weights

$w_{n,h,\theta}(X_j,X_i)=\frac{K\left(h^{-1}d_{\theta}\left(X_i,X_j\right)\right)}{\sum_{i=1}^nK\left(h^{-1}d_{\theta}\left(X_i,X_j\right)\right)},$

where

• $K$ is a kernel function (see the argument kind.of.kernel).

• for $x_1,x_2 \in \mathcal{H},$ $d_{\theta}(x_1,x_2)=|\langle\theta,x_1-x_2\rangle|$ is the projection semi-metric.

If the argument y.test is provided to the program (i. e. if(!is.null(y.test))), the function calculates the mean squared error of prediction (see the value MSE.test). This is computed as mean((y.test-y.estimated.test)^2).

Value

y.estimated.test	Predicted responses.
MSE.test	Mean squared error between predicted and observed responses in the testing sample.

Author(s)

German Aneiros Perez [email protected]

Silvia Novo Diaz [email protected]

References

Novo S., Aneiros, G., and Vieu, P., (2019) Automatic and location-adaptive estimation in functional single–index regression. Journal of Nonparametric Statistics, 31(2), 364–392, doi:10.1080/10485252.2019.1567726.

See Also

See also fsim.kernel.fit, fsim.kernel.fit.optim and predict.fsim.kernel.

Alternative procedure fsim.kNN.test.

Examples

data(Tecator)
y<-Tecator$fat
X<-Tecator$absor.spectra2

train<-1:160
test<-161:215

#FSIM fit. 
ptm<-proc.time()
fit<-fsim.kernel.fit(y=y[train],x=X[train,],max.q.h=0.35, nknot=20,
        range.grid=c(850,1050),nknot.theta=4)
proc.time()-ptm
fit

#FSIM prediction
test<-fsim.kernel.test(y=y[train],x=X[train,],x.test=X[test,],y.test=y[test],
        theta=fit$theta.est,h=fit$h.opt,nknot.theta=4,nknot=20,
        range.grid=c(850,1050))

#MSEP
test$MSE.test

---

Functional single-index model fit using kNN estimation and joint LOOCV minimisation

Description

This function fits a functional single-index model (FSIM) between a functional covariate and a scalar response. It employs kNN estimation with Nadaraya-Watson weights and uses B-spline expansions to represent curves and eligible functional indexes.

The function also utilises the leave-one-out cross-validation (LOOCV) criterion to select the number of neighbours (k.opt) and the coefficients of the functional index in the spline basis (theta.est). It performs a joint minimisation of the LOOCV objective function in both the number of neighbours and the functional index.

Usage

fsim.kNN.fit(x, y, seed.coeff = c(-1, 0, 1), order.Bspline = 3, nknot.theta = 3,
knearest = NULL, min.knn = 2, max.knn = NULL,  step = NULL, 
kind.of.kernel = "quad", range.grid = NULL, nknot = NULL, n.core = NULL)

Arguments

x	Matrix containing the observations of the functional covariate (i.e. curves) collected by row.
y	Vector containing the scalar response.
seed.coeff	Vector of initial values used to build the set $\Theta_n$ (see section Details). The coefficients for the B-spline representation of each eligible functional index $\theta \in \Theta_n$ are obtained from seed.coeff. The default is c(-1,0,1).
order.Bspline	Positive integer giving the order of the B-spline basis functions. This is the number of coefficients in each piecewise polynomial segment. The default is 3
nknot.theta	Positive integer indicating the number of regularly spaced interior knots in the B-spline expansion of $\theta_0$. The default is 3.
knearest	Vector of positive integers that defines the sequence within which the optimal number of nearest neighbours k.opt is selected. If knearest=NULL, then knearest <- seq(from =min.knn, to = max.knn, by = step).
min.knn	A positive integer that represents the minimum value in the sequence for selecting the number of nearest neighbours k.opt. This value should be less than the sample size. The default is 2.
max.knn	A positive integer that represents the maximum value in the sequence for selecting number of nearest neighbours k.opt. This value should be less than the sample size. The default is max.knn <- n%/%5.
step	A positive integer used to construct the sequence of k-nearest neighbours as follows: min.knn, min.knn + step, min.knn + 2*step, min.knn + 3*step,.... The default value for step is step<-ceiling(n/100).
kind.of.kernel	The type of kernel function used. Currently, only Epanechnikov kernel ("quad") is available.
range.grid	Vector of length 2 containing the endpoints of the grid at which the observations of the functional covariate x are evaluated (i.e. the range of the discretisation). If range.grid=NULL, then range.grid=c(1,p) is considered, where p is the discretisation size of x (i.e. ncol(x)).
nknot	Positive integer indicating the number of interior knots for the B-spline expansion of the functional covariate. The default value is (p - order.Bspline - 1)%/%2.
n.core	Number of CPU cores designated for parallel execution.The default is n.core<-availableCores(omit=1).

Details

The functional single-index model (FSIM) is given by the expression:

$Y_i=r(\langle\theta_0,X_i\rangle)+\varepsilon_i, \quad i=1,\dots,n,$

where $Y_i$ denotes a scalar response, $X_i$ is a functional covariate valued in a separable Hilbert space $\mathcal{H}$ with an inner product $\langle \cdot, \cdot\rangle$. The term $\varepsilon$ denotes the random error, $\theta_0 \in \mathcal{H}$ is the unknown functional index and $r(\cdot)$ denotes the unknown smooth link function.

The FSIM is fitted using the kNN estimator

$\widehat{r}_{k,\hat{\theta}}(x)=\sum_{i=1}^nw_{n,k,\hat{\theta}}(x,X_i)Y_i, \quad \forall x\in\mathcal{H},$

with Nadaraya-Watson weights

$w_{n,k,\hat{\theta}}(x,X_i)=\frac{K\left(H_{k,x,\hat{\theta}}^{-1}d_{\hat{\theta}}\left(X_i,x\right)\right)}{\sum_{i=1}^nK\left(H_{k,x,\hat{\theta}}^{-1}d_{\hat{\theta}}\left(X_i,x\right)\right)},$

where

• the positive integer $k$ is a smoothing factor, representing the number of nearest neighbours.

• $K$ is a kernel function (see the argument kind.of.kernel).

• $d_{\hat{\theta}}(x_1,x_2)=|\langle\hat{\theta},x_1-x_2\rangle|$ is the projection semi-metric, computed using semimetric.projec and $\hat{\theta}$ is an estimate of $\theta_0$.

• $H_{k,x,\hat{\theta}}=\min\{h\in R^+ \text{ such that } \sum_{i=1}^n1_{B_{\hat{\theta}}(x,h)}(X_i)=k\}$, where $1_{B_{\hat{\theta}}(x,h)}(\cdot)$ is the indicator function of the open ball defined by the projection semi-metric, with centre $x\in\mathcal{H}$ and radius $h$.

The procedure requires the estimation of the function-parameter $\theta_0$. Therefore, we use B-spline expansions to represent curves (dimension nknot+order.Bspline) and eligible functional indexes (dimension nknot.theta+order.Bspline). Then, we build a set $\Theta_n$ of eligible functional indexes by calibrating (to ensure the identifiability of the model) the set of initial coefficients given in seed.coeff. The larger this set is, the greater the size of $\Theta_n$. Since our approach requires intensive computation, a trade-off between the size of $\Theta_n$ and the performance of the estimator is necessary. For that, Ait-Saidi et al. (2008) suggested considering order.Bspline=3 and seed.coeff=c(-1,0,1). For details on the construction of $\Theta_n$, see Novo et al. (2019).

We obtain the estimated coefficients of $\theta_0$ in the spline basis (theta.est) and the selected number of neighbours (k.opt) by minimising the LOOCV criterion. This function performs a joint minimisation in both parameters, the number of neighbours and the functional index, and supports parallel computation. To avoid parallel computation, we can set n.core=1.

Value

call	The matched call.
fitted.values	Estimated scalar response.
residuals	Differences between y and the fitted.values
theta.est	Coefficients of $\hat{\theta}$ in the B-spline basis: a vector of length(order.Bspline+nknot.theta).
k.opt	Selected number of nearest neighbours.
r.squared	Coefficient of determination.
var.res	Redidual variance.
df	Residual degrees of freedom.
yhat.cv	Predicted values for the scalar response using leave-one-out samples.
CV.opt	Minimum value of the CV function, i.e. the value of CV for theta.est and k.opt.
CV.values	Vector containing CV values for each functional index in $\Theta_n$ and the value of $k$ that minimises the CV for such index (i.e. CV.values[j] contains the value of the CV function corresponding to theta.seq.norm[j,] and the best value of the k.seq for this functional index according to the CV criterion).
H	Hat matrix.
m.opt	Index of $\hat{\theta}$ in the set $\Theta_n$.
theta.seq.norm	The vector theta.seq.norm[j,] contains the coefficientes in the B-spline basis of the jth functional index in $\Theta_n$.
k.seq	Sequence of eligible values for $k$.
...

Author(s)

German Aneiros Perez [email protected]

Silvia Novo Diaz [email protected]

References

Ait-Saidi, A., Ferraty, F., Kassa, R., and Vieu, P. (2008) Cross-validated estimations in the single-functional index model, Statistics, 42(6), 475–494, doi:10.1080/02331880801980377.

Novo S., Aneiros, G., and Vieu, P., (2019) Automatic and location-adaptive estimation in functional single–index regression, Journal of Nonparametric Statistics, 31(2), 364–392, doi:10.1080/10485252.2019.1567726.

See Also

See also fsim.kNN.test, predict.fsim.kNN, plot.fsim.kNN.

Alternative procedures fsim.kernel.fit, fsim.kNN.fit.optim and fsim.kernel.fit.optim

Examples

data(Tecator)
y<-Tecator$fat
X<-Tecator$absor.spectra2

#FSIM fit.
ptm<-proc.time()
fit<-fsim.kNN.fit(y=y[1:160],x=X[1:160,],max.knn=20,nknot.theta=4,nknot=20,
range.grid=c(850,1050))
proc.time()-ptm
fit
names(fit)

---

Functional single-index model fit using kNN estimation and iterative LOOCV minimisation

Description

This function fits a functional single-index model (FSIM) between a functional covariate and a scalar response. It employs kNN estimation with Nadaraya-Watson weights and uses B-spline expansions to represent curves and eligible functional indexes.

The function also utilises the leave-one-out cross-validation (LOOCV) criterion to select the bandwidth (h.opt) and the coefficients of the functional index in the spline basis (theta.est). It performs an iterative minimisation of the LOOCV objective function, starting from an initial set of coefficients (gamma) for the functional index.

Usage

fsim.kNN.fit.optim(x, y, order.Bspline = 3, nknot.theta = 3, gamma = NULL, 
knearest = NULL, min.knn = 2, max.knn = NULL,  step = NULL, 
kind.of.kernel = "quad", range.grid = NULL, nknot = NULL, threshold = 0.005)

Arguments

x	Matrix containing the observations of the functional covariate (i.e. curves) collected by row.
y	Vector containing the scalar response.
order.Bspline	Positive integer giving the order of the B-spline basis functions. This is the number of coefficients in each piecewise polynomial segment. The default is 3
nknot.theta	Positive integer indicating the number of regularly spaced interior knots in the B-spline expansion of $\theta_0$. The default is 3.
gamma	Vector indicating the initial coefficients for the functional index used in the iterative procedure. By default, it is a vector of ones. The size of the vector is determined by the sum nknot.theta+order.Bspline.
knearest	Vector of positive integers that defines the sequence within which the optimal number of nearest neighbours k.opt is selected. If knearest=NULL, then knearest <- seq(from =min.knn, to = max.knn, by = step).
min.knn	A positive integer that represents the minimum value in the sequence for selecting the number of nearest neighbours k.opt. This value should be less than the sample size. The default is 2.
max.knn	A positive integer that represents the maximum value in the sequence for selecting number of nearest neighbours k.opt. This value should be less than the sample size. The default is max.knn <- n%/%5.
step	A positive integer used to construct the sequence of k-nearest neighbours as follows: min.knn, min.knn + step, min.knn + 2*step, min.knn + 3*step,.... The default value for step is step<-ceiling(n/100).
kind.of.kernel	The type of kernel function used. Currently, only Epanechnikov kernel ("quad") is available.
range.grid	Vector of length 2 containing the endpoints of the grid at which the observations of the functional covariate x are evaluated (i.e. the range of the discretisation). If range.grid=NULL, then range.grid=c(1,p) is considered, where p is the discretisation size of x (i.e. ncol(x)).
nknot	Positive integer indicating the number of regularly spaced interior knots for the B-spline expansion of the functional covariate. The default value is (p - order.Bspline - 1)%/%2.
threshold	The convergence threshold for the LOOCV function (scaled by the variance of the response). The default is 5e-3.

Details

The functional single-index model (FSIM) is given by the expression:

$Y_i=r(\langle\theta_0,X_i\rangle)+\varepsilon_i, \quad i=1,\dots,n,$

where $Y_i$ denotes a scalar response, $X_i$ is a functional covariate valued in a separable Hilbert space $\mathcal{H}$ with an inner product $\langle \cdot, \cdot\rangle$. The term $\varepsilon$ denotes the random error, $\theta_0 \in \mathcal{H}$ is the unknown functional index and $r(\cdot)$ denotes the unknown smooth link function.

The FSIM is fitted using the kNN estimator

$\widehat{r}_{k,\hat{\theta}}(x)=\sum_{i=1}^nw_{n,k,\hat{\theta}}(x,X_i)Y_i, \quad \forall x\in\mathcal{H},$

with Nadaraya-Watson weights

$w_{n,k,\hat{\theta}}(x,X_i)=\frac{K\left(H_{k,x,\hat{\theta}}^{-1}d_{\hat{\theta}}\left(X_i,x\right)\right)}{\sum_{i=1}^nK\left(H_{k,x,\hat{\theta}}^{-1}d_{\hat{\theta}}\left(X_i,x\right)\right)},$

where

• the positive integer $k$ is a smoothing factor, representing the number of nearest neighbours.

• $K$ is a kernel function (see the argument kind.of.kernel).

• $d_{\hat{\theta}}(x_1,x_2)=|\langle\hat{\theta},x_1-x_2\rangle|$ is the projection semi-metric and $\hat{\theta}$ is an estimate of $\theta_0$.

• $H_{k,x,\hat{\theta}}=\min\{h\in R^+ \text{ such that } \sum_{i=1}^n1_{B_{\hat{\theta}}(x,h)}(X_i)=k\}$, where $1_{B_{\hat{\theta}}(x,h)}(\cdot)$ is the indicator function of the open ball defined by the projection semi-metric, with centre $x\in\mathcal{H}$ and radius $h$.

The procedure requires the estimation of the function-parameter $\theta_0$. Therefore, we use B-spline expansions to represent curves (dimension nknot+order.Bspline) and eligible functional indexes (dimension nknot.theta+order.Bspline). We obtain the estimated coefficients of $\theta_0$ in the spline basis (theta.est) and the selected number of neighbours (k.opt) by minimising the LOOCV criterion. This function performs an iterative minimisation procedure, starting from an initial set of coefficients (gamma) for the functional index. Given a functional index, the optimal number of neighbours according to the LOOCV criterion is selected. For a given number of neighbours, the minimisation in the functional index is performed using the R function optim. The procedure is iterated until convergence. For details, see Ferraty et al. (2013).

Value

call	The matched call.
fitted.values	Estimated scalar response.
residuals	Differences between y and the fitted.values.
theta.est	Coefficients of $\hat{\theta}$ in the B-spline basis: a vector of length(order.Bspline+nknot.theta).
k.opt	Selected number of neighbours.
r.squared	Coefficient of determination.
var.res	Redidual variance.
df	Residual degrees of freedom.
CV.opt	Minimum value of the LOOCV function, i.e. the value of LOOCV for theta.est and k.opt.
err	Value of the LOOCV function divided by var(y) for each interaction.
H	Hat matrix.
k.seq	Sequence of eligible values for $k$.
CV.hseq	CV values for each $k$.
...

Author(s)

German Aneiros Perez [email protected]

Silvia Novo Diaz [email protected]

References

Ferraty, F., Goia, A., Salinelli, E., and Vieu, P. (2013) Functional projection pursuit regression. Test, 22, 293–320, doi:10.1007/s11749-012-0306-2.

Novo S., Aneiros, G., and Vieu, P., (2019) Automatic and location-adaptive estimation in functional single–index regression. Journal of Nonparametric Statistics, 31(2), 364–392, doi:10.1080/10485252.2019.1567726.

See Also

See also predict.fsim.kNN and plot.fsim.kNN.

Alternative procedures fsim.kernel.fit.optim, fsim.kernel.fit and fsim.kNN.fit.

Examples

data(Tecator)
y<-Tecator$fat
X<-Tecator$absor.spectra2

#FSIM fit.
ptm<-proc.time()
fit<-fsim.kNN.fit.optim(y=y[1:160],x=X[1:160,],max.knn=20,nknot.theta=4,nknot=20,
range.grid=c(850,1050))
proc.time()-ptm
fit
names(fit)

---

Functional single-index kNN predictor

Description

This function computes predictions for a functional single-index model (FSIM) with a scalar response, which is estimated using the Nadaraya-Watson kNN estimator. It requires a functional index ($\theta$), a global bandwidth (h), and the new observations of the functional covariate (x.test) as inputs.

Usage

fsim.kNN.test(x, y, x.test, y.test = NULL, theta, order.Bspline = 3, 
nknot.theta = 3, k = 4, kind.of.kernel = "quad", range.grid = NULL, 
nknot = NULL)

Arguments

x	Matrix containing the observations of the functional covariate in the training sample, collected by row.
y	Vector containing the scalar responses in the training sample.
x.test	Matrix containing the observations of the functional covariate in the the testing sample, collected by row.
y.test	(optional) Vector or matrix containing the scalar responses in the testing sample.
theta	Vector containing the coefficients of $\theta$ in a B-spline basis, such that length(theta)=order.Bspline+nknot.theta
nknot.theta	Number of regularly spaced interior knots in the B-spline expansion of $\theta_0$. The default is 3.
order.Bspline	Order of the B-spline basis functions. This is the number of coefficients in each piecewise polynomial segment. The default is 3
k	The number of nearest neighbours. The default is 4.
kind.of.kernel	The type of kernel function used. Currently, only Epanechnikov kernel ("quad") is available.
range.grid	Vector of length 2 containing the endpoints of the grid at which the observations of the functional covariate x are evaluated (i.e. the range of the discretisation). If range.grid=NULL, then range.grid=c(1,p) is considered, where p is the discretisation size of x (i.e. ncol(x)).
nknot	Number of regularly spaced interior knots for the B-spline expansion of the functional covariate. The default value is (p - order.Bspline - 1)%/%2.

Details

The functional single-index model (FSIM) is given by the expression:

$Y_i=r(\langle\theta_0,X_i\rangle)+\varepsilon_i, \quad i=1,\dots,n,$

where $Y_i$ denotes a scalar response, $X_i$ is a functional covariate valued in a separable Hilbert space $\mathcal{H}$ with an inner product $\langle \cdot, \cdot\rangle$. The term $\varepsilon$ denotes the random error, $\theta_0 \in \mathcal{H}$ is the unknown functional index and $r(\cdot)$ denotes the unknown smooth link function; $n$ is the training sample size.

Given $\theta \in \mathcal{H}$, $1<k<n$ and a testing sample {$X_j,\ j=1,\dots,n_{test}$}, the predicted responses (see the value y.estimated.test) can be computed using the kNN procedure by means of

$\widehat{r}_{k,\theta}(X_j)=\sum_{i=1}^nw_{n,k,\theta}(X_j,X_i)Y_i,\quad j=1,\dots,n_{test},$

with Nadaraya-Watson weights

$w_{n,k,\theta}(X_j,X_i)=\frac{K\left(H_{k,X_j,{\theta}}^{-1}d_{\theta}\left(X_i,X_j\right)\right)}{\sum_{i=1}^nK\left(H_{k,X_j,\theta}^{-1}d_{\theta}\left(X_i,X_j\right)\right)},$

where

• $K$ is a kernel function (see the argument kind.of.kernel).

• for $x_1,x_2 \in \mathcal{H},$ $d_{\theta}(x_1,x_2)=|\langle\theta,x_1-x_2\rangle|$ is the projection semi-metric.

• $H_{k,x,\theta}=\min\left\{h\in R^+ \text{ such that } \sum_{i=1}^n1_{B_{\theta}(x,h)}(X_i)=k\right\}$, where $1_{B_{\theta}(x,h)}(\cdot)$ is the indicator function of the open ball defined by the projection semi-metric, with centre $x\in\mathcal{H}$ and radius $h$.

If the argument y.test is provided to the program (i. e. if(!is.null(y.test))), the function calculates the mean squared error of prediction (see the value MSE.test). This is computed as mean((y.test-y.estimated.test)^2).

Value

y.estimated.test	Predicted responses.
MSE.test	Mean squared error between predicted and observed responses in the testing sample.

Author(s)

German Aneiros Perez [email protected]

Silvia Novo Diaz [email protected]

References

Novo S., Aneiros, G., and Vieu, P., (2019) Automatic and location-adaptive estimation in functional single–index regression. Journal of Nonparametric Statistics, 31(2), 364–392, doi:10.1080/10485252.2019.1567726.

See Also

See also fsim.kNN.fit, fsim.kNN.fit.optim and predict.fsim.kNN.

Alternative procedure fsim.kernel.test.

Examples

data(Tecator)
y<-Tecator$fat
X<-Tecator$absor.spectra2


train<-1:160
test<-161:215

#FSIM fit. 
ptm<-proc.time()
fit<-fsim.kNN.fit(y=y[train],x=X[train,],max.knn=20,nknot.theta=4,nknot=20,
      range.grid=c(850,1050))
proc.time()-ptm
fit

#FSIM prediction
test<-fsim.kNN.test(y=y[train],x=X[train,],x.test=X[test,],y.test=y[test],
        theta=fit$theta.est,k=fit$k.opt,nknot.theta=4,nknot=20,
        range.grid=c(850,1050))

#MSEP
test$MSE.test

---

Impact point selection with IASSMR and kernel estimation

Description

This function implements the Improved Algorithm for Sparse Semiparametric Multi-functional Regression (IASSMR) with kernel estimation. This algorithm is specifically designed for estimating multi-functional partial linear single-index models, which incorporate multiple scalar variables and a functional covariate as predictors. These scalar variables are derived from the discretisation of a curve and have linear effects while the functional covariate exhibits a single-index effect.

IASSMR is a two-stage procedure that selects the impact points of the discretised curve and estimates the model. The algorithm employs a penalised least-squares regularisation procedure, integrated with kernel estimation using Nadaraya-Watson weights. It uses B-spline expansions to represent curves and eligible functional indexes. Additionally, it utilises an objective criterion (criterion) to determine the initial number of covariates in the reduced model (w.opt), the bandwidth (h.opt), and the penalisation parameter (lambda.opt).

Usage

IASSMR.kernel.fit(x, z, y, train.1 = NULL, train.2 = NULL, 
seed.coeff = c(-1, 0, 1), order.Bspline = 3, nknot.theta = 3, 
min.q.h = 0.05, max.q.h = 0.5, h.seq = NULL, num.h = 10, range.grid = NULL, 
kind.of.kernel = "quad", nknot = NULL, lambda.min = NULL, lambda.min.h = NULL, 
lambda.min.l = NULL, factor.pn = 1, nlambda = 100, vn = ncol(z), nfolds = 10, 
seed = 123, wn = c(10, 15, 20), criterion = "GCV", penalty = "grSCAD", 
max.iter = 1000, n.core = NULL)

Arguments

x	Matrix containing the observations of the functional covariate (functional single-index component), collected by row .
z	Matrix containing the observations of the functional covariate that is discretised (linear component), collected by row.
y	Vector containing the scalar response.
train.1	Positions of the data that are used as the training sample in the 1st step. The default setting is train.1<-1:ceiling(n/2).
train.2	Positions of the data that are used as the training sample in the 2nd step. The default setting is train.2<-(ceiling(n/2)+1):n.
seed.coeff	Vector of initial values used to build the set $\Theta_n$ (see section Details). The coefficients for the B-spline representation of each eligible functional index $\theta \in \Theta_n$ are obtained from seed.coeff. The default is c(-1,0,1).
order.Bspline	Positive integer giving the order of the B-spline basis functions. This is the number of coefficients in each piecewise polynomial segment. The default is 3.
nknot.theta	Positive integer indicating the number of regularly spaced interior knots in the B-spline expansion of $\theta_0$. The default is 3.
min.q.h	Minimum quantile order of the distances between curves, which are computed using the projection semi-metric. This value determines the lower endpoint of the range from which the bandwidth is selected. The default is 0.05.
max.q.h	Maximum quantile order of the distances between curves, which are computed using the projection semi-metric. This value determines the upper endpoint of the range from which the bandwidth is selected. The default is 0.5.
h.seq	Vector containing the sequence of bandwidths. The default is a sequence of num.h equispaced bandwidths in the range constructed using min.q.h and max.q.h.
num.h	Positive integer indicating the number of bandwidths in the grid. The default is 10.
range.grid	Vector of length 2 containing the endpoints of the grid at which the observations of the functional covariate x are evaluated (i.e. the range of the discretisation). If range.grid=NULL, then range.grid=c(1,p) is considered, where p is the discretisation size of x (i.e. ncol(x)).
kind.of.kernel	The type of kernel function used. Currently, only Epanechnikov kernel ("quad") is available.
nknot	Positive integer indicating the number of interior knots for the B-spline expansion of the functional covariate. The default value is (p - order.Bspline - 1)%/%2.
lambda.min	The smallest value for lambda (i. e., the lower endpoint of the sequence in which lambda.opt is selected), as fraction of lambda.max. The defaults is lambda.min.l if the sample size is larger than factor.pn times the number of linear covariates and lambda.min.h otherwise.
lambda.min.h	The lower endpoint of the sequence in which lambda.opt is selected if the sample size is smaller than factor.pn times the number of linear covariates. The default is 0.05.
lambda.min.l	The lower endpoint of the sequence in which lambda.opt is selected if the sample size is larger than factor.pn times the number of linear covariates. The default is 0.0001.
factor.pn	Positive integer used to set lambda.min. The default value is 1.
nlambda	Positive integer indicating the number of values in the sequence from which lambda.opt is selected. The default is 100.
vn	Positive integer or vector of positive integers indicating the number of groups of consecutive variables to be penalised together. The default value is vn=ncol(z), resulting in the individual penalization of each scalar covariate.
nfolds	Number of cross-validation folds (used when criterion="k-fold-CV"). Default is 10.
seed	You may set the seed for the random number generator to ensure reproducible results (applicable when criterion="k-fold-CV" is used). The default seed value is 123.
wn	A vector of positive integers indicating the eligible number of covariates in the reduced model. For more information, refer to the section Details. The default is c(10,15,20).
criterion	The criterion used to select the tuning and regularisation parameters: wn.opt, lambda.opt and h.opt (also vn.opt if needed). Options include "GCV", "BIC", "AIC", or "k-fold-CV". The default setting is "GCV".
penalty	The penalty function applied in the penalised least-squares procedure. Currently, only "grLasso" and "grSCAD" are implemented. The default is "grSCAD".
max.iter	Maximum number of iterations allowed across the entire path. The default value is 1000.
n.core	Number of CPU cores designated for parallel execution. The default is n.core<-availableCores(omit=1).

Details

The multi-functional partial linear single-index model (MFPLSIM) is given by the expression

$Y_i=\sum_{j=1}^{p_n}\beta_{0j}\zeta_i(t_j)+r\left(\left<\theta_0,X_i\right>\right)+\varepsilon_i,\ \ \ (i=1,\dots,n),$

where:

• $Y_i$ represents a real random response and $X_i$ denotes a random element belonging to some separable Hilbert space $\mathcal{H}$ with inner product denoted by $\left\langle\cdot,\cdot\right\rangle$. The second functional predictor $\zeta_i$ is assumed to be a curve defined on the interval $[a,b]$, observed at the points $a\leq t_1<\dots<t_{p_n}\leq b$.

• $\mathbf{\beta}_0=(\beta_{01},\dots,\beta_{0p_n})^{\top}$ is a vector of unknown real coefficients, and $r(\cdot)$ denotes a smooth unknown link function. In addition, $\theta_0$ is an unknown functional direction in $\mathcal{H}$.

• $\varepsilon_i$ denotes the random error.

In the MFPLSIM, it is assumed that only a few scalar variables from the set $\{\zeta(t_1),\dots,\zeta(t_{p_n})\}$ are part of the model. Therefore, the relevant variables in the linear component (the impact points of the curve $\zeta$ on the response) must be selected, and the model estimated.

In this function, the MFPLSIM is fitted using the IASSMR. The IASSMR is a two-step procedure. For this, we divide the sample into two independent subsamples, each asymptotically half the size of the original sample ($n_1\sim n_2\sim n/2$). One subsample is used in the first stage of the method, and the other in the second stage.The subsamples are defined as follows:

$\mathcal{E}^{\mathbf{1}}=\{(\zeta_i,\mathcal{X}_i,Y_i),\quad i=1,\dots,n_1\},$

$\mathcal{E}^{\mathbf{2}}=\{(\zeta_i,\mathcal{X}_i,Y_i),\quad i=n_1+1,\dots,n_1+n_2=n\}.$

Note that these two subsamples are specified to the program through the arguments train.1 and train.2. The superscript $\mathbf{s}$, where $\mathbf{s}=\mathbf{1},\mathbf{2}$, indicates the stage of the method in which the sample, function, variable, or parameter is involved.

To explain the algorithm, we assume that the number $p_n$ of linear covariates can be expressed as follows: $p_n=q_nw_n$, with $q_n$ and $w_n$ being integers.

1. First step. The FASSMR (see FASSMR.kernel.fit) combined with kernel estimation is applied using only the subsample $\mathcal{E}^{\mathbf{1}}$. Specifically:

   • Consider a subset of the initial $p_n$ linear covariates, which contains only $w_n$ equally spaced discretized observations of $\zeta$ covering the interval $[a,b]$. This subset is the following:

     $\mathcal{R}_n^{\mathbf{1}}=\left\{\zeta\left(t_k^{\mathbf{1}}\right),\ \ k=1,\dots,w_n\right\},$

     where $t_k^{\mathbf{1}}=t_{\left[(2k-1)q_n/2\right]}$ and $\left[z\right]$ denotes the smallest integer not less than the real number $z$.The size (cardinality) of this subset is provided to the program in the argument wn (which contains a sequence of eligible sizes).

   • Consider the following reduced model, which involves only the $w_n$ linear covariates belonging to $\mathcal{R}_n^{\mathbf{1}}$:

     $Y_i=\sum_{k=1}^{w_n}\beta_{0k}^{\mathbf{1}}\zeta_i(t_k^{\mathbf{1}})+r^{\mathbf{1}}\left(\left<\theta_0^{\mathbf{1}},X_i\right>\right)+\varepsilon_i^{\mathbf{1}}.$

     The penalised least-squares variable selection procedure, with kernel estimation, is applied to the reduced model. This is done using the function sfplsim.kernel.fit, which requires the remaining arguments (see sfplsim.kernel.fit). The estimates obtained after that are the outputs of the first step of the algorithm.

2. Second step. The variables selected in the first step, along with those in their neighborhood, are included. The penalised least-squares procedure, combined with kernel estimation, is carried out again considering only the subsample $\mathcal{E}^{\mathbf{2}}$. Specifically:

   • Consider a new set of variables:

     $\mathcal{R}_n^{\mathbf{2}}=\bigcup_{\left\{k,\widehat{\beta}_{0k}^{\mathbf{1}}\not=0\right\}}\left\{\zeta(t_{(k-1)q_n+1}),\dots,\zeta(t_{kq_n})\right\}.$

     Denoting by $r_n=\sharp(\mathcal{R}_n^{\mathbf{2}})$, the variables in $\mathcal{R}_n^{\mathbf{2}}$ can be renamed as follows:

     $\mathcal{R}_n^{\mathbf{2}}=\left\{\zeta(t_1^{\mathbf{2}}),\dots,\zeta(t_{r_n}^{\mathbf{2}})\right\},$

   • Consider the following model, which involves only the linear covariates belonging to $\mathcal{R}_n^{\mathbf{2}}$

     $Y_i=\sum_{k=1}^{r_n}\beta_{0k}^{\mathbf{2}}\zeta_i(t_k^{\mathbf{2}})+r^{\mathbf{2}}\left(\left<\theta_0^{\mathbf{2}},X_i\right>\right)+\varepsilon_i^{\mathbf{2}}.$

     The penalised least-squares variable selection procedure, with kernel estimation, is applied to this model using the function sfplsim.kernel.fit.

The outputs of the second step are the estimates of the MFPLSIM. For further details on this algorithm, see Novo et al. (2021).

Remark: If the condition $p_n=w_n q_n$ is not met (then $p_n/w_n$ is not an integer), the function considers variable $q_n=q_{n,k}$ values $k=1,\dots,w_n$. Specifically:

$q_{n,k}= \left\{\begin{array}{ll} [p_n/w_n]+1 & k\in\{1,\dots,p_n-w_n[p_n/w_n]\},\\ {[p_n/w_n]} & k\in\{p_n-w_n[p_n/w_n]+1,\dots,w_n\}, \end{array} \right.$

where $[z]$ denotes the integer part of the real number $z$.

The function supports parallel computation. To avoid it, we can set n.core=1.

Value

call	The matched call.
fitted.values	Estimated scalar response.
residuals	Differences between y and the fitted.values.
beta.est	$\hat{\mathbf{\beta}}$ (i.e. estimate of $\mathbf{\beta}_0$ when the optimal tuning parameters w.opt, lambda.opt, h.opt and vn.opt are used).
theta.est	Coefficients of $\hat{\theta}$ in the B-spline basis (i.e. estimate of $\theta_0$when the optimal tuning parameters w.opt, lambda.opt, h.opt and vn.opt are used): a vector of length(order.Bspline+nknot.theta).
indexes.beta.nonnull	Indexes of the non-zero $\hat{\beta_{j}}$.
h.opt	Selected bandwidth (when w.opt is considered).
w.opt	Selected size for $\mathcal{R}_n^{\mathbf{1}}$.
lambda.opt	Selected value of the penalisation parameter $\lambda$ (when w.opt is considered).
IC	Value of the criterion function considered to select w.opt, lambda.opt, h.opt and vn.opt.
vn.opt	Selected value of vn in the second step (when w.opt is considered).
beta2	Estimate of $\mathbf{\beta}_0^{\mathbf{2}}$ for each value of the sequence wn.
theta2	Estimate of $\theta_0^{\mathbf{2}}$ for each value of the sequence wn (i.e. its coefficients in the B-spline basis).
indexes.beta.nonnull2	Indexes of the non-zero linear coefficients after the step 2 of the method for each value of the sequence wn.
h2	Selected bandwidth in the second step of the algorithm for each value of the sequence wn.
IC2	Optimal value of the criterion function in the second step for each value of the sequence wn.
lambda2	Selected value of penalisation parameter in the second step for each value of the sequence wn.
index02	Indexes of the covariates (in the entire set of $p_n$) used to build $\mathcal{R}_n^{\mathbf{2}}$ for each value of the sequence wn.
beta1	Estimate of $\mathbf{\beta}_0^{\mathbf{1}}$ for each value of the sequence wn.
theta1	Estimate of $\theta_0^{\mathbf{1}}$ for each value of the sequence wn (i.e. its coefficients in the B-spline basis).
h1	Selected bandwidth in the first step of the algorithm for each value of the sequence wn.
IC1	Optimal value of the criterion function in the first step for each value of the sequence wn.
lambda1	Selected value of penalisation parameter in the first step for each value of the sequence wn.
index01	Indexes of the covariates (in the whole set of $p_n$) used to build $\mathcal{R}_n^{\mathbf{1}}$ for each value of the sequence wn.
index1	Indexes of the non-zero linear coefficients after the step 1 of the method for each value of the sequence wn.
...	Further outputs to apply S3 methods.

Author(s)

German Aneiros Perez [email protected]

Silvia Novo Diaz [email protected]

References

Novo, S., Vieu, P., and Aneiros, G., (2021) Fast and efficient algorithms for sparse semiparametric bi-functional regression. Australian and New Zealand Journal of Statistics, 63, 606–638, doi:10.1111/anzs.12355.

See Also

See also sfplsim.kernel.fit, predict.IASSMR.kernel, plot.IASSMR.kernel and FASSMR.kernel.fit.

Alternative methods IASSMR.kNN.fit, FASSMR.kernel.fit and FASSMR.kNN.fit.

Examples

data(Sugar)

y<-Sugar$ash
x<-Sugar$wave.290
z<-Sugar$wave.240

#Outliers
index.y.25 <- y > 25
index.atip <- index.y.25
(1:268)[index.atip]

#Dataset to model
x.sug <- x[!index.atip,]
z.sug<- z[!index.atip,]
y.sug <- y[!index.atip]

train<-1:216

ptm=proc.time()
fit<- IASSMR.kernel.fit(x=x.sug[train,],z=z.sug[train,], y=y.sug[train],
        train.1=1:108,train.2=109:216,nknot.theta=2,lambda.min.h=0.03,
        lambda.min.l=0.03,  max.q.h=0.35, nknot=20,
        criterion="BIC", max.iter=5000)
proc.time()-ptm

fit 
names(fit)

---