Split (1)

train · 2.22k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

text stringlengths 35 1.54k	source stringclasses 1 value	page int64 1 800	book stringclasses 1 value
labeled. for a recent example of multi - instance learning with deep models, see kotzias 2015 et al. ( ). some machine learning algorithms do not just experience a ﬁxed dataset. for example, reinforcement learning algorithms interact with an environment, so there is a feedback loop between the learning system and its experiences. such algorithms are beyond the scope of this book. please see ( ) sutton and barto 1998 or bertsekas and tsitsiklis 1996 ( ) for information about reinforcement learning, and ( ) for the deep learning approach to reinforcement learning. mnih et al. 2013 most machine learning algorithms simply experience a dataset. a dataset can be described in many ways. in all cases, a dataset is a collection of examples, which are in turn collections of features. one common way of describing a dataset is with a. a design design matrix matrix is a matrix containing a [UNK] example in each row. each column of the matrix corresponds to a [UNK] feature. for instance, the iris dataset contains 150 examples with four features for each example. this means we can represent the dataset with a design matrix x ∈r150 4 ×, where xi, 1 is the sepal length of plant i, xi, 2 is the sep	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	121	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##set contains 150 examples with four features for each example. this means we can represent the dataset with a design matrix x ∈r150 4 ×, where xi, 1 is the sepal length of plant i, xi, 2 is the sepal width of plant i, etc. we will describe most of the learning algorithms in this book in terms of how they operate on design matrix datasets. of course, to describe a dataset as a design matrix, it must be possible to describe each example as a vector, and each of these vectors must be the same size. this is not always possible. for example, if you have a collection of photographs with [UNK] widths and heights, then [UNK] photographs will contain [UNK] numbers of pixels, so not all of the photographs may be described with the same length of vector. section and chapter describe how to handle [UNK] 9. 7 10 106	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	121	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics types of such heterogeneous data. in cases like these, rather than describing the dataset as a matrix with m rows, we will describe it as a set containing m elements : { x ( 1 ), x ( 2 ),..., x ( ) m }. this notation does not imply that any two example vectors x ( ) i and x ( ) j have the same size. in the case of supervised learning, the example contains a label or target as well as a collection of features. for example, if we want to use a learning algorithm to perform object recognition from photographs, we need to specify which object appears in each of the photos. we might do this with a numeric code, with 0 signifying a person, 1 signifying a car, 2 signifying a cat, etc. often when working with a dataset containing a design matrix of feature observations x, we also provide a vector of labels, with y yi providing the label for example. i of course, sometimes the label may be more than just a single number. for example, if we want to train a speech recognition system to transcribe entire sentences, then the label for each example sentence is a sequence of words. just as	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	122	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
i of course, sometimes the label may be more than just a single number. for example, if we want to train a speech recognition system to transcribe entire sentences, then the label for each example sentence is a sequence of words. just as there is no formal deﬁnition of supervised and unsupervised learning, there is no rigid taxonomy of datasets or experiences. the structures described here cover most cases, but it is always possible to design new ones for new applications. 5. 1. 4 example : linear regression our deﬁnition of a machine learning algorithm as an algorithm that is capable of improving a computer program ’ s performance at some task via experience is somewhat abstract. to make this more concrete, we present an example of a simple machine learning algorithm : linear regression. we will return to this example repeatedly as we introduce more machine learning concepts that help to understand its behavior. as the name implies, linear regression solves a regression problem. in other words, the goal is to build a system that can take a vector x ∈rn as input and predict the value of a scalar y ∈r as its output. in the case of linear regression, the output is a linear function of the input. let [UNK] be the value that	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	122	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
a system that can take a vector x ∈rn as input and predict the value of a scalar y ∈r as its output. in the case of linear regression, the output is a linear function of the input. let [UNK] be the value that our model predicts should take on. we deﬁne the output to be y [UNK] = wx ( 5. 3 ) where w ∈rn is a vector of. parameters parameters are values that control the behavior of the system. in this case, wi is the [UNK] that we multiply by feature xi before summing up the contributions from all the features. we can think of w as a set of weights that determine how each feature [UNK] the prediction. if a feature xi receives a positive weight wi, 107	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	122	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics then increasing the value of that feature increases the value of our prediction [UNK]. if a feature receives a negative weight, then increasing the value of that feature decreases the value of our prediction. if a feature ’ s weight is large in magnitude, then it has a large [UNK] on the prediction. if a feature ’ s weight is zero, it has no [UNK] on the prediction. we thus have a deﬁnition of our task t : to predict y from x by outputting [UNK] = wx. next we need a deﬁnition of our performance measure,. p suppose that we have a design matrix of m example inputs that we will not use for training, only for evaluating how well the model performs. we also have a vector of regression targets providing the correct value of y for each of these examples. because this dataset will only be used for evaluation, we call it the test set. we refer to the design matrix of inputs as x ( ) test and the vector of regression targets as y ( ) test. one way of measuring the performance of the model is to compute the mean squared error of the model on the test set. if [UNK] ( ) test gives the predictions of the model on the test set, then the mean	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	123	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
targets as y ( ) test. one way of measuring the performance of the model is to compute the mean squared error of the model on the test set. if [UNK] ( ) test gives the predictions of the model on the test set, then the mean squared error is given by msetest = 1 m i ( [UNK] ( ) test −y ( ) test ) 2 i. ( 5. 4 ) intuitively, one can see that this error measure decreases to 0 when [UNK] ( ) test = y ( ) test. we can also see that msetest = 1 m \| \| [UNK] ( ) test −y ( ) test \| \| 2 2, ( 5. 5 ) so the error increases whenever the euclidean distance between the predictions and the targets increases. to make a machine learning algorithm, we need to design an algorithm that will improve the weights w in a way that reduces msetest when the algorithm is allowed to gain experience by observing a training set ( x ( ) train, y ( ) train ). one intuitive way of doing this ( which we will justify later, in section ) is just to 5. 5. 1 minimize the mean squared error on the training set, msetrain. to minimize msetrain, we can simply solve for where its	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	123	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
intuitive way of doing this ( which we will justify later, in section ) is just to 5. 5. 1 minimize the mean squared error on the training set, msetrain. to minimize msetrain, we can simply solve for where its gradient is : 0 ∇wmsetrain = 0 ( 5. 6 ) ⇒∇w 1 m \| \| [UNK] ( ) train −y ( ) train \| \| 2 2 = 0 ( 5. 7 ) ⇒1 m∇w \| \| x ( ) train w y − ( ) train \| \| 2 2 = 0 ( 5. 8 ) 108	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	123	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics − − 1 0. 0 5 0 0 0 5 1 0.... x1 −3 −2 −1 0 1 2 3 y linear regression example 0 5 1 0 1 5... w1 0 20. 0 25. 0 30. 0 35. 0 40. 0 45. 0 50. 0 55. mse ( train ) optimization of w figure 5. 1 : a linear regression problem, with a training set consisting of ten data points, each containing one feature. because there is only one feature, the weight vector w contains only a single parameter to learn, w1. ( left ) observe that linear regression learns to set w1 such that the line y = w1x comes as close as possible to passing through all the training points. the plotted point indicates the value of ( right ) w1 found by the normal equations, which we can see minimizes the mean squared error on the training set. ⇒∇w x ( ) train w y − ( ) train x ( ) train w y − ( ) train = 0 ( 5. 9 ) ⇒∇w wx ( ) train x ( ) train w w −2 x ( ) train y ( ) train + y ( ) train y	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	124	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
( ) train x ( ) train w y − ( ) train = 0 ( 5. 9 ) ⇒∇w wx ( ) train x ( ) train w w −2 x ( ) train y ( ) train + y ( ) train y ( ) train = 0 ( 5. 10 ) ⇒2x ( ) train x ( ) train w x −2 ( ) train y ( ) train = 0 ( 5. 11 ) ⇒w = x ( ) train x ( ) train −1 x ( ) train y ( ) train ( 5. 12 ) the system of equations whose solution is given by equation is known as 5. 12 the normal equations. evaluating equation constitutes a simple learning 5. 12 algorithm. for an example of the linear regression learning algorithm in action, see ﬁgure. 5. 1 it is worth noting that the term linear regression is often used to refer to a slightly more sophisticated model with one additional parameter — an intercept term. in this model b [UNK] = wx + b ( 5. 13 ) so the mapping from parameters to predictions is still a linear function but the mapping from features to predictions is now an [UNK] function. this extension to [UNK] functions means that the plot of the model ’ s predictions still looks like a line, but	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	124	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
. 13 ) so the mapping from parameters to predictions is still a linear function but the mapping from features to predictions is now an [UNK] function. this extension to [UNK] functions means that the plot of the model ’ s predictions still looks like a line, but it need not pass through the origin. instead of adding the bias parameter 109	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	124	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics b, one can continue to use the model with only weights but augment x with an extra entry that is always set to. the weight corresponding to the extra entry 1 1 plays the role of the bias parameter. we will frequently use the term “ linear ” when referring to [UNK] functions throughout this book. the intercept term b is often called the bias parameter of the [UNK] transfor - mation. this terminology derives from the point of view that the output of the transformation is biased toward being b in the absence of any input. this term is [UNK] from the idea of a statistical bias, in which a statistical estimation algorithm ’ s expected estimate of a quantity is not equal to the true quantity. linear regression is of course an extremely simple and limited learning algorithm, but it provides an example of how a learning algorithm can work. in the subsequent sections we will describe some of the basic principles underlying learning algorithm design and demonstrate how these principles can be used to build more complicated learning algorithms. 5. 2 capacity, overﬁtting and underﬁtting the central challenge in machine learning is that we must perform well on new, previously unseen inputs — not just those on which our model was trained. the ability to perform well on previously unobserved inputs is called	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	125	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
, overﬁtting and underﬁtting the central challenge in machine learning is that we must perform well on new, previously unseen inputs — not just those on which our model was trained. the ability to perform well on previously unobserved inputs is called generalization. typically, when training a machine learning model, we have access to a training set, we can compute some error measure on the training set called the training error, and we reduce this training error. so far, what we have described is simply an optimization problem. what separates machine learning from optimization is that we want the generalization error, also called the test error, to be low as well. the generalization error is deﬁned as the expected value of the error on a new input. here the expectation is taken across [UNK] possible inputs, drawn from the distribution of inputs we expect the system to encounter in practice. we typically estimate the generalization error of a machine learning model by measuring its performance on a test set of examples that were collected separately from the training set. in our linear regression example, we trained the model by minimizing the training error, 1 m ( ) train \| \| x ( ) train w y − ( ) train \| \| 2 2, ( 5. 14 ) but we actually	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	125	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
set. in our linear regression example, we trained the model by minimizing the training error, 1 m ( ) train \| \| x ( ) train w y − ( ) train \| \| 2 2, ( 5. 14 ) but we actually care about the test error, 1 m ( ) test \| \| x ( ) test w y − ( ) test \| \| 2 2. how can we [UNK] performance on the test set when we get to observe only the 110	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	125	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics training set? the ﬁeld of statistical learning theory provides some answers. if the training and the test set are collected arbitrarily, there is indeed little we can do. if we are allowed to make some assumptions about how the training and test set are collected, then we can make some progress. the train and test data are generated by a probability distribution over datasets called the data generating process. we typically make a set of assumptions known collectively as the i. i. d. assumptions. these assumptions are that the examples in each dataset are independent from each other, and that the train set and test set are identically distributed, drawn from the same probability distribution as each other. this assumption allows us to describe the data gen - erating process with a probability distribution over a single example. the same distribution is then used to generate every train example and every test example. we call that shared underlying distribution the data generating distribution, denoted pdata. this probabilistic framework and the i. i. d. assumptions allow us to mathematically study the relationship between training error and test error. one immediate connection we can observe between the training and test error is that the expected training error of a randomly selected model is equal to the	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	126	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
the i. i. d. assumptions allow us to mathematically study the relationship between training error and test error. one immediate connection we can observe between the training and test error is that the expected training error of a randomly selected model is equal to the expected test error of that model. suppose we have a probability distribution p ( x, y ) and we sample from it repeatedly to generate the train set and the test set. for some ﬁxed value w, the expected training set error is exactly the same as the expected test set error, because both expectations are formed using the same dataset sampling process. the only [UNK] between the two conditions is the name we assign to the dataset we sample. of course, when we use a machine learning algorithm, we do not ﬁx the parameters ahead of time, then sample both datasets. we sample the training set, then use it to choose the parameters to reduce training set error, then sample the test set. under this process, the expected test error is greater than or equal to the expected value of training error. the factors determining how well a machine learning algorithm will perform are its ability to : 1. make the training error small. 2. make the gap between training and test error small. these two factors correspond to	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	126	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
equal to the expected value of training error. the factors determining how well a machine learning algorithm will perform are its ability to : 1. make the training error small. 2. make the gap between training and test error small. these two factors correspond to the two central challenges in machine learning : underﬁtting and overﬁtting. underﬁtting occurs when the model is not able to obtain a [UNK] low error value on the training set. overﬁtting occurs when the gap between the training error and test error is too large. we can control whether a model is more likely to overﬁt or underﬁt by altering its capacity. informally, a model ’ s capacity is its ability to ﬁt a wide variety of 111	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	126	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics functions. models with low capacity may struggle to ﬁt the training set. models with high capacity can overﬁt by memorizing properties of the training set that do not serve them well on the test set. one way to control the capacity of a learning algorithm is by choosing its hypothesis space, the set of functions that the learning algorithm is allowed to select as being the solution. for example, the linear regression algorithm has the set of all linear functions of its input as its hypothesis space. we can generalize linear regression to include polynomials, rather than just linear functions, in its hypothesis space. doing so increases the model ’ s capacity. a polynomial of degree one gives us the linear regression model with which we are already familiar, with prediction [UNK] b wx. = + ( 5. 15 ) by introducing x2 as another feature provided to the linear regression model, we can learn a model that is quadratic as a function of : x [UNK] b w = + 1x w + 2x2. ( 5. 16 ) though this model implements a quadratic function of its, the output is input still a linear function of the parameters, so we can still use the normal equations to train the model in closed form. we can continue	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	127	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##x2. ( 5. 16 ) though this model implements a quadratic function of its, the output is input still a linear function of the parameters, so we can still use the normal equations to train the model in closed form. we can continue to add more powers of x as additional features, for example to obtain a polynomial of degree 9 : [UNK] b = + 9 i = 1 wixi. ( 5. 17 ) machine learning algorithms will generally perform best when their capacity is appropriate for the true complexity of the task they need to perform and the amount of training data they are provided with. models with [UNK] capacity are unable to solve complex tasks. models with high capacity can solve complex tasks, but when their capacity is higher than needed to solve the present task they may overﬁt. figure shows this principle in action. we compare a linear, quadratic 5. 2 and degree - 9 predictor attempting to ﬁt a problem where the true underlying function is quadratic. the linear function is unable to capture the curvature in the true underlying problem, so it underﬁts. the degree - 9 predictor is capable of representing the correct function, but it is also capable of representing inﬁnitely many other functions that pass exactly through the training points, because	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	127	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
in the true underlying problem, so it underﬁts. the degree - 9 predictor is capable of representing the correct function, but it is also capable of representing inﬁnitely many other functions that pass exactly through the training points, because we 112	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	127	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics have more parameters than training examples. we have little chance of choosing a solution that generalizes well when so many wildly [UNK] solutions exist. in this example, the quadratic model is perfectly matched to the true structure of the task so it generalizes well to new data. figure 5. 2 : we ﬁt three models to this example training set. the training data was generated synthetically, by randomly sampling x values and choosing y deterministically by evaluating a quadratic function. ( left ) a linear function ﬁt to the data [UNK] from underﬁtting — it cannot capture the curvature that is present in the data. a ( center ) quadratic function ﬁt to the data generalizes well to unseen points. it does not [UNK] from a signiﬁcant amount of overﬁtting or underﬁtting. a polynomial of degree 9 ﬁt to ( right ) the data [UNK] from overﬁtting. here we used the moore - penrose pseudoinverse to solve the underdetermined normal equations. the solution passes through all of the training points exactly, but we have not been lucky enough for it to extract the correct structure. it now has a deep valley in between two training points that does not appear in the true	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	128	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##determined normal equations. the solution passes through all of the training points exactly, but we have not been lucky enough for it to extract the correct structure. it now has a deep valley in between two training points that does not appear in the true underlying function. it also increases sharply on the left side of the data, while the true function decreases in this area. so far we have described only one way of changing a model ’ s capacity : by changing the number of input features it has, and simultaneously adding new parameters associated with those features. there are in fact many ways of changing a model ’ s capacity. capacity is not determined only by the choice of model. the model speciﬁes which family of functions the learning algorithm can choose from when varying the parameters in order to reduce a training objective. this is called the representational capacity of the model. in many cases, ﬁnding the best function within this family is a very [UNK] optimization problem. in practice, the learning algorithm does not actually ﬁnd the best function, but merely one that signiﬁcantly reduces the training error. these additional limitations, such as 113	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	128	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics the imperfection of the optimization algorithm, mean that the learning algorithm ’ s [UNK] capacity may be less than the representational capacity of the model family. our modern ideas about improving the generalization of machine learning models are reﬁnements of thought dating back to philosophers at least as early as ptolemy. many early scholars invoke a principle of parsimony that is now most widely known as occam ’ s razor ( c. 1287 - 1347 ). this principle states that among competing hypotheses that explain known observations equally well, one should choose the “ simplest ” one. this idea was formalized and made more precise in the 20th century by the founders of statistical learning theory ( vapnik and chervonenkis 1971 vapnik 1982 blumer 1989 vapnik 1995, ;, ; et al., ;, ). statistical learning theory provides various means of quantifying model capacity. among these, the most well - known is the vapnik - chervonenkis dimension, or vc dimension. the vc dimension measures the capacity of a binary classiﬁer. the vc dimension is deﬁned as being the largest possible value of m for which there exists a training set of m [UNK]	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	129	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
- chervonenkis dimension, or vc dimension. the vc dimension measures the capacity of a binary classiﬁer. the vc dimension is deﬁned as being the largest possible value of m for which there exists a training set of m [UNK] x points that the classiﬁer can label arbitrarily. quantifying the capacity of the model allows statistical learning theory to make quantitative predictions. the most important results in statistical learning theory show that the discrepancy between training error and generalization error is bounded from above by a quantity that grows as the model capacity grows but shrinks as the number of training examples increases ( vapnik and chervonenkis, 1971 vapnik 1982 blumer 1989 vapnik 1995 ;, ; et al., ;, ). these bounds provide intellectual justiﬁcation that machine learning algorithms can work, but they are rarely used in practice when working with deep learning algorithms. this is in part because the bounds are often quite loose and in part because it can be quite [UNK] to determine the capacity of deep learning algorithms. the problem of determining the capacity of a deep learning model is especially [UNK] because the [UNK] capacity is limited by the capabilities of the optimization algorithm, and we have little theoretical understanding of the very	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	129	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
can be quite [UNK] to determine the capacity of deep learning algorithms. the problem of determining the capacity of a deep learning model is especially [UNK] because the [UNK] capacity is limited by the capabilities of the optimization algorithm, and we have little theoretical understanding of the very general non - convex optimization problems involved in deep learning. we must remember that while simpler functions are more likely to generalize ( to have a small gap between training and test error ) we must still choose a [UNK] complex hypothesis to achieve low training error. typically, training error decreases until it asymptotes to the minimum possible error value as model capacity increases ( assuming the error measure has a minimum value ). typically, generalization error has a u - shaped curve as a function of model capacity. this is illustrated in ﬁgure. 5. 3 to reach the most extreme case of arbitrarily high capacity, we introduce 114	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	129	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics 0 optimal capacity capacity error underﬁtting zone overﬁtting zone generalization gap training error generalization error figure 5. 3 : typical relationship between capacity and error. training and test error behave [UNK]. at the left end of the graph, training error and generalization error are both high. this is the underﬁtting regime. as we increase capacity, training error decreases, but the gap between training and generalization error increases. eventually, the size of this gap outweighs the decrease in training error, and we enter theoverﬁtting regime, where capacity is too large, above the optimal capacity. the concept of non - parametric models. so far, we have seen only parametric models, such as linear regression. parametric models learn a function described by a parameter vector whose size is ﬁnite and ﬁxed before any data is observed. non - parametric models have no such limitation. sometimes, non - parametric models are just theoretical abstractions ( such as an algorithm that searches over all possible probability distributions ) that cannot be implemented in practice. however, we can also design practical non - parametric models by making their complexity a function of the training set size. one example of such an algorithm is nearest neighbor regression.	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	130	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
that searches over all possible probability distributions ) that cannot be implemented in practice. however, we can also design practical non - parametric models by making their complexity a function of the training set size. one example of such an algorithm is nearest neighbor regression. unlike linear regression, which has a ﬁxed - length vector of weights, the nearest neighbor regression model simply stores the x and y from the training set. when asked to classify a test point x, the model looks up the nearest entry in the training set and returns the associated regression target. in other words, [UNK] = yi where i = arg min \| \| xi, : − \| \| x 2 2. the algorithm can also be generalized to distance metrics other than the l2 norm, such as learned distance metrics (, ). if the algorithm is goldberger et al. 2005 allowed to break ties by averaging the yi values for all xi, : that are tied for nearest, then this algorithm is able to achieve the minimum possible training error ( which might be greater than zero, if two identical inputs are associated with [UNK] outputs ) on any regression dataset. finally, we can also create a non - parametric learning algorithm by wrapping a 115	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	130	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics parametric learning algorithm inside another algorithm that increases the number of parameters as needed. for example, we could imagine an outer loop of learning that changes the degree of the polynomial learned by linear regression on top of a polynomial expansion of the input. the ideal model is an oracle that simply knows the true probability distribution that generates the data. even such a model will still incur some error on many problems, because there may still be some noise in the distribution. in the case of supervised learning, the mapping from x to y may be inherently stochastic, or y may be a deterministic function that involves other variables besides those included in x. the error incurred by an oracle making predictions from the true distribution is called the p, y ( x ) bayes error. training and generalization error vary as the size of the training set varies. expected generalization error can never increase as the number of training examples increases. for non - parametric models, more data yields better generalization until the best possible error is achieved. any ﬁxed parametric model with less than optimal capacity will asymptote to an error value that exceeds the bayes error. see ﬁgure for an illustration. note that it is possible for the model to	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	131	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
best possible error is achieved. any ﬁxed parametric model with less than optimal capacity will asymptote to an error value that exceeds the bayes error. see ﬁgure for an illustration. note that it is possible for the model to have optimal 5. 4 capacity and yet still have a large gap between training and generalization error. in this situation, we may be able to reduce this gap by gathering more training examples. 5. 2. 1 the no free lunch theorem learning theory claims that a machine learning algorithm can generalize well from a ﬁnite training set of examples. this seems to contradict some basic principles of logic. inductive reasoning, or inferring general rules from a limited set of examples, is not logically valid. to logically infer a rule describing every member of a set, one must have information about every member of that set. in part, machine learning avoids this problem by [UNK] only probabilistic rules, rather than the entirely certain rules used in purely logical reasoning. machine learning promises to ﬁnd rules that are probably most correct about members of the set they concern. unfortunately, even this does not resolve the entire problem. the no free lunch theorem for machine learning ( wolpert 1996, ) states	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	131	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
logical reasoning. machine learning promises to ﬁnd rules that are probably most correct about members of the set they concern. unfortunately, even this does not resolve the entire problem. the no free lunch theorem for machine learning ( wolpert 1996, ) states that, averaged over all possible data generating distributions, every classiﬁcation algorithm has the same error rate when classifying previously unobserved points. in other words, in some sense, no machine learning algorithm is universally any better than any other. the most sophisticated algorithm we can conceive of has the same average 116	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	131	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics figure 5. 4 : the [UNK] of the training dataset size on the train and test error, as well as on the optimal model capacity. we constructed a synthetic regression problem based on adding a moderate amount of noise to a degree - 5 polynomial, generated a single test set, and then generated several [UNK] sizes of training set. for each size, we generated 40 [UNK] training sets in order to plot error bars showing 95 percent conﬁdence intervals. ( top ) the mse on the training and test set for two [UNK] models : a quadratic model, and a model with degree chosen to minimize the test error. both are ﬁt in closed form. for the quadratic model, the training error increases as the size of the training set increases. this is because larger datasets are harder to ﬁt. simultaneously, the test error decreases, because fewer incorrect hypotheses are consistent with the training data. the quadratic model does not have enough capacity to solve the task, so its test error asymptotes to a high value. the test error at optimal capacity asymptotes to the bayes error. the training error can fall below the bayes error, due to the ability of the training algorithm	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	132	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
so its test error asymptotes to a high value. the test error at optimal capacity asymptotes to the bayes error. the training error can fall below the bayes error, due to the ability of the training algorithm to memorize speciﬁc instances of the training set. as the training size increases to inﬁnity, the training error of any ﬁxed - capacity model ( here, the quadratic model ) must rise to at least the bayes error. as the training set size increases, the optimal capacity ( bottom ) ( shown here as the degree of the optimal polynomial regressor ) increases. the optimal capacity plateaus after reaching [UNK] complexity to solve the task. 117	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	132	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics performance ( over all possible tasks ) as merely predicting that every point belongs to the same class. fortunately, these results hold only when we average over possible data all generating distributions. if we make assumptions about the kinds of probability distributions we encounter in real - world applications, then we can design learning algorithms that perform well on these distributions. this means that the goal of machine learning research is not to seek a universal learning algorithm or the absolute best learning algorithm. instead, our goal is to understand what kinds of distributions are relevant to the “ real world ” that an ai agent experiences, and what kinds of machine learning algorithms perform well on data drawn from the kinds of data generating distributions we care about. 5. 2. 2 regularization the no free lunch theorem implies that we must design our machine learning algorithms to perform well on a speciﬁc task. we do so by building a set of preferences into the learning algorithm. when these preferences are aligned with the learning problems we ask the algorithm to solve, it performs better. so far, the only method of modifying a learning algorithm that we have discussed concretely is to increase or decrease the model ’ s representational capacity by adding or removing functions from the hypothesis space of solutions the learning algorithm is able to	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	133	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
it performs better. so far, the only method of modifying a learning algorithm that we have discussed concretely is to increase or decrease the model ’ s representational capacity by adding or removing functions from the hypothesis space of solutions the learning algorithm is able to choose. we gave the speciﬁc example of increasing or decreasing the degree of a polynomial for a regression problem. the view we have described so far is oversimpliﬁed. the behavior of our algorithm is strongly [UNK] not just by how large we make the set of functions allowed in its hypothesis space, but by the speciﬁc identity of those functions. the learning algorithm we have studied so far, linear regression, has a hypothesis space consisting of the set of linear functions of its input. these linear functions can be very useful for problems where the relationship between inputs and outputs truly is close to linear. they are less useful for problems that behave in a very nonlinear fashion. for example, linear regression would not perform very well if we tried to use it to predict sin ( x ) from x. we can thus control the performance of our algorithms by choosing what kind of functions we allow them to draw solutions from, as well as by controlling the amount of these functions. we can also give a learning algorithm a	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	133	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
predict sin ( x ) from x. we can thus control the performance of our algorithms by choosing what kind of functions we allow them to draw solutions from, as well as by controlling the amount of these functions. we can also give a learning algorithm a preference for one solution in its hypothesis space to another. this means that both functions are eligible, but one is preferred. the unpreferred solution will be chosen only if it ﬁts the training 118	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	133	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics data signiﬁcantly better than the preferred solution. for example, we can modify the training criterion for linear regression to include weight decay. to perform linear regression with weight decay, we minimize a sum comprising both the mean squared error on the training and a criterion j ( w ) that expresses a preference for the weights to have smaller squaredl2 norm. speciﬁcally, j ( ) = w msetrain + λww, ( 5. 18 ) where λ is a value chosen ahead of time that controls the strength of our preference for smaller weights. when λ = 0, we impose no preference, and larger λ forces the weights to become smaller. minimizing j ( w ) results in a choice of weights that make a [UNK] ﬁtting the training data and being small. this gives us solutions that have a smaller slope, or put weight on fewer of the features. as an example of how we can control a model ’ s tendency to overﬁt or underﬁt via weight decay, we can train a high - degree polynomial regression model with [UNK] values of. see ﬁgure for the results. λ 5. 5 figure 5. 5 : we ﬁt a high - degree polynomial regression model to our	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	134	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##ﬁt via weight decay, we can train a high - degree polynomial regression model with [UNK] values of. see ﬁgure for the results. λ 5. 5 figure 5. 5 : we ﬁt a high - degree polynomial regression model to our example training set from ﬁgure. the true function is quadratic, but here we use only models with degree 9. 5. 2 we vary the amount of weight decay to prevent these high - degree models from overﬁtting. ( left ) with very large λ, we can force the model to learn a function with no slope at all. this underﬁts because it can only represent a constant function. with a ( center ) medium value of, the learning algorithm recovers a curve with the right general shape. λ even though the model is capable of representing functions with much more complicated shape, weight decay has encouraged it to use a simpler function described by smaller [UNK]. with weight decay approaching zero ( i. e., using the moore - penrose ( right ) pseudoinverse to solve the underdetermined problem with minimal regularization ), the degree - 9 polynomial overﬁts signiﬁcantly, as we saw in ﬁgure. 5. 2 119	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	134	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 5. machine learning basics more generally, we can regularize a model that learns a function f ( x ; θ ) by adding a penalty called a regularizer to the cost function. in the case of weight decay, the regularizer is ω ( w ) = w w. in chapter, we will see that many other 7 regularizers are possible. expressing preferences for one function over another is a more general way of controlling a model ’ s capacity than including or excluding members from the hypothesis space. we can think of excluding a function from a hypothesis space as expressing an inﬁnitely strong preference against that function. in our weight decay example, we expressed our preference for linear functions deﬁned with smaller weights explicitly, via an extra term in the criterion we minimize. there are many other ways of expressing preferences for [UNK] solutions, both implicitly and explicitly. together, these [UNK] approaches are known as regularization. regularization is any modiﬁcation we make to a learning algorithm that is intended to reduce its generalization error but not its training error. regularization is one of the central concerns of the ﬁeld of machine learning, rivaled in its importance only by optimization. the no free lunch theorem has made it clear that there is no best machine	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	135	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
its generalization error but not its training error. regularization is one of the central concerns of the ﬁeld of machine learning, rivaled in its importance only by optimization. the no free lunch theorem has made it clear that there is no best machine learning algorithm, and, in particular, no best form of regularization. instead we must choose a form of regularization that is well - suited to the particular task we want to solve. the philosophy of deep learning in general and this book in particular is that a very wide range of tasks ( such as all of the intellectual tasks that people can do ) may all be solved [UNK] using very general - purpose forms of regularization. 5. 3 hyperparameters and validation sets most machine learning algorithms have several settings that we can use to control the behavior of the learning algorithm. these settings are called hyperparame - ters. the values of hyperparameters are not adapted by the learning algorithm itself ( though we can design a nested learning procedure where one learning algorithm learns the best hyperparameters for another learning algorithm ). in the polynomial regression example we saw in ﬁgure, there is a single 5. 2 hyperparameter : the degree of the polynomial, which acts as a capacity hyper - parameter	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	135	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
learns the best hyperparameters for another learning algorithm ). in the polynomial regression example we saw in ﬁgure, there is a single 5. 2 hyperparameter : the degree of the polynomial, which acts as a capacity hyper - parameter. the λ value used to control the strength of weight decay is another example of a hyperparameter. sometimes a setting is chosen to be a hyperparameter that the learning al - gorithm does not learn because it is [UNK] to optimize. more frequently, the 120	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	135	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)