Split (1)

train · 2.22k rows

Subsets and Splits

No community queries yet

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

text stringlengths 35 1.54k	source stringclasses 1 value	page int64 1 800	book stringclasses 1 value
chapter 11. practical methodology monitor histograms of activations and gradient : it is often useful to visualize statistics of neural network activations and gradients, collected over a large amount of training iterations ( maybe one epoch ). the pre - activation value of hidden units can tell us if the units saturate, or how often they do. for example, for rectiﬁers, how often are they [UNK]? are there units that are always [UNK]? for tanh units, the average of the absolute value of the pre - activations tells us how saturated the unit is. in a deep network where the propagated gradients quickly grow or quickly vanish, optimization may be hampered. finally, it is useful to compare the magnitude of parameter gradients to the magnitude of the parameters themselves. as suggested by ( ), we would like the magnitude of parameter updates bottou 2015 over a minibatch to represent something like 1 % of the magnitude of the parameter, not 50 % or 0. 001 % ( which would make the parameters move too slowly ). it may be that some groups of parameters are moving at a good pace while others are stalled. when the data is sparse ( like in natural language ), some parameters may be very rarely updated,	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	455	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
( which would make the parameters move too slowly ). it may be that some groups of parameters are moving at a good pace while others are stalled. when the data is sparse ( like in natural language ), some parameters may be very rarely updated, and this should be kept in mind when monitoring their evolution. finally, many deep learning algorithms provide some sort of guarantee about the results produced at each step. for example, in part, we will see some approx - iii imate inference algorithms that work by using algebraic solutions to optimization problems. typically these can be debugged by testing each of their guarantees. some guarantees that some optimization algorithms [UNK] include that the objective function will never increase after one step of the algorithm, that the gradient with respect to some subset of variables will be zero after each step of the algorithm, and that the gradient with respect to all variables will be zero at convergence. usually due to rounding error, these conditions will not hold exactly in a digital computer, so the debugging test should include some tolerance parameter. 11. 6 example : multi - digit number recognition to provide an end - to - end description of how to apply our design methodology in practice, we present a brief account of the street view transcription system, from the point of view of designing	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	455	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
parameter. 11. 6 example : multi - digit number recognition to provide an end - to - end description of how to apply our design methodology in practice, we present a brief account of the street view transcription system, from the point of view of designing the deep learning components. obviously, many other components of the complete system, such as the street view cars, the database infrastructure, and so on, were of paramount importance. from the point of view of the machine learning task, the process began with data collection. the cars collected the raw data and human operators provided labels. the transcription task was preceded by a signiﬁcant amount of dataset curation, including using other machine learning techniques to detect the house 440	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	455	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 11. practical methodology numbers prior to transcribing them. the transcription project began with a choice of performance metrics and desired values for these metrics. an important general principle is to tailor the choice of metric to the business goals for the project. because maps are only useful if they have high accuracy, it was important to set a high accuracy requirement for this project. speciﬁcally, the goal was to obtain human - level, 98 % accuracy. this level of accuracy may not always be feasible to obtain. in order to reach this level of accuracy, the street view transcription system sacriﬁces coverage. coverage thus became the main performance metric optimized during the project, with accuracy held at 98 %. as the convolutional network improved, it became possible to reduce the conﬁdence threshold below which the network refuses to transcribe the input, eventually exceeding the goal of 95 % coverage. after choosing quantitative goals, the next step in our recommended methodol - ogy is to rapidly establish a sensible baseline system. for vision tasks, this means a convolutional network with rectiﬁed linear units. the transcription project began with such a model. at the time, it was not common for a con	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	456	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
is to rapidly establish a sensible baseline system. for vision tasks, this means a convolutional network with rectiﬁed linear units. the transcription project began with such a model. at the time, it was not common for a convolutional network to output a sequence of predictions. in order to begin with the simplest possible baseline, the ﬁrst implementation of the output layer of the model consisted of n [UNK] softmax units to predict a sequence of n characters. these softmax units were trained exactly the same as if the task were classiﬁcation, with each softmax unit trained independently. our recommended methodology is to iteratively reﬁne the baseline and test whether each change makes an improvement. the ﬁrst change to the street view transcription system was motivated by a theoretical understanding of the coverage metric and the structure of the data. speciﬁcally, the network refuses to classify an input x whenever the probability of the output sequence p ( y x \| ) < t for some threshold t. initially, the deﬁnition of p ( y x \| ) was ad - hoc, based on simply multiplying all of the softmax outputs together. this motivated the development of a specialized output layer and cost function that actually computed	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	456	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
t. initially, the deﬁnition of p ( y x \| ) was ad - hoc, based on simply multiplying all of the softmax outputs together. this motivated the development of a specialized output layer and cost function that actually computed a principled log - likelihood. this approach allowed the example rejection mechanism to function much more [UNK]. at this point, coverage was still below 90 %, yet there were no obvious theoretical problems with the approach. our methodology therefore suggests to instrument the train and test set performance in order to determine whether the problem is underﬁtting or overﬁtting. in this case, train and test set error were nearly identical. indeed, the main reason this project proceeded so smoothly was the availability of a dataset with tens of millions of labeled examples. because train and test set error were so similar, this suggested that the problem was either due 441	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	456	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 11. practical methodology to underﬁtting or due to a problem with the training data. one of the debugging strategies we recommend is to visualize the model ’ s worst errors. in this case, that meant visualizing the incorrect training set transcriptions that the model gave the highest conﬁdence. these proved to mostly consist of examples where the input image had been cropped too tightly, with some of the digits of the address being removed by the cropping operation. for example, a photo of an address “ 1849 ” might be cropped too tightly, with only the “ 849 ” remaining visible. this problem could have been resolved by spending weeks improving the accuracy of the address number detection system responsible for determining the cropping regions. instead, the team took a much more practical decision, to simply expand the width of the crop region to be systematically wider than the address number detection system predicted. this single change added ten percentage points to the transcription system ’ s coverage. finally, the last few percentage points of performance came from adjusting hyperparameters. this mostly consisted of making the model larger while main - taining some restrictions on its computational cost. because train and test error remained roughly equal, it was always clear that any performance deﬁcits	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	457	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
of performance came from adjusting hyperparameters. this mostly consisted of making the model larger while main - taining some restrictions on its computational cost. because train and test error remained roughly equal, it was always clear that any performance deﬁcits were due to underﬁtting, as well as due to a few remaining problems with the dataset itself. overall, the transcription project was a great success, and allowed hundreds of millions of addresses to be transcribed both faster and at lower cost than would have been possible via human [UNK]. we hope that the design principles described in this chapter will lead to many other similar successes. 442	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	457	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12 applications in this chapter, we describe how to use deep learning to solve applications in com - puter vision, speech recognition, natural language processing, and other application areas of commercial interest. we begin by discussing the large scale neural network implementations required for most serious ai applications. next, we review several speciﬁc application areas that deep learning has been used to solve. while one goal of deep learning is to design algorithms that are capable of solving a broad variety of tasks, so far some degree of specialization is needed. for example, vision tasks require processing a large number of input features ( pixels ) per example. language tasks require modeling a large number of possible values ( words in the vocabulary ) per input feature. 12. 1 large - scale deep learning deep learning is based on the philosophy of connectionism : while an individual biological neuron or an individual feature in a machine learning model is not intelligent, a large population of these neurons or features acting together can exhibit intelligent behavior. it truly is important to emphasize the fact that the number of neurons must be large. one of the key factors responsible for the improvement in neural network ’ s accuracy and the improvement of the complexity of tasks they can solve between the 1980s and today is the dramatic increase in the size of the networks	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	458	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
that the number of neurons must be large. one of the key factors responsible for the improvement in neural network ’ s accuracy and the improvement of the complexity of tasks they can solve between the 1980s and today is the dramatic increase in the size of the networks we use. as we saw in section, network sizes have 1. 2. 3 grown exponentially for the past three decades, yet artiﬁcial neural networks are only as large as the nervous systems of insects. because the size of neural networks is of paramount importance, deep learning 443	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	458	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12. applications requires high performance hardware and software infrastructure. 12. 1. 1 fast cpu implementations traditionally, neural networks were trained using the cpu of a single machine. today, this approach is generally considered [UNK]. we now mostly use gpu computing or the cpus of many machines networked together. before moving to these expensive setups, researchers worked hard to demonstrate that cpus could not manage the high computational workload required by neural networks. a description of how to implement [UNK] numerical cpu code is beyond the scope of this book, but we emphasize here that careful implementation for speciﬁc cpu families can yield large improvements. for example, in 2011, the best cpus available could run neural network workloads faster when using ﬁxed - point arithmetic rather than ﬂoating - point arithmetic. by creating a carefully tuned ﬁxed - point implementation, vanhoucke 2011 et al. ( ) obtained a threefold speedup over a strong ﬂoating - point system. each new model of cpu has [UNK] performance characteristics, so sometimes ﬂoating - point implementations can be faster too. the important principle is that careful specialization of numerical computation routines can yield a large [UNK]. other strategies, besides choosing whether to use ﬁxed or ﬂoating point, include	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	459	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
performance characteristics, so sometimes ﬂoating - point implementations can be faster too. the important principle is that careful specialization of numerical computation routines can yield a large [UNK]. other strategies, besides choosing whether to use ﬁxed or ﬂoating point, include optimizing data structures to avoid cache misses and using vector instructions. many machine learning researchers neglect these implementation details, but when the performance of an implementation restricts the size of the model, the accuracy of the model [UNK]. 12. 1. 2 gpu implementations most modern neural network implementations are based on graphics processing units. graphics processing units ( gpus ) are specialized hardware components that were originally developed for graphics applications. the consumer market for video gaming systems spurred development of graphics processing hardware. the performance characteristics needed for good video gaming systems turn out to be beneﬁcial for neural networks as well. video game rendering requires performing many operations in parallel quickly. models of characters and environments are speciﬁed in terms of lists of 3 - d coordinates of vertices. graphics cards must perform matrix multiplication and division on many vertices in parallel to convert these 3 - d coordinates into 2 - d on - screen coordinates. the graphics card must then perform many computations at each pixel in parallel to determine the color of each pixel. in	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	459	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
must perform matrix multiplication and division on many vertices in parallel to convert these 3 - d coordinates into 2 - d on - screen coordinates. the graphics card must then perform many computations at each pixel in parallel to determine the color of each pixel. in both cases, the 444	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	459	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12. applications computations are fairly simple and do not involve much branching compared to the computational workload that a cpu usually encounters. for example, each vertex in the same rigid object will be multiplied by the same matrix ; there is no need to evaluate an if statement per - vertex to determine which matrix to multiply by. the computations are also entirely independent of each other, and thus may be parallelized easily. the computations also involve processing massive [UNK] of memory, containing bitmaps describing the texture ( color pattern ) of each object to be rendered. together, this results in graphics cards having been designed to have a high degree of parallelism and high memory bandwidth, at the cost of having a lower clock speed and less branching capability relative to traditional cpus. neural network algorithms require the same performance characteristics as the real - time graphics algorithms described above. neural networks usually involve large and numerous [UNK] of parameters, activation values, and gradient values, each of which must be completely updated during every step of training. these [UNK] are large enough to fall outside the cache of a traditional desktop computer so the memory bandwidth of the system often becomes the rate limiting factor. gpus [UNK] a compelling advantage over cpus due to their high memory bandwidth. neural network training algorithms typically do	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	460	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
[UNK] are large enough to fall outside the cache of a traditional desktop computer so the memory bandwidth of the system often becomes the rate limiting factor. gpus [UNK] a compelling advantage over cpus due to their high memory bandwidth. neural network training algorithms typically do not involve much branching or sophisticated control, so they are appropriate for gpu hardware. since neural networks can be divided into multiple individual “ neurons ” that can be processed independently from the other neurons in the same layer, neural networks easily beneﬁt from the parallelism of gpu computing. gpu hardware was originally so specialized that it could only be used for graphics tasks. over time, gpu hardware became more ﬂexible, allowing custom subroutines to be used to transform the coordinates of vertices or assign colors to pixels. in principle, there was no requirement that these pixel values actually be based on a rendering task. these gpus could be used for scientiﬁc computing by writing the output of a computation to a [UNK] of pixel values. steinkrau et al. ( ) implemented a two - layer fully connected neural network on a gpu and 2005 reported a threefold speedup over their cpu - based baseline. shortly thereafter, chellapilla 2006 et al. ( ) demonstrated that	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	460	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
##krau et al. ( ) implemented a two - layer fully connected neural network on a gpu and 2005 reported a threefold speedup over their cpu - based baseline. shortly thereafter, chellapilla 2006 et al. ( ) demonstrated that the same technique could be used to accelerate supervised convolutional networks. the popularity of graphics cards for neural network training exploded after the advent of general purpose gpus. these gp - gpus could execute arbitrary code, not just rendering subroutines. nvidia ’ s cuda programming language provided a way to write this arbitrary code in a c - like language. with their relatively convenient programming model, massive parallelism, and high memory 445	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	460	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12. applications bandwidth, gp - gpus now [UNK] an ideal platform for neural network programming. this platform was rapidly adopted by deep learning researchers soon after it became available (, ;, ). raina et al. 2009 ciresan et al. 2010 writing [UNK] code for gp - gpus remains a [UNK] task best left to spe - cialists. the techniques required to obtain good performance on gpu are very [UNK] from those used on cpu. for example, good cpu - based code is usually designed to read information from the cache as much as possible. on gpu, most writable memory locations are not cached, so it can actually be faster to compute the same value twice, rather than compute it once and read it back from memory. gpu code is also inherently multi - threaded and the [UNK] threads must be coordinated with each other carefully. for example, memory operations are faster if they can be coalesced. coalesced reads or writes occur when several threads can each read or write a value that they need simultaneously, as part of a single memory transaction. [UNK] models of gpus are able to coalesce [UNK] kinds of read or write patterns. typically, memory operations are easier to coalesce if among n threads, thread i	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	461	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
value that they need simultaneously, as part of a single memory transaction. [UNK] models of gpus are able to coalesce [UNK] kinds of read or write patterns. typically, memory operations are easier to coalesce if among n threads, thread i accesses byte i + j of memory, and j is a multiple of some power of 2. the exact speciﬁcations [UNK] between models of gpu. another common consideration for gpus is making sure that each thread in a group executes the same instruction simultaneously. this means that branching can be [UNK] on gpu. threads are divided into small groups called warps. each thread in a warp executes the same instruction during each cycle, so if [UNK] threads within the same warp need to execute [UNK] code paths, these [UNK] code paths must be traversed sequentially rather than in parallel. due to the [UNK] of writing high performance gpu code, researchers should structure their workﬂow to avoid needing to write new gpu code in order to test new models or algorithms. typically, one can do this by building a software library of high performance operations like convolution and matrix multiplication, then specifying models in terms of calls to this library of operations. for example, the machine learning library pylearn	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	461	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
. typically, one can do this by building a software library of high performance operations like convolution and matrix multiplication, then specifying models in terms of calls to this library of operations. for example, the machine learning library pylearn2 ( goodfellow 2013c et al., ) speciﬁes all of its machine learning algorithms in terms of calls to theano (, ; bergstra et al. 2010 bastien 2012 et al., ) and cuda - convnet (, ), which provide these krizhevsky 2010 high - performance operations. this factored approach can also ease support for multiple kinds of hardware. for example, the same theano program can run on either cpu or gpu, without needing to change any of the calls to theano itself. other libraries like tensorflow (, ) and torch (, abadi et al. 2015 collobert et al. 2011b ) provide similar features. 446	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	461	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12. applications 12. 1. 3 large - scale distributed implementations in many cases, the computational resources available on a single machine are [UNK]. we therefore want to distribute the workload of training and inference across many machines. distributing inference is simple, because each input example we want to process can be run by a separate machine. this is known as. data parallelism it is also possible to get model parallelism, where multiple machines work together on a single datapoint, with each machine running a [UNK] part of the model. this is feasible for both inference and training. data parallelism during training is somewhat harder. we can increase the size of the minibatch used for a single sgd step, but usually we get less than linear returns in terms of optimization performance. it would be better to allow multiple machines to compute multiple gradient descent steps in parallel. unfortunately, the standard deﬁnition of gradient descent is as a completely sequential algorithm : the gradient at step is a function of the parameters produced by step. t t −1 this can be solved using asynchronous stochastic gradient descent ( ben - gio 2001 recht 2011 et al., ; et al., ). in this approach, several processor cores share the memory representing the	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	462	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
t −1 this can be solved using asynchronous stochastic gradient descent ( ben - gio 2001 recht 2011 et al., ; et al., ). in this approach, several processor cores share the memory representing the parameters. each core reads parameters without a lock, then computes a gradient, then increments the parameters without a lock. this reduces the average amount of improvement that each gradient descent step yields, because some of the cores overwrite each other ’ s progress, but the increased rate of production of steps causes the learning process to be faster overall. dean et al. ( ) pioneered the multi - machine implementation of this lock - free approach 2012 to gradient descent, where the parameters are managed by a parameter server rather than stored in shared memory. distributed asynchronous gradient descent remains the primary strategy for training large deep networks and is used by most major deep learning groups in industry (, ; chilimbi et al. 2014 wu et al., 2015 ). academic deep learning researchers typically cannot [UNK] the same scale of distributed learning systems but some research has focused on how to build distributed networks with relatively low - cost hardware available in the university setting (, ). coates et al. 2013 12. 1. 4	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	462	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
deep learning researchers typically cannot [UNK] the same scale of distributed learning systems but some research has focused on how to build distributed networks with relatively low - cost hardware available in the university setting (, ). coates et al. 2013 12. 1. 4 model compression in many commercial applications, it is much more important that the time and memory cost of running inference in a machine learning model be low than that the time and memory cost of training be low. for applications that do not require 447	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	462	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12. applications personalization, it is possible to train a model once, then deploy it to be used by billions of users. in many cases, the end user is more resource - constrained than the developer. for example, one might train a speech recognition network with a powerful computer cluster, then deploy it on mobile phones. a key strategy for reducing the cost of inference is model compression ( bu - [UNK] 2006 et al., ). the basic idea of model compression is to replace the original, expensive model with a smaller model that requires less memory and runtime to store and evaluate. model compression is applicable when the size of the original model is driven primarily by a need to prevent overﬁtting. in most cases, the model with the lowest generalization error is an ensemble of several independently trained models. evaluating all n ensemble members is expensive. sometimes, even a single model generalizes better if it is large ( for example, if it is regularized with dropout ). these large models learn some function f ( x ), but do so using many more parameters than are necessary for the task. their size is necessary only due to the limited number of training examples. as soon as we have ﬁt this function f ( x ), we can generate a training	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	463	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
x ), but do so using many more parameters than are necessary for the task. their size is necessary only due to the limited number of training examples. as soon as we have ﬁt this function f ( x ), we can generate a training set containing inﬁnitely many examples, simply by applying f to randomly sampled points x. we then train the new, smaller, model to match f ( x ) on these points. in order to most [UNK] use the capacity of the new, small model, it is best to sample the new x points from a distribution resembling the actual test inputs that will be supplied to the model later. this can be done by corrupting training examples or by drawing points from a generative model trained on the original training set. alternatively, one can train the smaller model only on the original training points, but train it to copy other features of the model, such as its posterior distribution over the incorrect classes ( hinton 2014 2015 et al.,, ). 12. 1. 5 dynamic structure one strategy for accelerating data processing systems in general is to build systems that have dynamic structure in the graph describing the computation needed to process an input. data processing systems can dynamically determine which subset of many neural networks should be run on a	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	463	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
5 dynamic structure one strategy for accelerating data processing systems in general is to build systems that have dynamic structure in the graph describing the computation needed to process an input. data processing systems can dynamically determine which subset of many neural networks should be run on a given input. individual neural networks can also exhibit dynamic structure internally by determining which subset of features ( hidden units ) to compute given information from the input. this form of dynamic structure inside neural networks is sometimes called conditional computation (, ;, ). since many components of bengio 2013 bengio et al. 2013b the architecture may be relevant only for a small amount of possible inputs, the 448	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	463	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12. applications system can run faster by computing these features only when they are needed. dynamic structure of computations is a basic computer science principle applied generally throughout the software engineering discipline. the simplest versions of dynamic structure applied to neural networks are based on determining which subset of some group of neural networks ( or other machine learning models ) should be applied to a particular input. a venerable strategy for accelerating inference in a classiﬁer is to use a cascade of classiﬁers. the cascade strategy may be applied when the goal is to detect the presence of a rare object ( or event ). to know for sure that the object is present, we must use a sophisticated classiﬁer with high capacity, that is expensive to run. however, because the object is rare, we can usually use much less computation to reject inputs as not containing the object. in these situations, we can train a sequence of classiﬁers. the ﬁrst classiﬁers in the sequence have low capacity, and are trained to have high recall. in other words, they are trained to make sure we do not wrongly reject an input when the object is present. the ﬁnal classiﬁer is trained to have high precision. at test time, we run inference by running	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	464	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
have high recall. in other words, they are trained to make sure we do not wrongly reject an input when the object is present. the ﬁnal classiﬁer is trained to have high precision. at test time, we run inference by running the classiﬁers in a sequence, abandoning any example as soon as any one element in the cascade rejects it. overall, this allows us to verify the presence of objects with high conﬁdence, using a high capacity model, but does not force us to pay the cost of full inference for every example. there are two [UNK] ways that the cascade can achieve high capacity. one way is to make the later members of the cascade individually have high capacity. in this case, the system as a whole obviously has high capacity, because some of its individual members do. it is also possible to make a cascade in which every individual model has low capacity but the system as a whole has high capacity due to the combination of many small models. viola and jones 2001 ( ) used a cascade of boosted decision trees to implement a fast and robust face detector suitable for use in handheld digital cameras. their classiﬁer localizes a face using essentially a sliding window approach in which many windows are examined and rejected if they do not contain	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	464	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
a cascade of boosted decision trees to implement a fast and robust face detector suitable for use in handheld digital cameras. their classiﬁer localizes a face using essentially a sliding window approach in which many windows are examined and rejected if they do not contain faces. another version of cascades uses the earlier models to implement a sort of hard attention mechanism : the early members of the cascade localize an object and later members of the cascade perform further processing given the location of the object. for example, google transcribes address numbers from street view imagery using a two - step cascade that ﬁrst locates the address number with one machine learning model and then transcribes it with another ( goodfellow 2014d et al., ). decision trees themselves are an example of dynamic structure, because each node in the tree determines which of its subtrees should be evaluated for each input. a simple way to accomplish the union of deep learning and dynamic structure 449	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	464	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12. applications is to train a decision tree in which each node uses a neural network to make the splitting decision (, ), though this has typically not been guo and gelfand 1992 done with the primary goal of accelerating inference computations. in the same spirit, one can use a neural network, called the gater to select which one out of several expert networks will be used to compute the output, given the current input. the ﬁrst version of this idea is called the mixture of experts ( nowlan 1990 jacobs 1991, ; et al., ), in which the gater outputs a set of probabilities or weights ( obtained via a softmax nonlinearity ), one per expert, and the ﬁnal output is obtained by the weighted combination of the output of the experts. in that case, the use of the gater does not [UNK] a reduction in computational cost, but if a single expert is chosen by the gater for each example, we obtain the hard mixture of experts (,, ), which collobert et al. 2001 2002 can considerably accelerate training and inference time. this strategy works well when the number of gating decisions is small because it is not combinatorial. but when we want to select [UNK] subsets of units	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	465	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
, which collobert et al. 2001 2002 can considerably accelerate training and inference time. this strategy works well when the number of gating decisions is small because it is not combinatorial. but when we want to select [UNK] subsets of units or parameters, it is not possible to use a “ soft switch ” because it requires enumerating ( and computing outputs for ) all the gater conﬁgurations. to deal with this problem, several approaches have been explored to train combinatorial gaters. ( ) experiment with bengio et al. 2013b several estimators of the gradient on the gating probabilities, while bacon et al. ( ) and ( ) use reinforcement learning techniques ( policy 2015 bengio et al. 2015a gradient ) to learn a form of conditional dropout on blocks of hidden units and get an actual reduction in computational cost without impacting negatively on the quality of the approximation. another kind of dynamic structure is a switch, where a hidden unit can receive input from [UNK] units depending on the context. this dynamic routing approach can be interpreted as an attention mechanism (, ). olshausen et al. 1993 so far, the use of a hard switch has not proven [UNK] on large - scale applications. contemporary approaches	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	465	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
units depending on the context. this dynamic routing approach can be interpreted as an attention mechanism (, ). olshausen et al. 1993 so far, the use of a hard switch has not proven [UNK] on large - scale applications. contemporary approaches instead use a weighted average over many possible inputs, and thus do not achieve all of the possible computational beneﬁts of dynamic structure. contemporary attention mechanisms are described in section. 12. 4. 5. 1 one major obstacle to using dynamically structured systems is the decreased degree of parallelism that results from the system following [UNK] code branches for [UNK] inputs. this means that few operations in the network can be described as matrix multiplication or batch convolution on a minibatch of examples. we can write more specialized sub - routines that convolve each example with [UNK] kernels or multiply each row of a design matrix by a [UNK] set of columns of weights. unfortunately, these more specialized subroutines are [UNK] to implement [UNK]. cpu implementations will be slow due to the lack of cache 450	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	465	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12. applications coherence and gpu implementations will be slow due to the lack of coalesced memory transactions and the need to serialize warps when members of a warp take [UNK] branches. in some cases, these issues can be mitigated by partitioning the examples into groups that all take the same branch, and processing these groups of examples simultaneously. this can be an acceptable strategy for minimizing the time required to process a ﬁxed amount of examples in an [UNK] setting. in a real - time setting where examples must be processed continuously, partitioning the workload can result in load - balancing issues. for example, if we assign one machine to process the ﬁrst step in a cascade and another machine to process the last step in a cascade, then the ﬁrst will tend to be overloaded and the last will tend to be underloaded. similar issues arise if each machine is assigned to implement [UNK] nodes of a neural decision tree. 12. 1. 6 specialized hardware implementations of deep networks since the early days of neural networks research, hardware designers have worked on specialized hardware implementations that could speed up training and / or inference of neural network algorithms. see early and more recent reviews of specialized hardware for deep networks (, ;, lindsey and lindblad	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	466	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
early days of neural networks research, hardware designers have worked on specialized hardware implementations that could speed up training and / or inference of neural network algorithms. see early and more recent reviews of specialized hardware for deep networks (, ;, lindsey and lindblad 1994 beiu et al. 2003 misra and saha 2010 ;, ). [UNK] forms of specialized hardware ( graf and jackel 1989 mead and, ; ismail 2012 kim 2009 pham 2012 chen 2014a b, ; et al., ; et al., ; et al.,, ) have been developed over the last decades, either with asics ( application - speciﬁc inte - grated circuit ), either with digital ( based on binary representations of numbers ), analog ( graf and jackel 1989 mead and ismail 2012, ;, ) ( based on physical imple - mentations of continuous values as voltages or currents ) or hybrid implementations ( combining digital and analog components ). in recent years more ﬂexible fpga ( ﬁeld programmable gated array ) implementations ( where the particulars of the circuit can be written on the chip after it has been built ) have been developed. though software implementations on general - purpose processing units ( cpus and gpus ) typically	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	466	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
ﬁeld programmable gated array ) implementations ( where the particulars of the circuit can be written on the chip after it has been built ) have been developed. though software implementations on general - purpose processing units ( cpus and gpus ) typically use 32 or 64 bits of precision to represent ﬂoating point numbers, it has long been known that it was possible to use less precision, at least at inference time ( holt and baker 1991 holi and hwang 1993 presley, ;, ; and haggard 1994 simard and graf 1994 wawrzynek 1996 savich, ;, ; et al., ; et al., 2007 ). this has become a more pressing issue in recent years as deep learning has gained in popularity in industrial products, and as the great impact of faster hardware was demonstrated with gpus. another factor that motivates current research on specialized hardware for deep networks is that the rate of progress of a single cpu or gpu core has slowed down, and most recent improvements in 451	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	466	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12. applications computing speed have come from parallelization across cores ( either in cpus or gpus ). this is very [UNK] from the situation of the 1990s ( the previous neural network era ) where the hardware implementations of neural networks ( which might take two years from inception to availability of a chip ) could not keep up with the rapid progress and low prices of general - purpose cpus. building specialized hardware is thus a way to push the envelope further, at a time when new hardware designs are being developed for low - power devices such as phones, aiming for general - public applications of deep learning ( e. g., with speech, computer vision or natural language ). recent work on low - precision implementations of backprop - based neural nets ( vanhoucke 2011 courbariaux 2015 gupta 2015 et al., ; et al., ; et al., ) suggests that between 8 and 16 bits of precision can [UNK] for using or training deep neural networks with back - propagation. what is clear is that more precision is required during training than at inference time, and that some forms of dynamic ﬁxed point representation of numbers can be used to reduce how many bits are required per number. traditional ﬁxed point numbers are restricted to a ﬁxed range (	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	467	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
that more precision is required during training than at inference time, and that some forms of dynamic ﬁxed point representation of numbers can be used to reduce how many bits are required per number. traditional ﬁxed point numbers are restricted to a ﬁxed range ( which corresponds to a given exponent in a ﬂoating point representation ). dynamic ﬁxed point representations share that range among a set of numbers ( such as all the weights in one layer ). using ﬁxed point rather than ﬂoating point representations and using less bits per number reduces the hardware surface area, power requirements and computing time needed for performing multiplications, and multiplications are the most demanding of the operations needed to use or train a modern deep network with backprop. 12. 2 computer vision computer vision has traditionally been one of the most active research areas for deep learning applications, because vision is a task that is [UNK] for humans and many animals but challenging for computers (, ). many of ballard et al. 1983 the most popular standard benchmark tasks for deep learning algorithms are forms of object recognition or optical character recognition. computer vision is a very broad ﬁeld encompassing a wide variety of ways of processing images, and an amazing diversity of applications. applications of computer vision range from reproducing human visual	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	467	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
deep learning algorithms are forms of object recognition or optical character recognition. computer vision is a very broad ﬁeld encompassing a wide variety of ways of processing images, and an amazing diversity of applications. applications of computer vision range from reproducing human visual abilities, such as recognizing faces, to creating entirely new categories of visual abilities. as an example of the latter category, one recent computer vision application is to recognize sound waves from the vibrations they induce in objects visible in a video (, davis et al. 2014 ). most deep learning research on computer vision has not focused on such 452	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	467	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
chapter 12. applications exotic applications that expand the realm of what is possible with imagery but rather a small core of ai goals aimed at replicating human abilities. most deep learning for computer vision is used for object recognition or detection of some form, whether this means reporting which object is present in an image, annotating an image with bounding boxes around each object, transcribing a sequence of symbols from an image, or labeling each pixel in an image with the identity of the object it belongs to. because generative modeling has been a guiding principle of deep learning research, there is also a large body of work on image synthesis using deep models. while image synthesis is usually not considered a ex nihilo computer vision endeavor, models capable of image synthesis are usually useful for image restoration, a computer vision task involving repairing defects in images or removing objects from images. 12. 2. 1 preprocessing many application areas require sophisticated preprocessing because the original input comes in a form that is [UNK] for many deep learning architectures to represent. computer vision usually requires relatively little of this kind of pre - processing. the images should be standardized so that their pixels all lie in the same, reasonable range, like [ 0, 1 ] or [ - 1, 1	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	468	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
learning architectures to represent. computer vision usually requires relatively little of this kind of pre - processing. the images should be standardized so that their pixels all lie in the same, reasonable range, like [ 0, 1 ] or [ - 1, 1 ]. mixing images that lie in [ 0, 1 ] with images that lie in [ 0, 255 ] will usually result in failure. formatting images to have the same scale is the only kind of preprocessing that is strictly necessary. many computer vision architectures require images of a standard size, so images must be cropped or scaled to ﬁt that size. even this rescaling is not always strictly necessary. some convolutional models accept variably - sized inputs and dynamically adjust the size of their pooling regions to keep the output size constant ( waibel et al., 1989 ). other convolutional models have variable - sized output that automatically scales in size with the input, such as models that denoise or label each pixel in an image (, ). hadsell et al. 2007 dataset augmentation may be seen as a way of preprocessing the training set only. dataset augmentation is an excellent way to reduce the general	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	468	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)
label each pixel in an image (, ). hadsell et al. 2007 dataset augmentation may be seen as a way of preprocessing the training set only. dataset augmentation is an excellent way to reduce the generalization error of most computer vision models. a related idea applicable at test time is to show the model many [UNK] versions of the same input ( for example, the same image cropped at slightly [UNK] locations ) and have the [UNK] instantiations of the model vote to determine the output. this latter idea can be interpreted as an ensemble approach, and helps to reduce generalization error. other kinds of preprocessing are applied to both the train and the test set with the goal of putting each example into a more canonical form in order to reduce the amount of variation that the model needs to account for. reducing the amount of 453	/home/ricoiban/GEMMA/mnlp_chatsplaining/RAG/Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org).pdf	468	Deep Learning by Ian Goodfellow, Yoshua Bengio, Aaron Courville (z-lib.org)