Patent Publication Number: US-8112375-B2

Title: Wavelength selection and outlier detection in reduced rank linear models

Description:
RELATED APPLICATIONS 
     This application claims priority to U.S. Provisional Application No. 61/072,601, filed Mar. 31, 2008, and is incorporated herein by reference in its entirety. 
    
    
     BACKGROUND 
     The present disclosure relates generally to selecting useful predictors for linear modeling and, more specifically, to selecting useful channels for non-invasive medical devices. 
     This section is intended to introduce the reader to various aspects of art that may be related to various aspects of the present disclosure, which are described and/or claimed below. This discussion is believed to be helpful in providing the reader with background information to facilitate a better understanding of the various aspects of the present disclosure. Accordingly, it should be understood that these statements are to be read in this light, and not as admissions of prior art. 
     In the field of medicine, doctors often desire to monitor certain physiological characteristics of their patients. Accordingly, a wide variety of devices may have been developed for monitoring many such characteristics of a patient. Such devices may provide doctors and other healthcare personnel with the information they need to provide the best possible healthcare for their patients. As a result, such monitoring devices have become useful in treating patients. 
     Non-invasive medical devices may be particularly useful and desirable, as they generally provide immediate feedback and do not traumatize a patient. Generally, non-invasive sensors may transmit electromagnetic radiation, such as light, through a patient&#39;s tissue. The sensor may photoelectrically detect the absorption and scattering of the transmitted light in such tissue. The light passed through the tissue may be selected to be of one or more wavelengths that may be absorbed and scattered by particular tissue constituents, such as blood, for example. One or more physiological characteristics may then be calculated based upon the amount of light absorbed and/or scattered. 
     One non-invasive technique for monitoring certain physiological characteristics of a patient is commonly referred to as pulse oximetry, and the devices built based upon pulse oximetry techniques are commonly referred to as pulse oximeters. Pulse oximetry may be used to measure various blood flow characteristics, such as the blood-oxygen saturation of hemoglobin in arterial blood, the volume of individual blood pulsations supplying the tissue, and/or the rate of blood pulsations corresponding to each heartbeat of a patient. In fact, the “pulse” in pulse oximetry refers to the time varying amount of arterial blood in the tissue during each cardiac cycle. Pulse oximetry readings may measure the pulsatile, dynamic changes in amount and type of blood constituents in tissue. 
     However, in pulse oximetry, as well as other non-invasive monitoring techniques, the investigative instruments (e.g., NIR spectroscopes) commonly allow measurements in more discrete channels than the relevant underlying degrees of freedom or the number of objects under investigation. While a wide array of channels may provide greater predictive power, some channels may confound prediction of the relevant response, essentially measuring only “noise.” Moreover, the principle of parsimony dictates that a predictive model must focus on as few of the channels as practical, or fewer. 
     SUMMARY 
     Certain aspects commensurate in scope with the originally claimed subject matter are set forth below. It should be understood that these aspects are presented merely to provide the reader with a brief summary of certain embodiments and that these aspects are not intended to limit the scope of the claims. Indeed, the claims may encompass a variety of aspects that may not be set forth below. 
     In accordance with an embodiment there is provided a method for selecting useful channels in a non-invasive medical device. The method includes embedding a discrete predictor problem into continuous space of a predictor preweighting and executing an optimization algorithm to optimize a preweighting vector, wherein the optimization algorithm determines the relative importance of the each predictor. Thereafter, n different models are constructed, wherein a k th  model comprises the k most important predictors and the models are compared using an information criterion to allow for automatic selection of a subset of the predictors. An analytical Jacobian of the partial least squares regression vector is derived with respect to the predictor weighting to optimize the predictor weighting and select useful channels for use in the non-invasive medical device. 
     In accordance with an embodiment a system for identifying useless predictors is provided comprising a processor and a memory communicatively coupled to the processor. The memory stores a program embedded with a discrete predictor problem. Execution of the program comprises executing an optimization algorithm to optimize a preweighting vector, wherein the optimization algorithm determines the relative importance of the each predictor. Additionally, the execution of the program includes constructing n different models, wherein a k th  model comprises the k most important predictors, and automatically selecting a subset of predictors by comparing the models using an information criterion. The system also derives an analytical Jacobian of the partial least squares regression vector with respect to the predictor weighting to optimize the predictor weighting and select useful channels for use in the non-invasive medical device. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       Certain embodiments may be understood reading the following detailed description and upon reference to the drawings in which: 
         FIG. 1  is a flow chart illustrating the use of the SRCEK method to determine useful predictor and eliminate outliers; 
         FIG. 2  illustrates a non-invasive medical device in accordance with an embodiment; 
         FIG. 3  illustrates a block diagram of the non-invasive medical device of  FIG. 1 ; 
         FIG. 4  is a graph plotting the fast analytical computation of the Jacobian of a residual, a slow analytic and a numerical approximation; 
         FIG. 5  illustrates a plot of the function Kp,q(λ) in polar coordinates for the two dimensional vector λ=(cos θ, sin θ), and various values of p and q in the quadrant 0≦θ≦π/2; 
         FIG. 6  is a plot of the vector Λβ(λ) for post-optimization λ on data set Kalivas, wherein RMSECV for MC CV groups was used as the objective function; 
         FIG. 7  is a plot of the vector Λβ(λ) for post-optimization λ on data set Kalivas, wherein the embedded aBIC using the same CV groups for the RMSECV part and K 1,1.01  was minimized; 
         FIG. 8  illustrates experimental results of using the SRCEK method to select predictors using a 2 factor WPLS to predict for water; and 
         FIG. 9  illustrates object weightings resulting from the use of the SRCEK method. 
     
    
    
     DETAILED DESCRIPTION OF SPECIFIC EMBODIMENTS 
     One or more specific embodiments will be described below. In an effort to provide a concise description of these embodiments, not all features of an actual implementation are described in the specification. It should be appreciated that in the development of any such actual implementation, as in any engineering or design project, numerous implementation-specific decisions must be made to achieve the developers&#39; specific goals, such as compliance with system-related and business-related constraints, which may vary from one implementation to another. Moreover, it should be appreciated that such a development effort might be complex and time consuming, but would nevertheless be a routine undertaking of design, fabrication, and manufacture for those of ordinary skill having the benefit of this disclosure. 
     In order to eliminate the “noise” that may be incurred by operating useless predictors, such as wavelengths that produce outlier readings in a non-invasive medical device, a system and method are disclosed for selecting useful predictors for linear modeling of a response by a partial least squares (PLS). In particular, there is provided means for fitting observed data X (an m by n matrix) and y (an m vector), which may be representative of the data generated by a non-invasive medical device, may be fit to a linear model of the form: y≈χβ+1b 0 . The fitting technique is capable of simultaneously selecting good subsets of the n available predictors in X and identifying outliers among the m objects of y. The linear model is then built by a weighted PLS regression on the “reduced” data (i.e., using non-outlier objects and the selected predictors). 
     Partial Least Squares (PLS) is a well known technique for estimation of linear models from data assumed to be of reduced rank. That is, it is assumed the number of relevant latent factors, l, is smaller (usually much smaller) than m and n. In the context of spectroscopy, usually m&lt;&lt;n, i.e., the number of objects observed is far fewer than the number of channels at which observations were made. It is also known that PLS should be combined with predictor selection, and not applied on full spectrum data, as the quality of fit degrades with a term proportional to (n/m) 2 . 
     A number of techniques exist for the selection of subsets of predictors, including heuristic and statistical approaches. Some work has been done on simultaneous subset of outlier selection, based on wavelets. Additionally, a subset selection method using genetic algorithms has been patented. However, these may be limited to only finding outliers or predictors (not both), and/or time consuming, among other things. Moreover, a number of clever and theoretically well grounded techniques exist for the rejection of the useless wavelengths. For example, the issue of too many channels may be mitigated by the use of principal component regression (PCR) and partial least squares PLS), two algorithmic techniques which essentially project many variate predictors onto a small dimensional vector space before building a predictive model. While these techniques are good at capturing the largest or most relevant underlying variations in multivariate predictors, they are not impervious to disinformative or useless predictors, as it has been shown that the predictive ability of PLS is degraded by a term quadratic in the number of predictors. Alternatively, a heuristic wavelength selection algorithm may be used to reject useless wavelengths, although, it is a particularly slow method. Rather than discuss the variety of techniques in detail, readers are referred to “Selection of Useful Predictors in Multivariate Calibration,” Forina et al.,  Analytical and Bioanalytical Chemistry,  380(3):387-418 (2004), which is incorporated herein by reference in its entirety, for further information. 
     Referring to the figures and initially turning to  FIG. 1 , a flow chart  10  illustrating the method for selecting useful predictors is shown. The method  10  embeds a discrete predictor selection problem into the continuous space of predictor preweighting, as indicated at block  12 . The problem is essentially binary in nature and may be framed in several different manners. For example, the problem may consider whether the predictor is useful or not. Alternatively, the problem may consider if the predictor an outlier. Although outliers are typically not useful predictors they can still provide beneficial information, i.e, can tell which predictors are not useful. 
     Once the problem is embedded, an optimization algorithm, such as a Quasi-Nesvton optimization algorithm, for example, to optimize the preweighting vector is employed to determine the relative importance of each predictor, as indicated at block  14 . The magnitudes of the weights indicate the relative importance of each predictor. The relative importances of the predictors are used to construct  7   a  different models, the k th  consisting of the k most important predictors, as indicated at block  16 . The different models are then compared by means of an information criterion (e.g., BIC), allowing automatic selection of a good subset of the predictors, as indicated at block  18 . The analytical Jacobian of the partial least squares (PLS) regression vector with respect to the predictor weighting is derived to facilitate optimization of the predictor weighting, as indicated at block  20 . 
     The method  10  exploits the reduced rank of the predictor matrix to gain some speedup when the number of observations is fewer than the number of predictors (the usual case for e.g., IR spectroscopy). The method  10  compares favourably with prior predictor selection techniques surveyed by Forina et al. and will be referred to herein as “SRCEK” which is an acronym for “Selecting Regressors by Continuous Embedding in k-dimensions.” 
     The following discussion includes a description of a non-invasive medical device in which the method  10  may be implemented. The method  10  will then be described in great detail beginning with a detailed discussion of the problem followed by descriptions of alternative techniques that may be implemented in SRCEK, and experimental results. 
     Non-Invasive Medical Device 
     Referring to  FIG. 2 , a non-invasive medical device that may implement the SRCEK method is illustrated in accordance with an embodiment and is generally designated by the reference numeral  110 . The system  110  includes a monitor  112  which may house hardware and sofgware configured to compute various physiological parameters. In accordance with an embodiment, the monitor  112  may be a pulse oximetry or multi-parameter monitor, such as those available from Nellcor Puritan Bennett L.L.C. and/or Covidien. The monitor  112  may include a display  114  to display the various physiological parameters, such as the percent oxygen saturation of hemoglobin and the pulse rate, for example. The display  114  may show the calculated values numerically and/or as a waveform over time. Additionally, any notifications or alerts prompted by abnormal measurements, calculated values and/or by poor contact between the sensor and the patient&#39;s tissue, as discussed below, may be displayed. 
     A sensor  116  may be communicatively coupled to the monitor  112  via a cable  118  and a connector  120 . A block diagram of the non-invasive medical device  110  is illustrated in  FIG. 3 . As can be seen, the sensor  116  includes emitters  120  which are capable of emitting electromagnetic radiation, or light. Specifically, the emitters  120  may be any suitable emitter such as LEDs, a broad spectrum emitter, or a scanning light source which may incrementally emit across a broad spectrum of wavelengths, for example. If a plurality of LEDs is used as emitters  120 , each may emit at a discrete wavelength. Specifically, a first emitter may emit light in the red region of the electromagnetic spectrum, i.e., approximately 600 nm to 750 nm, while a second emitter  20  may emit light in the infrared (IR) region of the electromagnetic spectrum i.e., approximately 750 nm to 1 mm. 
     When device  110  is operating, a detector  122  detects electromagnetic radiation originating from the emitters  120  after it has passed through blood perfused tissue of a patient  124 . For example, the detector may detect the electromagnetic radiation after it has passed through a tissue located on a patient&#39;s finger or a forehead. The detector  122  may include one or more photodetectors configured to detect light in the electromagnetic regions in which the emitters  120  operate. For example, in an embodiment, a silicon photodetector may be provided as well as an indium-gallium-arsenide photodetector, so that electromagnetic radiation in the red and infrared regions of the electromagnetic spectrum may be detected. The detector  122  generates a signal corresponding to the detected light. The signal generated by the detector  122  is provided to the monitor  112 . 
     As illustrated, the monitor  112  includes a microprocessor  126  which receives the signal after it has been amplified (amplifier  128 ), filtered (filter  130 ) and converted to a digital signal (A/D converter  132 ). The microprocessor  126  may be configured to calculate various physiological parameters, characteristics, and/or other metrics of the patient  124  using algorithms programmed into the monitor  112 . Additionally, the processor may be configured to operate the SRCEK algorithm in accordance with the following discussion. 
     The microprocessor  126  may be connected to other component parts of the monitor  112 , such as a ROM  134 , a RAM  136 , and control inputs  138 . The ROM  134  may be configured to store the algorithms used to compute the physiological parameters, characteristics, and/or metrics, and the RAM  136  may be configured to store the signals generated by the sensor  116  for use in the algorithms. The control inputs  138  may be provided to allow a user to interface with the monitor  112 . The control inputs  138  may include soft keys, dedicated function keys, a keyboard, and/or keypad type interfaces for providing parameters, data, and/or instructions to the monitor  112 . In certain embodiments, the control inputs  138  may also include speech or tone recognition or other audio, remote, and/or hands-free command input type devices. 
     A light drive unit  140  in the spectrophotometric monitor  112  may control the timing of the emitters  120 . Additionally, to help avoid inaccurate readings, an encoder  142  and decoder  144  may be used to calibrate the monitor  112  to the actual wavelengths emitted by the emitters  120 . The encoder  142  may be a resistor, for example, whose value corresponds to one or more of the emitter wavelengths so that proper coefficients stored in the monitor  112  may be selected. In another embodiment, the encoder  142  may be a memory device, such as an EPROM, that stores information, such as information related to the emitter wavelengths or the coefficients themselves, for example, Once the coefficients indicated by the encoder  142  are determined by the monitor  112 , they may be inserted into the algorithms in order to calibrate the calculations that are being performed by the system  110 . 
     In an alternative embodiment, the monitor may already be configured, i.e., programmed to operate on the basis that the emitters emit at certain wavelengths. These wavelengths are determined based on the techniques provided herein. Thus, for example, in the design of a medical device that uses spectroscopy to determine analyte concentrations in human tissue, a subset of available wavelengths are selected for use in the device and the device is programmed only for those selected wavelengths. 
     The Problem 
     Let X be an m×n matrix of observed predictors, with each row corresponding to an observed “object,” and each column a “channel” of the investigative instrument. Let y be an m-dimensional column vector of responses of each of the objects. In the general context of chemometrics, the number of objects is generally far fewer than the number of channels: m&lt;&lt;n. A linear predictive model is an n-vector β such that y≈χβ. When calibrated on a given collection of predictors and responses X and y, different algorithms produce different linear models. 
     A good model is marked by a residual with small norm. That is, Σ i ε 1   2  is small, where ε=y−χβ is the residual. However, a model which explains the observed data well may give poor predictive ability over as-yet-observed objects, due to “overfitting.” 
     Cross validation (CV) is used to address this deficiency. The idea is to divide the tested objects into two groups, one of which is used to build a model β, the other is used to test the quality of the model. By leaving these validation or test objects out of the calibration, this technique simulates the predictive ability of the observed data on unobserved data. 
     Because the division in two groups is arbitrary, the process is often repeated in a round robin fashion, with different subdivisions. The quality of prediction of each division is then averaged. In the most extreme form, known as “leave one out” (LOO) or “delete-1”, the model building and testing is performed m times, each time with m−1 objects in the calibration group, and the single remaining object in the test group. For comparing different subsets of the predictors, Shao proved that delete-1 CV is asymptotically inconsistent, i.e., it has a nonzero probability of overfitting. 
     To facilitate understanding, some terminology is presented. The norm (more specifically the 2-norm) of a vector ν is its Euclidian length: ∥ν∥ 2 =Σ i ν i   2 =√{square root over (ν T )}ν. The mean square norm of a k-dimensional vector, ∥ν∥ 2   2 /k. The mean squared error of a model β for a given data χ and y is the mean square norm of the residual y−χβ. The mean squared error of cross validation (MSECV) is the mean over each cross validation group of the mean square error of the model built by the calibration group on the test group: 
                 M   ⁢           ⁢   S   ⁢           ⁢   E   ⁢           ⁢   C   ⁢           ⁢   V     =       1   J     ⁢       ∑     J   =   1     J     ⁢       1     m   j       ⁢              y   j     -       χ   j     ⁢     β   j              2   2             ,         
