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
chapter 7. regularization for deep learning convolutional neural networks by far the most popular and extensive use of parameter sharing occurs in convolutional neural networks ( cnns ) applied to computer vision. natural images have many statistical properties that are invariant to translation. for example, a photo of a cat remains a photo of a cat if it is translated one pixel to the right. cnns take this property into account by sharing parameters across multiple image locations. the same feature ( a hidden unit with the same weights ) is computed over [UNK] locations in the input. this means that we can ﬁnd a cat with the same cat detector whether the cat appears at column i or column i + 1 in the image. parameter sharing has allowed cnns to dramatically lower the number of unique model parameters and to signiﬁcantly increase network sizes without requiring a corresponding increase in training data. it remains one of the best examples of how to [UNK] incorporate domain knowledge into the network architecture. cnns will be discussed in more detail in chapter. 9 7. 10 sparse representations weight decay acts by placing a penalty directly on the model parameters. another strategy is to place a penalty on the activations of the units in a neural network, encouraging their activations to be sparse.	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	269	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
detail in chapter. 9 7. 10 sparse representations weight decay acts by placing a penalty directly on the model parameters. another strategy is to place a penalty on the activations of the units in a neural network, encouraging their activations to be sparse. this indirectly imposes a complicated penalty on the model parameters. we have already discussed ( in section ) how 7. 1. 2 l1 penalization induces a sparse parametrization — meaning that many of the parameters become zero ( or close to zero ). representational sparsity, on the other hand, describes a representation where many of the elements of the representation are zero ( or close to zero ). a simpliﬁed view of this distinction can be illustrated in the context of linear regression : 18 5 15 −9 −3 = 4 0 0 2 0 0 − 0 0 1 0 3 0 − 0 5 0 0 0 0 1 0 0 1 0 4 − − 1 0 0 0 5 0 − 2 3 −2 −5 1 4 y ∈rm a ∈r m n × x ∈r n ( 7. 46 ) 254	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	269	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning −14 1 19 2 23 = 3 1 2 5 4 1 − − 4 2 3 1 1 3 − − − − − 1 5 4 2 3 2 3 1 2 3 0 3 − − − − − − 5 4 2 2 5 1 0 2 0 0 −3 0 y ∈rm b ∈rm n × h ∈rn ( 7. 47 ) in the ﬁrst expression, we have an example of a sparsely parametrized linear regression model. in the second, we have linear regression with a sparse representa - tion h of the data x. that is, h is a function of x that, in some sense, represents the information present in, but does so with a sparse vector. x representational regularization is accomplished by the same sorts of mechanisms that we have used in parameter regularization. norm penalty regularization of representations is performed by adding to the loss function j a norm penalty on the representation. this penalty is denoted ω ( ) h. as before, we denote the regularized loss function by [UNK] : [UNK], j, α ( ; θ x y ) = ( ; θ x y ) + ω ( ) h ( 7. 48 ) where α ∈ [ 0, ∞ ) weights the	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	270	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
before, we denote the regularized loss function by [UNK] : [UNK], j, α ( ; θ x y ) = ( ; θ x y ) + ω ( ) h ( 7. 48 ) where α ∈ [ 0, ∞ ) weights the relative contribution of the norm penalty term, with larger values of corresponding to more regularization. α just as an l1 penalty on the parameters induces parameter sparsity, an l1 penalty on the elements of the representation induces representational sparsity : ω ( h ) = \| \| \| \| h 1 = i \| hi \|. of course, the l1 penalty is only one choice of penalty that can result in a sparse representation. others include the penalty derived from a student - t prior on the representation (, ;, ) olshausen and field 1996 bergstra 2011 and kl divergence penalties (, ) that are especially larochelle and bengio 2008 useful for representations with elements constrained to lie on the unit interval. lee 2008 goodfellow 2009 et al. ( ) and et al. ( ) both provide examples of strategies based on regularizing the average activation across several examples, 1 m i h ( ) i, to be near some target value, such as a vector with	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	270	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##fellow 2009 et al. ( ) and et al. ( ) both provide examples of strategies based on regularizing the average activation across several examples, 1 m i h ( ) i, to be near some target value, such as a vector with. 01 for each entry. other approaches obtain representational sparsity with a hard constraint on the activation values. for example, orthogonal matching pursuit ( pati et al., 1993 ) encodes an input x with the representation h that solves the constrained optimization problem arg min h h, 0 < k − x w h 2, ( 7. 49 ) where h 0 is the number of non - zero entries of h. this problem can be solved [UNK] when w is constrained to be orthogonal. this method is often called 255	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	270	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning omp - k with the value of k speciﬁed to indicate the number of non - zero features allowed. ( ) demonstrated that omp - can be a very [UNK] coates and ng 2011 1 feature extractor for deep architectures. essentially any model that has hidden units can be made sparse. throughout this book, we will see many examples of sparsity regularization used in a variety of contexts. 7. 11 bagging and other ensemble methods bagging ( short for bootstrap aggregating ) is a technique for reducing gen - eralization error by combining several models (, ). the idea is to breiman 1994 train several [UNK] models separately, then have all of the models vote on the output for test examples. this is an example of a general strategy in machine learning called model averaging. techniques employing this strategy are known as ensemble methods. the reason that model averaging works is that [UNK] models will usually not make all the same errors on the test set. consider for example a set of k regression models. suppose that each model makes an error i on each example, with the errors drawn from a zero - mean multivariate normal distribution with variances e [ 2 i ] = v and covar	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	271	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
. consider for example a set of k regression models. suppose that each model makes an error i on each example, with the errors drawn from a zero - mean multivariate normal distribution with variances e [ 2 i ] = v and covariances e [ ij ] = c. then the error made by the average prediction of all the ensemble models is 1 k i i. the expected squared error of the ensemble predictor is e 1 k i i 2 = 1 k2 e i 2 i + j i = ij ( 7. 50 ) = 1 kv + k −1 k c. ( 7. 51 ) in the case where the errors are perfectly correlated and c = v, the mean squared error reduces to v, so the model averaging does not help at all. in the case where the errors are perfectly uncorrelated and c = 0, the expected squared error of the ensemble is only 1 kv. this means that the expected squared error of the ensemble decreases linearly with the ensemble size. in other words, on average, the ensemble will perform at least as well as any of its members, and if the members make independent errors, the ensemble will perform signiﬁcantly better than its members. [UNK] ensemble methods construct the	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	271	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
size. in other words, on average, the ensemble will perform at least as well as any of its members, and if the members make independent errors, the ensemble will perform signiﬁcantly better than its members. [UNK] ensemble methods construct the ensemble of models in [UNK] ways. for example, each member of the ensemble could be formed by training a completely 256	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	271	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning 8 8 first ensemble member second ensemble member original dataset first resampled dataset second resampled dataset figure 7. 5 : a cartoon depiction of how bagging works. suppose we train an 8 detector on the dataset depicted above, containing an 8, a 6 and a 9. suppose we make two [UNK] resampled datasets. the bagging training procedure is to construct each of these datasets by sampling with replacement. the ﬁrst dataset omits the 9 and repeats the 8. on this dataset, the detector learns that a loop on top of the digit corresponds to an 8. on the second dataset, we repeat the 9 and omit the 6. in this case, the detector learns that a loop on the bottom of the digit corresponds to an 8. each of these individual classiﬁcation rules is brittle, but if we average their output then the detector is robust, achieving maximal conﬁdence only when both loops of the 8 are present. [UNK] kind of model using a [UNK] algorithm or objective function. bagging is a method that allows the same kind of model, training algorithm and objective function to be reused several times. speciﬁcally, bagging involves	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	272	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
the 8 are present. [UNK] kind of model using a [UNK] algorithm or objective function. bagging is a method that allows the same kind of model, training algorithm and objective function to be reused several times. speciﬁcally, bagging involves constructing k [UNK] datasets. each dataset has the same number of examples as the original dataset, but each dataset is constructed by sampling with replacement from the original dataset. this means that, with high probability, each dataset is missing some of the examples from the original dataset and also contains several duplicate examples ( on average around 2 / 3 of the examples from the original dataset are found in the resulting training set, if it has the same size as the original ). model i is then trained on dataset i. the [UNK] between which examples are included in each dataset result in [UNK] between the trained models. see ﬁgure for an example. 7. 5 neural networks reach a wide enough variety of solution points that they can often beneﬁt from model averaging even if all of the models are trained on the same dataset. [UNK] in random initialization, random selection of minibatches, [UNK] in hyperparameters, or [UNK] outcomes of non - deterministic imple	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	272	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##ﬁt from model averaging even if all of the models are trained on the same dataset. [UNK] in random initialization, random selection of minibatches, [UNK] in hyperparameters, or [UNK] outcomes of non - deterministic imple - mentations of neural networks are often enough to cause [UNK] members of the 257	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	272	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning ensemble to make partially independent errors. model averaging is an extremely powerful and reliable method for reducing generalization error. its use is usually discouraged when benchmarking algorithms for scientiﬁc papers, because any machine learning algorithm can beneﬁt substan - tially from model averaging at the price of increased computation and memory. for this reason, benchmark comparisons are usually made using a single model. machine learning contests are usually won by methods using model averag - ing over dozens of models. a recent prominent example is the netﬂix grand prize ( koren 2009, ). not all techniques for constructing ensembles are designed to make the ensemble more regularized than the individual models. for example, a technique called boosting ( freund and schapire 1996b a,, ) constructs an ensemble with higher capacity than the individual models. boosting has been applied to build ensembles of neural networks ( schwenk and bengio 1998, ) by incrementally adding neural networks to the ensemble. boosting has also been applied interpreting an individual neural network as an ensemble (, ), incrementally adding hidden bengio et al. 2006a units to the neural network. 7. 12 drop	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	273	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##entally adding neural networks to the ensemble. boosting has also been applied interpreting an individual neural network as an ensemble (, ), incrementally adding hidden bengio et al. 2006a units to the neural network. 7. 12 dropout dropout ( srivastava 2014 et al., ) provides a computationally inexpensive but powerful method of regularizing a broad family of models. to a ﬁrst approximation, dropout can be thought of as a method of making bagging practical for ensembles of very many large neural networks. bagging involves training multiple models, and evaluating multiple models on each test example. this seems impractical when each model is a large neural network, since training and evaluating such networks is costly in terms of runtime and memory. it is common to use ensembles of ﬁve to ten neural networks — ( ) used six to win the ilsvrc — szegedy et al. 2014a but more than this rapidly becomes unwieldy. dropout provides an inexpensive approximation to training and evaluating a bagged ensemble of exponentially many neural networks. speciﬁcally, dropout trains the ensemble consisting of all sub - networks that can be formed by removing non - output units from an underlying base network,	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	273	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
inexpensive approximation to training and evaluating a bagged ensemble of exponentially many neural networks. speciﬁcally, dropout trains the ensemble consisting of all sub - networks that can be formed by removing non - output units from an underlying base network, as illustrated in ﬁgure. in most modern neural networks, based on a series of 7. 6 [UNK] transformations and nonlinearities, we can [UNK] remove a unit from a network by multiplying its output value by zero. this procedure requires some slight modiﬁcation for models such as radial basis function networks, which take 258	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	273	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning the [UNK] between the unit ’ s state and some reference value. here, we present the dropout algorithm in terms of multiplication by zero for simplicity, but it can be trivially modiﬁed to work with other operations that remove a unit from the network. recall that to learn with bagging, we deﬁne k [UNK] models, construct k [UNK] datasets by sampling from the training set with replacement, and then train model i on dataset i. dropout aims to approximate this process, but with an exponentially large number of neural networks. speciﬁcally, to train with dropout, we use a minibatch - based learning algorithm that makes small steps, such as stochastic gradient descent. each time we load an example into a minibatch, we randomly sample a [UNK] binary mask to apply to all of the input and hidden units in the network. the mask for each unit is sampled independently from all of the others. the probability of sampling a mask value of one ( causing a unit to be included ) is a hyperparameter ﬁxed before training begins. it is not a function of the current value of the model parameters or the input example. typically, an input unit is included	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	274	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
sampling a mask value of one ( causing a unit to be included ) is a hyperparameter ﬁxed before training begins. it is not a function of the current value of the model parameters or the input example. typically, an input unit is included with probability 0. 8 and a hidden unit is included with probability 0. 5. we then run forward propagation, back - propagation, and the learning update as usual. figure illustrates how to run forward propagation 7. 7 with dropout. more formally, suppose that a mask vector µ speciﬁes which units to include, and j ( θ µ, ) deﬁnes the cost of the model deﬁned by parameters θ and mask µ. then dropout training consists in minimizing eµj ( θ µ, ). the expectation contains exponentially many terms but we can obtain an unbiased estimate of its gradient by sampling values of. µ dropout training is not quite the same as bagging training. in the case of bagging, the models are all independent. in the case of dropout, the models share parameters, with each model inheriting a [UNK] subset of parameters from the parent neural network. this parameter sharing makes it possible to represent an exponential number of models with a tractable amount	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	274	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
are all independent. in the case of dropout, the models share parameters, with each model inheriting a [UNK] subset of parameters from the parent neural network. this parameter sharing makes it possible to represent an exponential number of models with a tractable amount of memory. in the case of bagging, each model is trained to convergence on its respective training set. in the case of dropout, typically most models are not explicitly trained at all — usually, the model is large enough that it would be infeasible to sample all possible sub - networks within the lifetime of the universe. instead, a tiny fraction of the possible sub - networks are each trained for a single step, and the parameter sharing causes the remaining sub - networks to arrive at good settings of the parameters. these are the only [UNK]. beyond these, dropout follows the bagging algorithm. for example, the training set encountered by each sub - network is indeed a subset of the original training set sampled with replacement. 259	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	274	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning y h1 h1 h2 h2 x1 x1 x2 x2 y h1 h1 h2 h2 x1 x1 x2 x2 y h1 h1 h2 h2 x2 x2 y h1 h1 h2 h2 x1 x1 y h2 h2 x1 x1 x2 x2 y h1 h1 x1 x1 x2 x2 y h1 h1 h2 h2 y x1 x1 x2 x2 y h2 h2 x2 x2 y h1 h1 x1 x1 y h1 h1 x2 x2 y h2 h2 x1 x1 y x1 x1 y x2 x2 y h2 h2 y h1 h1 y base network ensemble of subnetworks figure 7. 6 : dropout trains an ensemble consisting of all sub - networks that can be constructed by removing non - output units from an underlying base network. here, we begin with a base network with two visible units and two hidden units. there are sixteen possible subsets of these four units. we show all sixteen subnetworks that may be formed by dropping out [UNK] subsets of units from	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	275	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
network. here, we begin with a base network with two visible units and two hidden units. there are sixteen possible subsets of these four units. we show all sixteen subnetworks that may be formed by dropping out [UNK] subsets of units from the original network. in this small example, a large proportion of the resulting networks have no input units or no path connecting the input to the output. this problem becomes insigniﬁcant for networks with wider layers, where the probability of dropping all possible paths from inputs to outputs becomes smaller. 260	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	275	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning [UNK] µx1 µx1 x1 x1 [UNK] x2 x2 µx2 µx2 h1 h1 h2 h2 µh1 µh1 µh2 µh2 [UNK] [UNK] h1 [UNK] y y h1 h1 h2 h2 x1 x1 x2 x2 figure 7. 7 : an example of forward propagation through a feedforward network using dropout. ( top ) in this example, we use a feedforward network with two input units, one hidden layer with two hidden units, and one output unit. to perform forward ( bottom ) propagation with dropout, we randomly sample a vector µ with one entry for each input or hidden unit in the network. the entries of µ are binary and are sampled independently from each other. the probability of each entry being is a hyperparameter, usually 1 0. 5 for the hidden layers and 0. 8 for the input. each unit in the network is multiplied by the corresponding mask, and then forward propagation continues through the rest of the network as usual. this is equivalent to randomly selecting one of the sub - networks from ﬁgure and running forward propagation through it. 7. 6 261	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	276	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning to make a prediction, a bagged ensemble must accumulate votes from all of its members. we refer to this process as inference in this context. so far, our description of bagging and dropout has not required that the model be explicitly probabilistic. now, we assume that the model ’ s role is to output a probability distribution. in the case of bagging, each model iproduces a probability distribution p ( ) i ( y \| x ). the prediction of the ensemble is given by the arithmetic mean of all of these distributions, 1 k k i = 1 p ( ) i ( ) y \| x. ( 7. 52 ) in the case of dropout, each sub - model deﬁned by mask vector µ deﬁnes a prob - ability distribution p ( y, \| x µ ). the arithmetic mean over all masks is given by µ p p y, ( ) µ ( \| x µ ) ( 7. 53 ) where p ( µ ) is the probability distribution that was used to sample µ at training time. because this sum includes an exponential number of terms, it is intractable to evaluate except in cases where the structure of the model permits some form of simpli	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	277	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
p ( µ ) is the probability distribution that was used to sample µ at training time. because this sum includes an exponential number of terms, it is intractable to evaluate except in cases where the structure of the model permits some form of simpliﬁcation. so far, deep neural nets are not known to permit any tractable simpliﬁcation. instead, we can approximate the inference with sampling, by averaging together the output from many masks. even 10 - 20 masks are often [UNK] to obtain good performance. however, there is an even better approach, that allows us to obtain a good approximation to the predictions of the entire ensemble, at the cost of only one forward propagation. to do so, we change to using the geometric mean rather than the arithmetic mean of the ensemble members ’ predicted distributions. warde - farley 2014 et al. ( ) present arguments and empirical evidence that the geometric mean performs comparably to the arithmetic mean in this context. the geometric mean of multiple probability distributions is not guaranteed to be a probability distribution. to guarantee that the result is a probability distribution, we impose the requirement that none of the sub - models assigns probability 0 to any event, and we renormalize the resulting distribution. the unnormalized probability distribution	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	277	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
be a probability distribution. to guarantee that the result is a probability distribution, we impose the requirement that none of the sub - models assigns probability 0 to any event, and we renormalize the resulting distribution. the unnormalized probability distribution deﬁned directly by the geometric mean is given by [UNK] ( ) = y \| x 2d µ p y, ( \| x µ ) ( 7. 54 ) where d is the number of units that may be dropped. here we use a uniform distribution over µ to simplify the presentation, but non - uniform distributions are 262	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	277	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning also possible. to make predictions we must re - normalize the ensemble : pensemble ( ) = y \| x [UNK] ( ) y \| x y [UNK] ( y \| x ). ( 7. 55 ) a key insight (, ) involved in dropout is that we can approxi - hinton et al. 2012c mate pensemble by evaluating p ( y \| x ) in one model : the model with all units, but with the weights going out of unit i multiplied by the probability of including unit i. the motivation for this modiﬁcation is to capture the right expected value of the output from that unit. we call this approach the weight scaling inference rule. there is not yet any theoretical argument for the accuracy of this approximate inference rule in deep nonlinear networks, but empirically it performs very well. because we usually use an inclusion probability of 1 2, the weight scaling rule usually amounts to dividing the weights by at the end of training, and then using 2 the model as usual. another way to achieve the same result is to multiply the states of the units by during training. either way, the goal is to make sure that 2 the expected total input to a unit at test time is roughly the	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	278	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
2 the model as usual. another way to achieve the same result is to multiply the states of the units by during training. either way, the goal is to make sure that 2 the expected total input to a unit at test time is roughly the same as the expected total input to that unit at train time, even though half the units at train time are missing on average. for many classes of models that do not have nonlinear hidden units, the weight scaling inference rule is exact. for a simple example, consider a softmax regression classiﬁer with input variables represented by the vector : n v p y ( = y \| v ) = softmax w v + b y. ( 7. 56 ) we can index into the family of sub - models by element - wise multiplication of the input with a binary vector : d p y ( = y \| v ; ) = d softmax w ( ) + d v b y. ( 7. 57 ) the ensemble predictor is deﬁned by re - normalizing the geometric mean over all ensemble members ’ predictions : pensemble ( = ) = y y \| v [UNK] ( = ) y y \| v [UNK] ( = y y \| v ) ( 7. 58 ) where [UNK] ( = ) = y	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	278	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##izing the geometric mean over all ensemble members ’ predictions : pensemble ( = ) = y y \| v [UNK] ( = ) y y \| v [UNK] ( = y y \| v ) ( 7. 58 ) where [UNK] ( = ) = y y \| v 2n d∈ { } 0 1, n p y. ( = y \| v ; ) d ( 7. 59 ) 263	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	278	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning to see that the weight scaling rule is exact, we can simplify [UNK] : [UNK] ( = ) = y y \| v 2n d∈ { } 0 1, n p y ( = y \| v ; ) d ( 7. 60 ) = 2n d∈ { } 0 1, n softmax ( w ( ) + ) d v b y ( 7. 61 ) = 2n d∈ { } 0 1, n exp w y, : ( ) + d v by yexp w y, : ( ) + d v by ( 7. 62 ) = 2n d∈ { } 0 1, n exp w y, : ( ) + d v b y 2n d∈ { } 0 1, n yexp w y, : ( ) + d v by ( 7. 63 ) because [UNK] will be normalized, we can safely ignore multiplication by factors that are constant with respect to : y [UNK] ( = ) y y \| v [UNK] 2n d∈ { } 0 1, n exp w y, : ( ) + d v by ( 7. 64 ) = exp 1 2 n d∈ { } 0 1, n w y, : (	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	279	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
y \| v [UNK] 2n d∈ { } 0 1, n exp w y, : ( ) + d v by ( 7. 64 ) = exp 1 2 n d∈ { } 0 1, n w y, : ( ) + d v by ( 7. 65 ) = exp 1 2w y, : v + by. ( 7. 66 ) substituting this back into equation we obtain a softmax classiﬁer with weights 7. 58 1 2w. the weight scaling rule is also exact in other settings, including regression networks with conditionally normal outputs, and deep networks that have hidden layers without nonlinearities. however, the weight scaling rule is only an approxi - mation for deep models that have nonlinearities. though the approximation has not been theoretically characterized, it often works well, empirically. goodfellow et al. ( ) found experimentally that the weight scaling approximation can work 2013a better ( in terms of classiﬁcation accuracy ) than monte carlo approximations to the ensemble predictor. this held true even when the monte carlo approximation was allowed to sample up to 1, 000 sub - networks. ( ) found gal and ghahramani 2015 that some models obtain better classiﬁcation accuracy	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	279	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
approximations to the ensemble predictor. this held true even when the monte carlo approximation was allowed to sample up to 1, 000 sub - networks. ( ) found gal and ghahramani 2015 that some models obtain better classiﬁcation accuracy using twenty samples and 264	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	279	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning the monte carlo approximation. it appears that the optimal choice of inference approximation is problem - dependent. srivastava 2014 et al. ( ) showed that dropout is more [UNK] than other standard computationally inexpensive regularizers, such as weight decay, ﬁlter norm constraints and sparse activity regularization. dropout may also be combined with other forms of regularization to yield a further improvement. one advantage of dropout is that it is very computationally cheap. using dropout during training requires only o ( n ) computation per example per update, to generate n random binary numbers and multiply them by the state. depending on the implementation, it may also require o ( n ) memory to store these binary numbers until the back - propagation stage. running inference in the trained model has the same cost per - example as if dropout were not used, though we must pay the cost of dividing the weights by 2 once before beginning to run inference on examples. another signiﬁcant advantage of dropout is that it does not signiﬁcantly limit the type of model or training procedure that can be used. it works well with nearly any model that uses a distributed representation and can be trained with stochastic gradient descent.	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	280	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
advantage of dropout is that it does not signiﬁcantly limit the type of model or training procedure that can be used. it works well with nearly any model that uses a distributed representation and can be trained with stochastic gradient descent. this includes feedforward neural networks, probabilistic models such as restricted boltzmann machines ( srivastava 2014 et al., ), and recurrent neural networks ( bayer and osendorfer 2014 pascanu 2014a, ; et al., ). many other regularization strategies of comparable power impose more severe restrictions on the architecture of the model. though the cost per - step of applying dropout to a speciﬁc model is negligible, the cost of using dropout in a complete system can be signiﬁcant. because dropout is a regularization technique, it reduces the [UNK] capacity of a model. to [UNK] this [UNK], we must increase the size of the model. typically the optimal validation set error is much lower when using dropout, but this comes at the cost of a much larger model and many more iterations of the training algorithm. for very large datasets, regularization confers little reduction in generalization error. in these cases,	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	280	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
much lower when using dropout, but this comes at the cost of a much larger model and many more iterations of the training algorithm. for very large datasets, regularization confers little reduction in generalization error. in these cases, the computational cost of using dropout and larger models may outweigh the beneﬁt of regularization. when extremely few labeled training examples are available, dropout is less [UNK]. bayesian neural networks (, ) outperform dropout on the neal 1996 alternative splicing dataset (, ) where fewer than 5, 000 examples xiong et al. 2011 are available ( srivastava 2014 et al., ). when additional unlabeled data is available, unsupervised feature learning can gain an advantage over dropout. wager 2013 et al. ( ) showed that, when applied to linear regression, dropout is equivalent to l2 weight decay, with a [UNK] weight decay [UNK] for 265	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	280	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning each input feature. the magnitude of each feature ’ s weight decay [UNK] is determined by its variance. similar results hold for other linear models. for deep models, dropout is not equivalent to weight decay. the stochasticity used while training with dropout is not necessary for the approach ’ s success. it is just a means of approximating the sum over all sub - models. wang and manning 2013 ( ) derived analytical approximations to this marginalization. their approximation, known as fast dropout resulted in faster convergence time due to the reduced stochasticity in the computation of the gradient. this method can also be applied at test time, as a more principled ( but also more computationally expensive ) approximation to the average over all sub - networks than the weight scaling approximation. fast dropout has been used to nearly match the performance of standard dropout on small neural network problems, but has not yet yielded a signiﬁcant improvement or been applied to a large problem. just as stochasticity is not necessary to achieve the regularizing [UNK] of dropout, it is also not [UNK]. to demonstrate this, warde - farley 2014 et al. ( ) designed control experiments using a method called drop	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	281	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
problem. just as stochasticity is not necessary to achieve the regularizing [UNK] of dropout, it is also not [UNK]. to demonstrate this, warde - farley 2014 et al. ( ) designed control experiments using a method called dropout boosting that they designed to use exactly the same mask noise as traditional dropout but lack its regularizing [UNK]. dropout boosting trains the entire ensemble to jointly maximize the log - likelihood on the training set. in the same sense that traditional dropout is analogous to bagging, this approach is analogous to boosting. as intended, experiments with dropout boosting show almost no regularization [UNK] compared to training the entire network as a single model. this demonstrates that the interpretation of dropout as bagging has value beyond the interpretation of dropout as robustness to noise. the regularization [UNK] of the bagged ensemble is only achieved when the stochastically sampled ensemble members are trained to perform well independently of each other. dropout has inspired other stochastic approaches to training exponentially large ensembles of models that share weights. dropconnect is a special case of dropout where each product between a single scalar weight and a single hidden unit state is considered a unit that can be dropped ( wan 2013	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	281	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
approaches to training exponentially large ensembles of models that share weights. dropconnect is a special case of dropout where each product between a single scalar weight and a single hidden unit state is considered a unit that can be dropped ( wan 2013 et al., ). stochastic pooling is a form of randomized pooling ( see section ) for building ensembles 9. 3 of convolutional networks with each convolutional network attending to [UNK] spatial locations of each feature map. so far, dropout remains the most widely used implicit ensemble method. one of the key insights of dropout is that training a network with stochastic behavior and making predictions by averaging over multiple stochastic decisions implements a form of bagging with parameter sharing. earlier, we described 266	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	281	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning dropout as bagging an ensemble of models formed by including or excluding units. however, there is no need for this model averaging strategy to be based on inclusion and exclusion. in principle, any kind of random modiﬁcation is admissible. in practice, we must choose modiﬁcation families that neural networks are able to learn to resist. ideally, we should also use model families that allow a fast approximate inference rule. we can think of any form of modiﬁcation parametrized by a vector µ as training an ensemble consisting of p ( y, \| x µ ) for all possible values of µ. there is no requirement that µ have a ﬁnite number of values. for example, µ can be real - valued. srivastava 2014 et al. ( ) showed that multiplying the weights by µ [UNK] ( 1, i ) can outperform dropout based on binary masks. because e [ µ ] = 1 the standard network automatically implements approximate inference in the ensemble, without needing any weight scaling. so far we have described dropout purely as a means of performing [UNK], approximate bagging. however, there is another view of dropout that goes further than this. dropout trains	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	282	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
implements approximate inference in the ensemble, without needing any weight scaling. so far we have described dropout purely as a means of performing [UNK], approximate bagging. however, there is another view of dropout that goes further than this. dropout trains not just a bagged ensemble of models, but an ensemble of models that share hidden units. this means each hidden unit must be able to perform well regardless of which other hidden units are in the model. hidden units must be prepared to be swapped and interchanged between models. hinton et al. ( ) were inspired by an idea from biology : sexual reproduction, which involves 2012c swapping genes between two [UNK] organisms, creates evolutionary pressure for genes to become not just good, but to become readily swapped between [UNK] organisms. such genes and such features are very robust to changes in their environment because they are not able to incorrectly adapt to unusual features of any one organism or model. dropout thus regularizes each hidden unit to be not merely a good feature but a feature that is good in many contexts. warde - farley 2014 et al. ( ) compared dropout training to training of large ensembles and concluded that dropout [UNK] additional improvements to generalization error beyond those obtained by ensembles of independent models. it is important to	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	282	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
good in many contexts. warde - farley 2014 et al. ( ) compared dropout training to training of large ensembles and concluded that dropout [UNK] additional improvements to generalization error beyond those obtained by ensembles of independent models. it is important to understand that a large portion of the power of dropout arises from the fact that the masking noise is applied to the hidden units. this can be seen as a form of highly intelligent, adaptive destruction of the information content of the input rather than destruction of the raw values of the input. for example, if the model learns a hidden unit hi that detects a face by ﬁnding the nose, then dropping hi corresponds to erasing the information that there is a nose in the image. the model must learn another hi, either that redundantly encodes the presence of a nose, or that detects the face by another feature, such as the mouth. traditional noise injection techniques that add unstructured noise at the input are not able to randomly erase the information about a nose from an image of a face unless the magnitude of the noise is so great that nearly all of the information in 267	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	282	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 7. regularization for deep learning the image is removed. destroying extracted features rather than original values allows the destruction process to make use of all of the knowledge about the input distribution that the model has acquired so far. another important aspect of dropout is that the noise is multiplicative. if the noise were additive with ﬁxed scale, then a rectiﬁed linear hidden unit hi with added noise could simply learn to have hi become very large in order to make the added noise insigniﬁcant by comparison. multiplicative noise does not allow such a pathological solution to the noise robustness problem. another deep learning algorithm, batch normalization, reparametrizes the model in a way that introduces both additive and multiplicative noise on the hidden units at training time. the primary purpose of batch normalization is to improve optimization, but the noise can have a regularizing [UNK], and sometimes makes dropout unnecessary. batch normalization is described further in section. 8. 7. 1 7. 13 adversarial training in many cases, neural networks have begun to reach human performance when evaluated on an i. i. d. test set. it is natural therefore to wonder whether these models have obtained a true human - level understanding of	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	283	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
. 13 adversarial training in many cases, neural networks have begun to reach human performance when evaluated on an i. i. d. test set. it is natural therefore to wonder whether these models have obtained a true human - level understanding of these tasks. in order to probe the level of understanding a network has of the underlying task, we can search for examples that the model misclassiﬁes. ( ) found that szegedy et al. 2014b even neural networks that perform at human level accuracy have a nearly 100 % error rate on examples that are intentionally constructed by using an optimization procedure to search for an input xnear a data point x such that the model output is very [UNK] at x. in many cases, xcan be so similar to x that a human observer cannot tell the [UNK] between the original example and the adversarial example, but the network can make highly [UNK] predictions. see ﬁgure for an example. 7. 8 adversarial examples have many implications, for example, in computer security, that are beyond the scope of this chapter. however, they are interesting in the context of regularization because one can reduce the error rate on the original i. i. d. test set via adversarial	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	283	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)