*This post was originally published by Ravi Charan at Towards Data Science*

## Compute the Effective Number of Parameters in Ridge Regression and More

Back in middle and high school you likely learned to calculate the mean and standard deviation of a dataset. And your teacher probably told you that there are two kinds of standard deviation: population and sample. The formulas for the two are just small variations on one another:

Different Formulas for the Standard Deviation

where μ is the population mean and x-bar is the sample mean. Typically, one just learns the formulas and is told when to use them. If you ask why, the answer is something vague like “there was one degree of freedom used up when estimating the sample mean.” without a true definition of a “degree of freedom.”

Degrees of freedom also show up in several other places in statistics, for example: when doing t-tests, F-tests, χ² tests, and generally studying regression problems. Depending on the circumstance, degrees of freedom can mean subtly different things (the wikipedia article lists at least 9 closely-related definitions by my count¹).

In this article, we’ll focus on the meaning of degrees of freedom in a regression context. Specifically we’ll use the sense in which “degrees of freedom” is the “effective number of parameters” for a model. We’ll see how to compute the number of degrees of freedom of the standard deviation problem above alongside linear regression, ridge regression, and k-nearest neighbors regression. As we go we’ll also briefly discuss the relation to statistical inference (like a t-test) and model selection (how to compare two different models using their effective degrees of freedom).

In the regression context we have N samples each with a real-valued outcome value *y*. For each sample, we have a vector of covariates *x*, usually taken to include a constant. In other words, the first entry of the *x*-vector is 1 for each sample. We have some sort of model or procedure (which could be parametric or non-parametric) that is fit to the data (or otherwise uses the data) to produce predictions about what we think the value of y should be given an *x*-vector (which could be out-of-sample or not).

The result is the predicted value, y-hat, for each of the N samples. We’ll define the degrees of freedom, which we denote as ν (nu):

Definition of the Degrees of Freedom

And we’ll interpret the degrees of freedom as the “effective number of parameters” of the model. Now let’s see some examples.

Let’s return to the school-age problem we started with. Computing the mean of a sample is just making the prediction that every data point has value equal to the mean (after all, that’s the best guess you can make under the circumstances). In other words:

Estimating the Mean as a Prediction Problem

Note that estimating the mean is equivalent to running a linear regression with only one covariate, a constant: x = [1]. Hopefully this makes it clear why we can re-cast the problem as a prediction problem.

Now it’s simple to compute the degrees of freedom. Unsurprisingly we get 1 degree of freedom:

To understand the relationship to the standard deviation, we have to use another closely related definition of degrees of freedom (which we won’t go into depth on). If our samples were independent and identically distributed, then we can say, informally, that we started out with N degrees of freedom. We lost one in estimating the mean, leaving N–1 left over for the standard deviation.

Now let’s expand this into the context of regular old linear regression. In this context, we like to collect the sample data into a vector Y and matrix X. Throughout this article we will use *p* to denote the number of covariates for each sample (the length of the *x*-vector).

It shouldn’t come as a spoiler that the number of degrees of freedom will end up being *p*. But the method used to calculate this will pay off for us when we turn to Ridge Regression.

The count of *p* covariates includes a constant if we include one in our model as we usually do. Each row in the X matrix corresponds to the *x-*vector for each observation in our sample:

Our response matrix Y (an N⨉1 vector) and design matrix X (shape N⨉p)

The model is that there are *p* parameters collected into a vector β. Y = Xβ plus an error term. We’ll go through the derivation because it will be useful for us later. We pick an estimate for β that minimizes the sum of squares of the errors. In other words our loss function is

Loss function for Linear Regression

The first sum is in terms of each sample with row-vectors x labeled by *i*. To optimize L, we differentiate with respect to the vector β, obtaining a *p⨉*1 vector of derivatives.

Set it equal to 0 and solve for β

And finally form our estimate

Our estimate for Y, using a hat matrix

We call the matrix H for “hat matrix” because it “puts the hat” on the Y (producing our fitted/predicted values). The hat matrix is an N⨉N matrix. We are assuming that the y’s are independent, so we can compute the effective degrees of freedom:

Degrees of Freedom for Vanilla Linear Regression

where the second sum is over the diagonal terms in the matrix. If you write out the matrix and write out the formula for the predicted value of sample 1, you will see that these derivatives are in fact just the diagonal entries of the hat matrix. The sum of the diagonals of a matrix is called the Trace of matrix and we have denoted that in the second line.

## Computing the Trace

Now we turn to computing the trace of *H*. We had better hope it is *p*!

There is a simple way to compute the trace of H using the cyclicality of the trace. But we’ll take another approach that will be generalized when we discuss ridge regression.

