naginterfaces.library.smooth.fit_​spline_​parest

naginterfaces.library.smooth.fit_spline_parest(method, x, y, crit, wt=None, u=0.0, tol=0.0, maxcal=0)

fit_spline_parest estimates the values of the smoothing parameter and fits a cubic smoothing spline to a set of data.

For full information please refer to the NAG Library document for g10ac

https://support.nag.com/numeric/nl/nagdoc_30.2/flhtml/g10/g10acf.html

Parameters

methodstr, length 1

Indicates whether the smoothing parameter is to be found by minimization of the CV or GCV functions, or by finding the smoothing parameter corresponding to a specified degrees of freedom value.

$method=\text{'C'}$

Cross-validation is used.

$method=\text{'D'}$

The degrees of freedom are specified.

$method=\text{'G'}$

Generalized cross-validation is used.

xfloat, array-like, shape $\left(n\right)$

The distinct and ordered values $x_{\text{i}}$, for $\text{i}=1,2,\dots ,n$.

yfloat, array-like, shape $\left(n\right)$

The values $y_{\text{i}}$, for $\text{i}=1,2,\dots ,n$.

critfloat

If $method=\text{'D'}$, the required degrees of freedom for the spline.

If $method=\text{'C'}$ or $\text{'G'}$, $crit$ need not be set.

wtNone or float, array-like, shape $\left(n\right)$, optional

If $\text{weight}=\text{'W'}$, $wt$ must contain the $n$ weights. Otherwise $wt$ is not referenced and unit weights are assumed.

ufloat, optional

The upper bound on the smoothing parameter. If $u\le tol$, $u=1000.0$ will be used instead. See Further Comments for details on how this argument is used.

tolfloat, optional

The accuracy to which the smoothing parameter $rho$ is required. $tol$ should preferably be not much less than $\sqrt{ϵ}$, where $ϵ$ is the machine precision. If $tol<ϵ$, $tol=\sqrt{ϵ}$ will be used instead.

maxcalint, optional

The maximum number of spline evaluations to be used in finding the value of $\rho$. If $maxcal<3$, $maxcal=100$ will be used instead.

Returns

yhatfloat, ndarray, shape $\left(n\right)$

The fitted values, ${\hat{y}}_{\text{i}}$, for $\text{i}=1,2,\dots ,n$.

cfloat, ndarray, shape $(n-1,3)$

The spline coefficients. More precisely, the value of the spline approximation at $t$ is given by $(\left(c\right[i-1,2]\times d+c[i-1,1\left]\right)\times d+c[i-1,0\left]\right)\times d+{\hat{y}}_i$, where $x_i\le t<x_{i+1}$ and $d=t-x_i$.

rssfloat

The (weighted) residual sum of squares.

dffloat

The residual degrees of freedom. If $method=\text{'D'}$ this will be $n-crit$ to the required accuracy.

resfloat, ndarray, shape $\left(n\right)$

The (weighted) residuals, $r_{\text{i}}$, for $\text{i}=1,2,\dots ,n$.

hfloat, ndarray, shape $\left(n\right)$

The leverages, $h_{\text{i}\text{i}}$, for $\text{i}=1,2,\dots ,n$.

critfloat

If $method=\text{'C'}$, the value of the cross-validation, or if $method=\text{'G'}$, the value of the generalized cross-validation function, evaluated at the value of $\rho$ returned in $rho$.

rhofloat

The smoothing parameter, $\rho$.

Raises

NagValueError

(errno $1$)

On entry, $crit=⟨value⟩$.

Constraint: if $method=\text{'D'}$, $crit\le n$.

(errno $1$)

On entry, $crit=⟨value⟩$.

Constraint: if $method=\text{'D'}$, $crit>2.0$.

(errno $1$)

On entry, $method$ is not valid: $method=⟨value⟩$.

(errno $1$)

On entry, $n=⟨value⟩$.

Constraint: $n\ge 3$.

(errno $2$)

On entry, at least one element of $wt\le 0.0$.

(errno $3$)