where χ j  and y j  are predictors and response of the j th  calibration group. The mean squared error of prediction (NSEP) of a model is the mean square error of the data used to build the model: MSEP=∥y−χβ∥ 2   2 /m, where β is built using the data χ and y.
 
     The prefix “roof” refers to square root, thus, the root mean squared error of cross validation (RMSECV) is √{square root over (MSECV)}; similarly for RMSEP, etc. The RMSECV has the same units as the response. Thus, while a smaller RMSECV usually signifies a better model building technique, interpretation of RMSECV is difficult without comparison to the distribution of the responses. Thus, a modeling technique is often compared to a trivial modeler, one which approximates the response by the mean of the calibration responses and ignores the predictors altogether. The MSECV of this technique is a weighted average estimate of the variance of the observed responses: 
               MSETCV   =       1   j     ⁢       ∑     j   =   1     j     ⁢       1     m   j       ⁢              y   j     -       y   _     j            2   2             ,         
where  y   j  is the mean of the calibration responses in the j th  cross validation group. The “T” stands for “trivial.” This terminology is nonstandard. Comparing the MSECV to the MSETCV gives the cross-validation percent explained variance of the model building technique, Q 2 =100% (MSETCV−MSETCV)/MSETCV.
 
     The goal of channel selection appears to be, given the observed data, the CV groups and a model building technique, select the subset of the n available columns of χ which minimizes RMSECV (or equivalently, maximizes Q 2 ) when only those columns of χ are used in the model building and testing. In this formulation the number of possible solutions is 2 n  and an exhaustive search becomes impractical when n is larger than about 17. Subset selection heuristics such as Tabu search, Simulated Annealing (SA) and Genetic Algorithms (GA), which generate and test subsets of the n available columns, can only hope to explore a small part of the 2 n  sized discrete space of possible subsets, and are susceptible to falling into local minima. 
     Considerable progress was made on the problem by the introduction of iterative predictor weighting (IPW). This channel selection technique reformulates the problem as one of selecting a vector in n dimensional Euclidian space, hereafter denoted  , rather than on the discrete space of binary n-dimensional vectors. In teems of size if the search space there would seem to be no advantage to this reformulation. However, the continuous embedding allows the importance of each channel to be evaluated and changed simultaneously, in parallel, rather than serially. 
     Predictive weighting can be viewed as a preprocessing step. Let λε  be a vector of weights. Let   be the diagonal n×n matrix whose diagonal is the vector λ. Hereafter, diag (ν) denotes the diagonal matrix whose diagonal is ν, so  =diag (λ). The λ-weighted predictor matrix is the product X : the k th  column of the weighted predictor matrix is the k th  column of X times λ k . Weighted predictors are then used in the cross validation study, both in the calibration and test sets. As such the quality of the cross validation (RMSECV or Q 2 ) can be viewed as a scalar function of the vector λ, once the data and CV groups and model building method (and order) have been fixed. 
     Note that when the regression model β is built by ordinary least squares (OLS), the quality of cross validation is constant with respect to λ. This occurs because the weighted regression model output by OLS is constant with respect to nonzero predictor weighting, i.e.,  β(λ), is constant over all λ with nonzero elements, PLS, however, does not share this property, and the quality of cross validation is affected by predictor weighting. When used as a preprocessing technique prior to the application of PLS, the usual strategy is to apply predictor weighting A where λ k =1/{circumflex over (σ)} k   2 , where {circumflex over (σ)} k   2  is the sample standard deviation of the k th  channel based on the observations in the entire sample X, a technique called “autoscaling.” There is no reason to believe a priori that this choice of λ gives good cross validation. Rather an a priori choice of weighting should depend on knowledge of the test instrument of the tested objects. Alternatively, one can let the data inform the choice of predictor weighting. 
     The SRCEK method disclosed herein minimizes the RMSECV as a function of λ. This can be achieved by any of a number of modern optimization algorithms, including BFGS, as will be discussed in detail below. Once a local minimum has been found, the magnitude of the elements of the optimal λ suggests the importance of the corresponding channels to the observed data. This ordering suggests n different models, the k th  consisting of the first k channels by order of decreasing importance. These models can then be compared using any model selection technique, e.g., minimization of RMSECV or an information criterion. 
     The SRCEK method can accept, as an objective function, the root mean square error of cross validation (RMSECV) for a given set of cross validation (CV) groupings. Alternatively, there is an embedding of Schwvarz&#39; Bayesian Information Criterion (BIC), which mixes model quality with model parsimony, avoiding overfitting (i.e., models with too may predictors or outliers). One can, optionally select to not allow any outliers or to use all predictors and only find outliers. 
     The SRCEK method has a number of advantages over other techniques for predictor selection. Specifically, it can simultaneously find outliers and predictors, it is deterministic and has a sound theoretical basis, it can be easily adapted to the latest trends in model comparison (e.g., using GIC instead of BIC), it takes advantage of extant optimization software, it is fast (although the computational speed tradeoff should be balanced by using more CV groups), and it does not assume that adjacent predictors have high covariance (like some wavelet techniques). Moreover, early experiments indicate it is equal or superior to those techniques surveyed by Forina et al. Additionally, the SRCEK method provides many tweakable parameters, for which reasonable defaults values are not yet generally known, that allow for broad applicability. 
     As mentioned earlier, SRCEK is an optimization approach that embeds the essentially binary problem of selecting/rejecting predictors and objects into a continuous space where they are each given a weighting. Any modern optimization technique (for example, the quasi-Newton algorithm known as BEGS), can then optimize an objective function (usually a measure of the quality of the fit) with respect to the weights. The embedding can then be reversed by using the weights to order the predictors and objects, then checking the successive models suggested by the weights. In order to interface with the optimization code, an algorithm has been devised which quickly computes the Jacobian of the residual with respect to the weightings. This formulation exploits the reduced rank (m≦n) to get a runtime speedup. 
     PLS Regression 
     The assumption underlying PLS regression is that predictor and response take the form
 
 X={tilde over (T)}   (0)   {tilde over (P)}   (0)     T     +{tilde over (T)}   (1)   {tilde over (P)}   (1)     T     + . . . +{tilde over (T)}   (1)   P   (1)     T     +E,   (1)
 
 y={tilde over (T)}   (0)   {tilde over (q)} 0+ {tilde over (T)}   (1)   {tilde over (q)} 1+ . . . {tilde over (T)} (1)   {tilde over (q)}l+f,   (2)
 
where the vectors {tilde over (T)} (k)  are orthogonal, and the remainder terms, E and f, are random variables. The vector T (0)  is 1, the vector of all ones. It is also assumed that the response remainder term, f, is homoscedastic, i.e.,
 
E[ff T ]=σ y   2 l.
 
When this assumption cannot be supported, weighted PLS (WPLS) regression is appropriate. [19, 14, 17] Let Γ be a symmetric positive definite matrix such that Γ=cE[ff T ] −1 , for some (perhaps unknown) scalar c. Weighted PLS assumes a decomposition of X and y as in equations 1 and 2, but with the property that the vectors {tilde over (T)} (k)  are Γ-orthogonal: {tilde over (T)} (k) Γ{tilde over (T)} (j) =0 if k≠j.
 
     WPLS regression with l factors computes m×l matrix T, n×l matrix P and l vector q such that
 
X≈T (0) P (0)     T   , and  y≈T   (0)   q 0+ Tq,  
 
where T (0)  is the vector of all ones, and P (0)  and q0 are the (Γ-weighted) means X and y. The linear (actually affine) model constructed by WPLS takes the form β=W(P T W) −1 q, for some matrix W, with offset b 0 =q 0 −P 0     T   β. Thus X k β+T (0) b 0 ≈T (0) P (0)     T   β+TP T W(P T W) −1 q+T (0) q 0 −T (0) P (0)     T   β=T (0) q 0 −Tq≈y.
 
     The use of the words “weight” or “weighting” in this context is traditional, and parallels the usage for ordinary least squares. It should not be confused with the predictor weighting of the channels. To distinguish them, Γ will refer to the object weights and is assumed to be a diagonal vector, Γ=diag(γ). This is not necessary for correctness of the algorithm, only for the fast runtime of the algorithm, for which a sufficiently sparse Γ would also suffice. 
     RMSECV and its Gradient 
     Given fixed data) the existence of a selected order l is presupposed The selection of l should be informed by the underlying structure of the objects under investigation, or by an automatic technique. In the chemometric context, the number of factors should be less preferably far less) than the number of objects: l≦m. Let φ(λ) be the RMSECV for the CV when the CV groups are fixed, and the linear model is built by l-factor WPLS with γ given, and using predictor weights λ. To employ quasi-Newton minimization, the gradient of φ with respect to λ must be computed. While this can be approximated numerically with little extra programmer effort, the computational overhead can be prohibitive. Thus the analytic formulation of the gradient is developed. 
     In general formulation, there is an object weight associated with each observation. These weights should be used in both the model construction and error computation phases. Thus, the RMSECV is rewritten as a weighted RMSECV as follows: 
                 ϕ   ⁡     (   λ   )       =         1   J     ⁢       ∑     j   =   1     J     ⁢         ɛ       (   j   )     T       ⁢     Γ     (   j   )       ⁢     ɛ     (   j   )             1       (   j   )     T       ⁢     Γ     (   j   )       ⁢     1     (   j   )                   ,         
where ε (j)  is the residual of the j th  test group, Γ (j)  is the diagonal matrix of the object weights of the j th  test group, and l (j)  is the appropriate length vector of all ones. The gradient of this is:
 
                   ∇   λϕ     ⁢     (   λ   )       =       1     ϕ   ⁡     (   λ   )         ⁢     1   j     ⁢       ∑     j   =   1     J     ⁢       1       1       (   j   )     T       ⁢     Γ     (   j   )       ⁢     1     (   j   )           ⁢       ∂     ɛ       (   j   )     T           ∂   λ       ⁢     Γ     (   j   )       ⁢     ɛ     (   j   )               ,         
