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
simulated annealing, which adds noise to the parameters ( kirkpatrick 1983 et al., ). continuation methods have been extremely successful in recent years. see mobahi and fisher ( ) for an overview of recent literature, especially for ai applications. 2015 continuation methods traditionally were mostly designed with the goal of overcoming the challenge of local minima. speciﬁcally, they were designed to reach a global minimum despite the presence of many local minima. to do so, these continuation methods would construct easier cost functions by “ blurring ” the original cost function. this blurring operation can be done by approximating j ( ) i ( ) = θ [UNK] ( θ ; θ, σ ( ) 2 i ) j ( θ ) ( 8. 40 ) via sampling. the intuition for this approach is that some non - convex functions 327	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	342	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 8. optimization for training deep models become approximately convex when blurred. in many cases, this blurring preserves enough information about the location of a global minimum that we can ﬁnd the global minimum by solving progressively less blurred versions of the problem. this approach can break down in three [UNK] ways. first, it might successfully deﬁne a series of cost functions where the ﬁrst is convex and the optimum tracks from one function to the next arriving at the global minimum, but it might require so many incremental cost functions that the cost of the entire procedure remains high. np - hard optimization problems remain np - hard, even when continuation methods are applicable. the other two ways that continuation methods fail both correspond to the method not being applicable. first, the function might not become convex, no matter how much it is blurred. consider for example the function j ( θ ) = −θθ. second, the function may become convex as a result of blurring, but the minimum of this blurred function may track to a local rather than a global minimum of the original cost function. though continuation methods were mostly originally designed to deal with the problem of local minima, local minima are no longer believed to be the primary problem for neural network optimization. fortunately, continuation methods	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	343	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
local rather than a global minimum of the original cost function. though continuation methods were mostly originally designed to deal with the problem of local minima, local minima are no longer believed to be the primary problem for neural network optimization. fortunately, continuation methods can still help. the easier objective functions introduced by the continuation method can eliminate ﬂat regions, decrease variance in gradient estimates, improve conditioning of the hessian matrix, or do anything else that will either make local updates easier to compute or improve the correspondence between local update directions and progress toward a global solution. bengio 2009 et al. ( ) observed that an approach called curriculum learning or shaping can be interpreted as a continuation method. curriculum learning is based on the idea of planning a learning process to begin by learning simple concepts and progress to learning more complex concepts that depend on these simpler concepts. this basic strategy was previously known to accelerate progress in animal training (, ;, ; skinner 1958 peterson 2004 krueger and dayan 2009, ) and machine learning (, ;, ;, ). ( ) [UNK] elman 1993 sanger 1994 bengio et al. 2009 justiﬁed this strategy as a continuation method, where earlier j ( ) i are made easier by increasing the inﬂuence of simpler examples ( either	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	343	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
, ). ( ) [UNK] elman 1993 sanger 1994 bengio et al. 2009 justiﬁed this strategy as a continuation method, where earlier j ( ) i are made easier by increasing the inﬂuence of simpler examples ( either by assigning their contributions to the cost function larger [UNK], or by sampling them more frequently ), and experimentally demonstrated that better results could be obtained by following a curriculum on a large - scale neural language modeling task. curriculum learning has been successful on a wide range of natural language ( spitkovsky 2010 et al., ; collobert 2011a mikolov 2011b tu and honavar 2011 et al., ; et al., ;, ) and computer vision (, ;, ;, ) kumar et al. 2010 lee and grauman 2011 supancic and ramanan 2013 tasks. curriculum learning was also veriﬁed as being consistent with the way in which humans teach (, ) : teachers start by showing easier and khan et al. 2011 328	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	343	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 8. optimization for training deep models more prototypical examples and then help the learner reﬁne the decision surface with the less obvious cases. curriculum - based strategies are more [UNK] for teaching humans than strategies based on uniform sampling of examples, and can also increase the [UNK] of other teaching strategies (, basu and christensen 2013 ). another important contribution to research on curriculum learning arose in the context of training recurrent neural networks to capture long - term dependencies : zaremba and sutskever 2014 ( ) found that much better results were obtained with a stochastic curriculum, in which a random mix of easy and [UNK] examples is always presented to the learner, but where the average proportion of the more [UNK] examples ( here, those with longer - term dependencies ) is gradually increased. with a deterministic curriculum, no improvement over the baseline ( ordinary training from the full training set ) was observed. we have now described the basic family of neural network models and how to regularize and optimize them. in the chapters ahead, we turn to specializations of the neural network family, that allow neural networks to scale to very large sizes and process input data that has special structure. the optimization methods discussed in this chapter are often directly applicable to these specialized	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	344	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
. in the chapters ahead, we turn to specializations of the neural network family, that allow neural networks to scale to very large sizes and process input data that has special structure. the optimization methods discussed in this chapter are often directly applicable to these specialized architectures with little or no modiﬁcation. 329	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	344	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9 convolutional networks convolutional networks (, ), also known as lecun 1989 convolutional neural networks or cnns, are a specialized kind of neural network for processing data that has a known, grid - like topology. examples include time - series data, which can be thought of as a 1d grid taking samples at regular time intervals, and image data, which can be thought of as a 2d grid of pixels. convolutional networks have been tremendously successful in practical applications. the name “ convolutional neural network ” indicates that the network employs a mathematical operation called convolution. convolution is a specialized kind of linear operation. convolutional networks are simply neural networks that use convolution in place of general matrix multiplication in at least one of their layers. in this chapter, we will ﬁrst describe what convolution is. next, we will explain the motivation behind using convolution in a neural network. we will then describe an operation called pooling, which almost all convolutional networks employ. usually, the operation used in a convolutional neural network does not correspond precisely to the deﬁni	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	345	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##tion in a neural network. we will then describe an operation called pooling, which almost all convolutional networks employ. usually, the operation used in a convolutional neural network does not correspond precisely to the deﬁnition of convolution as used in other ﬁelds such as engineering or pure mathematics. we will describe several variants on the convolution function that are widely used in practice for neural networks. we will also show how convolution may be applied to many kinds of data, with [UNK] numbers of dimensions. we then discuss means of making convolution more [UNK]. convolutional networks stand out as an example of neuroscientiﬁc principles inﬂuencing deep learning. we will discuss these neuroscientiﬁc principles, then conclude with comments about the role convolutional networks have played in the history of deep learning. one topic this chapter does not address is how to choose the architecture of your convolutional network. the goal of this chapter is to describe the kinds of tools that convolutional networks provide, while chapter 11 330	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	345	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks describes general guidelines for choosing which tools to use in which circumstances. research into convolutional network architectures proceeds so rapidly that a new best architecture for a given benchmark is announced every few weeks to months, rendering it impractical to describe the best architecture in print. however, the best architectures have consistently been composed of the building blocks described here. 9. 1 the convolution operation in its most general form, convolution is an operation on two functions of a real - valued argument. to motivate the deﬁnition of convolution, we start with examples of two functions we might use. suppose we are tracking the location of a spaceship with a laser sensor. our laser sensor provides a single output x ( t ), the position of the spaceship at time t. both x and t are real - valued, i. e., we can get a [UNK] reading from the laser sensor at any instant in time. now suppose that our laser sensor is somewhat noisy. to obtain a less noisy estimate of the spaceship ’ s position, we would like to average together several measurements. of course, more recent measurements are more relevant, so we will want this to be a	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	346	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
now suppose that our laser sensor is somewhat noisy. to obtain a less noisy estimate of the spaceship ’ s position, we would like to average together several measurements. of course, more recent measurements are more relevant, so we will want this to be a weighted average that gives more weight to recent measurements. we can do this with a weighting function w ( a ), where a is the age of a measurement. if we apply such a weighted average operation at every moment, we obtain a new function providing a smoothed estimate of the position of the spaceship : s s t ( ) = x a w t a da ( ) ( − ) ( 9. 1 ) this operation is called convolution. the convolution operation is typically denoted with an asterisk : s t x w t ( ) = ( ∗ ) ( ) ( 9. 2 ) in our example, w needs to be a valid probability density function, or the output is not a weighted average. also, w needs to be for all negative arguments, 0 or it will look into the future, which is presumably beyond our capabilities. these limitations are particular to our example though. in general, convolution is deﬁned for any functions for which the above integral is deﬁ	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	346	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
negative arguments, 0 or it will look into the future, which is presumably beyond our capabilities. these limitations are particular to our example though. in general, convolution is deﬁned for any functions for which the above integral is deﬁned, and may be used for other purposes besides taking weighted averages. in convolutional network terminology, the ﬁrst argument ( in this example, the function x ) to the convolution is often referred to as the input and the second 331	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	346	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks argument ( in this example, the function w ) as the kernel. the output is sometimes referred to as the. feature map in our example, the idea of a laser sensor that can provide measurements at every instant in time is not realistic. usually, when we work with data on a computer, time will be discretized, and our sensor will provide data at regular intervals. in our example, it might be more realistic to assume that our laser provides a measurement once per second. the time index t can then take on only integer values. if we now assume that x and w are deﬁned only on integer t, we can deﬁne the discrete convolution : s t x w t ( ) = ( ∗ ) ( ) = ∞ a = −∞ x a w t a ( ) ( − ) ( 9. 3 ) in machine learning applications, the input is usually a multidimensional array of data and the kernel is usually a multidimensional array of parameters that are adapted by the learning algorithm. we will refer to these multidimensional arrays as tensors. because each element of the input and kernel must be explicitly stored separately, we usually assume that these functions are zero everywhere	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	347	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##ensional array of parameters that are adapted by the learning algorithm. we will refer to these multidimensional arrays as tensors. because each element of the input and kernel must be explicitly stored separately, we usually assume that these functions are zero everywhere but the ﬁnite set of points for which we store the values. this means that in practice we can implement the inﬁnite summation as a summation over a ﬁnite number of array elements. finally, we often use convolutions over more than one axis at a time. for example, if we use a two - dimensional image i as our input, we probably also want to use a two - dimensional kernel : k s i, j i k i, j ( ) = ( ∗ ) ( ) = m n i m, n k i m, j n. ( ) ( − − ) ( 9. 4 ) convolution is commutative, meaning we can equivalently write : s i, j k i i, j ( ) = ( ∗ ) ( ) = m n i i m, j n k m, n. ( − − ) ( ) ( 9. 5 ) usually the latter formula is more straightforward to implement in a machine learning library,	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	347	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
, j ( ) = ( ∗ ) ( ) = m n i i m, j n k m, n. ( − − ) ( ) ( 9. 5 ) usually the latter formula is more straightforward to implement in a machine learning library, because there is less variation in the range of valid values of m and. n the commutative property of convolution arises because we have ﬂipped the kernel relative to the input, in the sense that as m increases, the index into the input increases, but the index into the kernel decreases. the only reason to ﬂip the kernel is to obtain the commutative property. while the commutative property 332	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	347	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks is useful for writing proofs, it is not usually an important property of a neural network implementation. instead, many neural network libraries implement a related function called the cross - correlation, which is the same as convolution but without ﬂipping the kernel : s i, j i k i, j ( ) = ( ∗ ) ( ) = m n i i m, j n k m, n. ( + + ) ( ) ( 9. 6 ) many machine learning libraries implement cross - correlation but call it convolution. in this text we will follow this convention of calling both operations convolution, and specify whether we mean to ﬂip the kernel or not in contexts where kernel ﬂipping is relevant. in the context of machine learning, the learning algorithm will learn the appropriate values of the kernel in the appropriate place, so an algorithm based on convolution with kernel ﬂipping will learn a kernel that is ﬂipped relative to the kernel learned by an algorithm without the ﬂipping. it is also rare for convolution to be used alone in machine learning ; instead convolution is used simultaneously with other functions, and the combination of these functions does not	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	348	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
to the kernel learned by an algorithm without the ﬂipping. it is also rare for convolution to be used alone in machine learning ; instead convolution is used simultaneously with other functions, and the combination of these functions does not commute regardless of whether the convolution operation ﬂips its kernel or not. see ﬁgure for an example of convolution ( without kernel ﬂipping ) applied 9. 1 to a 2 - d tensor. discrete convolution can be viewed as multiplication by a matrix. however, the matrix has several entries constrained to be equal to other entries. for example, for univariate discrete convolution, each row of the matrix is constrained to be equal to the row above shifted by one element. this is known as a toeplitz matrix. in two dimensions, a doubly block circulant matrix corresponds to convolution. in addition to these constraints that several elements be equal to each other, convolution usually corresponds to a very sparse matrix ( a matrix whose entries are mostly equal to zero ). this is because the kernel is usually much smaller than the input image. any neural network algorithm that works with matrix multiplication and does not depend on	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	348	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##volution usually corresponds to a very sparse matrix ( a matrix whose entries are mostly equal to zero ). this is because the kernel is usually much smaller than the input image. any neural network algorithm that works with matrix multiplication and does not depend on speciﬁc properties of the matrix structure should work with convolution, without requiring any further changes to the neural network. typical convolutional neural networks do make use of further specializations in order to deal with large inputs [UNK], but these are not strictly necessary from a theoretical perspective. 333	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	348	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks a b c d e f g h i j k l w x y z aw + bx + ey + fz aw + bx + ey + fz bw + cx + fy + gz bw + cx + fy + gz cw + dx + gy + hz cw + dx + gy + hz ew + fx + iy + jz ew + fx + iy + jz fw + gx + jy + kz fw + gx + jy + kz gw + hx + ky + lz gw + hx + ky + lz input kernel output figure 9. 1 : an example of 2 - d convolution without kernel - ﬂipping. in this case we restrict the output to only positions where the kernel lies entirely within the image, called “ valid ” convolution in some contexts. we draw boxes with arrows to indicate how the upper - left element of the output tensor is formed by applying the kernel to the corresponding upper - left region of the input tensor. 334	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	349	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks 9. 2 motivation convolution leverages three important ideas that can help improve a machine learning system : sparse interactions, parameter sharing and equivariant representations. moreover, convolution provides a means for working with inputs of variable size. we now describe each of these ideas in turn. traditional neural network layers use matrix multiplication by a matrix of parameters with a separate parameter describing the interaction between each input unit and each output unit. this means every output unit interacts with every input unit. convolutional networks, however, typically have sparse interactions ( also referred to as sparse connectivity or sparse weights ). this is accomplished by making the kernel smaller than the input. for example, when processing an image, the input image might have thousands or millions of pixels, but we can detect small, meaningful features such as edges with kernels that occupy only tens or hundreds of pixels. this means that we need to store fewer parameters, which both reduces the memory requirements of the model and improves its statistical [UNK]. it also means that computing the output requires fewer operations. these improvements in [UNK] are usually quite large. if there are m inputs and n outputs, then matrix multiplication requires m n × parameters and the algorithms used	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	350	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
of the model and improves its statistical [UNK]. it also means that computing the output requires fewer operations. these improvements in [UNK] are usually quite large. if there are m inputs and n outputs, then matrix multiplication requires m n × parameters and the algorithms used in practice have o ( m n × ) runtime ( per example ). if we limit the number of connections each output may have to k, then the sparsely connected approach requires only k n × parameters and o ( k n × ) runtime. for many practical applications, it is possible to obtain good performance on the machine learning task while keeping k several orders of magnitude smaller than m. for graphical demonstrations of sparse connectivity, see ﬁgure and ﬁgure. in a deep convolutional network, 9. 2 9. 3 units in the deeper layers may indirectly interact with a larger portion of the input, as shown in ﬁgure. this allows the network to [UNK] describe complicated 9. 4 interactions between many variables by constructing such interactions from simple building blocks that each describe only sparse interactions. parameter sharing refers to using the same parameter for more than one function in a model. in a traditional neural net, each element of the weight matrix is used exactly once when computing the output of a layer. it	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	350	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
blocks that each describe only sparse interactions. parameter sharing refers to using the same parameter for more than one function in a model. in a traditional neural net, each element of the weight matrix is used exactly once when computing the output of a layer. it is multiplied by one element of the input and then never revisited. as a synonym for parameter sharing, one can say that a network has tied weights, because the value of the weight applied to one input is tied to the value of a weight applied elsewhere. in a convolutional neural net, each member of the kernel is used at every position of the input ( except perhaps some of the boundary pixels, depending on the design decisions regarding the boundary ). the parameter sharing used by the convolution operation means that rather than learning a separate set of parameters 335	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	350	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks x1 x1 x2 x2 x3 x3 s2 s2 s1 s1 s3 s3 x4 x4 s4 s4 x5 x5 s5 s5 x1 x1 x2 x2 x3 x3 s2 s2 s1 s1 s3 s3 x4 x4 s4 s4 x5 x5 s5 s5 figure 9. 2 : sparse connectivity, viewed from below : we highlight one input unit, x3, and also highlight the output units in s that are [UNK] by this unit. ( top ) when s is formed by convolution with a kernel of width, only three outputs are [UNK] by 3 x. ( bottom ) when is formed by matrix multiplication, connectivity is no longer sparse, so s all of the outputs are [UNK] by x3. 336	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	351	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks x1 x1 x2 x2 x3 x3 s2 s2 s1 s1 s3 s3 x4 x4 s4 s4 x5 x5 s5 s5 x1 x1 x2 x2 x3 x3 s2 s2 s1 s1 s3 s3 x4 x4 s4 s4 x5 x5 s5 s5 figure 9. 3 : sparse connectivity, viewed from above : we highlight one output unit, s3, and also highlight the input units in x that [UNK] this unit. these units are known as the receptive ﬁeld of s3. ( top ) when s is formed by convolution with a kernel of width, only three inputs [UNK] 3 s3. when ( bottom ) s is formed by matrix multiplication, connectivity is no longer sparse, so all of the inputs [UNK] s3. x1 x1 x2 x2 x3 x3 h2h2 h1h1 h3 h3 x4 x4 h4h4 x5 x5 h5h5 g2g2 g1g1 g3 g3 g4g4 g5g5 figure 9. 4 : the rec	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	352	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##1h1 h3 h3 x4 x4 h4h4 x5 x5 h5h5 g2g2 g1g1 g3 g3 g4g4 g5g5 figure 9. 4 : the receptive ﬁeld of the units in the deeper layers of a convolutional network is larger than the receptive ﬁeld of the units in the shallow layers. this [UNK] increases if the network includes architectural features like strided convolution ( ﬁgure ) or pooling 9. 12 ( section ). this means that even though 9. 3 direct connections in a convolutional net are very sparse, units in the deeper layers can be indirectly connected to all or most of the input image. 337	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	352	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks x1 x1 x2 x2 x3 x3 s2 s2 s1 s1 s3 s3 x4 x4 s4 s4 x5 x5 s5 s5 x1 x1 x2 x2 x3 x3 x4 x4 x5 x5 s2 s2 s1 s1 s3 s3 s4 s4 s5 s5 figure 9. 5 : parameter sharing : black arrows indicate the connections that use a particular parameter in two [UNK] models. ( top ) the black arrows indicate uses of the central element of a 3 - element kernel in a convolutional model. due to parameter sharing, this single parameter is used at all input locations. the single black arrow indicates ( bottom ) the use of the central element of the weight matrix in a fully connected model. this model has no parameter sharing so the parameter is used only once. for every location, we learn only one set. this does not [UNK] the runtime of forward propagation — it is still o ( k n × ) — but it does further reduce the storage requirements of the model to k parameters. recall that k is usually several orders of magnitude less than m. since m and n are	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	353	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
the runtime of forward propagation — it is still o ( k n × ) — but it does further reduce the storage requirements of the model to k parameters. recall that k is usually several orders of magnitude less than m. since m and n are usually roughly the same size, k is practically insigniﬁcant compared to m n ×. convolution is thus dramatically more [UNK] than dense matrix multiplication in terms of the memory requirements and statistical [UNK]. for a graphical depiction of how parameter sharing works, see ﬁgure. 9. 5 as an example of both of these ﬁrst two principles in action, ﬁgure shows 9. 6 how sparse connectivity and parameter sharing can dramatically improve the [UNK] of a linear function for detecting edges in an image. in the case of convolution, the particular form of parameter sharing causes the layer to have a property called equivariance to translation. to say a function is equivariant means that if the input changes, the output changes in the same way. speciﬁcally, a function f ( x ) is equivariant to a function g if f ( g ( x ) ) = g ( f ( x ) ). in the case of convolu	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	353	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
the same way. speciﬁcally, a function f ( x ) is equivariant to a function g if f ( g ( x ) ) = g ( f ( x ) ). in the case of convolution, if we let g be any function that translates the input, i. e., shifts it, then the convolution function is equivariant to g. for example, let i be a function giving image brightness at integer coordinates. let g be a function 338	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	353	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks mapping one image function to another image function, such that i = g ( i ) is the image function with i ( x, y ) = i ( x −1, y ). this shifts every pixel of i one unit to the right. if we apply this transformation to i, then apply convolution, the result will be the same as if we applied convolution to i, then applied the transformation g to the output. when processing time series data, this means that convolution produces a sort of timeline that shows when [UNK] features appear in the input. if we move an event later in time in the input, the exact same representation of it will appear in the output, just later in time. similarly with images, convolution creates a 2 - d map of where certain features appear in the input. if we move the object in the input, its representation will move the same amount in the output. this is useful for when we know that some function of a small number of neighboring pixels is useful when applied to multiple input locations. for example, when processing images, it is useful to detect edges in the ﬁrst layer of a convolutional network. the same edges	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	354	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
know that some function of a small number of neighboring pixels is useful when applied to multiple input locations. for example, when processing images, it is useful to detect edges in the ﬁrst layer of a convolutional network. the same edges appear more or less everywhere in the image, so it is practical to share parameters across the entire image. in some cases, we may not wish to share parameters across the entire image. for example, if we are processing images that are cropped to be centered on an individual ’ s face, we probably want to extract [UNK] features at [UNK] locations — the part of the network processing the top of the face needs to look for eyebrows, while the part of the network processing the bottom of the face needs to look for a chin. convolution is not naturally equivariant to some other transformations, such as changes in the scale or rotation of an image. other mechanisms are necessary for handling these kinds of transformations. finally, some kinds of data cannot be processed by neural networks deﬁned by matrix multiplication with a ﬁxed - shape matrix. convolution enables processing of some of these kinds of data. we discuss this further in section. 9. 7 9. 3 pooling a typical layer of a	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	354	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
neural networks deﬁned by matrix multiplication with a ﬁxed - shape matrix. convolution enables processing of some of these kinds of data. we discuss this further in section. 9. 7 9. 3 pooling a typical layer of a convolutional network consists of three stages ( see ﬁgure ). 9. 7 in the ﬁrst stage, the layer performs several convolutions in parallel to produce a set of linear activations. in the second stage, each linear activation is run through a nonlinear activation function, such as the rectiﬁed linear activation function. this stage is sometimes called the detector stage. in the third stage, we use a pooling function to modify the output of the layer further. a pooling function replaces the output of the net at a certain location with a summary statistic of the nearby outputs. for example, the max pooling ( zhou 339	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	354	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks figure 9. 6 : [UNK] of edge detection. the image on the right was formed by taking each pixel in the original image and subtracting the value of its neighboring pixel on the left. this shows the strength of all of the vertically oriented edges in the input image, which can be a useful operation for object detection. both images are 280 pixels tall. the input image is 320 pixels wide while the output image is 319 pixels wide. this transformation can be described by a convolution kernel containing two elements, and requires 319 × 280 × 3 = 267, 960 ﬂoating point operations ( two multiplications and one addition per output pixel ) to compute using convolution. to describe the same transformation with a matrix multiplication would take 320× 280× 319 × 280, or over eight billion, entries in the matrix, making convolution four billion times more [UNK] for representing this transformation. the straightforward matrix multiplication algorithm performs over sixteen billion ﬂoating point operations, making convolution roughly 60, 000 times more [UNK] computationally. of course, most of the entries of the matrix would be zero. if we stored only the nonzero entries of the matrix, then both matrix multiplication and convo	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	355	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
, making convolution roughly 60, 000 times more [UNK] computationally. of course, most of the entries of the matrix would be zero. if we stored only the nonzero entries of the matrix, then both matrix multiplication and convolution would require the same number of ﬂoating point operations to compute. the matrix would still need to contain 2 × 319 × 280 = 178, 640 entries. convolution is an extremely [UNK] way of describing transformations that apply the same linear transformation of a small, local region across the entire input. ( photo credit : paula goodfellow ) 340	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	355	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks convolutional layer input to layer convolution stage : a ne transform [UNK] detector stage : nonlinearity e. g., rectiﬁed linear pooling stage next layer input to layers convolution layer : a ne transform [UNK] detector layer : nonlinearity e. g., rectiﬁed linear pooling layer next layer complex layer terminology simple layer terminology figure 9. 7 : the components of a typical convolutional neural network layer. there are two commonly used sets of terminology for describing these layers. ( left ) in this terminology, the convolutional net is viewed as a small number of relatively complex layers, with each layer having many “ stages. ” in this terminology, there is a one - to - one mapping between kernel tensors and network layers. in this book we generally use this terminology. ( right ) in this terminology, the convolutional net is viewed as a larger number of simple layers ; every step of processing is regarded as a layer in its own right. this means that not every “ layer ” has parameters. 341	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	356	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks and chellappa 1988, ) operation reports the maximum output within a rectangular neighborhood. other popular pooling functions include the average of a rectangular neighborhood, the l2 norm of a rectangular neighborhood, or a weighted average based on the distance from the central pixel. in all cases, pooling helps to make the representation become approximately invariant to small translations of the input. invariance to translation means that if we translate the input by a small amount, the values of most of the pooled outputs do not change. see ﬁgure for an example of how this works. 9. 8 invariance to local translation can be a very useful property if we care more about whether some feature is present than exactly where it is. for example, when determining whether an image contains a face, we need not know the location of the eyes with pixel - perfect accuracy, we just need to know that there is an eye on the left side of the face and an eye on the right side of the face. in other contexts, it is more important to preserve the location of a feature. for example, if we want to ﬁnd a corner deﬁned by two edges meeting at a speciﬁc orientation, we need to preserve	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	357	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
of the face. in other contexts, it is more important to preserve the location of a feature. for example, if we want to ﬁnd a corner deﬁned by two edges meeting at a speciﬁc orientation, we need to preserve the location of the edges well enough to test whether they meet. the use of pooling can be viewed as adding an inﬁnitely strong prior that the function the layer learns must be invariant to small translations. when this assumption is correct, it can greatly improve the statistical [UNK] of the network. pooling over spatial regions produces invariance to translation, but if we pool over the outputs of separately parametrized convolutions, the features can learn which transformations to become invariant to ( see ﬁgure ). 9. 9 because pooling summarizes the responses over a whole neighborhood, it is possible to use fewer pooling units than detector units, by reporting summary statistics for pooling regions spaced k pixels apart rather than 1 pixel apart. see ﬁgure for an example. this improves the computational [UNK] of the 9. 10 network because the next layer has roughly k times fewer inputs to process. when the number of parameters in the next layer is a function of its input size ( such as when	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	357	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##gure for an example. this improves the computational [UNK] of the 9. 10 network because the next layer has roughly k times fewer inputs to process. when the number of parameters in the next layer is a function of its input size ( such as when the next layer is fully connected and based on matrix multiplication ) this reduction in the input size can also result in improved statistical [UNK] and reduced memory requirements for storing the parameters. for many tasks, pooling is essential for handling inputs of varying size. for example, if we want to classify images of variable size, the input to the classiﬁcation layer must have a ﬁxed size. this is usually accomplished by varying the size of an [UNK] between pooling regions so that the classiﬁcation layer always receives the same number of summary statistics regardless of the input size. for example, the ﬁnal pooling layer of the network may be deﬁned to output four sets of summary statistics, one for each quadrant of an image, regardless of the image size. 342	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	357	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks 0. 1 1. 0. 2 1. 1. 1. 0. 1 0. 2............ 0. 3 0. 1 1. 1. 0. 3 1. 0. 2 1............. detector stage pooling stage pooling stage detector stage figure 9. 8 : max pooling introduces invariance. ( top ) a view of the middle of the output of a convolutional layer. the bottom row shows outputs of the nonlinearity. the top row shows the outputs of max pooling, with a stride of one pixel between pooling regions and a pooling region width of three pixels. a view of the same network, after ( bottom ) the input has been shifted to the right by one pixel. every value in the bottom row has changed, but only half of the values in the top row have changed, because the max pooling units are only sensitive to the maximum value in the neighborhood, not its exact location. 343	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	358	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks large response in pooling unit large response in pooling unit large response in detector unit 1 large response in detector unit 3 figure 9. 9 : example of learned invariances : a pooling unit that pools over multiple features that are learned with separate parameters can learn to be invariant to transformations of the input. here we show how a set of three learned ﬁlters and a max pooling unit can learn to become invariant to rotation. all three ﬁlters are intended to detect a hand - written 5. each ﬁlter attempts to match a slightly [UNK] orientation of the 5. when a 5 appears in the input, the corresponding ﬁlter will match it and cause a large activation in a detector unit. the max pooling unit then has a large activation regardless of which detector unit was activated. we show here how the network processes two [UNK] inputs, resulting in two [UNK] detector units being activated. the [UNK] on the pooling unit is roughly the same either way. this principle is leveraged by maxout networks ( goodfellow et al., 2013a ) and other convolutional networks. max pooling over spatial positions is naturally invariant to translation ; this multi - channel approach is only necessary for learning other	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	359	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
is leveraged by maxout networks ( goodfellow et al., 2013a ) and other convolutional networks. max pooling over spatial positions is naturally invariant to translation ; this multi - channel approach is only necessary for learning other transformations. 0. 1 1. 0. 2 1. 0. 2 0. 1 0. 1 0. 0 0. 1 figure 9. 10 : pooling with downsampling. here we use max - pooling with a pool width of three and a stride between pools of two. this reduces the representation size by a factor of two, which reduces the computational and statistical burden on the next layer. note that the rightmost pooling region has a smaller size, but must be included if we do not want to ignore some of the detector units. 344	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	359	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 9. convolutional networks some theoretical work gives guidance as to which kinds of pooling one should use in various situations (, ). it is also possible to dynamically boureau et al. 2010 pool features together, for example, by running a clustering algorithm on the locations of interesting features (, ). this approach yields a boureau et al. 2011 [UNK] set of pooling regions for each image. another approach is to learn a single pooling structure that is then applied to all images (, ). jia et al. 2012 pooling can complicate some kinds of neural network architectures that use top - down information, such as boltzmann machines and autoencoders. these issues will be discussed further when we present these types of networks in part. iii pooling in convolutional boltzmann machines is presented in section. the 20. 6 inverse - like operations on pooling units needed in some [UNK] networks will be covered in section. 20. 10. 6 some examples of complete convolutional network architectures for classiﬁcation using convolution and pooling are shown in ﬁgure. 9. 11 9. 4 convolution and pooling as an	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	360	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)