lazy                  package:lazy                  R Documentation

_L_a_z_y _l_e_a_r_n_i_n_g _f_o_r _l_o_c_a_l _r_e_g_r_e_s_s_i_o_n

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

     By combining constant, linear, and quadratic local models, 'lazy'
     estimates the value of an unknown multivariate function on the
     basis of a set of possibly noisy samples of the function itself.
     This implementation of lazy learning automatically adjusts the
     bandwidth on a query-by-query basis through a leave-one-out
     cross-validation.

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

     lazy(formula, data=NULL, weights, subset, na.action,
             control=lazy.control(...), ...)

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

 formula: A formula specifying the response and some numeric
          predictors.

    data: An optional data frame within which to look first for the
          response, predictors, and weights (the latter will be
          ignored).

 weights: Optional weights for each case (ignored).

  subset: An optional specification of a subset of the data to be used.

na.action: The action to be taken with missing values in the response
          or predictors.  The default is to stop.

 control: Control parameters: see 'lazy.control'

     ...: Control parameters can also be supplied directly.

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

     For one or more query points, 'lazy' estimates the value of an
     unknown multivariate function on the basis of a set of possibly
     noisy samples of the function itself.  Each sample is an
     input/output pair where the input is a vector and the output is a
     number.  For each query point, the estimation of the function is
     obtained by combining different local models.  Local models
     considered for combination by 'lazy' are polynomials of zeroth,
     first, and second degree that fit a set of samples in the
     neighborhood of the query point. The neighbors are selected
     according to either the Manhattan or the Euclidean distance. It is
     possible to assign weights to the different directions of the
     input domain for modifying their importance in the computation of
     the distance.  The number of neighbors used for identifying local
     models is automatically adjusted on a query-by-query basis through
     a leave-one-out validations of models, each fitting a different
     numbers of neighbors.  The local models are identified using the
     recursive least-squares algorithm, and the leave-one-out
     cross-validation is obtained through the PRESS statistic.

     As the name 'lazy' suggests, this function does not do anything...
     apart from checking the options and properly packing the data. All
     the actual computation is done when a prediction is request for a
     specific query point, or for a set of query points: see
     'predict.lazy'.

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

     An object of class 'lazy'.

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

     Mauro Birattari and Gianluca Bontempi

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

     D.W. Aha (1997) Editorial. _Artificial Intelligence Review_,
     *11*(1-5), pp. 1-6. Special Issue on Lazy Learning.

     C.G. Atkeson, A.W. Moore, and S. Schaal (1997) Locally Weighted
     Learning. _Artificial Intelligence Review_, *11*(1-5), pp. 11-73.
     Special Issue on Lazy Learning.

     W.S. Cleveland, S.J. Devlin, and S.J. Grosse (1988) Regression by
     Local Fitting: Methods, Prospectives and Computational Algorithms.
     _Journal of Econometrics_, *37*, pp. 87-114.

     M. Birattari, G. Bontempi, and H. Bersini (1999) Lazy learning
     meets the recursive least squares algorithm. _Advances in Neural
     Information Processing Systems 11_, pp. 375-381. MIT Press.

     G. Bontempi, M. Birattari, and H. Bersini (1999) Lazy learning for
     modeling and control design. _International Journal of Control_,
     *72*(7/8), pp. 643-658.

     G. Bontempi, M. Birattari, and H. Bersini (1999) Local learning
     for iterated time-series prediction. _International Conference on
     Machine Learning_, pp. 32-38. Morgan Kaufmann.

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

     'lazy.control', 'predict.lazy'

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

     data(cars)
     cars.lazy <- lazy(dist ~ speed, cars)
     predict(cars.lazy, data.frame(speed = seq(5, 30, 1)))

