gausspr               package:kernlab               R Documentation

_G_a_u_s_s_i_a_n _p_r_o_c_e_s_s_e_s _f_o_r _r_e_g_r_e_s_s_i_o_n _a_n_d _c_l_a_s_s_i_f_i_c_a_t_i_o_n

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

     'gausspr' is an implementation of Gaussian processes for
     classification and regression.

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

     ## S4 method for signature 'formula':
     gausspr(x, data=NULL, ..., subset, na.action = na.omit)

     ## S4 method for signature 'vector':
     gausspr(x,...)

     ## S4 method for signature 'matrix':
     gausspr(x, y, type="classification", kernel="rbfdot", kpar=list(sigma = 0.1),
               var=1, tol=0.001, cross=0, fit=TRUE, ... , subset, na.action = na.omit)

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

       x: a symbolic description of the model to be fit or a matrix or
          vector when a formula interface is not used.  When not using
          a formula x is a matrix or vector containg the variables in
          the model

    data: an optional data frame containing the variables in the model.
          By default the variables are taken from the environment which
          `gausspr' is called from.

       y: a response vector with one label for each row/component of
          'x'. Can be either a factor (for classification tasks) or a
          numeric vector (for regression).

    type: Type of problem. Either "classification" or "regression"

  kernel: the kernel function used in training and predicting. This
          parameter can be set to any function, of class kernel, which
          computes a dot product between two vector arguments. kernlab
          provides the most popular kernel functions which can be used
          by setting the kernel parameter to the following strings:

             *  'rbfdot' Radial Basis kernel function "Gaussian"

             *  'polydot' Polynomial kernel function

             *  'vanilladot' Linear kernel function

             *  'tanhdot' Hyperbolic tangent kernel function

             *  'laplacedot' Laplacian kernel function

             *  'besseldot' Bessel kernel function

             *  'anovadot' ANOVA RBF kernel function

             *  'splinedot' Spline kernel 

          The kernel parameter can also be set to a user defined
          function of class kernel by passing the function name as an
          argument. 

    kpar: the list of hyper-parameters (kernel parameters). This is a
          list which contains the parameters to be used with the kernel
          function. Valid parameters for existing kernels are :

             *  'sigma' inverse kernel width for the Radial Basis
                kernel function "rbfdot" and the Laplacian kernel
                "laplacedot".

             *  'degree, scale, offset' for the Polynomial kernel
                "polydot"

             *  'scale, offset' for the Hyperbolic tangent kernel
                function "tanhdot"

             *  'sigma, order, degree' for the Bessel kernel
                "besseldot". 

             *  'sigma, degree' for the ANOVA kernel "anovadot".

          Hyper-parameters for user defined kernels can be passed
          through the kpar parameter as well.

     var: the initial noise variance, (only for regression) (default :
          0.001)

     tol: tolerance of termination criterion (default: 0.001)

     fit: indicates whether the fitted values should be computed and
          included in the model or not (default: 'TRUE')

   cross: if a integer value k>0 is specified, a k-fold cross
          validation on the training data is performed to assess the
          quality of the model: the Mean Squared Error for regression

  subset: An index vector specifying the cases to be used in the
          training sample.  (NOTE: If given, this argument must be
          named.)

na.action: A function to specify the action to be taken if 'NA's are
          found. The default action is 'na.omit', which leads to
          rejection of cases with missing values on any required
          variable. An alternative is 'na.fail', which causes an error
          if 'NA' cases are found. (NOTE: If given, this argument must
          be named.)

     ...: additional parameters

_D_e_t_a_i_l_s:

     A Gaussian process is specified by a mean and a covariance
     function. The mean is a function of x (which is often the zero
     function), and the covariance is a function C(x,x') which
     expresses the expected covariance between the value of the
     function y at the points x and x'. The actual function y(x) in any
     data modelling problem is assumed to be a single sample from this
     Gaussian distribution. Laplace approximation is used for the
     parameter estimation in gaussian processes for classification.

     The predict function can return class probabilities for 
     classification problems by setting the 'type' parameter to
     "probabilities".

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

     An S4 object of class "gausspr" containing the fitted model along
     with information. Accessor functions can be used to access the
     slots of the object which include : 

   alpha: The resulting model parameters

   error: Training error (if fit == TRUE)

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

     Alexandros Karatzoglou 
      alexandros.karatzoglou@ci.tuwien.ac.at

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

     C. K. I. Williams and D. Barber 
      Bayesian classification with Gaussian processes. 
      IEEE Transactions on Pattern Analysis and Machine Intelligence,
     20(12):1342-1351, 1998
      <URL:
     http://www.dai.ed.ac.uk/homes/ckiw/postscript/pami_final.ps.gz>

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

     'predict.gausspr', 'rvm', 'ksvm', 'gausspr-class', 'lssvm'

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

     # train model
     data(iris)
     test <- gausspr(Species~.,data=iris,var=2)
     test
     alpha(test)

     # predict on the training set
     predict(test,iris[,-5])
     # class probabilities 
     predict(test, iris[,-5], type="probabilities")

     # create regression data
     x <- seq(-20,20,0.1)
     y <- sin(x)/x + rnorm(401,sd=0.03)

     # regression with gaussian processes
     foo <- gausspr(x, y)
     foo

     # predict and plot
     ytest <- predict(foo, x)
     plot(x, y, type ="l")
     lines(x, ytest, col="red")

