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
exponentially with the depth of the forward propagation graph. this large cost would be incurred because the same computation for ∂u ( ) i ∂u ( ) j would be redone many times. to avoid such recomputation, we can think of back - propagation as a table - ﬁlling algorithm that takes advantage of storing intermediate results ∂u ( ) n ∂u ( ) i. each node in the graph has a corresponding slot in a table to store the gradient for that node. by ﬁlling in these table entries in order, 218	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	233	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 6. deep feedforward networks back - propagation avoids repeating many common subexpressions. this table - ﬁlling strategy is sometimes called. dynamic programming 6. 5. 7 example : back - propagation for mlp training as an example, we walk through the back - propagation algorithm as it is used to train a multilayer perceptron. here we develop a very simple multilayer perception with a single hidden layer. to train this model, we will use minibatch stochastic gradient descent. the back - propagation algorithm is used to compute the gradient of the cost on a single minibatch. speciﬁcally, we use a minibatch of examples from the training set formatted as a design matrix x and a vector of associated class labels y. the network computes a layer of hidden features h = max { 0, xw ( 1 ) }. to simplify the presentation we do not use biases in this model. we assume that our graph language includes a relu operation that can compute max { 0, z } element - wise. the predictions of the unnormalized log probabilities over classes are then given by hw ( 2 ). we assume that our graph language includes a cross _ entropy operation	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	234	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
operation that can compute max { 0, z } element - wise. the predictions of the unnormalized log probabilities over classes are then given by hw ( 2 ). we assume that our graph language includes a cross _ entropy operation that computes the cross - entropy between the targets y and the probability distribution deﬁned by these unnormalized log probabilities. the resulting cross - entropy deﬁnes the cost jmle. minimizing this cross - entropy performs maximum likelihood estimation of the classiﬁer. however, to make this example more realistic, we also include a regularization term. the total cost j j = mle + λ i, j w ( 1 ) i, j 2 + i, j w ( 2 ) i, j 2 ( 6. 56 ) consists of the cross - entropy and a weight decay term with [UNK] λ. the computational graph is illustrated in ﬁgure. 6. 11 the computational graph for the gradient of this example is large enough that it would be tedious to draw or to read. this demonstrates one of the beneﬁts of the back - propagation algorithm, which is that it can automatically generate gradients that would be straightforward but tedious for a software engineer to derive	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	234	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
that it would be tedious to draw or to read. this demonstrates one of the beneﬁts of the back - propagation algorithm, which is that it can automatically generate gradients that would be straightforward but tedious for a software engineer to derive manually. we can roughly trace out the behavior of the back - propagation algorithm by looking at the forward propagation graph in ﬁgure. to train, we wish 6. 11 to compute both ∇w ( 1 ) j and ∇w ( 2 ) j. there are two [UNK] paths leading backward from j to the weights : one through the cross - entropy cost, and one through the weight decay cost. the weight decay cost is relatively simple ; it will always contribute 2λw ( ) i to the gradient on w ( ) i. 219	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	234	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 6. deep feedforward networks x w ( 1 ) w ( 1 ) u ( 1 ) u ( 1 ) matmul h relu u ( 3 ) u ( 3 ) sqr u ( 4 ) u ( 4 ) sum λ u ( 7 ) u ( 7 ) w ( 2 ) w ( 2 ) u ( 2 ) u ( 2 ) matmul y j mle j mle cross _ entropy u ( 5 ) u ( 5 ) sqr u ( 6 ) u ( 6 ) sum u ( 8 ) u ( 8 ) j + × + figure 6. 11 : the computational graph used to compute the cost used to train our example of a single - layer mlp using the cross - entropy loss and weight decay. the other path through the cross - entropy cost is slightly more complicated. let g be the gradient on the unnormalized log probabilities u ( 2 ) provided by the cross _ entropy operation. the back - propagation algorithm now needs to explore two [UNK] branches. on the shorter branch, it adds h g to the gradient on w ( 2 ), using the back - propagation rule for the second argument to the matrix multiplication operation. the other branch corresponds to the longer chain descending further along the network.	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	235	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
branches. on the shorter branch, it adds h g to the gradient on w ( 2 ), using the back - propagation rule for the second argument to the matrix multiplication operation. the other branch corresponds to the longer chain descending further along the network. first, the back - propagation algorithm computes ∇hj = gw ( 2 ) using the back - propagation rule for the ﬁrst argument to the matrix multiplication operation. next, the relu operation uses its back - propagation rule to zero out components of the gradient corresponding to entries of u ( 1 ) that were less than. let the result be called 0 g. the last step of the back - propagation algorithm is to use the back - propagation rule for the second argument of the operation to add matmul xgto the gradient on w ( 1 ). after these gradients have been computed, it is the responsibility of the gradient descent algorithm, or another optimization algorithm, to use these gradients to update the parameters. for the mlp, the computational cost is dominated by the cost of matrix multiplication. during the forward propagation stage, we multiply by each weight 220	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	235	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 6. deep feedforward networks matrix, resulting in o ( w ) multiply - adds, where w is the number of weights. during the backward propagation stage, we multiply by the transpose of each weight matrix, which has the same computational cost. the main memory cost of the algorithm is that we need to store the input to the nonlinearity of the hidden layer. this value is stored from the time it is computed until the backward pass has returned to the same point. the memory cost is thus o ( mnh ), where m is the number of examples in the minibatch and nh is the number of hidden units. 6. 5. 8 complications our description of the back - propagation algorithm here is simpler than the imple - mentations actually used in practice. as noted above, we have restricted the deﬁnition of an operation to be a function that returns a single tensor. most software implementations need to support operations that can return more than one tensor. for example, if we wish to compute both the maximum value in a tensor and the index of that value, it is best to compute both in a single pass through memory, so it is most [UNK] to implement this procedure as a single operation with two outputs. we have not	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	236	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
wish to compute both the maximum value in a tensor and the index of that value, it is best to compute both in a single pass through memory, so it is most [UNK] to implement this procedure as a single operation with two outputs. we have not described how to control the memory consumption of back - propagation. back - propagation often involves summation of many tensors together. in the naive approach, each of these tensors would be computed separately, then all of them would be added in a second step. the naive approach has an overly high memory bottleneck that can be avoided by maintaining a single [UNK] and adding each value to that [UNK] as it is computed. real - world implementations of back - propagation also need to handle various data types, such as 32 - bit ﬂoating point, 64 - bit ﬂoating point, and integer values. the policy for handling each of these types takes special care to design. some operations have undeﬁned gradients, and it is important to track these cases and determine whether the gradient requested by the user is undeﬁned. various other technicalities make real - world [UNK] more complicated. these technicalities are not insurmountable, and this chapter has described the key intellectual tools needed to compute derivatives, but it	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	236	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
the gradient requested by the user is undeﬁned. various other technicalities make real - world [UNK] more complicated. these technicalities are not insurmountable, and this chapter has described the key intellectual tools needed to compute derivatives, but it is important to be aware that many more subtleties exist. 6. 5. 9 [UNK] outside the deep learning community the deep learning community has been somewhat isolated from the broader computer science community and has largely developed its own cultural attitudes 221	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	236	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 6. deep feedforward networks concerning how to perform [UNK]. more generally, the ﬁeld of automatic [UNK] is concerned with how to compute derivatives algorithmically. the back - propagation algorithm described here is only one approach to automatic [UNK]. it is a special case of a broader class of techniques called reverse mode accumulation. other approaches evaluate the subexpressions of the chain rule in [UNK] orders. in general, determining the order of evaluation that results in the lowest computational cost is a [UNK] problem. finding the optimal sequence of operations to compute the gradient is np - complete (, ), naumann 2008 in the sense that it may require simplifying algebraic expressions into their least expensive form. for example, suppose we have variables p1, p2,..., pn representing probabilities and variables z1, z2,..., zn representing unnormalized log probabilities. suppose we deﬁne qi = exp ( zi ) i exp ( zi ), ( 6. 57 ) where we build the softmax function out of exponentiation, summation and division operations, and construct a cross - entropy loss j = − i pilog qi. a human mathematician can observe that the derivative of	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	237	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
), ( 6. 57 ) where we build the softmax function out of exponentiation, summation and division operations, and construct a cross - entropy loss j = − i pilog qi. a human mathematician can observe that the derivative of j with respect to zi takes a very simple form : qi −pi. the back - propagation algorithm is not capable of simplifying the gradient this way, and will instead explicitly propagate gradients through all of the logarithm and exponentiation operations in the original graph. some software libraries such as theano (, ;, ) are able to bergstra et al. 2010 bastien et al. 2012 perform some kinds of algebraic substitution to improve over the graph proposed by the pure back - propagation algorithm. when the forward graph g has a single output node and each partial derivative ∂u ( ) i ∂u ( ) j can be computed with a constant amount of computation, back - propagation guarantees that the number of computations for the gradient computation is of the same order as the number of computations for the forward computation : this can be seen in algorithm because each local partial derivative 6. 2 ∂u ( ) i ∂u ( ) j needs to be computed only once along with an associated	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	237	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
is of the same order as the number of computations for the forward computation : this can be seen in algorithm because each local partial derivative 6. 2 ∂u ( ) i ∂u ( ) j needs to be computed only once along with an associated multiplication and addition for the recursive chain - rule formulation ( equation ). the overall computation is 6. 49 therefore o ( # edges ). however, it can potentially be reduced by simplifying the computational graph constructed by back - propagation, and this is an np - complete task. implementations such as theano and tensorflow use heuristics based on matching known simpliﬁcation patterns in order to iteratively attempt to simplify the graph. we deﬁned back - propagation only for the computation of a gradient of a scalar output but back - propagation can be extended to compute a jacobian ( either of k [UNK] scalar nodes in the graph, or of a tensor - valued node containing k values ). a naive implementation may then need k times more computation : for 222	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	237	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 6. deep feedforward networks each scalar internal node in the original forward graph, the naive implementation computes k gradients instead of a single gradient. when the number of outputs of the graph is larger than the number of inputs, it is sometimes preferable to use another form of automatic [UNK] called forward mode accumulation. forward mode computation has been proposed for obtaining real - time computation of gradients in recurrent networks, for example (, ). this williams and zipser 1989 also avoids the need to store the values and gradients for the whole graph, trading [UNK] [UNK] for memory. the relationship between forward mode and backward mode is analogous to the relationship between left - multiplying versus right - multiplying a sequence of matrices, such as abcd, ( 6. 58 ) where the matrices can be thought of as jacobian matrices. for example, if d is a column vector while a has many rows, this corresponds to a graph with a single output and many inputs, and starting the multiplications from the end and going backwards only requires matrix - vector products. this corresponds to the backward mode. instead, starting to multiply from the left would involve a series of matrix - matrix products, which makes the whole computation much more expensive. however, if	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	238	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
the end and going backwards only requires matrix - vector products. this corresponds to the backward mode. instead, starting to multiply from the left would involve a series of matrix - matrix products, which makes the whole computation much more expensive. however, if a has fewer rows than d has columns, it is cheaper to run the multiplications left - to - right, corresponding to the forward mode. in many communities outside of machine learning, it is more common to im - plement [UNK] software that acts directly on traditional programming language code, such as python or c code, and automatically generates programs that [UNK] functions written in these languages. in the deep learning com - munity, computational graphs are usually represented by explicit data structures created by specialized libraries. the specialized approach has the drawback of requiring the library developer to deﬁne the bprop methods for every operation and limiting the user of the library to only those operations that have been deﬁned. however, the specialized approach also has the beneﬁt of allowing customized back - propagation rules to be developed for each operation, allowing the developer to improve speed or stability in non - obvious ways that an automatic procedure would presumably be unable to replicate. back - propagation is therefore not the only way or the optimal way of computing the	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	238	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
- propagation rules to be developed for each operation, allowing the developer to improve speed or stability in non - obvious ways that an automatic procedure would presumably be unable to replicate. back - propagation is therefore not the only way or the optimal way of computing the gradient, but it is a very practical method that continues to serve the deep learning community very well. in the future, [UNK] technology for deep networks may improve as deep learning practitioners become more aware of advances in the broader ﬁeld of automatic [UNK]. 223	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	238	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 6. deep feedforward networks 6. 5. 10 higher - order derivatives some software frameworks support the use of higher - order derivatives. among the deep learning software frameworks, this includes at least theano and tensorflow. these libraries use the same kind of data structure to describe the expressions for derivatives as they use to describe the original function being [UNK]. this means that the symbolic [UNK] machinery can be applied to derivatives. in the context of deep learning, it is rare to compute a single second derivative of a scalar function. instead, we are usually interested in properties of the hessian matrix. if we have a function f : rn →r, then the hessian matrix is of size n n ×. in typical deep learning applications, n will be the number of parameters in the model, which could easily number in the billions. the entire hessian matrix is thus infeasible to even represent. instead of explicitly computing the hessian, the typical deep learning approach is to use krylov methods. krylov methods are a set of iterative techniques for performing various operations like approximately inverting a matrix or ﬁnding approximations to its eigenvectors or eigenvalues, without using any operation other than matrix - vector products	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	239	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
. krylov methods are a set of iterative techniques for performing various operations like approximately inverting a matrix or ﬁnding approximations to its eigenvectors or eigenvalues, without using any operation other than matrix - vector products. in order to use krylov methods on the hessian, we only need to be able to compute the product between the hessian matrix h and an arbitrary vector v. a straightforward technique (, ) for doing so is to compute christianson 1992 hv = ∇x ( ∇xf x ( ) ) v. ( 6. 59 ) both of the gradient computations in this expression may be computed automati - cally by the appropriate software library. note that the outer gradient expression takes the gradient of a function of the inner gradient expression. if v is itself a vector produced by a computational graph, it is important to specify that the automatic [UNK] software should not [UNK] through the graph that produced. v while computing the hessian is usually not advisable, it is possible to do with hessian vector products. one simply computes he ( ) i for all i = 1,..., n, where e ( ) i is the one - hot vector with e ( ) i i =	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	239	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
, it is possible to do with hessian vector products. one simply computes he ( ) i for all i = 1,..., n, where e ( ) i is the one - hot vector with e ( ) i i = 1 and all other entries equal to 0. 6. 6 historical notes feedforward networks can be seen as [UNK] nonlinear function approximators based on using gradient descent to minimize the error in a function approximation. 224	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	239	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 6. deep feedforward networks from this point of view, the modern feedforward network is the culmination of centuries of progress on the general function approximation task. the chain rule that underlies the back - propagation algorithm was invented in the 17th century (, ;, ). calculus and algebra have leibniz 1676 l ’ hopital 1696 long been used to solve optimization problems in closed form, but gradient descent was not introduced as a technique for iteratively approximating the solution to optimization problems until the 19th century ( cauchy 1847, ). beginning in the 1940s, these function approximation techniques were used to motivate machine learning models such as the perceptron. however, the earliest models were based on linear models. critics including marvin minsky pointed out several of the ﬂaws of the linear model family, such as its inability to learn the xor function, which led to a backlash against the entire neural network approach. learning nonlinear functions required the development of a multilayer per - ceptron and a means of computing the gradient through such a model. [UNK] applications of the chain rule based on dynamic programming began to appear in the 1960s and 1970s, mostly for control applications (, ; kelley 1960 bryson and denham 1961	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	240	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
per - ceptron and a means of computing the gradient through such a model. [UNK] applications of the chain rule based on dynamic programming began to appear in the 1960s and 1970s, mostly for control applications (, ; kelley 1960 bryson and denham 1961 dreyfus 1962 bryson and ho 1969 dreyfus 1973, ;, ;, ;, ) but also for sensitivity analysis (, ). linnainmaa 1976 werbos 1981 ( ) proposed applying these techniques to training artiﬁcial neural networks. the idea was ﬁnally developed in practice after being independently rediscovered in [UNK] ways (, ; lecun 1985 parker 1985 rumelhart 1986a, ; et al., ). the book parallel distributed pro - cessing presented the results of some of the ﬁrst successful experiments with back - propagation in a chapter (, ) that contributed greatly rumelhart et al. 1986b to the popularization of back - propagation and initiated a very active period of research in multi - layer neural networks. however, the ideas put forward by the authors of that book and in particular by rumelhart and hinton go much beyond back - propagation. they include crucial ideas about the possible computational implementation of several central aspects of cognition and learning, which came under the name	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	240	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
the ideas put forward by the authors of that book and in particular by rumelhart and hinton go much beyond back - propagation. they include crucial ideas about the possible computational implementation of several central aspects of cognition and learning, which came under the name of “ connectionism ” because of the importance this school of thought places on the connections between neurons as the locus of learning and memory. in particular, these ideas include the notion of distributed representation ( hinton et al., ). 1986 following the success of back - propagation, neural network research gained pop - ularity and reached a peak in the early 1990s. afterwards, other machine learning techniques became more popular until the modern deep learning renaissance that began in 2006. the core ideas behind modern feedforward networks have not changed sub - stantially since the 1980s. the same back - propagation algorithm and the same 225	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	240	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 6. deep feedforward networks approaches to gradient descent are still in use. most of the improvement in neural network performance from 1986 to 2015 can be attributed to two factors. first, larger datasets have reduced the degree to which statistical generalization is a challenge for neural networks. second, neural networks have become much larger, due to more powerful computers, and better software infrastructure. however, a small number of algorithmic changes have improved the performance of neural networks noticeably. one of these algorithmic changes was the replacement of mean squared error with the cross - entropy family of loss functions. mean squared error was popular in the 1980s and 1990s, but was gradually replaced by cross - entropy losses and the principle of maximum likelihood as ideas spread between the statistics community and the machine learning community. the use of cross - entropy losses greatly improved the performance of models with sigmoid and softmax outputs, which had previously [UNK] from saturation and slow learning when using the mean squared error loss. the other major algorithmic change that has greatly improved the performance of feedforward networks was the replacement of sigmoid hidden units with piecewise linear hidden units, such as rectiﬁed linear units. rectiﬁcation using the max { 0, z } function was introduced in	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	241	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
greatly improved the performance of feedforward networks was the replacement of sigmoid hidden units with piecewise linear hidden units, such as rectiﬁed linear units. rectiﬁcation using the max { 0, z } function was introduced in early neural network models and dates back at least as far as the cognitron and neocognitron ( fukushima 1975 1980,, ). these early models did not use rectiﬁed linear units, but instead applied rectiﬁcation to nonlinear functions. despite the early popularity of rectiﬁcation, rectiﬁcation was largely replaced by sigmoids in the 1980s, perhaps because sigmoids perform better when neural networks are very small. as of the early 2000s, rectiﬁed linear units were avoided due to a somewhat superstitious belief that activation functions with non - [UNK] points must be avoided. this began to change in about 2009. jarrett 2009 et al. ( ) observed that “ using a rectifying nonlinearity is the single most important factor in improving the performance of a recognition system ” among several [UNK] factors of neural network architecture design. for small datasets, ( ) observed that using rectifying non - jarrett et al. 2009 linearities is even more important than learning	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	241	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
important factor in improving the performance of a recognition system ” among several [UNK] factors of neural network architecture design. for small datasets, ( ) observed that using rectifying non - jarrett et al. 2009 linearities is even more important than learning the weights of the hidden layers. random weights are [UNK] to propagate useful information through a rectiﬁed linear network, allowing the classiﬁer layer at the top to learn how to map [UNK] feature vectors to class identities. when more data is available, learning begins to extract enough useful knowledge to exceed the performance of randomly chosen parameters. ( ) glorot et al. 2011a showed that learning is far easier in deep rectiﬁed linear networks than in deep networks that have curvature or two - sided saturation in their activation functions. 226	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	241	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 6. deep feedforward networks rectiﬁed linear units are also of historical interest because they show that neuroscience has continued to have an inﬂuence on the development of deep learning algorithms. ( ) motivate rectiﬁed linear units from glorot et al. 2011a biological considerations. the half - rectifying nonlinearity was intended to capture these properties of biological neurons : 1 ) for some inputs, biological neurons are completely inactive. 2 ) for some inputs, a biological neuron ’ s output is proportional to its input. 3 ) most of the time, biological neurons operate in the regime where they are inactive ( i. e., they should have sparse activations ). when the modern resurgence of deep learning began in 2006, feedforward networks continued to have a bad reputation. from about 2006 - 2012, it was widely believed that feedforward networks would not perform well unless they were assisted by other models, such as probabilistic models. today, it is now known that with the right resources and engineering practices, feedforward networks perform very well. today, gradient - based learning in feedforward networks is used as a tool to develop probabilistic models, such as the variational autoencode	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	242	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
known that with the right resources and engineering practices, feedforward networks perform very well. today, gradient - based learning in feedforward networks is used as a tool to develop probabilistic models, such as the variational autoencoder and generative adversarial networks, described in chapter. rather than being viewed as an unreliable 20 technology that must be supported by other techniques, gradient - based learning in feedforward networks has been viewed since 2012 as a powerful technology that may be applied to many other machine learning tasks. in 2006, the community used unsupervised learning to support supervised learning, and now, ironically, it is more common to use supervised learning to support unsupervised learning. feedforward networks continue to have unfulﬁlled potential. in the future, we expect they will be applied to many more tasks, and that advances in optimization algorithms and model design will improve their performance even further. this chapter has primarily described the neural network family of models. in the subsequent chapters, we turn to how to use these models — how to regularize and train them. 227	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	242	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7 regularization for deep learning a central problem in machine learning is how to make an algorithm that will perform well not just on the training data, but also on new inputs. many strategies used in machine learning are explicitly designed to reduce the test error, possibly at the expense of increased training error. these strategies are known collectively as regularization. as we will see there are a great many forms of regularization available to the deep learning practitioner. in fact, developing more [UNK] regularization strategies has been one of the major research [UNK] in the ﬁeld. chapter introduced the basic concepts of generalization, underﬁtting, overﬁt - 5 ting, bias, variance and regularization. if you are not already familiar with these notions, please refer to that chapter before continuing with this one. in this chapter, we describe regularization in more detail, focusing on regular - ization strategies for deep models or models that may be used as building blocks to form deep models. some sections of this chapter deal with standard concepts in machine learning. if you are already familiar with these concepts, feel free to skip the relevant sections. however, most of this chapter is concerned with the extension of these basic concepts to the particular case of neural networks. in section, we deﬁned regular	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	243	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
learning. if you are already familiar with these concepts, feel free to skip the relevant sections. however, most of this chapter is concerned with the extension of these basic concepts to the particular case of neural networks. in section, we deﬁned regularization as “ any modiﬁcation we make to 5. 2. 2 a learning algorithm that is intended to reduce its generalization error but not its training error. ” there are many regularization strategies. some put extra constraints on a machine learning model, such as adding restrictions on the parameter values. some add extra terms in the objective function that can be thought of as corresponding to a soft constraint on the parameter values. if chosen carefully, these extra constraints and penalties can lead to improved performance 228	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	243	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning on the test set. sometimes these constraints and penalties are designed to encode speciﬁc kinds of prior knowledge. other times, these constraints and penalties are designed to express a generic preference for a simpler model class in order to promote generalization. sometimes penalties and constraints are necessary to make an underdetermined problem determined. other forms of regularization, known as ensemble methods, combine multiple hypotheses that explain the training data. in the context of deep learning, most regularization strategies are based on regularizing estimators. regularization of an estimator works by trading increased bias for reduced variance. an [UNK] regularizer is one that makes a proﬁtable trade, reducing variance signiﬁcantly while not overly increasing the bias. when we discussed generalization and overﬁtting in chapter, we focused on three situations, 5 where the model family being trained either ( 1 ) excluded the true data generating process — corresponding to underﬁtting and inducing bias, or ( 2 ) matched the true data generating process, or ( 3 ) included the generating process but also many other possible generating processes — the overﬁtting regime where variance rather than bias dominates the estimation error. the goal of regularization is to take	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	244	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
or ( 2 ) matched the true data generating process, or ( 3 ) included the generating process but also many other possible generating processes — the overﬁtting regime where variance rather than bias dominates the estimation error. the goal of regularization is to take a model from the third regime into the second regime. in practice, an overly complex model family does not necessarily include the target function or the true data generating process, or even a close approximation of either. we almost never have access to the true data generating process so we can never know for sure if the model family being estimated includes the generating process or not. however, most applications of deep learning algorithms are to domains where the true data generating process is almost certainly outside the model family. deep learning algorithms are typically applied to extremely complicated domains such as images, audio sequences and text, for which the true generation process essentially involves simulating the entire universe. to some extent, we are always trying to ﬁt a square peg ( the data generating process ) into a round hole ( our model family ). what this means is that controlling the complexity of the model is not a simple matter of ﬁnding the model of the right size, with the right number of parameters. instead, we might ﬁnd — and indeed in practical deep learning	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	244	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
model family ). what this means is that controlling the complexity of the model is not a simple matter of ﬁnding the model of the right size, with the right number of parameters. instead, we might ﬁnd — and indeed in practical deep learning scenarios, we almost always do ﬁnd — that the best ﬁtting model ( in the sense of minimizing generalization error ) is a large model that has been regularized appropriately. we now review several strategies for how to create such a large, deep, regularized model. 229	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	244	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning 7. 1 parameter norm penalties regularization has been used for decades prior to the advent of deep learning. linear models such as linear regression and logistic regression allow simple, straightforward, and [UNK] regularization strategies. many regularization approaches are based on limiting the capacity of models, such as neural networks, linear regression, or logistic regression, by adding a pa - rameter norm penalty ω ( θ ) to the objective function j. we denote the regularized objective function by [UNK] : [UNK] j, j, α ( ; θ x y ) = ( ; θ x y ) + ω ( ) θ ( 7. 1 ) where α ∈ [ 0, ∞ ) is a hyperparameter that weights the relative contribution of the norm penalty term,, relative to the standard objective function ω j. setting α to 0 results in no regularization. larger values of α correspond to more regularization. when our training algorithm minimizes the regularized objective function [UNK] it will decrease both the original objective j on the training data and some measure of the size of the parameters θ ( or some subset of the parameters ). [UNK] choices for the parameter norm can result in [UNK] solutions being preferred. ω in this section, we discuss the [UNK] of the	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	245	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
objective j on the training data and some measure of the size of the parameters θ ( or some subset of the parameters ). [UNK] choices for the parameter norm can result in [UNK] solutions being preferred. ω in this section, we discuss the [UNK] of the various norms when used as penalties on the model parameters. before delving into the regularization behavior of [UNK] norms, we note that for neural networks, we typically choose to use a parameter norm penalty that ω penalizes of the [UNK] transformation at each layer and leaves only the weights the biases unregularized. the biases typically require less data to ﬁt accurately than the weights. each weight speciﬁes how two variables interact. fitting the weight well requires observing both variables in a variety of conditions. each bias controls only a single variable. this means that we do not induce too much variance by leaving the biases unregularized. also, regularizing the bias parameters can introduce a signiﬁcant amount of underﬁtting. we therefore use the vector w to indicate all of the weights that should be [UNK] by a norm penalty, while the vector θ denotes all of the parameters, including both w and the unregularized parameters. in the context of neural networks, it is	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	245	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
use the vector w to indicate all of the weights that should be [UNK] by a norm penalty, while the vector θ denotes all of the parameters, including both w and the unregularized parameters. in the context of neural networks, it is sometimes desirable to use a separate penalty with a [UNK] α [UNK] for each layer of the network. because it can be expensive to search for the correct value of multiple hyperparameters, it is still reasonable to use the same weight decay at all layers just to reduce the size of search space. 230	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	245	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning 7. 1. 1 l2 parameter regularization we have already seen, in section, one of the simplest and most common kinds 5. 2. 2 of parameter norm penalty : the l2 parameter norm penalty commonly known as weight decay. this regularization strategy drives the weights closer to the origin1 by adding a regularization term ω ( θ ) = 1 2 w 2 2 to the objective function. in other academic communities, l2 regularization is also known as ridge regression or tikhonov regularization. we can gain some insight into the behavior of weight decay regularization by studying the gradient of the regularized objective function. to simplify the presentation, we assume no bias parameter, so θ is just w. such a model has the following total objective function : [UNK], ( ; w x y ) = α 2 ww w x y + ( j ;, ), ( 7. 2 ) with the corresponding parameter gradient ∇w [UNK], α ( ; w x y ) = w + ∇wj,. ( ; w x y ) ( 7. 3 ) to take a single gradient step to update the weights, we perform this update : w w w ← −α ( + ∇wj,.	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	246	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
y ) = w + ∇wj,. ( ; w x y ) ( 7. 3 ) to take a single gradient step to update the weights, we perform this update : w w w ← −α ( + ∇wj,. ( ; w x y ) ) ( 7. 4 ) written another way, the update is : w w ← − ( 1 α ) −∇ wj,. ( ; w x y ) ( 7. 5 ) we can see that the addition of the weight decay term has modiﬁed the learning rule to multiplicatively shrink the weight vector by a constant factor on each step, just before performing the usual gradient update. this describes what happens in a single step. but what happens over the entire course of training? we will further simplify the analysis by making a quadratic approximation to the objective function in the neighborhood of the value of the weights that obtains minimal unregularized training cost, w∗ = arg minw j ( w ). if the objective function is truly quadratic, as in the case of ﬁtting a linear regression model with 1more generally, we could regularize the parameters to be near any speciﬁc point in space and, surprisingly, still get	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	246	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
). if the objective function is truly quadratic, as in the case of ﬁtting a linear regression model with 1more generally, we could regularize the parameters to be near any speciﬁc point in space and, surprisingly, still get a regularization [UNK], but better results will be obtained for a value closer to the true one, with zero being a default value that makes sense when we do not know if the correct value should be positive or negative. since it is far more common to regularize the model parameters towards zero, we will focus on this special case in our exposition. 231	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	246	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning mean squared error, then the approximation is perfect. the approximation [UNK] is given by [UNK] j ( ) = θ ( w∗ ) + 1 2 ( w w − ∗ ) h w w ( − ∗ ), ( 7. 6 ) where h is the hessian matrix of j with respect to w evaluated at w∗. there is no ﬁrst - order term in this quadratic approximation, because w∗is deﬁned to be a minimum, where the gradient vanishes. likewise, because w∗is the location of a minimum of, we can conclude that is positive semideﬁnite. j h the minimum of [UNK] occurs where its gradient ∇w [UNK] ( ) = ( w h w w − ∗ ) ( 7. 7 ) is equal to. 0 to study the [UNK] of weight decay, we modify equation by adding the 7. 7 weight decay gradient. we can now solve for the minimum of the regularized version of [UNK]. we use the variable [UNK] to represent the location of the minimum. α [UNK] h + ( [UNK] w − ∗ ) = 0 ( 7. 8 ) ( + ) h αi [UNK] hw = ∗ ( 7. 9 ) [UNK] h i = ( + α ) −	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	247	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
to represent the location of the minimum. α [UNK] h + ( [UNK] w − ∗ ) = 0 ( 7. 8 ) ( + ) h αi [UNK] hw = ∗ ( 7. 9 ) [UNK] h i = ( + α ) −1hw∗. ( 7. 10 ) as α approaches 0, the regularized solution [UNK] approaches w∗. but what happens as α grows? because h is real and symmetric, we can decompose it into a diagonal matrix λ and an orthonormal basis of eigenvectors, q, such that h q q = λ. applying the decomposition to equation, we obtain : 7. 10 [UNK] q q = ( λ + ) αi −1q q λ w∗ ( 7. 11 ) = q i q ( + λ α ) −1 q q λ w∗ ( 7. 12 ) = ( + ) q λ αi −1λqw∗. ( 7. 13 ) we see that the [UNK] of weight decay is to rescale w ∗along the axes deﬁned by the eigenvectors of h. speciﬁcally, the component of w ∗that is aligned with the i - th eigenvector of h is	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	247	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
is to rescale w ∗along the axes deﬁned by the eigenvectors of h. speciﬁcally, the component of w ∗that is aligned with the i - th eigenvector of h is rescaled by a factor of λi λi + α. ( you may wish to review how this kind of scaling works, ﬁrst explained in ﬁgure ). 2. 3 along the directions where the eigenvalues of h are relatively large, for example, where λi α, the [UNK] of regularization is relatively small. however, components with λi α will be shrunk to have nearly zero magnitude. this [UNK] is illustrated in ﬁgure. 7. 1 232	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	247	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)