Sign in to continue learning
Supervised Machine Learning: Regression and Classification
33h17m
In the last video, we saw that regularization tries to make the parameter values w1 through wn small to reduce overfitting. In this video, we'll build on that intuition and develop a modified cost function for your learning algorithm that you can use to actually apply regularization. Let's jump in. Recall this example from the previous video, in which we saw that if you fit a quadratic function to this data, it gives a pretty good fit. But if you fit a very high-order polynomial, you end up with a curve that overfits the data. But now, consider the following. Suppose that you had a way to make the parameters w3 and w4 really, really small, say close to zero. Here's what I mean. Let's say instead of minimizing this objective function, this is the cost function for linear regression. Let's say you were to modify the cost function and add to it 1000 times w3 squared plus 1000 times w4 squared. And here, I'm just choosing 1000 because it's a big number, but any other really large number would be okay. So with this modified cost function, you'd in effect be penalizing the model if w3 and w4 are large. Because if you want to minimize this function, the only way to make this new cost function small is if w3 and w4 are both small, right? Because otherwise, this 1000 times w3 squared and 1000 times w4 squared terms are going to be really, really big. So when you minimize this function, you're going to end up with w3 close to zero and w4 close to zero. So we're effectively nearly canceling out the effect of the features x cubed and x to the power of 4 and getting rid of these two terms over here. And if we do that, then we end up with a fit to the data that's much closer to the quadratic function, including maybe just tiny contributions from the features x cubed and x to the 4. And this is good because it's a much better fit to the data compared to if all the parameters could be large and you end up with this weakly quadratic function. More generally, here's the idea behind regularization. The idea is that if there are smaller values for the parameters, then that's a bit like having a simpler model, maybe one with fewer features, which is therefore less prone to overfitting. On the last slide, we penalized or we say we regularized only w3 and w4. But more generally, the way that regularization tends to be implemented is if you have a lot of features, say 100 features, you may not know which are the most important features and which ones to penalize. So the way regularization is typically implemented is to penalize all of the features, or more precisely, you penalize all the wj parameters. And it's possible to show that this will usually result in fitting a smoother, simpler, less weakly function that's less prone to overfitting. So for this example, if you have data with 100 features for each host, it may be hard to pick and advance which features to include and which ones to exclude. So let's build a model that uses all 100 features. So you have these 100 parameters, w1 through w100, as well as the 101st parameter, b. Because we don't know which of these parameters are going to be the important ones, let's penalize all of them a bit and shrink all of them by adding this new term, lambda times the sum from j equals 1 through n, where n is 100, the number of features, of wj squared. This value, lambda here, is the Greek alphabet lambda, and is also called a regularization parameter. So similar to picking a learning rate alpha, you now also have to choose a number for lambda. A couple things I would like to point out. By convention, instead of using lambda times the sum of wj squared, we also divide lambda by 2m, so that both the first and second terms here are scaled by 1 over 2m. It turns out that by scaling both terms the same way, it becomes a little bit easier to choose a good value for lambda. In particular, you find that even if your training set size grows, say you find more training examples, so m, the training set size, is now bigger, the same value of lambda that you have picked previously is now also more likely to continue to work if you have this extra scaling by 2m. Also, by the way, by convention, we're not going to penalize the parameter b for being large. In practice, it makes very little difference whether you do or not, and some machine learning engineers and actually some learning algorithm implementations will also include lambda over 2m times the b squared term. But this makes very little difference in practice, and the more common convention which we'll use in this course is to regularize only the parameters w rather than the parameters b. So to summarize, in this modified cost function, we want to minimize the original cost, which is the mean squared error cost, plus additionally the second term, which is called the regularization term. And so this new cost function trades off two goals that you might have. Trying to minimize this first term encourages the algorithm to fit the training data well by minimizing the squared differences of the predictions and the actual values. And trying to minimize the second term, the algorithm also tries to keep the parameters wj small, which will tend to reduce overfitting. The value of lambda that you choose specifies the relative importance or the relative tradeoff or how you balance between these two goals. Let's take a look at what different values of lambda will cause your learning algorithm to do. Let's use the housing price prediction example using linear regression. So f of x is the linear regression model. If lambda was set to be 0, then you're not using the regularization term at all because the regularization term is multiplied by 0. And so if lambda was 0, you end up fitting this overly wiggly, overly complex curve and it overfits. So that was one extreme of if lambda was 0. Let's now look at the other extreme. If you set lambda to be a really, really, really large number, say lambda equals 10 to the power of 10, then you're placing a very heavy weight on this regularization term on the right. And the only way to minimize this is to be sure that all the values of w are pretty much very close to 0. So if lambda is very, very large, the learning algorithm will choose w1, w2, w3, and w4 to be extremely close to 0. And thus, f of x is basically equal to b. And so the learning algorithm fits a horizontal straight line and underfits. To recap, if lambda is 0, this model will overfit. If lambda is enormous, like 10 to the power of 10, this model will underfit. And so what you want is some value of lambda that is in between, that more appropriately balances these first and second terms of trading off minimizing the mean squared error and keeping the parameters small. And when the value of lambda is not too small and not too large, but just right, then hopefully you end up able to fit a fourth-order polynomial keeping all of these features, but with a function that looks like this. So that's how regularization works. When we talk about model selection later into specialization, we'll also see a variety of ways to choose good values for lambda. In the next two videos, we'll flesh out how to apply regularization to linear regression and logistic regression, and how to train these models with gradient descent. With that, you'll be able to avoid overfitting with both of these algorithms.