Each residual takes the form: ε= tst −(X tst   β(λ)+1 tst b 0 (λ)).
 
Thus, the Jacobian of the residual is:
 
                       ∂   ɛ       ∂   λ       =       -       X   tst     ⁡     (       diag   ⁡     (     β   ⁡     (   λ   )       )       +     ⋀       ∂     β   ⁡     (   λ   )           ∂   λ           )         -       1   tst     ⁢       ∇     λ   0     b   T         .                 (   3   )               
(Consult equation 7 and equation 8 in Section A for proofs.) Here and in the following, X cat , Y cat  are used to refer to the calibration objects, and X tst  and Y tst  to refer to the test objects of a single cross validation partitioning. This reduces the problem to the computation of the Jacobian and gradient of the WPLS regression vector and offset with respect to λ.
 
WPLS Computation
 
     A variant of the canonical WPLS computation is given in Algorithm 1. This algorithm is different from the usual formulation in that the vectors and W (k) , T (k)  and P (k)  are not normalized; it is simple to show, however, that the resultant vectors W (k) , T (k)  and P (k)  are identical to those produced by the canonical computation, up to scaling. The change in scaling does not affect the resultant regression vector, β, nor does it change the matrix X (k) . 
     
       
         
           
               
             
               
                   
               
               
                 Algorithm 1 Algorithm to compute the WPLS regression vector. 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
            
               
                 Input: m × n matrix and m vector, number of factors, and a diagonal 
               
               
                 object weight matrix. 
               
               
                 Output: The regression vector and offset. 
               
               
                 WPLS (X (o) , y ,l, Γ = diag (λ)) 
               
            
           
           
               
               
               
            
               
                 (1) 
                 T (U)  ← 1. 
                   
               
               
                 (2) 
                 for k = 0 to l 
               
               
                 (3) 
                  t k  ← T (k)     T   ΓT (k) . 
                  (Requires ⊖(m) flops per loop.) 
               
               
                 (4) 
                  P (k)  ← X (k)     T   ΓT (k) /t k . 
                 (Requires ⊖(mn) flops per loop.) 
               
               
                 (5) 
                  q k  ← y T ΓT (k) /t k . 
                  (Requires ⊖(m) flops per loop.) 
               
               
                 (6) 
                  if y T ΓT (k)  = 0 
               
            
           
           
               
               
            
               
                 (7) 
                   Maximum rank achieved; Let l = k and break the for loop. 
               
            
           
           
               
               
               
            
               
                 (8) 
                  if k &lt; l 
                   
               
               
                 (9) 
                   X (k+1)  ← X (k)  − T (k) P (k)     T   . 
                 (Requires ⊖(mn) flops per loop.) 
               
               
                 (10) 
                   W (k+1)  ← X (k+1)     T   Γ y . 
                 (Requires ⊖(mn) flops per loop.) 
               
               
                 (11) 
                   T (k+1)  ← X (k+1) W (k+1) . 
                 (Requires ⊖(mn) flops per loop.) 
               
            
           
           
               
               
            
               
                 (12) 
                 Let W be the matrix with columns W (1,2,...,l) . Similarly define P, q. 
               
               
                 (13) 
                 β ← W (P T W) −1 q. (Requires ⊖(nl) flops, using back substitution.) 
               
               
                 (14) 
                 b 0  ← q 0  → P (0)     T   β. 
               
               
                 (15) 
                 return (β, b 0 ) 
               
               
                   
               
            
           
         
       
     
     As in canonical WPLS, the matrix PTW is bidiagonal upper triangular; however, for this variant, the matrix has unit main diagonal. This variant of the algorithm may be more amenable to a Jacobian computation, although conceivably it could be susceptible to numerical underflow or overflow. 
     A Rank Sensitive Implicit WPLS Algorithm 
     A different way of computing the same results as Algorithm 1 is now presented, but by reusing old computations to compute seemingly unnecessary intermediate quantities which will be useful in the Jacobian computation. Moreover, the Jacobian computation will exploit the assumption that m&lt;&lt;n to gain an asympototic reduction in runtime. This is achieved by performing the computations in the m-dimensional space, that is in the quantities related toy and T (k) , and avoiding the n-dimensional quantities W (k)  and P (k) . 
     The variant algorithm introduces the “preimage” vectors V (k)  and the preimage of the regression coefficient α. “Preimage” means in X (0)     T   ┌, thus, as an invariant, these vectors will satisfy W (k) =X (0)     T   ┌V (k)  and β=X (0)     T   ┌α. The variant algorithm also computes the vectors Q (k) =X (0) X (0)     T   ┌V (k) , and U (k) =Q (k −T (0) T (0)     T   ┌Q (k) /t 0 , and the scalars r k =y T ┌T (k)  and w k =T (k)     1   ┌U (k+1) /t k . 
     Note that any explicit updating of the matrix X (k)  is absent from this version of the algorithm, rather than updating is performed implicitly. This will facilitate the computation of the Jacobian when X (0)  is replaced in the sequel by X (0) ^. The following Lemma 6 confirms that this variant form of the algorithm produces the same results as Algorithm 1, that is the same vectors T and q, consistent vectors V, and produces the same linear model β. 
     Lemma 6.1. Let X (k) , ┌, W (k) , T (k) , P (k) , and q k  be us in Algorithm 1. Let V (k)  be the preimage of W (k) , i.e., V (k)  is a vector such that W (k) =X (0)     T   ┌V (k) . Let Q (k) =X (0) X (0)     T   ┌V (k) , and U (k) =Q (k) −T (0) T (0)     T   ┌Q (k) /t 0  for k≧1. Let r k =y T ┌T (k) , and w k =T (k)     T   U (k+1) /t k  for k≧0. Then the following hold:
 
 P   (k)   =X   (0)     T     ┌T   (k)   /t   k , for k≧0.  1.
 
 w   k   =P   (k)     T     W   (k+1)  for k≧1, and w 0 =0.  2.
 
 T   (k+1)   =U   (k+1)   −w   k   T   (k)  for k≧0.  3.
 
 V   (k+1)   =V   (k)   −q   k T (k)  for k≧0, where V (0) =y by convention.  4.
 
Proof: The Parts of the Lemma:
 
     1. Rewrite X (k) , then use the fact that the T are Γ-orthogonal Lemma 5.1 item 5): 
     
       
         
           
               
             
               
                 
                   
                     
                       P 
                       
                         ( 
                         k 
                         ) 
                       
                     
                     = 
                       
                     ⁢ 
                     
                       
                         X 
                         
                           
                             ( 
                             k 
                             ) 
                           
                           T 
                         
                       
                       ⁢ 
                       Γ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           T 
                           
                             ( 
                             k 
                             ) 
                           
                         
                         / 
                         
                           t 
                           k 
                         
                       
                     
                   
                 
               
               
                 
                   
                     = 
                       
                     ⁢ 
                     
                       
                         
                           ( 
                           
                             
                               X 
                               
                                 ( 
                                 0 
                                 ) 
                               
                             
                             - 
                             
                               
                                 T 
                                 
                                   ( 
                                   0 
                                   ) 
                                 
                               
                               ⁢ 
                               
                                 P 
                                 
                                   
                                     ( 
                                     0 
                                     ) 
                                   
                                   T 
                                 
                               
                             
                             - 
                             … 
                             - 
                             
                               
                                 T 
                                 
                                   ( 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                               ⁢ 
                               
                                 P 
                                 
                                   
                                     ( 
                                     
                                       k 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                   T 
                                 
                               
                             
                           
                           ) 
                         
                         T 
                       
                       ⁢ 
                       Γ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           T 
                           
                             ( 
                             k 
                             ) 
                           
                         
                         / 
                         
                           t 
                           k 
                         
                       
                     
                   
                 
               
               
                 
                   
                     = 
                       
                     ⁢ 
                     
                       
                         ( 
                         
                           
                             X 
                             
                               
                                 ( 
                                 0 
                                 ) 
                               
                               T 
                             
                           
                           - 
                           
                             
                               P 
                               
                                 ( 
                                 0 
                                 ) 
                               
                             
                             ⁢ 
                             
                               T 
                               
                                 
                                   ( 
                                   0 
                                   ) 
                                 
                                 T 
                               
                             
                           
                           - 
                           … 
                           - 
                           
                             
                               P 
                               
                                 ( 
                                 
                                   k 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                             ⁢ 
                             
                               T 
                               
                                 
                                   ( 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 T 
                               
                             
                           
                         
                         ) 
                       
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       Γ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           T 
                           
                             ( 
                             k 
                             ) 
                           
                         
                         / 
                         
                           t 
                           k 
                         
                       
                     
                   
                 
               
               
                 
                   
                     = 
                       
                     ⁢ 
                     
                       
                         X 
                         
                           
                             ( 
                             0 
                             ) 
                           
                           T 
                         
                       
                       ⁢ 
                       Γ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           T 
                           
                             ( 
                             k 
                             ) 
                           
                         
                         / 
                         
                           
                             t 
                             k 
                           
                           . 
                         
                       
                     
                   
                 
               
             
           
         
       
     
     2. By definition, and Γ-orthogonality of the T: 
     
       
         
           
               
             
               
                 
                   
                     
                       w 
                       k 
                     
                     = 
                       
                     ⁢ 
                     
                       
                         T 
                         
                           
                             ( 
                             k 
                             ) 
                           
                           T 
                         
                       
                       ⁢ 
                       Γ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           U 
                           
                             ( 
                             
                               k 
                               + 
                               1 
                             
                             ) 
                           
                         
                         / 
                         
                           t 
                           k 
                         
                       
                     
                   
                 
               
               
                 
                   
                     = 
                       
                     ⁢ 
                     
                       
                         T 
                         
                           
                             ( 
                             k 
                             ) 
                           
                           T 
                         
                       
                       ⁢ 
                       
                         
                           Γ 
                           ⁡ 
                           
                             ( 
                             
                               
                                 Q 
                                 
                                   ( 
                                   
                                     k 
                                     + 
                                     1 
                                   
                                   ) 
                                 
                               
                               - 
                               
                                 
                                   T 
                                   
                                     ( 
                                     0 
                                     ) 
                                   
                                 
                                 ⁢ 
                                 c 
                               
                             
                             ) 
                           
                         
                         / 
                         
                           t 
                           k 
                         
                       
                     
                   
                 
               
               
                 
                   
                     
                       = 
                         
                       ⁢ 
                       
                         
                           T 
                           
                             
                               ( 
                               k 
                               ) 
                             
                             T 
                           
                         
                         ⁢ 
                         Γ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           
                             Q 
                             
                               ( 
                               
                                 k 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                           / 
                           
                             t 
                             k 
                           
                         
                       
                     
                     , 
                   
                 
               
               
                 
                   
                     = 
                       
                     ⁢ 
                     
                       
                         T 
                         
                           
                             ( 
                             k 
                             ) 
                           
                           T 
                         
                       
                       ⁢ 
                       Γ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         X 
                         
                           ( 
                           0 
                           ) 
                         
                       
                       ⁢ 
                       
                         X 
                         
                           
                             ( 
                             0 
                             ) 
                           
                           T 
                         
                       
                       ⁢ 
                       Γ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           V 
                           
                             ( 
                             
                               k 
                               + 
                               1 
                             
                             ) 
                           
                         
                         / 
                         
                           t 
                           k 
                         
                       
                     
                   
                 
               
               
                 
                   
                     = 
                       
                     ⁢ 
                     
                       
                         ( 
                         
                           
                             T 
                             
                               
                                 ( 
                                 k 
                                 ) 
                               
                               T 
                             
                           
                           ⁢ 
                           Γ 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               X 
                               
                                 ( 
                                 0 
                                 ) 
                               
                             
                             / 
                             
                               t 
                               k 
                             
                           
                         
                         ) 
                       
                       ⁢ 
                       
                         ( 
                         
                           
                             X 
                             
                               
                                 ( 
                                 0 
                                 ) 
                               
                               T 
                             
                           
                           ⁢ 
                           Γ 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             V 
                             
                               ( 
                               
                                 k 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   
                     
                       = 
                         
                       ⁢ 
                       
                         
                           P 
                           
                             
                               ( 
                               k 
                               ) 
                             
                             T 
                           
                         
                         ⁢ 
                         
                           W 
                           
                             ( 
                             
                               k 
                               + 
                               1 
                             
                             ) 
                           
                         
                       
                     
                     , 
                     
                       using 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       item 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       1. 
                     
                   
                 
               
             
           
         
       
     
     To show w 0 =0 it suffices to note that U (k)  is chosen to be r-orthogonal to T (0) : T (0)     T   ┌U (k) =T (0)     T   ┌(Q (k) −T (0) T( 0 )   T   ┌Q (k) /t 0 )=T (O)     T   ┌Q (k) −(t 0 /t 0 )T (0)     T   ┌Q (k)    
     3. For k&gt;0, rewrite X (k+1) : 
     
       
         
           
             
               
                 
                   
                     T 
                     
                       ( 
                       
                         k 
                         + 
                         1 
                       
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     
                       X 
                       
                         ( 
                         
                           k 
                           + 
                           1 
                         
                         ) 
                       
                     
                     ⁢ 
                     
                       W 
                       
                         ( 
                         
                           k 
                           + 
                           1 
                         
                         ) 
                       
                     
                   
                 
               
             
             
               
                 
                   
                     = 
                       
                     ⁢ 
                     
                       
                         ( 
                         
                           
                             X 
                             
                               ( 
                               0 
                               ) 
                             
                           
                           - 
                           
                             
                               T 
                               
                                 ( 
                                 0 
                                 ) 
                               
                             
                             ⁢ 
                             
                               P 
                               
                                 
                                   ( 
                                   0 
                                   ) 
                                 
                                 ⊤ 
                               
                             
                           
                           - 
                           … 
                           - 
                           
                             
                               T 
                               
                                 ( 
                                 
                                   k 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                             ⁢ 
                             
                               P 
                               
                                 
                                   ( 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 ⊤ 
                               
                             
                           
                           - 
                           
                             
                               T 
                               
                                 ( 
                                 k 
                                 ) 
                               
                             
                             ⁢ 
                             
                               P 
                               
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                                 ⊤ 
                               
                             
                           
                         
                         ) 
                       
                       ⁢ 
                       
                         W 
                         
                           ( 
                           
                             k 
                             + 
                             1 
                           
                           ) 
                         
                       
                     
                   
                   , 
                 
               
             
             
               
                 
                   
                     = 
                       
                     ⁢ 
                     
                       
                         
                           X 
                           
                             ( 
                             0 
                             ) 
                           
                         
                         ⁢ 
                         
                           W 
                           
                             ( 
                             
                               k 
                               + 
                               1 
                             
                             ) 
                           
                         
                       
                       - 
                       
                         
                           T 
                           
                             ( 
                             0 
                             ) 
                           
                         
                         ⁢ 
                         
                           P 
                           
                             
                               ( 
                               0 
                               ) 
                             
                             ⊤ 
                           
                         
                         ⁢ 
                         
                           W 
                           
                             ( 
                             
                               k 
                               + 
                               1 
                             
                             ) 
                           
                         
                       
                       - 
                       
                         
                           T 
                           
                             ( 
                             k 
                             ) 
                           
                         
                         ⁢ 
                         
                           P 
                           
                             
                               ( 
                               k 
                               ) 
                             
                             ⊤ 
                           
                         
                         ⁢ 
                         
                           W 
                           
                             ( 
                             
                               k 
                               + 
                               1 
                             
                             ) 
                           
                         
                       
                     
                   
                   , 
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     
                       ( 
                       
                         Lemma 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         5.1 
                         ⁢ 
                         
                           
                               
                           
                           ⁢ 
                           
                               
                           
                         
                         ⁢ 
                         item 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         7 
                       
                       ) 
                     
                     , 
                   
                 
               
             
             
               
                 
                   
                     = 
                       
                     ⁢ 
                     
                       
                         Q 
                         
                           ( 
                           
                             k 
                             + 
                             1 
                           
                           ) 
                         
                       
                       - 
                       
                         
                           T 
                           
                             ( 
                             0 
                             ) 
                           
                         
                         ⁢ 
                         
                           T 
                           
                             
                               ( 
                               0 
                               ) 
                             
                             ⊤ 
                           
                         
                         ⁢ 
                         
                           X 
                           
                             ( 
                             0 
                             ) 
                           
                         
                         ⁢ 
                         
                           
                             W 
                             
                               ( 
                               
                                 k 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                           / 
                           
                             t 
                             0 
                           
                         
                       
                       - 
                       
                         
                           T 
                           
                             ( 
                             k 
                             ) 
                           
                         
                         ⁢ 
                         
                           w 
                           k 
                         
                       
                     
                   
                   , 
                   
                     ( 
                     
                       using 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       item 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       2 
                     
                     ) 
                   
                   , 
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       U 
                       
                         ( 
                         
                           k 
                           + 
                           1 
                         
                         ) 
                       
                     
                     - 
                     
                       
                         T 
                         
                           ( 
                           k 
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           w 
                           k 
                         
                         . 
                       
                     
                   
                 
               
             
           
         
       
     
     For k=0, since w 0 =0, it suffices to show T (1) =U (1) . Rewriting X (1) : 
     
       
         
           
             
               
                 
                   
                     T 
                     
                       ( 
                       1 
                       ) 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     
                       X 
                       
                         ( 
                         1 
                         ) 
                       
                     
                     ⁢ 
                     
                       W 
                       
                         ( 
                         1 
                         ) 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       
                         X 
                         
                           ( 
                           0 
                           ) 
                         
                       
                       ⁢ 
                       
                         W 
                         
                           ( 
                           1 
                           ) 
                         
                       
                     
                     - 
                     
                       
                         T 
                         
                           ( 
                           0 
                           ) 
                         
                       
                       ⁢ 
                       
                         P 
                         
                           
                             ( 
                             0 
                             ) 
                           
                           ⊤ 
                         
                       
                       ⁢ 
                       
                         W 
                         
                           ( 
                           1 
                           ) 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       Q 
                       
                         ( 
                         1 
                         ) 
                       
                     
                     - 
                     
                       
                         T 
                         
                           ( 
                           0 
                           ) 
                         
                       
                       ⁢ 
                       
                         T 
                         
                           
                             ( 
                             0 
                             ) 
                           
                           ⊤ 
                         
                       
                       ⁢ 
                       
                         X 
                         
                           ( 
                           0 
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           W 
                           
                             ( 
                             1 
                             ) 
                           
                         
                         / 
                         
                           t 
                           0 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       U 
                       
                         ( 
                         1 
                         ) 
                       
                     
                     . 
                   
                 
               
             
           
         
       
     
     4. First, for k&gt;0, restate item 6 of Lemma 5.1: W (k+1) =W (k) −P (k) T (k)     T   ┌y. Factoring to preimages using item 1 gives V (k+1) =V (k) −T (k) T (k)     T   ┌y/t k . The definition of q k  then gives the result. For k=0, rewrite X (1) : W (1) =(X (0) −T (0) P (0)     T   ) T ┌y−X (0)     T   ┌T (0) T (0) ┌y/t 0 , thus V (1)=y−T   (0) q 0 . 
     For concreteness, the WPLS algorithm is presented via intermediate calculations as Algorithm 2. 
                             Algorithm 2 Algorithm to compute the WPLS regression vector,       with X(k) implicit.                                            Input: Matrix and vector, factors, and diagonal object weight matrix.           Output: The regression vector and offset.             IMPLICIT WPLS(X (0) ,y,l,Γ = diag(γ))                             (1)   M ← l l , the l × l identity matrix.           (2)   Precompute X (0) X (0)     T   Γ.           (3)   T (0)  ← 1, V (0)  ← y.           (4)   for k = 0 to l           (5)    r k  ← y T ΓT (k) .           (6)    if r k  = 0           (7)     Full rank achieved; Let l = k and break the for loop.           (8)    t k  ← T (k)     T   ΓT (k) .           (9)    q k  ← r k /t k .           (10)    if k &lt; l           (11)     V (k+1)  ← V (k)  − q k T (k) .           (12)     Let Q (k+1)  ← (X (0) X (0)     T   Γ) V (k+1) .           (13)     Let U (k+1)  ← Q (k+1)  − T (0) T (0)     T   ΓQ (k+1) /t 0 .           (14)     w k  ← T (k)     T   ΓU (k+1) /t k .           (15)     T (k+1)  ← U (k+1)  − w k T (k) .           (16)     if k &gt; 0           (17)      M k,k+1  ← w k .           (18)   Let V be the matrix with columns V (1,2,...,l) . Similarly define q.           (19)   α ← VM −1 q, β ← X (0)     T   Γα, b 0  ← q 0  → T (0)     T   ΓX (0) β/t 0 .           (20)   return (β, b 0 ).                        
WPLS Computation with Jacobian
 
     Algorithm 2 is amended with derivative computations to create an algorithm that computes the regression coefficient for input X (1) ^, and y (1) , and returns the preimage of the regression vector, α, as well as its Jacobian ∂α/∂λ, and the gradient of the offset, ∇λb 0 . This is given as Algorithm 3 on the following page. In addition to the intermediate quantities used in Algorithm 2, this algorithm also computes some intermediate derivatives, some which need to be stored until the end of the computation. The required derivatives are: 
                 ∂     V     (   k   )           ∂   λ       ,           ∇   λ     ⁢     q   k       ⁢           ⁢   and   ⁢           ⁢       ∇   λ     ⁢     w   k       ⁢           ⁢   for   ⁢           ⁢   k     ≥   1     ,     and   ⁢           ⁢       ∇   λ     ⁢     r   k         ,       ∂     U     (   k   )           ∂   λ       ,     
     ⁢       ∇   λ     ⁢     t   k       ,     and   ⁢             ⁢             ⁢       ∂     T     (   k   )           ∂   λ         ,         
for the most recent k.
 
     Careful inspection and the vector calculus rules outlined above in Section A are all that is required to verify that Algorithm 3 correctly computes the Jacobian of the model B. The only theoretical complication in the transformation of Algorithm 2 to Algorithm 3 is the explicit formulation of the back substitution to compute ν=M −1 q. Given that M is upper triangular, bidiagonal with unit diagonal, inspection reveals that the back substitution in Algorithm 3 is computed correctly. 
     
       
         
           
               
             
               
                 Algorithm 3 
               
             
            
               
                   
               
               
                 Algorithm to compute the WPLS regression vector and Jacobian. 
               
               
                 Input: Predictor and response, factors, object weights and channel weights. 
               
               
                 Output: The preimage of the regression vector and its Jacobian, and the 
               
               
                 offset and its gradient. 
               
               
                   
               
            
           
           
               
            
               
                 
                   
                     
                       
                           
                         
                           
                             
                               
                                 WPLSANDJACOBIAN 
                                 ( 
                                 
                                   
                                     X 
                                     
                                       ( 
                                       1 
                                       ) 
                                     
                                   
                                   , 
                                   y 
                                   , 
                                   l 
                                   , 
                                   γ 
                                   , 
                                   λ 
                                 
                                 ) 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     1 
                                     ) 
                                   
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   Precompute 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     X 
                                     
                                       ( 
                                       0 
                                       ) 
                                     
                                   
                                 
                                 ⁢ 
                                 
                                   ⩓ 
                                   2 
                                 
                                 ⁢ 
                                 
                                   
                                     X 
                                     
                                       
                                         ( 
                                         0 
                                         ) 
                                       
                                       T 
                                     
                                   
                                   ⁢ 
                                   
                                     Γ 
                                     . 
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       2 
                                       ) 
                                     
                                     ⁢ 
                                     
                                       
                                           
                                       
                                       ⁢ 
                                       
                                           
                                       
                                     
                                     ⁢ 
                                     
                                       τ 
                                       
                                         ( 
                                         0 
                                         ) 
                                       
                                     
                                   
                                   ← 
                                   1 
                                 
                                 , 
                                 
                                   
                                     
                                       ∂ 
                                       
                                         τ 
                                         
                                           ( 
                                           0 
                                           ) 
                                         
                                       
                                     
                                     
                                       ∂ 
                                       λ 
                                     
                                   
                                   ← 
                                   0 
                                 
                                 , 
                                 
                                   
                                     V 
                                     
                                       ( 
                                       0 
                                       ) 
                                     
                                   
                                   ← 
                                   y 
                                 
                                 , 
                                 
                                   
                                     
                                       ∂ 
                                       
                                         V 
                                         
                                           ( 
                                           0 
                                           ) 
                                         
                                       
                                     
                                     
                                       ∂ 
                                       λ 
                                     
                                   
                                   ← 
                                   0. 
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     3 
                                     ) 
                                   
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   for 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   k 
                                 
                                 = 
                                 
                                   0 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   to 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   l 
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       4 
                                       ) 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       r 
                                       k 
                                     
                                   
                                   ← 
                                   
                                     
                                       y 
                                       T 
                                     
                                     ⁢ 
                                     
                                       Γτ 
                                       
                                         ( 
                                         k 
                                         ) 
                                       
                                     
                                   
                                 
                                 , 
                                 
                                   
                                     
                                       ∇ 
                                       λ 
                                     
                                     ⁢ 
                                     
                                       r 
                                       k 
                                     
                                   
                                   ← 
                                   
                                     
                                       
                                         ∂ 
                                         
                                           τ 
                                           
                                             ( 
                                             k 
                                             ) 
                                           
                                         
                                       
                                       
                                         ∂ 
                                         λ 
                                       
                                     
                                     ⁢ 
                                     
                                       
                                         
                                             
                                           T 
                                         
                                         ⁢ 
                                         Γy 
                                       
                                       . 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     5 
                                     ) 
                                   
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   if 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     r 
                                     k 
                                   
                                 
                                 = 
                                 0 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     6 
                                     ) 
                                   
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   Full 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   rank 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   achieved 
                                 
                                 ; 
                                 
                                   
                                     Let 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     l 
                                   
                                   = 
                                   
                                     k 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     and 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     break 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     the 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     for 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       loop 
                                       . 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       7 
                                       ) 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       t 
                                       k 
                                     
                                   
                                   ← 
                                   
                                     
                                       T 
                                       
                                         
                                           ( 
                                           k 
                                           ) 
                                         
                                         T 
                                       
                                     
                                     ⁢ 
                                     
                                       ΓT 
                                       
                                         ( 
                                         k 
                                         ) 
                                       
                                     
                                   
                                 
                                 , 
                                 
                                   
                                     
                                       ∇ 
                                       λ 
                                     
                                     ⁢ 
                                     
                                       t 
                                       k 
                                     
                                   
                                   ← 
                                   
                                     2 
                                     ⁢ 
                                     
                                       
                                         ∂ 
                                         
                                           T 
                                           
                                             ( 
                                             k 
                                             ) 
                                           
                                         
                                       
                                       
                                         ∂ 
                                         λ 
                                       
                                     
                                     ⁢ 
                                     
                                       
                                         ΓT 
                                           
                                         
                                           ( 
                                           k 
                                           ) 
                                         
                                           
                                           
                                         T 
                                       
                                       . 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       8 
                                       ) 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       q 
                                       k 
                                     
                                   
                                   ← 
                                   
                                     
                                       r 
                                       k 
                                     
                                     / 
                                     
                                       t 
                                       k 
                                     
                                   
                                 
                                 , 
                                 
                                   
                                     
                                       ∇ 
                                       λ 
                                     
                                     ⁢ 
                                     
                                       q 
                                       k 
                                     
                                   
                                   ← 
                                   
                                     
                                       ( 
                                       
                                         
                                           
                                             t 
                                             k 
                                           
                                           ⁢ 
                                           
                                             
                                               ∇ 
                                               λ 
                                             
                                             ⁢ 
                                             
                                               τ 
                                               k 
                                             
                                           
                                         
                                         - 
                                         
                                           
                                             τ 
                                             k 
                                           
                                           ⁢ 
                                           
                                             
                                               ∇ 
                                               λ 
                                             
                                             ⁢ 
                                             
                                               t 
                                               k 
                                             
                                           
                                         
                                       
                                       ) 
                                     
                                     / 
                                     
                                       
                                         t 
                                         k 
                                         2 
                                       
                                       . 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       9 
                                       ) 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     if 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     k 
                                   
                                   &lt; 
                                   l 
                                 
                                 ⁢ 
                                 
                                     
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     10 
                                     ) 
                                   
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     V 
                                     
                                       ( 
                                       
                                         k 
                                         + 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                                 ← 
                                 
                                   
                                     V 
                                     
                                       ( 
                                       k 
                                       ) 
                                     
                                   
                                   - 
                                   
                                     
                                       q 
                                       k 
                                     
                                     ⁢ 
                                     
                                       T 
                                       
                                         ( 
                                         k 
                                         ) 
                                       
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       ∂ 
                                       
                                         V 
                                         
                                           ( 
                                           
                                             k 
                                             + 
                                             1 
                                           
                                           ) 
                                         
                                       
                                     
                                     
                                       ∂ 
                                       λ 
                                     
                                   
                                   ← 
                                   
                                     
                                       
                                         ∂ 
                                         
                                           V 
                                           
                                             ( 
                                             k 
                                             ) 
                                           
                                         
                                       
                                       
                                         ∂ 
                                         λ 
                                       
                                     
                                     - 
                                     
                                       
                                         q 
                                         k 
                                       
                                       ⁢ 
                                       
                                         
                                           ∂ 
                                           
                                             T 
                                             
                                               ( 
                                               k 
                                               ) 
                                             
                                           
                                         
                                         
                                           ∂ 
                                           λ 
                                         
                                       
                                     
                                     - 
                                     
                                       
                                         T 
                                         
                                           ( 
                                           k 
                                           ) 
                                         
                                       
                                       ⁢ 
                                       
                                         
                                           
                                             ∇ 
                                             λ 
                                           
                                           ⁢ 
                                           
                                             q 
                                             k 
                                             T 
                                           
                                         
                                         . 
                                       
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       11 
                                       ) 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     Let 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       Q 
                                       
                                         ( 
                                         
                                           k 
                                           + 
                                           1 
                                         
                                         ) 
                                       
                                     
                                   
                                   ← 
                                   
                                     
                                       ( 
                                       
                                         
                                           X 
                                           
                                             ( 
                                             0 
                                             ) 
                                           
                                         
                                         ⁢ 
                                         
                                           ⩓ 
                                           2 
                                         
                                         ⁢ 
                                         
                                           
                                             X 
                                             
                                               
                                                 ( 
                                                 0 
                                                 ) 
                                               
                                               T 
                                             
                                           
                                           ⁢ 
                                           Γ 
                                         
                                       
                                       ) 
                                     
                                     ⁢ 
                                     
                                       V 
                                       
                                         ( 
                                         
                                           k 
                                           + 
                                           1 
                                         
                                         ) 
                                       
                                     
                                   
                                 
                                 , 
                               
                             
                           
                           
                             
                               
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       
                                         ∂ 
                                         
                                           Q 
                                           
                                             ( 
                                             
                                               k 
                                               + 
                                               1 
                                             
                                             ) 
                                           
                                         
                                       
                                       
                                         ∂ 
                                         λ 
                                       
                                     
                                     ← 
                                     
                                       X 
                                       
                                         ( 
                                         0 
                                         ) 
                                       
                                     
                                   
                                   ⁢ 
                                   
                                     ⩓ 
                                     2 
                                   
                                   ⁢ 
                                   
                                     
                                       
                                         X 
                                         
                                           
                                             ( 
                                             0 
                                             ) 
                                           
                                           T 
                                         
                                       
                                       ⁢ 
                                       Γ 
                                       ⁢ 
                                       
                                         
                                           ∂ 
                                           
                                             V 
                                             
                                               ( 
                                               
                                                 k 
                                                 + 
                                                 1 
                                               
                                               ) 
                                             
                                           
                                         
                                         
                                           ∂ 
                                           λ 
                                         
                                       
                                     
                                     + 
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     2 
                                     ⁢ 
                                     
                                       X 
                                       
                                         ( 
                                         0 
                                         ) 
                                       
                                     
                                   
                                   ⩓ 
                                   
                                     diag 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       
                                         ( 
                                         
                                           
                                             X 
                                             
                                               
                                                 ( 
                                                 0 
                                                 ) 
                                               
                                               T 
                                             
                                           
                                           ⁢ 
                                           
                                             
                                               Γ 
                                               ⁢ 
                                               V 
                                             
                                             
                                               ( 
                                               
                                                 k 
                                                 + 
                                                 1 
                                               
                                               ) 
                                             
                                           
                                         
                                         ) 
                                       
                                       . 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       12 
                                       ) 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     Let 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       U 
                                       
                                         ( 
                                         
                                           k 
                                           + 
                                           1 
                                         
                                         ) 
                                       
                                     
                                   
                                   ← 
                                   
                                     
                                       Q 
                                       
                                         ( 
                                         
                                           k 
                                           + 
                                           1 
                                         
                                         ) 
                                       
                                     
                                     - 
                                     
                                       
                                         T 
                                         
                                           ( 
                                           0 
                                           ) 
                                         
                                       
                                       ⁢ 
                                       
                                         T 
                                         
                                           
                                             ( 
                                             0 
                                             ) 
                                           
                                           T 
                                         
                                       
                                       ⁢ 
                                       
                                         
                                           ΓQ 
                                           
                                             ( 
                                             
                                               k 
                                               + 
                                               1 
                                             
                                             ) 
                                           
                                         
                                         / 
                                         
                                           t 
                                           0 
                                         
                                       
                                     
                                   
                                 
                                 , 
                               
                             
                           
                           
                             
                               
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       
                                         ∂ 
                                         
                                           U 
                                           
                                             ( 
                                             
                                               k 
                                               + 
                                               1 
                                             
                                             ) 
                                           
                                         
                                       
                                       
                                         ∂ 
                                         λ 
                                       
                                     
                                     ← 
                                     
                                       
                                         
                                           ∂ 
                                           
                                             Q 
                                             
                                               ( 
                                               
                                                 k 
                                                 + 
                                                 1 
                                               
                                               ) 
                                             
                                           
                                         
                                         
                                           ∂ 
                                           λ 
                                         
                                       
                                       - 
                                       
                                         
                                           T 
                                           
                                             ( 
                                             0 
                                             ) 
                                           
                                         
                                         ⁢ 
                                         
                                           T 
                                           
                                             
                                               ( 
                                               0 
                                               ) 
                                             
                                             T 
                                           
                                         
                                         ⁢ 
                                         Γ 
                                         ⁢ 
                                         
                                           
                                             
                                               ∂ 
                                               
                                                 Q 
                                                 
                                                   ( 
                                                   
                                                     k 
                                                     + 
                                                     1 
                                                   
                                                   ) 
                                                 
                                               
                                             
                                             
                                               ∂ 
                                               λ 
                                             
                                           
                                           / 
                                           
                                             t 
                                             0 
                                           
                                         
                                       
                                     
                                   
                                   , 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   
                     
                       
                           
                         
                             
                         
                         ⁢ 
                         
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       13 
                                       ) 
                                     
                                     ⁢ 
                                     
                                       
                                           
                                       
                                       ⁢ 
                                       
                                           
                                       
                                     
                                     ⁢ 
                                     
                                       w 
                                       k 
                                     
                                   
                                   ← 
                                   
                                     
                                       T 
                                       
                                         
                                           ( 
                                           k 
                                           ) 
                                         
                                         T 
                                       
                                     
                                     ⁢ 
                                     
                                       
                                         ΓU 
                                         
                                           ( 
                                           
                                             k 
                                             + 
                                             1 
                                           
                                           ) 
                                         
                                       
                                       / 
                                       
                                         t 
                                         k 
                                       
                                     
                                   
                                 
                                 , 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ∇ 
                                     λ 
                                   
                                   ⁢ 
                                   
                                     w 
                                     k 
                                   
                                 
                                 ← 
                                 
                                   
                                     ( 
                                     
                                       
                                         
                                           
                                             ∂ 
                                             
                                               T 
                                               
                                                 
                                                   ( 
                                                   k 
                                                   ) 
                                                 
                                                 T 
                                               
                                             
                                           
                                           
                                             ∂ 
                                             λ 
                                           
                                         
                                         ⁢ 
                                         
                                           ΓU 
                                           
                                             ( 
                                             
                                               k 
                                               + 
                                               1 
                                             
                                             ) 
                                           
                                         
                                       
                                       + 
                                       
                                         
                                           
                                             ∂ 
                                             
                                               U 
                                               
                                                 
                                                   ( 
                                                   
                                                     k 
                                                     + 
                                                     1 
                                                   
                                                   ) 
                                                 
                                                 T 
                                               
                                             
                                           
                                           
                                             ∂ 
                                             λ 
                                           
                                         
                                         ⁢ 
                                         
                                           ΓT 
                                           
                                             ( 
                                             k 
                                             ) 
                                           
                                         
                                       
                                       - 
                                       
                                         
                                           w 
                                           k 
                                         
                                         ⁢ 
                                         
                                           
                                             ∇ 
                                             λ 
                                           
                                           ⁢ 
                                           
                                             t 
                                             k 
                                           
                                         
                                       
                                     
                                     ) 
                                   
                                   / 
                                   
                                     
                                       t 
                                       k 
                                     
                                     . 
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     14 
                                     ) 
                                   
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     T 
                                     
                                       ( 
                                       
                                         k 
                                         + 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                                 ← 
                                 
                                   
                                     U 
                                     
                                       ( 
                                       
                                         k 
                                         + 
                                         1 
                                       
                                       ) 
                                     
                                   
                                   - 
                                   
                                     
                                       w 
                                       k 
                                     
                                     ⁢ 
                                     
                                       T 
                                       
                                         ( 
                                         k 
                                         ) 
                                       
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       
                                         ∂ 
                                         
                                           T 
                                           
                                             ( 
                                             
                                               k 
                                               + 
                                               1 
                                             
                                             ) 
                                           
                                         
                                       
                                       
                                         ∂ 
                                         λ 
                                       
                                     
                                     ← 
                                     
                                       
                                         
                                           ∂ 
                                           
                                             U 
                                             
                                               ( 
                                               
                                                 k 
                                                 + 
                                                 1 
                                               
                                               ) 
                                             
                                           
                                         
                                         
                                           ∂ 
                                           λ 
                                         
                                       
                                       - 
                                       
                                         
                                           w 
                                           k 
                                         
                                         ⁢ 
                                         
                                           
                                             ∂ 
                                             
                                               T 
                                               
                                                 ( 
                                                 k 
                                                 ) 
                                               
                                             
                                           
                                           
                                             ∂ 
                                             λ 
                                           
                                         
                                       
                                       - 
                                       
                                         
                                           T 
                                           
                                             ( 
                                             k 
                                             ) 
                                           
                                         
                                         ⁢ 
                                         
                                           
                                             ∇ 
                                             λ 
                                           
                                           ⁢ 
                                           
                                             w 
                                             k 
                                             T 
                                           
                                         
                                       
                                     
                                   
                                   , 
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       15 
                                       ) 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     Let 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       v 
                                       l 
                                     
                                   
                                   ← 
                                   
                                     q 
                                     l 
                                   
                                 
                                 , 
                                 
                                   
                                     
                                       ∇ 
                                       λ 
                                     
                                     ⁢ 
                                     
                                       v 
                                       l 
                                     
                                   
                                   ← 
                                   
                                     
                                       
                                         ∇ 
                                         λ 
                                       
                                       ⁢ 
                                       
                                         q 
                                         l 
                                       
                                     
                                     . 
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     16 
                                     ) 
                                   
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   for 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   j 
                                 
                                 = 
                                 
                                   l 
                                   - 
                                   
                                     1 
                                     ⁢ 
                                     
                                       
                                           
                                       
                                       ⁢ 
                                       
                                           
                                       
                                     
                                     ⁢ 
                                     to 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     1 
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       17 
                                       ) 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       v 
                                       j 
                                     
                                   
                                   ← 
                                   
                                     
                                       q 
                                       j 
                                     
                                     - 
                                     
                                       
                                         w 
                                         j 
                                       
                                       ⁢ 
                                       
                                         v 
                                         
                                           j 
                                           + 
                                           1 
                                         
                                       
                                     
                                   
                                 
                                 , 
                               
                             
                           
                           
                             
                               
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       ∇ 
                                       λ 
                                     
                                     ⁢ 
                                     
                                       v 
                                       j 
                                     
                                   
                                   ← 
                                   
                                     
                                       
                                         ∇ 
                                         λ 
                                       
                                       ⁢ 
                                       
                                         q 
                                         j 
                                       
                                     
                                     - 
                                     
                                       
                                         w 
                                         j 
                                       
                                       ⁢ 
                                       
                                         
                                           ∇ 
                                           λ 
                                         
                                         ⁢ 
                                         
                                           v 
                                           
                                             j 
                                             + 
                                             1 
                                           
                                         
                                       
                                     
                                     - 
                                     
                                       
                                         v 
                                         
                                           j 
                                           + 
                                           1 
                                         
                                       
                                       ⁢ 
                                       
                                         
                                           
                                             ∇ 
                                             λ 
                                           
                                           ⁢ 
                                           
                                             w 
                                             j 
                                           
                                         
                                         . 
                                       
                                     
                                   
                                 
                                 ⁢ 
                                 
                                     
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       18 
                                       ) 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     α 
                                   
                                   ← 
                                   Vv 
                                 
                                 , 
                                 
                                   
                                     
                                       ∂ 
                                       α 
                                     
                                     
                                       ∂ 
                                       λ 
                                     
                                   
                                   ← 
                                   
                                     V 
                                     ⁢ 
                                     
                                       
                                         
                                           ∂ 
                                           v 
                                         
                                         
                                           ∂ 
                                           λ 
                                         
                                       
                                       . 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     19 
                                     ) 
                                   
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   for 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   j 
                                 
                                 = 
                                 
                                   1 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   to 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   l 
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     20 
                                     ) 
                                   
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     
                                       ∂ 
                                       α 
                                     
                                     
                                       ∂ 
                                       λ 
                                     
                                   
                                 
                                 ← 
                                 
                                   
                                     
                                       ∂ 
                                       α 
                                     
                                     
                                       ∂ 
                                       λ 
                                     
                                   
                                   + 
                                   
                                     
                                       v 
                                       j 
                                     
                                     ⁢ 
                                     
                                       
                                         
                                           ∂ 
                                           
                                             V 
                                             
                                               ( 
                                               j 
                                               ) 
                                             
                                           
                                         
                                         
                                           ∂ 
                                           λ 
                                         
                                       
                                       . 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     
                                       ( 
                                       21 
                                       ) 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       b 
                                       0 
                                     
                                   
                                   ← 
                                   
                                     
                                       T 
                                       
                                         
                                           ( 
                                           0 
                                           ) 
                                         
                                         T 
                                       
                                     
                                     ⁢ 
                                     
                                       
                                         Γ 
                                         ⁡ 
                                         
                                           ( 
                                           
                                             
                                               y 
                                               - 
                                               
                                                 X 
                                                 
                                                   ( 
                                                   0 
                                                   ) 
                                                 
                                               
                                             
                                             ⁢ 
                                             
                                               ⩓ 
                                               2 
                                             
                                             ⁢ 
                                             
                                               
                                                 X 
                                                 
                                                   
                                                     ( 
                                                     0 
                                                     ) 
                                                   
                                                   T 
                                                 
                                               
                                               ⁢ 
                                               Γα 
                                             
                                           
                                           ) 
                                         
                                       
                                       / 
                                       
                                         t 
                                         0 
                                       
                                     
                                   
                                 
                                 , 
                               
                             
                           
                           
                             
                               
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     
                                       
                                         θ 
                                         ⁢ 
                                         b 
                                       
                                       0 
                                     
                                     
                                       ∂ 
                                       λ 
                                     
                                   
                                   ← 
                                   
                                     
                                       - 
                                       
                                         
                                           ( 
                                           
                                             
                                               X 
                                               
                                                 ( 
                                                 0 
                                                 ) 
                                               
                                             
                                             ⁢ 
                                             
                                               ⩓ 
                                               2 
                                             
                                             ⁢ 
                                             
                                               
                                                 
                                                   X 
                                                   
                                                     
                                                       ( 
                                                       0 
                                                       ) 
                                                     
                                                     T 
                                                   
                                                 
                                                 ⁢ 
                                                 Γ 
                                                 ⁢ 
                                                 
                                                   
                                                     ∂ 
                                                     α 
                                                   
                                                   
                                                     ∂ 
                                                     λ 
                                                   
                                                 
                                               
                                               + 
                                               
                                                 2 
                                                 ⁢ 
                                                 
                                                   X 
                                                   
                                                     ( 
                                                     0 
                                                     ) 
                                                   
                                                 
                                               
                                             
                                             ⩓ 
                                             
                                               diag 
                                               ⁢ 
                                               
                                                   
                                               
                                               ⁢ 
                                               
                                                 ( 
                                                 
                                                   
                                                     X 
                                                     
                                                       
                                                         ( 
                                                         0 
                                                         ) 
                                                       
                                                       T 
                                                     
                                                   
                                                   ⁢ 
                                                   Γα 
                                                 
                                                 ) 
                                               
                                             
                                           
                                           ) 
                                         
                                         T 
                                       
                                     
                                     ⁢ 
                                     
                                       
                                         ΓT 
                                         
                                           ( 
                                           0 
                                           ) 
                                         
                                       
                                       / 
                                       
                                         
                                           t 
                                           0 
                                         
                                         . 
                                       
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   ( 
                                   22 
                                   ) 
                                 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 return 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     ( 
                                     
                                       α 
                                       , 
                                       
                                         
                                           ∂ 
                                           α 
                                         
                                         
                                           ∂ 
                                           λ 
                                         
                                       
                                       , 
                                       
                                         b 
                                         0 
                                       
                                       , 
                                       
                                         
                                           ∇ 
                                           λ 
                                         
                                         ⁢ 
                                         
                                           b 
                                           0 
                                         
                                       
                                     
                                     ) 
                                   
                                   . 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                   
               
            
           
         
       
     
     Inspection of Algorithm 1 reveals that WPLS computation requires Θ (mnl) floating point operations where X (1)  is m×n, and 1 is the ultimate number of factors used. Thus, a numerical approximation to the Jacobian using n evaluations of Algorithm 1 gives an algorithm with asymptotic runtime of Θ (mn 2 l). Inspection of Algorithm 3 reveals that it computes the Jacobian exactly in Θ (m 2 nl). The runtime limiting operation is the multiplication 
             (       X     (   0   )       ⁢     ⩓   2     ⁢       X       (   0   )     ⊤       ⁢     ⌈   )     ⁢       ∂     V     (     k   +   1     )           ∂   λ                 