We use the singular value decomposition of X. (See my earlier article for a geometric explanation of the singular value decomposition and the linear algebra we are about to do). The trace of a matrix is a basis-independent number, so we can choose whatever basis we want for the vector space containing Y. Similarly, we can choose whatever basis we want for the vector space containing the parameters β. The singular value decomposition says that there exists a basis for each such that the matrix X is diagonal. The entries on the diagonal in the first *p* rows are called the *singular values*. The “no perfect multi-collinearity” assumption for linear regression means that none of the singular values are 0. The remaining N–p rows of the matrix are all full of 0s.

X using the bases given by the Singular Value Decomposition

Now it’s easy to compute H. You can just multiply the versions of X by hand and get a diagonal matrix with the first *p* diagonal entries all 1 and the rest 0. The entries not shown (the off-diagonal ones) are all 0 as well.

The Hat Matrix using the basis for Y given by the Singular Value Decomposition

So we conlude Tr(H) = *p*.

## Analogue of the Standard Deviation: Standard Error

In our previous example (mean and standard deviation), we computed the standard deviation after computing the mean, using *n–1* for the denominator because we “lost 1 degree of freedom” to estimate the mean.

In this context, the standard deviation gets renamed as the “standard error” but the formula should look analogous:

Just as before, we compare the sum of squares of the difference between each measured value *y* and its predicted value. We used up *p* degrees of freedom to compute the estimate, so only N–p are left.

In Ridge Regression, we add a regularization term to our loss function. Done properly, this increases bias in our coefficient but decreases variance to result in overall lower error in our predictions.

Using our definition of degrees of freedom, we can compute the effective number of parameters in a ridge regression. We would expect the regularization to decrease this below the original number *p* of parameters (since they no longer freely vary).

We go through the same steps to compute the hat matrix as in linear regression.

- The loss function gets an extra term with a fixed, known hyper-parameter λ setting the amount of regularization.

2. We take the derivative, set it equal to 0, and solve for β. I is the identity matrix here

3. We compute the fitted values and extract the hat matrix *H*. The formula is the same as last time except that we add λ to each diagonal entry of the matrix in parentheses.

4. We use the singular value decomposition to choose bases for the vector spaces containing Y and β so that we can write X as a diagonal matrix, and compute H.

Which leaves us with the following formulas for the degrees of freedom of regular (λ = 0) regression and Ridge regression (λ>0) in terms of the singular values *d*, indexed by *i*.

## Discussion

The above calculations using the singular value decomposition give us a good perspective on Ridge Regression.

First of all, if the design matrix is perfectly (multi-)collinear, one of its singular values will be 0. A common case where this happens is if there are more covariates than samples. This is a problem in a regular regression because it means the term in parentheses in the hat matrix isn’t invertible (the denominators are 0 in the formula above). Ridge regression fixes this problem by adding a positive term to each squared singular value.

Second, we can see that the coefficient shrinkage is high for terms with a small singular value. Such terms correspond to components of the β estimate that have high variance in a regular regression (due to high correlation between regressor). On the other hand, for terms with a higher singular value, the shrinkage is comparatively smaller.

The degrees of freedom calculation we have done perfectly encapsulates this shrinkage to give us an estimate for the effective number of parameters we actually used. Note also that the singular values are a function of the design matrix X and not of Y. That means that you could, in theory, choose λ by computing the number of effective parameters you want and finding λ to achieve that.

## Inference and Model Selection

In our vanilla regression examples we saw that the standard error (or standard deviation) can be computed by assuming that we started with N degrees of freedom and subtracting out the number of effective parameters we used. This doesn’t necessarily make as much sense with the Ridge, which gives a biased estimator for the coefficients (albeit with lower mean-squared error for correctly chosen λ). In particular, the residuals are no longer nicely distributed.

Instead, we can use our effective number of parameters to plug into the AIC (Akaike Information Criterion), an alternative to cross-validation for model selection. The AIC penalizes models for having more parameters and approximates the expected test error if we were to use a held-out test set. Then choosing λ to optimize it can replace cross-validation, provided we use the effective degrees of freedom in the formula for the AIC. Note, however, that if we choose λ adaptively before computing the AIC, then there are extra effective degrees of freedom added.

As a final example, consider k-nearest neighbors regression. It should be apparent that the fitted value for each data point is the average of k nearby points, including itself. This means that the degrees of freedom is

Degrees of Freedom for k-nearest neighbors

This enables us to do model comparison between different types of models (for example, comparing k-nearest neighbors to a ridge regression using the AIC as above).

I hope you see that the degrees of freedom is a very general measure and can be applied to all sorts of regression models (kernel regression, splines, etc.).

Hopefully this article will give you a more solid understanding of degrees of freedom and make the whole concept less of a vague statistical idea. I mentioned that there are other, closely related, definitions of degrees of freedom. The other main version is a geometric idea. If you want to know more about that, read my article about the geometric approach to linear regression. If you want to understand more of the algebra we did to compute the degrees of freedom, read a non-algebraic approach to the singular value decomposition.

*This post was originally published by Ravi Charan at Towards Data Science*