tsapp (version 1.0.4)

rlassoLoad: rlassoLoad performs Lasso estimation under heteroscedastic and autocorrelated non-Gaussian disturbances with predefined penalty loadings.

Description

rlassoLoad performs Lasso estimation under heteroscedastic and autocorrelated non-Gaussian disturbances with predefined penalty loadings.

Usage

rlassoLoad(
  x,
  y,
  load,
  bns = 10,
  lns = NULL,
  nboot = 5000,
  post = TRUE,
  intercept = TRUE,
  model = TRUE,
  X.dependent.lambda = FALSE,
  c = 2,
  gamma = NULL,
  numIter = 15,
  tol = 10^-5,
  threshold = NULL,
  ...
)

Arguments

x

Regressors (vector, matrix or object can be coerced to matrix).

y

Dependent variable (vector, matrix or object can be coerced to matrix).

load

Penalty loadings, vector of length p (no. of regressors).

bns

Block length with default bns=10.

lns

Number of blocks with default lns = floor(T/bns).

nboot

Number of bootstrap iterations with default nboot=5000.

post

Logical. If TRUE (default), post-Lasso estimation is conducted, i.e. a refit of the model with the selected variables.

intercept

Logical. If TRUE, intercept is included which is not penalized.

model

Logical. If TRUE (default), model matrix is returned.

X.dependent.lambda

Logical, TRUE, if the penalization parameter depends on the design of the matrix x. FALSE (default), if independent of the design matrix.

c

Constant for the penalty default is 2.

gamma

Constant for the penalty default gamma=0.1/log(T) with T=data length.

numIter

Number of iterations for the algorithm for the estimation of the variance and data-driven penalty.

tol

Constant tolerance for improvement of the estimated variances.

threshold

Constant applied to the final estimated lasso coefficients. Absolute values below the threshold are set to zero.

...

further parameters

Value

rlassoLoad returns an object of class "rlasso". An object of class "rlasso" is a list containing at least the following components:

coefficients

Parameter estimates.

beta

Parameter estimates (named vector of coefficients without intercept).

intercept

Value of the intercept.

index

Index of selected variables (logical vector).

lambda

Data-driven penalty term for each variable, product of lambda0 (the penalization parameter) and the loadings.

lambda0

Penalty term.

loadings

Penalty loadings, vector of lenght p (no. of regressors).

residuals

Residuals, response minus fitted values.

sigma

Root of the variance of the residuals.

iter

Number of iterations.

call

Function call.

options

Options.

model

Model matrix (if model = TRUE in function call).

Examples

# NOT RUN {
set.seed(1)
T = 100 #sample size
p = 20 # number of variables
b = 5 # number of variables with non-zero coefficients
beta0 = c(rep(10,b), rep(0,p-b))
rho = 0.1 #AR parameter
Cov = matrix(0,p,p)
for(i in 1:p){
  for(j in 1:p){
     Cov[i,j] = 0.5^(abs(i-j))
  }
} 
C <- chol(Cov)
X <- matrix(rnorm(T*p),T,p)%*%C
eps <- arima.sim(list(ar=rho), n = T+100)
eps <- eps[101:(T+100)] 
Y = X%*%beta0 + eps

fit1 =  rlasso(X, Y, penalty = list(homoscedastic = "none",
              lambda.start = 2*0.5*sqrt(T)*qnorm(1-0.1/(2*p))), post=FALSE)
beta = fit1$beta
intercept = fit1$intercept
res = Y - X %*% beta - intercept * rep(1, length(Y))

load = rep(0,p)
for(i in 1:p){
  load[i] = sqrt(lrvar(X[,i]*res)*T)
  }
reg.lasso.load1 <- rlassoLoad(X,Y,load) #lambda is chosen independent of regressor 
                                             #matrix X by default.

bn = 10 # block length
reg.lasso.load2 <- rlassoLoad(X, Y,load, bns=bn, nboot=5000,
                            X.dependent.lambda = TRUE, c=2.7)
# }