in the calculation of
 
                 ∂     U     (     k   +   1     )           ∂   λ       ,   ,         
with runtime of a Θ (m 2 n) per loop.
 
     It would appear that one would incur a further cost of Θ (mn 2 ) in the conversion of 
                   ∂   α       ∂   λ       ⁢           ⁢   to   ⁢           ⁢       ∂   β       ∂   λ         ,         
as it requires the multiplication
 
             ⩓       X       (   1   )     ⊤       ⁢     ⌈         ∂   α       ∂   λ       .               
However, this can be avoided if the ultimate goal is computation of the Jacobian of the residual, rather than the Jacobian of the regression coefficients. Referring back to equation 3, we have
 
                     ∂   ɛ       ∂   λ       +       1   tst     ⁢       ∇   λ     ⁢     b   0   ⊤           =     -       X   tst     ⁡     (         diag   ⁡     (     β   ⁡     (   λ   )       )       +     ⩓       ∂     β   ⁡     (   λ   )           ∂   λ         )           ,     =     -       X   tst     (       diag   (     ⩓         X   cal   ⊤     ⁢     ⌈     α   ⁡     (   λ   )       )       +     ⩓       ∂     ⩓       X   cal   ⊤     ⁢     ⌈     α   ⁡     (   λ   )                 ∂   λ         )     ,     =     -       X   tst     (     diag   (     ⩓         X   cal   ⊤     ⁢     ⌈     α   ⁡     (   λ   )       )       +     ⩓     diag   (             X   cal   ⊤     ⁢     ⌈     α   ⁡     (   λ   )       )       +     ⁢     ⩓   2     ⁢       X   cal   ⊤     ⁢     ⌈       ∂     α   ⁡     (   λ   )           ∂   λ       )         ,     =       -   2     ⁢     X   tst     ⁢     diag   (     ⩓         X   cal   ⊤     ⁢     ⌈     α   ⁡     (   λ   )       )       -       (       X   tst     ⁢     ⩓   2     ⁢     X   cal   ⊤       )     ⁢     ⌈         ∂     α   ⁡     (   λ   )           ∂   λ       .                                               
