SimulationStudy.Rmd

---
title: "Simulation Study for T-ridge"
author: "Shih-Ting Huang, Fang Xie, and Johannes Lederer"
date: "`r format(Sys.time(), '%d %B, %Y')`"
output: html_document
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

#### Description

This is an R markdown document provides the simulation study of the method described in 
**Tuning-free ridge estimators for high-dimensional generalized linear models** 
by Shih-Ting Huang, Fang Xie, and Johannes Lederer.

#### Settings

The settings include some simulation parameters described in the following :   

1. num.runs : Number of runs of the test (for averaging). 

2. num.obs : Number of observations (n). 

3. num.par : Number of parameters (p). 

4. k : Magnitude of mutual correlations. 

5. Test.case : Test cases for generalized linear models ("gaussian", "poisson", or "binomial"). 

6. SNR : Signal-to-noise ratio for gaussian test case. 

```{r}
num.runs <- 1  
num.obs <- 100 
num.par <- 300 
k <- 0 
Test.case <- "gaussian"
SNR <- 10
```

#### Required packages

The required packages for this simulation study contains : 

1. glmnet : Applying cross validation for generalized linear models.

2. MASS : Creating samples from multivariate normal distribution. 

3. htmlTable : Creating html tables for simulation result.

4. pander : Using specified text elements for output results.

```{r}
library(glmnet) 
library(MASS) 
library(htmlTable)
library(pander)
```

#### Loading additional functions

Some additional functions are loaded below and the description of each function 
can be found in the folder named **Additional functions**.

```{r}
source("./Additional functions/qnorm.R")
source("./Additional functions/MeanFunction.R")
source("./Additional functions/bFunction.R")
source("./Additional functions/MeanPrime.R")
source("./Additional functions/ObjectiveFunction.R")
source("./Additional functions/Gradient.R")
source("./Additional functions/ObjectEdr.R")
source("./Additional functions/GradientEdr.R")
source("./Additional functions/ObjectRidge.R")
source("./Additional functions/GradientRidge.R")
source("./Additional functions/ObjectLs.R")
source("./Additional functions/GradientLs.R")
```

#### Simulation process

The simulation process is performed by two parts : 

1. Initialization process.

2. Loop over the number of runs.

Initialization process : 

This process initialize the absolute errors that are going to be computed later and basic setup.

```{r}
source("./SimulationProcess/Initialize.R")
```

Loop over the number of runs : 

For each loop, we contain the following four steps in order : 

1. Data generation.

2. 10-fold cross validation pipeline.

3. T-ridge pipeline.

4. Compute errors.

```{r}
for (run in 1:num.runs){
  source("./SimulationProcess/DataGeneration.R")
  source("./SimulationProcess/K-foldCV.R")
  source("./SimulationProcess/TRidge.R")
  source("./SimulationProcess/ComputeErrors.R")
}
```

#### Results and Output

The results are summarized by R dataframe and the output is formatted by HTML table.

Results : 

```{r}
source("./SimulationProcess/ResultsOutput.R")
```

Output HTML Table :

```{r}
htmlTable(output,
          header =  H,
          rnames = "Mean relative errors",
          rgroup = paste0("Case : ", Test.case),
          n.rgroup = c(1),
          cgroup = c(pander("$\\frac{||X\\hat{\\beta}_{t-ridge} - X\\beta^{*}||_{2}}{||X\\beta^{*}||_{2}}$"), pander("$\\frac{||\\hat{\\beta}_{t-ridge} - \\beta^{*}||_{2}}{||\\beta^{*}||_{2}}$")),
          n.cgroup = c(2,2), 
          caption=paste0("(n,p,k)=(", num.obs, ",", num.par, ",", k, ")"))
```