MetaModel_qmax: Function to produce a sequence of meta models, with at most...
In RKHSMetaMod: Ridge Group Sparse Optimization Problem for Estimation of a Meta Model Based on Reproducing Kernel Hilbert Spaces

Description Usage Arguments Details Value Note Author(s) References See Also Examples

Calculates the Gram matrices K_v for a chosen kernel, determines μ, note μ (qmax), for which the number of active groups in the RKHS group lasso solution is equal to qmax, and fits a solution of an RKHS ridge group sparse or an RKHS group lasso problem for each pair of penalty parameters (μ (qmax),γ), in the Gaussian regression model.

1	RKHSMetMod_qmax(Y, X, kernel, Dmax, gamma, qmax, rat, Num, verbose)

`Y`	Vector of response observations of size n.
`X`	Matrix of observations with n rows and d columns.
`kernel`	Character, indicates the type of the reproducing kernel: matern (matern kernel), brownian (brownian kernel), gaussian (gaussian kernel), linear (linear kernel), quad (quadratic kernel). See the function `calc_Kv`.
`Dmax`	Integer, between 1 and d, indicates the order of interactions considered in the meta model: Dmax=1 is used to consider only the main effects, Dmax=2 to include the main effects and the interactions of order 2,…. See the function `calc_Kv`.
`gamma`	Vector of non negative scalars, values of the penalty parameter γ in decreasing order. If γ=0 the function solves an RKHS Group Lasso problem and for γ>0 it solves an RKHS Ridge Group Sparse problem.
`qmax`	Integer, shows the maximum number of active groups in the obtained solution.
`rat`	Positive scalar, to restrict the minimum value of μ considered in the algorithm, μ_{min}=μ_{max}/(√{n}\times rat). The value μ_{max} is calculated inside the program, see function `mu_max`.
`Num`	Integer, it is used to restrict the number of different values of the penalty parameter μ to be evaluated in the RKHS Group Lasso algorithm until it achieves μ (qmax): for Num = 1 the program is done for 3 different values of μ, μ_{1}=(μ_{min}+μ_{max})/2, μ_{2}=(μ_{min}+μ_{1})/2 or μ_{2}=(μ_{1}+μ_{max})/2 depending on the number of active groups in the meta model associated with μ_{1}, μ_{3}=μ_{min}.
`verbose`	Logical, if TRUE, prints: the group v for which the correction of Gram matrix K_v is done, and for each pair of (μ,γ): the number of current iteration, active groups and convergence criterias. Set as FALSE by default.

Details.

List of three components "mus", "qs", and "MetaModel":

`mus`	Vector, values of the evaluated penalty parameters μ in the RKHS Group Lasso algorithm until it achieves μ (qmax).
`qs`	Vector, number of active groups associated with each element in mus.
`MetaModel`	List with the same length as the vector gamma. Each component of the list is a list of 3 components "mu", "gamma" and "Meta-Model":
`mu`	Scalar, the value μ (qmax).
`gamma`	Positive scalar, element of the input vector gamma associated with the estimated Meta-Model.
`Meta-Model`	An RKHS Ridge Group Sparse or RKHS Group Lasso object associated with the penalty parameters mu and gamma:
`intercept`	Scalar, estimated value of intercept.
`teta`	Matrix with vMax rows and n columns. Each row of the matrix is the estimated vector θ_{v} for v=1,...,vMax.
`fit.v`	Matrix with n rows and vMax columns. Each row of the matrix is the estimated value of f_{v}=K_{v}θ_{v}.
`fitted`	Vector of size n, indicates the estimator of m.
`Norm.n`	Vector of size vMax, estimated values for the Ridge penalty norm.
`Norm.H`	Vector of size vMax, estimated values of the Sparse Group penalty norm.
`supp`	Vector of active groups.
`Nsupp`	Vector of the names of the active groups.
`SCR`	Scalar, equals to \Vert Y-f_{0}-∑_{v}K_{v}θ_{v}\Vert ^{2}.
`crit`	Scalar, indicates the value of penalized criteria.
`gamma.v`	Vector, coefficients of the Ridge penalty norm, √{n}γ\timesgama_v.
`mu.v`	Vector, coefficients of the Group Sparse penalty norm, nμ\timesmu_v.
`iter`	List of two components: maxIter, and the number of iterations until the convergence is achieved.
`convergence`	TRUE or FALSE. Indicates whether the algorithm has converged or not.
`RelDiffCrit`	Scalar, value of the first convergence criteria at the last iteration, \Vert\frac{θ_{lastIter}-θ_{lastIter-1}}{θ_{lastIter-1}}\Vert ^{2}.
`RelDiffPar`	Scalar, value of the second convergence criteria at the last iteration, \frac{crit_{lastIter}-crit_{lastIter-1}}{crit_{lastIter-1}}.

For the case γ=0 the outputs "mu"=μ_{g} and "Meta-Model" is the same as the one returned by the function RKHSgrplasso.

Halaleh Kamari

Kamari, H., Huet, S. and Taupin, M.-L. (2019) RKHSMetaMod : An R package to estimate the Hoeffding decomposition of an unknown function by solving RKHS Ridge Group Sparse optimization problem. <arXiv:1905.13695>

calc_Kv, mu_max, RKHSgrplasso, pen_MetMod, grplasso_q

d <- 3
n <- 50
library(lhs)
X <- maximinLHS(n, d)
c <- c(0.2,0.6,0.8)
F <- 1;for (a in 1:d) F <- F*(abs(4*X[,a]-2)+c[a])/(1+c[a])
epsilon <- rnorm(n,0,1);sigma <- 0.2
Y <- F + sigma*epsilon
Dmax <- 3
kernel <- "matern"
gamma <- c(.5,.01,.001,0)
Num <- 10
rat <- 100
qmax <- 4
result <- RKHSMetMod_qmax(Y, X, kernel, Dmax, gamma, qmax, rat, Num,FALSE)
names(result)
result$mus
result$qs
l <- length(gamma)
for(i in 1:l){print(result$MetaModel[[i]]$mu)}
for(i in 1:l){print(result$MetaModel[[i]]$gamma)}
for(i in 1:l){print(result$MetaModel[[i]]$`Meta-Model`$Nsupp)}