Letting m t  be the number of objects in the calibration object, the multiplication X tst     2 X cal   T  requires O (mm t n) flops, and the multiplication
 
               (       X   tst     ⁢     ⩓   2     ⁢     X   cal   ⊤       )     ⁢     ⌈       ∂     α   ⁡     (   λ   )           ∂   λ               
also requires O (mm t n) flops, Thus, the computation of
 
               ∂   ε       ∂   λ           
can be done with O (mm t n+m 2 nl) flops, which is linear in n.
 
     For concreteness, the residual computation with analytic Jacobian was coded and compared for accuracy and speed against a “slow” analytic version (one which does not exploit the reduced rank in the Jacobian computation) and a numerical approximation to the Jacobian. Run times are compared in  FIG. 4  for varying number of channels. The difference in asympototic behavior with respect to n is evident. Specifically, referring to  FIG. 4 , run times of the fast analytical computation of the Jacobian (markers  150 ) of the residual are compared against a slow analytic (markers  152 ) and a numerical approximation (markers  154 ). The number of channels, n is shown in the horizontal axis, while the vertical axis is CPU time in seconds. The number of objects in the calibration and test groups remained constant, at 40 and 10 throughout, as did the number of PLS factors, 5. Times are the mean of seven runs, and single standard deviation bars are plotted, although they are mostly too small to see. For the case of 40 calibration objects and 10 test objects generated randomly with 2000 channels, the fast analytic computation of residual Jacobian took about 1.7 seconds, the slow analytic took about 44 seconds, and the numeric approximation took about 84 seconds on the platform tested (see Section 11 for details). Note that the “slow” analytic version is actually preferred in the case that m&gt;n, as it runs in time Θ (mn 2 l). However, in spectroscopy it is usually the case that m&lt;n. 
     The BFGS Algorithm 
     The Boyden, Fletcher, Goldfarb and Shanno (BFGS) algorithm 3 is a quasi-Newton optimization algorithm. That is, the algorithm models a scalar function of many variables by a quadratic function with an approximate Hessian. The approximation to the Hessian is improved at each step by two rank one up-dates. The BFGS algorithm enjoys a number of properties which make it attractive to the numerical analyst: provable superlinear global convergence for some convex optimization problems; provable superlinear local convergence for some nonconvex problems; robustness and good performance in practice; deterministic formulation; relative simplicity of implementation; and, perhaps most importantly to the practical analyst, the algorithm has been implemented in a number of widely available libraries and packages, many of which accept the objective function as a blackbox. 
     The BFGS algorithm is an iterative solver. That is, it starts with some initial estimate of a good λ, say λ (0) , and produces successive estimates, λ (k) , which are supposed to converge to a local minimizer of the objective function. Each iteration consists of a computation of the gradient of the objective at λ (k) . The algorithm constructs a search direction, call it p (k) , by multiplying the inverse approximate Hessian by the negative gradient. Then a line search is performed to find an acceptable step in the search direction, that is to find the α (k)  used to construct λ (k+1) =λ (k) +α (k) ρ (k) . In the backtracking algorithm used to perform line search described by Nocedal and Wright, a number of prospective values of α (k)  may be tested; the objective function must be computed for each prospective value, but the gradient need not be computed. [Algorithm 3.1] A fast implementation of the BFGS algorithm should not query the blackbox function for gradients during the backtracking phase. 
     As mentioned above, the BFGS requires some initial estimate of the Hessian of the objective function. When a good initial estimate of the Hessian is impractical, the practical analyst resorts to the identity matrix. Under this choice, the first search direction is the negative gradient, i.e., the direction of steepest descent. The BFGS constructs better estimates of the Hessian by local measurement of the curvature of the objective function. 
     Depending on the implementation, the BFGS algorithm may have to store the approximate Hessian of the objective function or the inverse approximate Hessian. In either case, the storage requirement is Ω(n 2 ). To avoid this, one can use the limited memory BFGS algorithm, which approximately the Hessian by a fixed number of the previous iterative updates, which avoids the need for quadratic storage. This method evidently works as well as BFGS in practice for many problems. 
     Selecting Wavelengths from an Optimal λ 
     Once a predictor weighting λ has been found which gives a small RMSECV, the λ is used to select a subset of the channels. That is, the embedding is reversed to find a subset of the channels in the discrete space of all such subsets which approximates the continuous solution given by λ. Without loss of generality, it may be assumed that λ has unit norm, i.e., ∥λ∥ 2 =1, since the effective WPLS regression vector is invariant under scaling, i.e., c β(cλ) is constant for all nonzero values of c. This latter fact is proved by considering the output of the canonical WPLS algorithm, which normalizes the vectors W (k)  and T (k) . Moreover, the elements of λ are assumed to be nonnegative, again without loss of generality. 
     Clearly, the weightings of the channels somehow signify their importance, and can be used in the selection of a subset of the channels. The ordering in significance indicated by λ suggests n different possible choices of subsets 4, the k th  of which is the subset with the k most significant channels. If the acceptable number of channels is bounded by an external restriction, say an upper bound of n f , then one should select the subset of the n f  most significant channels. Without any external restrictions, one should select the subset of channels (or “model”) which minimizes some measure of predictive quality, such as RMSECV or an information criterion like Schwarz&#39; Bayesian Information Criterion (BIC). 
     The asymptotic (in m) consistency of model selection criteria was examined by others. A number of differences exist between the formulation previously studied and that presented here: the present design matrix is assumed to be of reduced rank (i.e., equation 1 describes a reduced rank matrix) and nondeterministic (which previous work dismissed by simply stating that results would hold under almost any circumstance); the present linear model is built by PLS rather than OLS. However, absent any extant results for the reduced rank formulation, the present technique follows previous work set forth in Jun Shao&#39;s “Linear Model Selection by Cross-Validation,”  Journal of the American Statistical Association,  88(422):486-494 (June 1993) and “An Asymptotic Theory for Linear Model Selection,”  Statistica Sinica,  7:221-264 (1997), both of which are herein incorporated by reference in their entirety. 
     Specifically, Shao discloses twvo model comparison criteria: delete-d CV, and BIC. Delete-d CV is regular cross validation with d objects in the validation set. The model which minimizes RMSECV under the given grouping is selected. Because (md) can be very large, only a number of the possible CV groupings are used. Shao&#39;s study suggests that Monte Carlo selection of the DV groups can be effective only O (m) of the possible groupings used. Note also that Shao proves that d/m→1 is a prerequisite for asymptotic consistency. In the simulation study, d≈m−m 3/4  was used, and found to outperform delete-1 CV, especially in those tests where selecting overly large models is possible. 
     Shao also examined a class of model selection criteria which contains the General Information Criterion described in Rao and Wut&#39;s “A Strongly Consistent Procedure for Model Selection in a Regression Problem,”  Biometrika,  76(2):369-374 (1989), which is incorporated herein by reference in its entirety, the minimization of which, under certain assumptions, is equivalent to minimizing BIC. For a subset of k predictors, the reduced rank form of the criterion is 
               BIC   =       ln   ⁢           ⁢   MSEP     +         log   ⁢           ⁢   m       m   -   l   -   1       ⁢   k         ,         
