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
is able to represent long term dependencies, the gradient of a long term interaction has exponentially smaller magnitude than the gradient of a short term interaction. it does not mean that it is impossible to learn, but that it might take a very long time to learn long - term dependencies, because the signal about these dependencies will tend to be hidden by the smallest ﬂuctuations arising from short - term dependencies. in practice, the experiments in ( ) show that as we increase the span of the dependencies that bengio et al. 1994 need to be captured, gradient - based optimization becomes increasingly [UNK], with the probability of successful training of a traditional rnn via sgd rapidly reaching 0 for sequences of only length 10 or 20. for a deeper treatment of recurrent networks as dynamical systems, see doya ( ), ( ) and ( ), with a review 1993 bengio et al. 1994 siegelmann and sontag 1995 in pascanu 2013 et al. ( ). the remaining sections of this chapter discuss various approaches that have been proposed to reduce the [UNK] of learning long - term dependencies ( in some cases allowing an rnn to learn dependencies across 403	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	418	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets hundreds of steps ), but the problem of learning long - term dependencies remains one of the main challenges in deep learning. 10. 8 echo state networks the recurrent weights mapping from h ( 1 ) t− to h ( ) t and the input weights mapping from x ( ) t to h ( ) t are some of the most [UNK] parameters to learn in a recurrent network. one proposed (, ;, ;, ; jaeger 2003 maass et al. 2002 jaeger and haas 2004 jaeger 2007b, ) approach to avoiding this [UNK] is to set the recurrent weights such that the recurrent hidden units do a good job of capturing the history of past inputs, and learn only the output weights. this is the idea that was independently proposed for echo state networks or esns (, ;, ) jaeger and haas 2004 jaeger 2007b and liquid state machines (, ). the latter is similar, except maass et al. 2002 that it uses spiking neurons ( with binary outputs ) instead of the continuous - valued hidden units used for esns. both esns and liquid state machines are termed reservoir computing ( lukosevicius and jaeger 2009, ) to denote	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	419	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
2002 that it uses spiking neurons ( with binary outputs ) instead of the continuous - valued hidden units used for esns. both esns and liquid state machines are termed reservoir computing ( lukosevicius and jaeger 2009, ) to denote the fact that the hidden units form of reservoir of temporal features which may capture [UNK] aspects of the history of inputs. one way to think about these reservoir computing recurrent networks is that they are similar to kernel machines : they map an arbitrary length sequence ( the history of inputs up to time t ) into a ﬁxed - length vector ( the recurrent state h ( ) t ), on which a linear predictor ( typically a linear regression ) can be applied to solve the problem of interest. the training criterion may then be easily designed to be convex as a function of the output weights. for example, if the output consists of linear regression from the hidden units to the output targets, and the training criterion is mean squared error, then it is convex and may be solved reliably with simple learning algorithms (, ). jaeger 2003 the important question is therefore : how do we set the input and recurrent weights so that a rich set of histories can be represented in the recurrent neural network state? the answer proposed in	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	419	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##bly with simple learning algorithms (, ). jaeger 2003 the important question is therefore : how do we set the input and recurrent weights so that a rich set of histories can be represented in the recurrent neural network state? the answer proposed in the reservoir computing literature is to view the recurrent net as a dynamical system, and set the input and recurrent weights such that the dynamical system is near the edge of stability. the original idea was to make the eigenvalues of the jacobian of the state - to - state transition function be close to. as explained in section, an important 1 8. 2. 5 characteristic of a recurrent network is the eigenvalue spectrum of the jacobians j ( ) t = ∂s ( ) t ∂s ( 1 ) t−. of particular importance is the spectral radius of j ( ) t, deﬁned to be the maximum of the absolute values of its eigenvalues. 404	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	419	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets to understand the [UNK] of the spectral radius, consider the simple case of back - propagation with a jacobian matrix j that does not change with t. this case happens, for example, when the network is purely linear. suppose that j has an eigenvector v with corresponding eigenvalue λ. consider what happens as we propagate a gradient vector backwards through time. if we begin with a gradient vector g, then after one step of back - propagation, we will have jg, and after n steps we will have jng. now consider what happens if we instead back - propagate a perturbed version of g. if we begin with g + δv, then after one step, we will have j ( g + δv ). after n steps, we will have j n ( g + δv ). from this we can see that back - propagation starting from g and back - propagation starting from g + δv diverge by δj nv after n steps of back - propagation. if v is chosen to be a unit eigenvector of j with eigenvalue λ, then multiplication by the jacobian simply scales the [UNK] at each step	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	420	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##v diverge by δj nv after n steps of back - propagation. if v is chosen to be a unit eigenvector of j with eigenvalue λ, then multiplication by the jacobian simply scales the [UNK] at each step. the two executions of back - propagation are separated by a distance of δ λ \| \| n. when v corresponds to the largest value of \| \| λ, this perturbation achieves the widest possible separation of an initial perturbation of size. δ when \| \| λ > 1, the deviation size δ λ \| \| n grows exponentially large. when \| \| λ < 1, the deviation size becomes exponentially small. of course, this example assumed that the jacobian was the same at every time step, corresponding to a recurrent network with no nonlinearity. when a nonlinearity is present, the derivative of the nonlinearity will approach zero on many time steps, and help to prevent the explosion resulting from a large spectral radius. indeed, the most recent work on echo state networks advocates using a spectral radius much larger than unity (, ;, ). yildiz et al. 2012 jaeger 2012 everything we have said about back - propagation via repeated matrix multipli - cation applies equally to	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	420	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
work on echo state networks advocates using a spectral radius much larger than unity (, ;, ). yildiz et al. 2012 jaeger 2012 everything we have said about back - propagation via repeated matrix multipli - cation applies equally to forward propagation in a network with no nonlinearity, where the state h ( + 1 ) t = h ( ) t w. when a linear map w always shrinks h as measured by the l2 norm, then we say that the map is contractive. when the spectral radius is less than one, the mapping from h ( ) t to h ( + 1 ) t is contractive, so a small change becomes smaller after each time step. this necessarily makes the network forget information about the past when we use a ﬁnite level of precision ( such as 32 bit integers ) to store the state vector. the jacobian matrix tells us how a small change of h ( ) t propagates one step forward, or equivalently, how the gradient on h ( + 1 ) t propagates one step backward, during back - propagation. note that neither w nor j need to be symmetric ( al - though they are square and real ), so they can have complex - valued eigenvalues and e	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	420	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
+ 1 ) t propagates one step backward, during back - propagation. note that neither w nor j need to be symmetric ( al - though they are square and real ), so they can have complex - valued eigenvalues and eigenvectors, with imaginary components corresponding to potentially oscillatory 405	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	420	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets behavior ( if the same jacobian was applied iteratively ). even though h ( ) t or a small variation of h ( ) t of interest in back - propagation are real - valued, they can be expressed in such a complex - valued basis. what matters is what happens to the magnitude ( complex absolute value ) of these possibly complex - valued basis [UNK], when we multiply the matrix by the vector. an eigenvalue with magnitude greater than one corresponds to magniﬁcation ( exponential growth, if applied iteratively ) or shrinking ( exponential decay, if applied iteratively ). with a nonlinear map, the jacobian is free to change at each step. the dynamics therefore become more complicated. however, it remains true that a small initial variation can turn into a large variation after several steps. one [UNK] between the purely linear case and the nonlinear case is that the use of a squashing nonlinearity such as tanh can cause the recurrent dynamics to become bounded. note that it is possible for back - propagation to retain unbounded dynamics even when forward propagation has bounded dynamics, for example, when a sequence of tanh units are all in the middle of their linear regime	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	421	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
the recurrent dynamics to become bounded. note that it is possible for back - propagation to retain unbounded dynamics even when forward propagation has bounded dynamics, for example, when a sequence of tanh units are all in the middle of their linear regime and are connected by weight matrices with spectral radius greater than. however, it is 1 rare for all of the units to simultaneously lie at their linear activation point. tanh the strategy of echo state networks is simply to ﬁx the weights to have some spectral radius such as, where information is carried forward through time but 3 does not explode due to the stabilizing [UNK] of saturating nonlinearities like tanh. more recently, it has been shown that the techniques used to set the weights in esns could be used to the weights in a fully trainable recurrent net - initialize work ( with the hidden - to - hidden recurrent weights trained using back - propagation through time ), helping to learn long - term dependencies ( sutskever 2012 sutskever, ; et al., ). in this setting, an initial spectral radius of 1. 2 performs well, combined 2013 with the sparse initialization scheme described in section. 8. 4 10. 9 leaky units and other strategies for multiple time	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	421	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
, ; et al., ). in this setting, an initial spectral radius of 1. 2 performs well, combined 2013 with the sparse initialization scheme described in section. 8. 4 10. 9 leaky units and other strategies for multiple time scales one way to deal with long - term dependencies is to design a model that operates at multiple time scales, so that some parts of the model operate at ﬁne - grained time scales and can handle small details, while other parts operate at coarse time scales and transfer information from the distant past to the present more [UNK]. various strategies for building both ﬁne and coarse time scales are possible. these include the addition of skip connections across time, “ leaky units ” that integrate signals with [UNK] time constants, and the removal of some of the connections 406	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	421	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets used to model ﬁne - grained time scales. 10. 9. 1 adding skip connections through time one way to obtain coarse time scales is to add direct connections from variables in the distant past to variables in the present. the idea of using such skip connections dates back to ( ) and follows from the idea of incorporating delays in lin et al. 1996 feedforward neural networks (, ). in an ordinary recurrent lang and hinton 1988 network, a recurrent connection goes from a unit at time t to a unit at time t + 1. it is possible to construct recurrent networks with longer delays (, ). bengio 1991 as we have seen in section, gradients may vanish or explode exponentially 8. 2. 5 with respect to the number of time steps. ( ) introduced recurrent lin et al. 1996 connections with a time - delay of d to mitigate this problem. gradients now diminish exponentially as a function of τ d rather than τ. since there are both delayed and single step connections, gradients may still explode exponentially in τ. this allows the learning algorithm to capture longer dependencies although not all long - term dependencies may be represented well	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	422	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
function of τ d rather than τ. since there are both delayed and single step connections, gradients may still explode exponentially in τ. this allows the learning algorithm to capture longer dependencies although not all long - term dependencies may be represented well in this way. 10. 9. 2 leaky units and a spectrum of [UNK] time scales another way to obtain paths on which the product of derivatives is close to one is to have units with linear self - connections and a weight near one on these connections. when we accumulate a running average µ ( ) t of some value v ( ) t by applying the update µ ( ) t ←αµ ( 1 ) t− + ( 1 −α ) v ( ) t the α parameter is an example of a linear self - connection from µ ( 1 ) t− to µ ( ) t. when α is near one, the running average remembers information about the past for a long time, and when α is near zero, information about the past is rapidly discarded. hidden units with linear self - connections can behave similarly to such running averages. such hidden units are called leaky units. skip connections through d time steps are a way of ensuring that a unit can always learn to be inﬂuenced by a value from d	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	422	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
with linear self - connections can behave similarly to such running averages. such hidden units are called leaky units. skip connections through d time steps are a way of ensuring that a unit can always learn to be inﬂuenced by a value from d time steps earlier. the use of a linear self - connection with a weight near one is a [UNK] way of ensuring that the unit can access values from the past. the linear self - connection approach allows this [UNK] to be adapted more smoothly and ﬂexibly by adjusting the real - valued α rather than by adjusting the integer - valued skip length. these ideas were proposed by ( ) and by ( ). mozer 1992 el hihi and bengio 1996 leaky units were also found to be useful in the context of echo state networks (, ). jaeger et al. 2007 407	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	422	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets there are two basic strategies for setting the time constants used by leaky units. one strategy is to manually ﬁx them to values that remain constant, for example by sampling their values from some distribution once at initialization time. another strategy is to make the time constants free parameters and learn them. having such leaky units at [UNK] time scales appears to help with long - term dependencies (, ; mozer 1992 pascanu 2013 et al., ). 10. 9. 3 removing connections another approach to handle long - term dependencies is the idea of organizing the state of the rnn at multiple time - scales (, ), with el hihi and bengio 1996 information ﬂowing more easily through long distances at the slower time scales. this idea [UNK] from the skip connections through time discussed earlier because it involves actively removing length - one connections and replacing them with longer connections. units modiﬁed in such a way are forced to operate on a long time scale. skip connections through time edges. units receiving such add new connections may learn to operate on a long time scale but may also choose to focus on their other short - term connections. there are [UNK] ways in which a group of	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	423	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
on a long time scale. skip connections through time edges. units receiving such add new connections may learn to operate on a long time scale but may also choose to focus on their other short - term connections. there are [UNK] ways in which a group of recurrent units can be forced to operate at [UNK] time scales. one option is to make the recurrent units leaky, but to have [UNK] groups of units associated with [UNK] ﬁxed time scales. this was the proposal in ( ) and has been successfully used in mozer 1992 pascanu et al. ( ). another option is to have explicit and discrete updates taking place 2013 at [UNK] times, with a [UNK] frequency for [UNK] groups of units. this is the approach of ( ) and el hihi and bengio 1996 koutnik 2014 et al. ( ). it worked well on a number of benchmark datasets. 10. 10 the long short - term memory and other gated rnns as of this writing, the most [UNK] sequence models used in practical applications are called gated rnns. these include the long short - term memory and networks based on the. gated recurrent unit like leaky units, gated rnns are based on the idea of creating paths through time that have derivatives	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	423	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
practical applications are called gated rnns. these include the long short - term memory and networks based on the. gated recurrent unit like leaky units, gated rnns are based on the idea of creating paths through time that have derivatives that neither vanish nor explode. leaky units did this with connection weights that were either manually chosen constants or were parameters. gated rnns generalize this to connection weights that may change 408	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	423	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets at each time step. × input input gate forget gate output gate output state self - loop × + × figure 10. 16 : block diagram of the lstm recurrent network “ cell. ” cells are connected recurrently to each other, replacing the usual hidden units of ordinary recurrent networks. an input feature is computed with a regular artiﬁcial neuron unit. its value can be accumulated into the state if the sigmoidal input gate allows it. the state unit has a linear self - loop whose weight is controlled by the forget gate. the output of the cell can be shut [UNK] the output gate. all the gating units have a sigmoid nonlinearity, while the input unit can have any squashing nonlinearity. the state unit can also be used as an extra input to the gating units. the black square indicates a delay of a single time step. leaky units allow the network to accumulate information ( such as evidence for a particular feature or category ) over a long duration. however, once that information has been used, it might be useful for the neural network to forget the old state. for example, if a sequence is made of sub - sequences and we	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	424	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
evidence for a particular feature or category ) over a long duration. however, once that information has been used, it might be useful for the neural network to forget the old state. for example, if a sequence is made of sub - sequences and we want a leaky unit to accumulate evidence inside each sub - subsequence, we need a mechanism to forget the old state by setting it to zero. instead of manually deciding when to clear the state, we want the neural network to learn to decide when to do it. this 409	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	424	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets is what gated rnns do. 10. 10. 1 lstm the clever idea of introducing self - loops to produce paths where the gradient can ﬂow for long durations is a core contribution of the initial long short - term memory ( lstm ) model ( hochreiter and schmidhuber 1997, ). a crucial addition has been to make the weight on this self - loop conditioned on the context, rather than ﬁxed (, ). by making the weight of this self - loop gated ( controlled gers et al. 2000 by another hidden unit ), the time scale of integration can be changed dynamically. in this case, we mean that even for an lstm with ﬁxed parameters, the time scale of integration can change based on the input sequence, because the time constants are output by the model itself. the lstm has been found extremely successful in many applications, such as unconstrained handwriting recognition ( graves et al., ), speech recognition ( 2009 graves 2013 graves and jaitly 2014 et al., ;, ), handwriting generation ( graves 2013, ), machine translation ( sutskever 2014 et al., ),	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	425	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
handwriting recognition ( graves et al., ), speech recognition ( 2009 graves 2013 graves and jaitly 2014 et al., ;, ), handwriting generation ( graves 2013, ), machine translation ( sutskever 2014 et al., ), image captioning (, ; kiros et al. 2014b vinyals 2014b xu 2015 et al., ; et al., ) and parsing ( vinyals 2014a et al., ). the lstm block diagram is illustrated in ﬁgure. the corresponding 10. 16 forward propagation equations are given below, in the case of a shallow recurrent network architecture. deeper architectures have also been successfully used ( graves et al., ; 2013 pascanu 2014a et al., ). instead of a unit that simply applies an element - wise nonlinearity to the [UNK] transformation of inputs and recurrent units, lstm recurrent networks have “ lstm cells ” that have an internal recurrence ( a self - loop ), in addition to the outer recurrence of the rnn. each cell has the same inputs and outputs as an ordinary recurrent network, but has more parameters and a system of gating units that controls the ﬂow of information	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	425	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
- loop ), in addition to the outer recurrence of the rnn. each cell has the same inputs and outputs as an ordinary recurrent network, but has more parameters and a system of gating units that controls the ﬂow of information. the most important component is the state unit s ( ) t i that has a linear self - loop similar to the leaky units described in the previous section. however, here, the self - loop weight ( or the associated time constant ) is controlled by a forget gate unit f ( ) t i ( for time step t and cell ), that sets this weight to a value between 0 and 1 via a sigmoid unit : i f ( ) t i = σ bf i + j u f i, j x ( ) t j + j wf i, j h ( 1 ) t− j, ( 10. 40 ) where x ( ) t is the current input vector and h ( ) t is the current hidden layer vector, containing the outputs of all the lstm cells, and bf, uf, w f are respectively biases, input weights and recurrent weights for the forget gates. the lstm cell 410	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	425	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets internal state is thus updated as follows, but with a conditional self - loop weight f ( ) t i : s ( ) t i = f ( ) t i s ( 1 ) t− i + g ( ) t i σ b i + j ui, jx ( ) t j + j wi, jh ( 1 ) t− j, ( 10. 41 ) where b, u and w respectively denote the biases, input weights and recurrent weights into the lstm cell. the external input gate unit g ( ) t i is computed similarly to the forget gate ( with a sigmoid unit to obtain a gating value between 0 and 1 ), but with its own parameters : g ( ) t i = σ bg i + j ug i, jx ( ) t j + j wg i, jh ( 1 ) t− j. ( 10. 42 ) the output h ( ) t i of the lstm cell can also be shut [UNK], via the output gate q ( ) t i, which also uses a sigmoid unit for gating : h ( ) t i = tanh s ( ) t i q ( )	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	426	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
of the lstm cell can also be shut [UNK], via the output gate q ( ) t i, which also uses a sigmoid unit for gating : h ( ) t i = tanh s ( ) t i q ( ) t i ( 10. 43 ) q ( ) t i = σ bo i + j uo i, jx ( ) t j + j w o i, j h ( 1 ) t− j ( 10. 44 ) which has parameters bo, u o, w o for its biases, input weights and recurrent weights, respectively. among the variants, one can choose to use the cell state s ( ) t i as an extra input ( with its weight ) into the three gates of the i - th unit, as shown in ﬁgure. this would require three additional parameters. 10. 16 lstm networks have been shown to learn long - term dependencies more easily than the simple recurrent architectures, ﬁrst on artiﬁcial data sets designed for testing the ability to learn long - term dependencies (, ; bengio et al. 1994 hochreiter and schmidhuber 1997 hochreiter 2001, ; et al., ), then on challenging sequence processing tasks	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	426	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
data sets designed for testing the ability to learn long - term dependencies (, ; bengio et al. 1994 hochreiter and schmidhuber 1997 hochreiter 2001, ; et al., ), then on challenging sequence processing tasks where state - of - the - art performance was obtained ( graves 2012, ; graves 2013 sutskever 2014 et al., ; et al., ). variants and alternatives to the lstm have been studied and used and are discussed next. 10. 10. 2 other gated rnns which pieces of the lstm architecture are actually necessary? what other successful architectures could be designed that allow the network to dynamically control the time scale and forgetting behavior of [UNK] units? 411	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	426	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets some answers to these questions are given with the recent work on gated rnns, whose units are also known as gated recurrent units or grus (, ; cho et al. 2014b chung 2014 2015a jozefowicz 2015 chrupala 2015 et al.,, ; et al., ; et al., ). the main [UNK] with the lstm is that a single gating unit simultaneously controls the forgetting factor and the decision to update the state unit. the update equations are the following : h ( ) t i = u ( 1 ) t− i h ( 1 ) t− i + ( 1 −u ( 1 ) t− i ) σ bi + j ui, jx ( 1 ) t− j + j wi, j r ( 1 ) t− j h ( 1 ) t− j, ( 10. 45 ) where u stands for “ update ” gate and r for “ reset ” gate. their value is deﬁned as usual : u ( ) t i = σ bu i + j uu i, jx ( ) t j + j wu i, jh ( ) t j ( 10. 46 ) and r ( ) t	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	427	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
value is deﬁned as usual : u ( ) t i = σ bu i + j uu i, jx ( ) t j + j wu i, jh ( ) t j ( 10. 46 ) and r ( ) t i = σ br i + j u r i, jx ( ) t j + j wr i, jh ( ) t j. ( 10. 47 ) the reset and updates gates can individually “ ignore ” parts of the state vector. the update gates act like conditional leaky integrators that can linearly gate any dimension, thus choosing to copy it ( at one extreme of the sigmoid ) or completely ignore it ( at the other extreme ) by replacing it by the new “ target state ” value ( towards which the leaky integrator wants to converge ). the reset gates control which parts of the state get used to compute the next target state, introducing an additional nonlinear [UNK] in the relationship between past state and future state. many more variants around this theme can be designed. for example the reset gate ( or forget gate ) output could be shared across multiple hidden units. alternately, the product of a global gate ( covering a whole group of units, such as an entire layer ) and a	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	427	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
around this theme can be designed. for example the reset gate ( or forget gate ) output could be shared across multiple hidden units. alternately, the product of a global gate ( covering a whole group of units, such as an entire layer ) and a local gate ( per unit ) could be used to combine global control and local control. however, several investigations over architectural variations of the lstm and gru found no variant that would clearly beat both of these across a wide range of tasks (, ; [UNK] al. 2015 jozefowicz 2015 [UNK] et al., ). et al. ( ) found that a crucial ingredient is the forget gate, while 2015 jozefowicz et al. ( ) found that adding a bias of 1 to the lstm forget gate, a practice 2015 advocated by ( ), makes the lstm as strong as the best of the gers et al. 2000 explored architectural variants. 412	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	427	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets 10. 11 optimization for long - term dependencies section and section have described the vanishing and exploding gradient 8. 2. 5 10. 7 problems that occur when optimizing rnns over many time steps. an interesting idea proposed by martens and sutskever 2011 ( ) is that second derivatives may vanish at the same time that ﬁrst derivatives vanish. second - order optimization algorithms may roughly be understood as dividing the ﬁrst derivative by the second derivative ( in higher dimension, multiplying the gradient by the inverse hessian ). if the second derivative shrinks at a similar rate to the ﬁrst derivative, then the ratio of ﬁrst and second derivatives may remain relatively constant. unfortunately, second - order methods have many drawbacks, including high computational cost, the need for a large minibatch, and a tendency to be attracted to saddle points. martens and sutskever 2011 ( ) found promising results using second - order methods. later, sutskever 2013 et al. ( ) found that simpler methods such as nesterov momentum with careful initialization could achieve similar results. see sutskever 2012 ( ) for more detail. both of these approaches have largely been replaced by simply using	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	428	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
sutskever 2013 et al. ( ) found that simpler methods such as nesterov momentum with careful initialization could achieve similar results. see sutskever 2012 ( ) for more detail. both of these approaches have largely been replaced by simply using sgd ( even without momentum ) applied to lstms. this is part of a continuing theme in machine learning that it is often much easier to design a model that is easy to optimize than it is to design a more powerful optimization algorithm. 10. 11. 1 clipping gradients as discussed in section, strongly nonlinear functions such as those computed 8. 2. 4 by a recurrent net over many time steps tend to have derivatives that can be either very large or very small in magnitude. this is illustrated in ﬁgure and 8. 3 ﬁgure, in which we see that the objective function ( as a function of the 10. 17 parameters ) has a “ landscape ” in which one ﬁnds “ [UNK] ” : wide and rather ﬂat regions separated by tiny regions where the objective function changes quickly, forming a kind of [UNK]. the [UNK] that arises is that when the parameter gradient is very large, a gradient descent parameter update could throw the parameters very far, into a region where the objective function	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	428	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
separated by tiny regions where the objective function changes quickly, forming a kind of [UNK]. the [UNK] that arises is that when the parameter gradient is very large, a gradient descent parameter update could throw the parameters very far, into a region where the objective function is larger, undoing much of the work that had been done to reach the current solution. the gradient tells us the direction that corresponds to the steepest descent within an inﬁnitesimal region surrounding the current parameters. outside of this inﬁnitesimal region, the cost function may begin to curve back upwards. the update must be chosen to be small enough to avoid traversing too much upward curvature. we typically use learning rates that 413	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	428	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets decay slowly enough that consecutive steps have approximately the same learning rate. a step size that is appropriate for a relatively linear part of the landscape is often inappropriate and causes uphill motion if we enter a more curved part of the landscape on the next step. figure 10. 17 : example of the [UNK] of gradient clipping in a recurrent network with two parameters w and b. gradient clipping can make gradient descent perform more reasonably in the vicinity of extremely steep [UNK]. these steep [UNK] commonly occur in recurrent networks near where a recurrent network behaves approximately linearly. the [UNK] exponentially steep in the number of time steps because the weight matrix is multiplied by itself once for each time step. ( left ) gradient descent without gradient clipping overshoots the bottom of this small ravine, then receives a very large gradient from the [UNK]. the large gradient catastrophically propels the parameters outside the axes of the plot. gradient descent with gradient clipping has a more moderate ( right ) reaction to the [UNK]. while it does ascend the [UNK], the step size is restricted so that it cannot be propelled away from steep region near the solution. figure adapted with permission from pascanu 2013 et al. ( )	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	429	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
moderate ( right ) reaction to the [UNK]. while it does ascend the [UNK], the step size is restricted so that it cannot be propelled away from steep region near the solution. figure adapted with permission from pascanu 2013 et al. ( ). a simple type of solution has been in use by practitioners for many years : clipping the gradient. there are [UNK] instances of this idea ( mikolov 2012, ; pascanu 2013 et al., ). one option is to clip the parameter gradient from a minibatch element - wise ( mikolov 2012, ) just before the parameter update. another is to clip the norm \| \| \| \| g of the gradient g ( pascanu 2013 et al., ) just before the parameter update : if \| \| \| \| g > v ( 10. 48 ) g ←gv \| \| \| \| g ( 10. 49 ) 414	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	429	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets where v is the norm threshold and g is used to update parameters. because the gradient of all the parameters ( including [UNK] groups of parameters, such as weights and biases ) is renormalized jointly with a single scaling factor, the latter method has the advantage that it guarantees that each step is still in the gradient direction, but experiments suggest that both forms work similarly. although the parameter update has the same direction as the true gradient, with gradient norm clipping, the parameter update vector norm is now bounded. this bounded gradient avoids performing a detrimental step when the gradient explodes. in fact, even simply taking a random step when the gradient magnitude is above a threshold tends to work almost as well. if the explosion is so severe that the gradient is numerically inf or nan ( considered inﬁnite or not - a - number ), then a random step of size v can be taken and will typically move away from the numerically unstable conﬁguration. clipping the gradient norm per - minibatch will not change the direction of the gradient for an individual minibatch. however, taking the average of the norm - clipped gradient from many minibatches is not equivalent to clipping the norm	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	430	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
. clipping the gradient norm per - minibatch will not change the direction of the gradient for an individual minibatch. however, taking the average of the norm - clipped gradient from many minibatches is not equivalent to clipping the norm of the true gradient ( the gradient formed from using all examples ). examples that have large gradient norm, as well as examples that appear in the same minibatch as such examples, will have their contribution to the ﬁnal direction diminished. this stands in contrast to traditional minibatch gradient descent, where the true gradient direction is equal to the average over all minibatch gradients. put another way, traditional stochastic gradient descent uses an unbiased estimate of the gradient, while gradient descent with norm clipping introduces a heuristic bias that we know empirically to be useful. with element - wise clipping, the direction of the update is not aligned with the true gradient or the minibatch gradient, but it is still a descent direction. it has also been proposed ( graves 2013, ) to clip the back - propagated gradient ( with respect to hidden units ) but no comparison has been published between these variants ; we conjecture that all these methods behave similarly. 10. 11. 2 regularizing	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	430	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
also been proposed ( graves 2013, ) to clip the back - propagated gradient ( with respect to hidden units ) but no comparison has been published between these variants ; we conjecture that all these methods behave similarly. 10. 11. 2 regularizing to encourage information flow gradient clipping helps to deal with exploding gradients, but it does not help with vanishing gradients. to address vanishing gradients and better capture long - term dependencies, we discussed the idea of creating paths in the computational graph of the unfolded recurrent architecture along which the product of gradients associated with arcs is near 1. one approach to achieve this is with lstms and other self - loops and gating mechanisms, described above in section. another idea is 10. 10 to regularize or constrain the parameters so as to encourage “ information ﬂow. ” in particular, we would like the gradient vector ∇h ( ) t l being back - propagated to 415	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	430	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets maintain its magnitude, even if the loss function only penalizes the output at the end of the sequence. formally, we want ( ∇h ( ) t l ) ∂h ( ) t ∂h ( 1 ) t− ( 10. 50 ) to be as large as ∇h ( ) t l. ( 10. 51 ) with this objective, pascanu 2013 et al. ( ) propose the following regularizer : ω = t \| ∇ ( h ( ) t l ) ∂h ( ) t ∂h ( 1 ) t− \| \| \| ∇h ( ) t l \| \| −1 2. ( 10. 52 ) computing the gradient of this regularizer may appear [UNK], but pascanu et al. ( ) propose an approximation in which we consider the back - propagated 2013 vectors ∇h ( ) t l as if they were constants ( for the purpose of this regularizer, so that there is no need to back - propagate through them ). the experiments with this regularizer suggest that, if combined with the norm clipping heuristic ( which handles gradient explosion ), the regularizer can considerably increase the span of the dependencies that an rn	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	431	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
back - propagate through them ). the experiments with this regularizer suggest that, if combined with the norm clipping heuristic ( which handles gradient explosion ), the regularizer can considerably increase the span of the dependencies that an rnn can learn. because it keeps the rnn dynamics on the edge of explosive gradients, the gradient clipping is particularly important. without gradient clipping, gradient explosion prevents learning from succeeding. a key weakness of this approach is that it is not as [UNK] as the lstm for tasks where data is abundant, such as language modeling. 10. 12 explicit memory intelligence requires knowledge and acquiring knowledge can be done via learning, which has motivated the development of large - scale deep architectures. however, there are [UNK] kinds of knowledge. some knowledge can be implicit, sub - conscious, and [UNK] to verbalize — such as how to walk, or how a dog looks [UNK] from a cat. other knowledge can be explicit, declarative, and relatively straightforward to put into words — every day commonsense knowledge, like “ a cat is a kind of animal, ” or very speciﬁc facts that you need to know to accomplish your current goals, like “ the meeting with the sales team is at 3 : 00	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	431	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
words — every day commonsense knowledge, like “ a cat is a kind of animal, ” or very speciﬁc facts that you need to know to accomplish your current goals, like “ the meeting with the sales team is at 3 : 00 pm in room 141. ” neural networks excel at storing implicit knowledge. however, they struggle to memorize facts. stochastic gradient descent requires many presentations of the 416	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	431	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 10. sequence modeling : recurrent and recursive nets task network, controlling the memory memory cells writing mechanism reading mechanism figure 10. 18 : a schematic of an example of a network with an explicit memory, capturing some of the key design elements of the neural turing machine. in this diagram we distinguish the “ representation ” part of the model ( the “ task network, ” here a recurrent net in the bottom ) from the “ memory ” part of the model ( the set of cells ), which can store facts. the task network learns to “ control ” the memory, deciding where to read from and where to write to within the memory ( through the reading and writing mechanisms, indicated by bold arrows pointing at the reading and writing addresses ). 417	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	432	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)