On entry, $x$ is not a strictly ordered array.

(errno $4$)

For the specified degrees of freedom, $rho>u$: $u=⟨value⟩$.

Warns

NagAlgorithmicWarning

(errno $5$)

Accuracy of $tol$ cannot be achieved: $tol=⟨value⟩$.

(errno $6$)

$maxcal$ iterations have been performed.

(errno $7$)

Optimum value of $rho$ lies above $u$: $u=⟨value⟩$.

Notes

In the NAG Library the traditional C interface for this routine uses a different algorithmic base. Please contact NAG if you have any questions about compatibility.

For a set of $n$ observations $(x_{\text{i}},y_{\text{i}})$, for $\text{i}=1,2,\dots ,n$, the spline provides a flexible smooth function for situations in which a simple polynomial or nonlinear regression model is not suitable.

Cubic smoothing splines arise as the unique real-valued solution function $f$, with absolutely continuous first derivative and squared-integrable second derivative, which minimizes

$$\sum _{i=1}^n{w}_i{(y_i-f\left(x_i\right))}^2+\rho {\int }_{-\infty }^{\infty }{\left(f^{\prime \prime }\left(x\right)\right)}^{2}dx\text{,}$$

where $w_i$ is the (optional) weight for the $i$th observation and $\rho$ is the smoothing parameter. This criterion consists of two parts: the first measures the fit of the curve and the second the smoothness of the curve. The value of the smoothing parameter $\rho$ weights these two aspects; larger values of $\rho$ give a smoother fitted curve but, in general, a poorer fit. For details of how the cubic spline can be fitted see Hutchinson and de Hoog (1985) and Reinsch (1967).

The fitted values, $\hat{y}={({\hat{y}}_1,{\hat{y}}_2,\dots ,{\hat{y}}_n)}^T$, and weighted residuals, $r_i$, can be written as:

$$\hat{y}=Hy\text{and}{r}_i=\sqrt{w_i}(y_i-{\hat{y}}_i)$$

for a matrix $H$. The residual degrees of freedom for the spline is $trace(I-H)$ and the diagonal elements of $H$ are the leverages.

The parameter $\rho$ can be estimated in a number of ways.

1. The degrees of freedom for the spline can be specified, i.e., find $\rho$ such that $trace\left(H\right)={\nu }_0$ for given ${\nu }_0$.

2. Minimize the cross-validation (CV), i.e., find $\rho$ such that the CV is minimized, where

   $$CV=\frac{1}{{\sum }_{i=1}^n{w}_i}\sum _{i=1}^n{\left[\frac{r_i}{1-h_{ii}}\right]}^2\text{.}$$

3. Minimize the generalized cross-validation (GCV), i.e., find $\rho$ such that the GCV is minimized, where

   $$GCV=\frac{n^2}{{\sum }_{i=1}^n{w}_i}\left[\frac{{\sum }_{i=1}^n{r}_i^2}{{\left({\sum }_{i=1}^n(1-h_{ii})\right)}^2}\right]\text{.}$$

fit_spline_parest requires the $x_i$ to be strictly increasing. If two or more observations have the same $x_i$ value then they should be replaced by a single observation with $y_i$ equal to the (weighted) mean of the $y$ values and weight, $w_i$, equal to the sum of the weights. This operation can be performed by data_order().

The algorithm is based on Hutchinson (1986). roots.contfn_brent_rcomm is used to solve for $\rho$ given ${\nu }_0$ and the method of opt.one_var_func is used to minimize the GCV or CV.

References

Hastie, T J and Tibshirani, R J, 1990, Generalized Additive Models, Chapman and Hall

Hutchinson, M F, 1986, Algorithm 642: A fast procedure for calculating minimum cross-validation cubic smoothing splines, ACM Trans. Math. Software (12), 150–153

Hutchinson, M F and de Hoog, F R, 1985, Smoothing noisy data with spline functions, Numer. Math. (47), 99–106

Reinsch, C H, 1967, Smoothing by spline functions, Numer. Math. (10), 177–183