where MSEP is based on the given set of k predictors and 1 factor PLS. The denominator term m−l−1 is used rather than m−k as suggested by Shao for the OLS formulation, based on a simulation study. This allows meaningful comparison in situations where k&gt;m, although in this case the expected value of MSEP is penalized by a term quadratic in k/m. To continue the mongrelization of this criterion, it may be useful to replace MSEP by MSECV for appropriately chosen CV groups:
 
             aBIC   =       ln   ⁢           ⁢   MSECV     +         log   ⁢           ⁢   m       m   -   l   -   1       ⁢     k   .               
Minimization of this criterion favors parsimony more than minimization of RMSECV alone. Until the asymptotic consistency of the reduced rank/PLS model selection problem is addressed theoretically, one criteria is not recommend over the other.
 
     It is not obvious that the magnitudes of the elements of λ are sufficient to establish an importance ordering on the channels. For instance, it might be appropriate to multiply the elements of λ by the corresponding element of the linear model β chosen by WPLS on the entire data set, and use that Kronecker product vector as the importance ordering. As there seems to be no general trend in comparing the two methods, both techniques may be implemented and subsequently the information criterion may select whichever model is best, irrespective of which pragma produced the ordering. 
     Crafting an Objective Function 
     The ultimate goal is selection of a subset of the predictors which minimizes delete-d RMSECV or one or the information criteria. This should guide the choice of the objective function which we numerically minimize in the continuous framework. The obvious choice is to minimize RMSECV, however; the choice of the CV groups can lead to an asymptotically inconsistent selection procedure or long runtime. Moreover, the minimization of RMSECV may also select a en with a large number of nontrivial elements, which makes reversing the embedding difficult or noninformative. 
     Thus, one may choose to minimize an objective function which approximates one of the information criteria, balancing quality and parsimony, rather than minimizing RMSECV. Recall, for example, aBIC=ln MSECV+(k log m)/(m−l−1). The continuous embedding of the MSECV term with respect to λ is understood. To complete the embedding it only remains to estimate the subset size (number of predictors retained) of the model indicated by a continuous predictor weighting λ. A ratio of the p-norm to the q-norm may be used: 
     
       
         
           
             
               
                 
                   κ 
                   
                     p 
                     , 
                     q 
                   
                 
                 ⁡ 
                 
                   ( 
                   λ 
                   ) 
                 
               
               = 
               
                 
                   ( 
                   
                     
                       
                          
                         λ 
                          
                       
                       p 
                     
                     
                       
                          
                         λ 
                          
                       
                       q 
                     
                   
                   ) 
                 
                 
                   pq 
                   / 
                   
                     ( 
                     
                       q 
                       - 
                       p 
                     
                     ) 
                   
                 
               
             
             , 
             
               
 
             
             ⁢ 
             
               
                 where 
                 ⁢ 
                 
                   
 
                 
                 ⁢ 
                 
                   
                      
                     λ 
                      
                   
                   p 
                 
               
               = 
               
                 
                   ( 
                   
                     
                       ∑ 
                       j 
                     
                     ⁢ 
                     
                       
                          
                         
                           λ 
                           j 
                         
                          
                       
                       p 
                     
                   
                   ) 
                 
                 
                   1 
                   / 
                   p 
                 
               
             
             , 
           
         
       
     
     For 1≦p&lt;q&lt;∞ An appropriate choice of model size estimate may be κ p,q (λ). Note that K p,q  is scale invariant, that is, κ p,q (λ) is constant for each nonzero choice of the scalar C. Also note that if λ consists of j ones and n−j zeros, then κ p,q (λ)=j.  FIG. 5  illustrates the behavior of this function for various values of p,q. Specifically, the function κ p,q (λ) is plotted in polar coordinates for the two dimensional vector λ=(cos θ, sin θ), and various values of p,q in the quadrant 0≦θ≦π/2. Note that each of the plots passes through (0,1), (π/4,2) and (π/2,1), as guaranteed by the fact that K p,q  measures the number of nonzero elements in a scaled binary vector. Using smaller values of p,q creates a stronger drive towards binary vectors by penalizing non binary vectors. This function is ad-hoc and, as such, there may be a more statistically valid substitute. However, it may be well approximated by a K p,q  function. 
     Thus, to approximately minimize BIC, φ(λ)= df  ln(MSECV(λ))+(ln(m)κ p,q (λ))/(m−l−1), may be minimized, the gradient of which is 
                 ∇   λ     ⁢     ψ   ⁡     (   λ   )         =           Δ   λ     ⁢     MSECV   ⁡     (   λ   )           MSECV   ⁡     (   λ   )         +       (       ln   ⁡     (   m   )       ⁢       ∇   λ     ⁢       k     p   ,   q       ⁡     (   λ   )           )     /       (     m   -   l   -   1     )     .               
