kgplm                package:KernGPLM                R Documentation

_G_e_n_e_r_a_l_i_z_e_d _p_a_r_t_i_a_l _l_i_n_e_a_r _m_o_d_e_l

_D_e_s_c_r_i_p_t_i_o_n:

     Fits a generalized partial linear model (kernel-based) using the
     (generalized) Speckman estimator or backfitting (in the
     generalized case combined with local scoring) for two additive
     component functions. (Note that currently only the PLM as well as
     partial linear Logit and Probit models are implemented.)

_U_s_a_g_e:

     kgplm(x, t, y, h, family, link,
               b.start=NULL, m.start=NULL, grid = NULL, m.grid.start = NULL, 
               offset = 0, method = "speckman", sort = TRUE, weights = 1,
               weights.trim = 1, weights.conv = 1, max.iter = 25, eps.conv = 1e-8,
               kernel.p = 2, kernel.q = 2, kernel.product = TRUE, verbose = FALSE)

_A_r_g_u_m_e_n_t_s:

       x: n x p matrix, data for linear part

       y: n x 1 vector, responses

       t: n x q matrix, data for nonparametric part

       h: scalar or 1 x q, bandwidth(s)

  family: text string (currently "gaussian", "bernoulli")

    link: text string (currently "identity" for "gaussian", "logit" or
          "probit" for "bernoulli")

 b.start: p x 1 vector, start values for linear part

 m.start: n x 1 vector, start values for nonparametric part

    grid: m x q matrix, where to calculate the nonparametric function
          (default = t)

m.grid.start: m x 1 vector, start values for nonparametric part on grid

  offset: offset

  method: "speckman" or "backfit"

    sort: sort data (default=TRUE)

 weights: binomial weights

weights.trim: trimming weights for fitting the linear part

weights.conv: weights for convergence criterion

max.iter: maximal number of iterations

eps.conv: convergence criterion

kernel.p: integer or text, see 'kernel.function'

kernel.q: integer, see 'kernel.function'

kernel.product: (if p>1) product or spherical kernel

 verbose: print additional convergence information

_V_a_l_u_e:

     List with components: 

       b: p x 1 vector, linear coefficients

   b.cov: p x p matrix, linear coefficients

       m: n x 1 vector, nonparametric function estimate

  m.grid: m x 1 vector, nonparametric function estimate on grid

      it: number of iterations

deviance: deviance

df.residual: approximate degrees of freedom (residuals)

     aic: Akaike's information criterion

_A_u_t_h_o_r(_s):

     Marlene Mueller

_R_e_f_e_r_e_n_c_e_s:

     Mueller, M. (2001) Estimation and testing in generalized partial
     linear models - A comparative study. _Statistics and Computing,_
     11:299-309.

     Hastie, T. and Tibshirani, R. (1990) _Generalized Additive
     Models._ London: Chapman and Hall.

_S_e_e _A_l_s_o:

     'kernel.function', 'kreg'

_E_x_a_m_p_l_e_s:

       ## partial linear model (PLM)
       n <- 1000; b <- c(1,-1); rho <- 0.7
       m <- function(t){ 1.5*sin(pi*t) }
       x1 <- runif(n,min=-1,max=1); u  <- runif(n,min=-1,max=1)
       t  <- runif(n,min=-1,max=1); x2 <- round(m(rho*t + (1-rho)*u))
       x  <- cbind(x1,x2)
       y  <- x1*b[1]+x2*b[2] + m(t) + rnorm(n)
       gh <- kgplm(x,t,y,h=0.25,family="gaussian",link="identity")
       o <- order(t)
       plot(t[o],m(t[o]),type="l",col="green")
       lines(t[o],gh$m[o]); rug(t)

       ## partial linear probit model (GPLM)
       y <- (y>0)
       gh <- kgplm(x,t,y,h=0.25,family="bernoulli",link="probit")

       o <- order(t)
       plot(t[o],m(t[o]),type="l",col="green")
       lines(t[o],gh$m[o]); rug(t)

       ## two-dimensional PLM
       n <- 1000; b <- c(1,-1); rho <- 0.7
       m <- function(t1,t2){ 1.5*sin(pi*t1)+t2 }
       x1 <- runif(n,min=-1,max=1); u  <- runif(n,min=-1,max=1)
       t1 <- runif(n,min=-1,max=1); t2 <- runif(n,min=-1,max=1)
       x2 <- round( m( rho*t1 + (1-rho)*u , t2 ) )
       x  <- cbind(x1,x2); t  <- cbind(t1,t2)
       y  <- x1*b[1]+x2*b[2] + m(t1,t2) + rnorm(n)
       grid1 <- seq(min(t[,1]),max(t[,1]),length=20)
       grid2 <- seq(min(t[,2]),max(t[,2]),length=25)
       grid  <- create.grid(list(grid1,grid2))

       gh <- kgplm(x,t,y,h=0.5,grid=grid,family="gaussian",link="identity")

       o <- order(grid[,2],grid[,1])
       biv.m <- (matrix(gh$m.grid[o],length(grid1),length(grid2)))
       orig.m <- outer(grid1,grid2,m)
       par(mfrow=c(1,2))
       persp(grid1,grid2,orig.m,main="Original Function",
             theta=30,phi=30,expand=0.5,col="lightblue",shade=0.5)
       persp(grid1,grid2,biv.m,main="Estimated Function",
             theta=30,phi=30,expand=0.5,col="lightblue",shade=0.5)
       par(mfrow=c(1,1))