Implementation Notes
 
     The method was implemented in the Matlab™ language. All results set forth herein were performed in the GPL Matlab clone, GNU Octave (version 2.1.69), compiled with BLAS, on an AMD Athlon 64 4000+ (2.4 GHz) running Gentoo Linux, 2.6.15 kernel. 
     The BFGS and backtracking line search algorithms were implemented as outlined by Nocedal and Wright in  Numerical Optimization , Springer Series in Operations research, Springer-Verlag, New York, N.Y. (1999), which is incorporated herein by reference in its entirety. The objective function was supplemented by an optional term to simulate BIC, with the p and q terms of K p,q  tunable parameters. The inverse of the sample standard deviation of each channel is generally used as the starting iterate, λ (0) . The initial approximation to the Hessian is taken as some constant times the identity matrix. Termination of BFGS was triggered by the computation of a gradient smaller in norm than a lower bound, by an upper limit on the number of major iterates, function evaluations, or achievement of a lower bound on the change of the objective function. Object weighting (i.e., WPLS) has not yet been implemented. 
     Selection of optimal wavelengths was performed by minimization of a delete-d RMSECV or a BIC, with the different models determined by ordering of λ or by diag (β)λ, whichever is chosen by the information criterion. The trivial model (responses are normal with approximated means and variances and predictors are ignored) is also compared. An optional post-selection minimization is allowed on the selected channels. The final results consist of a subset of the available channels and predictor weightings for those channels. This bit of cheating allows the method to keep the advantages of properly weighted channels. Note that the weighting is irrelevant and ignored in the case where the number of selected channels is equal to the number of latent factors. 
     Unless specified by the user, the system must choose the cross validation groups. By default, this is done using the Monte Carlo framework suggested by Shao: 2m different partitions of m 3/4  calibration objects and m-m 3/4  test objects are randomly selected. 
     Experiments and Results 
     SRCEK was tested on the three data sets used to compare wavelength selection procedures by Forina et al. As in the original publication, these are referred to as Moisture, Kalivas, and Artificial. The data set Moisture consists of moisture responses of 60 samples of soy flour, with predictors measured with a filter instrument and originally appeared in Forina et al. “Transfer of Calibration Function in Near-Infrared Spectroscopy,”  Chemometrics and Intelligent Laboratory Systems,  27(2):189-203, which is incorporated herein in its entirety by reference. The data set of Kalivas, originally from a paper by Kalivas (“Two Data Sets of Near Infrared Spectra,”  Chemometrics and Intelligent Laboratory System,  37(2):255-259), which is incorporated herein by reference in its entirety, consists of moisture responses of 100 samples of wheat flour, with 701 responses measured by an NIR spectrometer. The data set Artificial consists of 400 randomly generated objects with 300 predictors. The predictors are grouped into six classes, with a high degree of correlation between elements of the first five classes, each consisting of 10 channels. The response was generated by a linear combination of five of the responses (the first response in each of the first five classes), plus some noise; the 250 predictors of the sixth class are entirely irrelevant to the responses. However, the level of noise in the response is large enough to mask the effects of the fifth relevant predictor. The objects are divided into a training set of 100 objects, and an external set with the remainder. 
     In order to allow meaningful comparisons between the results found here and in the study of Forina et al., RMSECV values using the same CV groupings of that study were used. These were generated by dividing the objects into groups in their given order. Thus, e.g., the first group consists of the 1 st , 6 th , 11 th  objects and so on, the second group is the 2 nd , 7 th , 12 th  objects and so on, etc., for a total of five groups. However, the objective function was computed based on other groupings, as described below. 
     Note that, in light of Shao&#39;s studies, the CV groupings used by Forina et al. seem sparse both in number and in the number deleted (m/5). For this reason, it may be meaningless to compare the different subset selection techniques based on the RMSECV for this grouping. However, since the predictors retained by the different methods are not reported for the data sets Kalivas and Artificial, the results of SRCEK can only be compared to those of the other methods by the RMSECV of this grouping or by the aBIC based on that RMSECV. For Moisture, Forina et al. reported the selected predictors, making comparison based on Monte Carlo CV Groupings possible. These are denoted by RMSEMCCV, and based on 120 delete-38 groupings. 
     SRCEK was applied to Moisture with 120 delete-38 Monte Carlo CV groups, using RMSEMCCV as the objective function for 2 and 3 factor PLS. Termination was triggered by small relative change in the objective (relative tolerance in objective of 10-5), which was achieved in both cases in at most 25 major iterates. Model selection is performed by minimization of aBIC. Results are summarized in Table 1, and compared to the results found by Forina et al. For two factor PLS, SRCEK selects two predictors, L14:2100 and L16.1940, the same choice made by SOLS and GA-OLS. For three factor PLS, SRCEK selects three predictors, adding L20:1680 to the previous two predictors. The two factor choice is preferred by both the DV error and aBIC. In this case, aBIC matches an intuitive ordering of these results. 
     
       
         
           
               
               
               
               
               
               
               
             
               
                 TABLE 1 
               
               
                   
               
               
                 Method 
                 L 
                 K 
                 RMSECV 
                 aBIC 
                 RMSEMCCV 
                 aBIC 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
               
               
               
               
            
               
                 PLS 
                 2 
                 19 
                 1.369 
                 1.99 
                 1.438 
                 2.09 
               
               
                 MUT 
                 2 
                 8 
                 1.354 
                 1.18 
                 1.407 
                 1.26 
               
               
                 UVE 
                 2 
                 7 
                 1.350 
                 1.10 
                 1.403 
                 1.18 
               
               
                 norml 
               
               
                 UVE 95 
                 2 
                 10 
                 1.346 
                 1.31 
                 1.395 
                 1.38 
               
               
                 GOLPE I 
                 2 
                 15 
                 1.319 
                 1.63 
                 1.389 
                 1.73 
               
               
                 UVE 90 
                 2 
                 12 
                 1.338 
                 1.44 
                 1.387 
                 1.52 
               
               
                 IPW 
                 3 
                 3 
                 1.308 
                 0.756 
                 1.361 
                 0.836 
               
               
                 GOLPE III 
                 2 
                 3 
                 1.307 
                 0.752 
                 1.356 
                 0.824 
               
               
                 MAXCOR 
                 2 
                 10 
                 1.268 
                 1.19 
                 1.318 
                 1.27 
               
               
                 ISE 
                 2 
                 2 
                 1.264 
                 0.613 
                 1.311 
                 0.686 
               
               
                 GOLPE II 
                 2 
                 6 
                 1.256 
                 0.887 
                 1.298 
                 0.953 
               
               
                 SOLS(5) 
                 2 
                 2 
                 1.203 
                 0.514 
                 1.240 
                 0.574 
               
               
                 SRCEK(2) 
                 2 
                 2 
                 1.203 
                 0.514 
                 1.240 
                 0.574 
               
               
                 SRCEK(3) 
                 3 
                 3 
                 1.259 
                 0.680 
                 1.285 
                 0.720 
               
               
                   
               
            
           
         
       
     
     Results from selection methods applied to data set Moisture are shown ordered by decreasing RMSEMCCV (120 delete-38 MC groupings), with results from SRCEK, in Table 1, which is adapted from the study of Forina et al. The number of retained predictors is indicated by k, the number of latent factors is 1. The RMSECV based on the groupings of Forina et al. are also given. Two aBIC values are reported, based on the Forina and Monte Carlo CV groupings. The last digit of the SOLS(5) method RMSECV was apparently misreported by Forina et al. 
     The results of SRCEK applied to Kalivas are summarized in Table 2, and compared to the results from the previous study. Several experiments were attempted, each using three to five factors. Each use a factor of all ones as the initial λ, and 80 delete-68 MC CV groups for computing RMSECV. In experiments (a) and (b), RMSECV is minimized, and predictor selection is made based on, respectively, RMSECV or aBIC. In the experiments (c) and (d), the embedded aBIC (using k1,1.01) is minimized, and selection is based on, respectively, RMSECV or aBIC. 
     The effect of the objective function on the algorithm outcome for this data set is shown in  FIGS. 6 and 7 . In  FIGS. 6 and 7 , graphs showing the effective regression vector Λβ(λ), for the λ found by BFGS minimization are illustrated. Specifically, the vector Λβ(λ) is plotted for post-optimization λ on data set Kalivas. In  FIG. 6 , RMSEVC for MC CV groups was used as the objective function, while in  FIG. 7 , the embedded aBIC using the same CV groups for the RMSECV part and K 1,1.01  was minimized. When RMSECV alone is minimized, the regression vector has no clear structure. However, when aBIC is minimized, the regression vector divides the predictors into two groups, those with ‘low’ relevance, and those with ‘high’ relevance. Moreover, as expected from spectroscopic data, the relevant predictors appear in contiguous groups. 
     
       
         
           
               
               
               
               
               
               
             
               
                 TABLE 2 
               
               
                   
               
               
                 Method 
                 L 
                 K 
                 RMSECV 
                 aBIC 
                 RMSEMCCV 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
               
               
               
            
               
                 PLS 
                 5 
                 701 
                 0.2218 
                 3.13E+01 
                   
               
               
                 MAXCOR 
                 5 
                 684 
                 0.2217 
                 3.05E+01 
               
               
                 UVE 95% 
                 5 
                 657 
                 0.2227 
                 2.92E+01 
               
               
                 GOLPE I 
                 6 
                 648 
                 0.2216 
                 2.91E+01 
               
               
                 MUT 
                 6 
                 575 
                 0.2227 
                 2.55E+01 
               
               
                 GOLPE II 
                 6 
                 352 
                 0.2167 
                 1.44E+01 
               
               
                 GOLPE III 
                 6 
                 32 
                 0.2231 
                 −1.42E+00 
               
               
                 LASSO 
                 14 
                 14 
                 0.2153 
                 −2.31E+00 
               
               
                 VS 
                 6 
                 14 
                 0.2111 
                 −2.42E+00 
               
               
                 IPW 3 
                 3 
                 11 
                 0.2174 
                 −2.52E+00 
               
               
                 IPW 2 
                 2 
                 11 
                 0.2155 
                 −2.55E+00 
               
               
                 GAPLS 
                 6 
                 11 
                 0.2078 
                 −2.60E+00 
               
               
                 ISE 
                 2 
                 7 
                 0.2151 
                 −2.74E+00 
               
               
                 SOLS(2) 
                 2 
                 2 
                 0.2408 
                 −2.75E+00 
               
               
                 SOLS(4) 
                 4 
                 4 
                 0.2207 
                 −2.83E+00 
               
               
                 GAOLS a 
                 4 
                 4 
                 0.2154 
                 −2.88E+00 
               
               
                 GAOLS b 
                 4 
                 4 
                 0.209 
                 −2.94E+00 
               
               
                 SRCEK(3) d 
                 3 
                 3 
                 0.2305 
                 −2.79E+00 
                 0.25195 
               
               
                 SRCEK(3) d 
                 4 
                 20 
                 0.2739 
                 −1.62E+00 
                 0.30089 
               
               
                 SRCEK(3) d 
                 5 
                 5 
                 0.2877 
                 −2.25E+00 
                 0.3179 
               
               
                 SRCEK(3) c 
                 3 
                 11 
                 0.231 
                 −2.40E+00 
                 0.24823 
               
               
                 SRCEK(3) c 
                 4 
                 24 
                 0.2627 
                 −1.51E+00 
                 0.28804 
               
               
                 SRCEK(3) c 
                 5 
                 17 
                 0.2779 
                 −1.73E+00 
                 0.31725 
               
               
                 SRCEK(3) a 
                 3 
                 30 
                 0.2017 
                 −1.76E+00 
                 0.20896 
               
               
                 SRCEK(3) a 
                 4 
                 28 
                 0.1914 
                 −1.95E+00 
                 0.20958 
               
               
                 SRCEK(3) a 
                 5 
                 26 
                 0.1935 
                 −2.01E+00 
                 0.20842 
               
               
                 SRCEK(3) b 
                 3 
                 6 
                 0.2068 
                 −2.86E+00 
                 0.22187 
               
               
                 SRCEK(3) b 
                 4 
                 8 
                 0.202 
                 −2.81E+00 
                 0.21891 
               
               
                 SRCEK(3) b 
                 5 
                 8 
                 0.1993 
                 −2.83E+00 
                 0.22755 
               
               
                   
               
            
           
         
       
     
     Results from selection methods applied to data set Kalivas are shown ordered by decreasing aBIC, with results from SRCEK. The results of SRCEK, and other methods, applied to Artificial are summarized in Table 3, below. 
     
       
         
           
               
               
               
               
               
               
               
               
             
               
                 TABLE 3 
               
               
                   
               
               
                 Method 
                 L 
                 K 
                 RMSECV 
                 aBIC 
                 Kbad 
                 ext RMSEP 
                 RMSEMCCV 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
               
               
               
               
               
            
               
                 GOLPE I 
                 3 
                 279 
                 207.6 
                 2.41E+01 
                 229 
                 229.1 
                   
               
               
                 GOLPE II 
                 3 
                 142 
                 141.1 
                 1.67E+01 
                 102 
                 207.9 
               
               
                 ISE 
                 3 
                 109 
                 122.2 
                 1.48E+01 
                 63 
                 206.7 
               
               
                 UVE 
                 3 
                 67 
                 139.5 
                 1.31E+01 
                 17 
                 189.6 
               
               
                 MUT 
                 3 
                 59 
                 147.8 
                 1.28E+01 
                 9 
                 184.5 
               
               
                 ISE 
                 3 
                 61 
                 121.3 
                 1.25E+01 
                 17 
                 189.1 
               
               
                 MAXCOR 
                 3 
                 42 
                 171.7 
                 1.23E+01 
                 2 
                 192.6 
               
               
                 GOLPE III 
                 4 
                 34 
                 166.1 
                 1.19E+01 
                 12 
                 199.8 
               
               
                 SOLS(20) 
                 20 
                 20 
                 106.1 
                 1.05E+01 
                 13 
                 240.5 
               
               
                 GAPLS 
                 4 
                 17 
                 122.2 
                 1.04E+01 
                 11 
                 214 
               
               
                 SOLS(4) 
                 4 
                 4 
                 166.9 
                 1.04E+01 
                 0 
                 195.3 
               
               
                 IPW 
                 4 
                 4 
                 163.3 
                 1.04E+01 
                 0 
                 192.6 
               
               
                 SOLS(5) 
                 5 
                 5 
                 154.8 
                 1.03E+01 
                 0 
                 180.5 
               
               
                 GAOLS 
                 10 
                 10 
                 126 
                 1.02E+01 
                 3 
                 218.3 
               
               
                 SRCEK(3) a 
                 3 
                 4 
                 164.3 
                 1.04E+01 
                 0 
                 196.1 
                 176.2 
               
               
                 SRCEK(4) a 
                 4 
                 36 
                 170.6 
                 1.20E+01 
                 0 
                 193.3 
                 178.3 
               
               
                 SRCEK(5) a 
                 5 
                 33 
                 131.1 
                 1.14E+01 
                 14 
                 195.3 
                 148.2 
               
               
                 SRCEK(6) a 
                 6 
                 23 
                 153.9 
                 1.12E+01 
                 4 
                 209.1 
                 171.1 
               
               
                 SRCEK(3) b 
                 3 
                 4 
                 164.3 
                 1.04E+01 
                 0 
                 196.1 
                 176.2 
               
               
                 SRCEK(4) b 
                 4 
                 14 
                 261.5 
                 1.18E+01 
                 0 
                 253.8 
                 277.1 
               
               
                 SRCEK(5) b 
                 5 
                 5 
                 166.5 
                 1.05E+01 
                 0 
                 199.2 
                 175.1 
               
               
                 SRCEK(6) b 
                 6 
                 19 
                 154.1 
                 1.10E+01 
                 3 
                 207.5 
                 172.7 
               
               
                   
               
            
           
         
       
     
     Results from selection methods applied to data set Artificial are shown in Table 3 ordered by decreasing aBIC, with results from SRCEK. The number of uninformative predictors selected is shown as well as the RMSEP for the external set of 300 objects. 
     Referring to  FIGS. 8 and 9 , the end results of SRCEK applied to tissue phantoms, using a two factor WPLS to predict water are shown. In  FIG. 8 , the effective weighted regression vector  200  across the channels of the spectrometer is illustrated. Additionally, 15 selected predictors  202  are each indicated by an “x.”  FIG. 9  shows the object weightings along with 37 retained objects (shown as x&#39;s. Two object weightings were reveled to be outliers  210 . The WPLS model output by the algorithm explains 98% of the observed variance in the response, although without an information theoretic study of the problem, it is not clear this a meaning measure. The PLS model explains only 91% of the variance, 
     Directions for Further Study 
     The RMSECV should be optimizable with respect to predictor weightings, γ, in addition to predictor weights λ. Algorithm 3 may be altered to also compute the gradients with respect to γ. The increased degrees of freedom, however, increases the risk of overfitting. The embedded information criterion objective function described above may be altered to balance this risk. Since it is assumed the data are distributed as y j ˜X j   T β+b 0 N(0,σ 2 /γ j ), m−1 new estimated parameters have been added by way of the separate variances of each observation. One strategy to embed the information criterion then, is to let φ(λ)=ln(MSECV(λ))+(κ p,q (λ)−κ p,q (γy))ln(m)/(m−l−1). The initial estimate should be that of homoscedasticity. This has not been explored as a valid measure of quality, however, the SRCEK method may be used to optimize both the vectors λ and γ simultaneously, and use this function for the final comparison. Again, the problem is that increasing the number of fit parameters increases the chances of overfitting. This comparison function φ punishes models with a lot of parameter in the K p,q  term. That is, if there are many significant λ (i.e. many channels) or few significant γ (i.e. few high-weighted samples), then φ is big, and smallest φ may be used for selection of wavelengths. It is not clear if the balance betnveen K p,q (λ) and K p,q  Kp,q(γ) is correct—that is, whether one sample can count against one channel in this manner. In any event, this φ function is an example of one possibility, but others may be found which may be better. 
     The method of ordering the successively larger models based on the optimal λ, or on the Kronecker product of λ with the regression coefficient seems rather ad hoc. This step may also benefit from some theory, or may perhaps be replaced by strategies cribbed from other predictor selection techniques (e.g., IPW). Conversely, some of these techniques may benefit from a preliminary channel weight optimization step via BFGS. 
     The SRCEK method may also be extended to Kernel PLS regression, however, it may require the kernel to also compute derivatives. Additionally, an analysis of the structure of the RMSECV and embedded aBIC objective functions may be interesting to determine whether either can be shown to be convex (in %) in general or under assumptions on the data X and y which are justifiable in the chemometric context and whether sufficient sizes for the CV groupings can be found to sufficiently reduce dependence of the objective on the groupings. 
     The iterates of the BFGS algorithm for this objective function often display a zigzagging behavior towards the minimum. Often this is the result of some elements of λ “overshooting” zero. It may be possible to avoid this by using other minimization techniques, for example the conjugate gradient method, or a proper constrained minimization implementation of BFGS. 
     As mentioned above, the SRCEK method as described herein has many tweakable parameters: initial iterate λ (0) , initial approximation of the Hessian, termination condition for BFGS, choice of objective function, p and q for the continuous embedding of number of estimated parameters, etc. While these provide many possibilities to the researcher of the technique, they are an obstacle for the end user. Thus, reasonable heuristics for setting these parameters which work well in a wide range of settings would be welcome. 
     Specific embodiments have been shown by way of example in the drawings and have been described in detail herein. However, it should be understood that the claims are not intended to be limited to the particular forms disclosed. Rather, the claims are to cover all modifications, equivalents, and alternatives falling within their spirit and scope.