Deep Learning Srihari 1. Ex: XOR problem • XOR: an operation on binary variables x 1 and x 2 – When exactly one value equals 1 it returns 1 otherwise it returns 0 – Target function is y=f * ( x ) that we want to learn • Our model is y =f ([ x 1 , x 2 ] ; θ ) which we learn, i.e., adapt parameters θ to make it similar to f * • Not concerned with statistical generalization – Perform correctly on four training points: • X= {[0,0] T , [0,1] T , [1,0] T , [1,1] T } – Challenge is to fit the training set • We want f ( [0,0] T ; θ ) = f ( [1,1] T ; θ ) = 0 • f ( [0,1] T ; θ ) = f ( [1,0] T ; θ ) = 1 23
Deep Learning Srihari ML for XOR: linear model doesn’t fit • Treat it as regression with MSE loss function J ( θ ) = 1 = 1 4 ( ) 2 ( ) 2 ∑ ∑ f *( x ) − f ( x ; θ ) f *( x n ) − f ( x n ; θ ) 4 4 x ∈ X n = 1 Alternative is Cross-entropy J( θ ) – Usually not used for binary data J ( θ ) = − ln p ( t | θ ) N { } ∑ = − t n ln y n + (1 − t n )ln(1 − y n ) – But math is simple n = 1 y n = σ ( θ T x n ) • We must choose the form of the model • Consider a linear model with θ = { w, b } where f ( x ; w , b ) = x T w + b J ( θ ) = 1 4 ( ) 2 ∑ – Minimize to get closed-form solution t n − x n T w - b ) 4 n = 1 • Differentiate wrt w and b to obtain w = 0 and b= ½ – Then the linear model f( x ; w ,b)= ½ simply outputs 0.5 everywhere 24 – Why does this happen?
Deep Learning Srihari Linear model cannot solve XOR • Bold numbers are values system must output • When x 1 =0 , output has to increase with x 2 • When x 1 =1 , output has to decrease with x 2 • Linear model f ( x ; w , b ) = x 1 w 1 + x 2 w 2 + b has to assign a single weight to x 2 , so it cannot solve this problem • A better solution: – use a model to learn a different representation • in which a linear model is able to represent the solution – We use a simple feedforward network • one hidden layer containing two hidden units 25
Deep Learning Srihari Feedforward Network for XOR • Introduce a simple feedforward network – with one hidden layer containing two units • Same network drawn in two different styles – Matrix W describes mapping from x to h – Vector w describes mapping from h to y – Intercept parameters b are omitted 26
Deep Learning Srihari Functions computed by Network • Layer 1 (hidden layer): vector of hidden units h computed by function f (1) ( x ; W, c ) – c are bias variables • Layer 2 (output layer) computes f (2) ( h ; w ,b ) – w are linear regression weights – Output is linear regression applied to h rather than to x • Complete model is f ( x ; W, c,w,b )= f (2) ( f (1) ( x )) 27
Deep Learning Srihari Linear vs Nonlinear functions • If we choose both f (1) and f (2) to be linear, the total function will still be linear f ( x )= x T w’ – Suppose f (1) ( x )= W T x and f (2) ( h )= h T w – Then we could represent this function as f ( x ) = x T w’ f ( x )= x T w’ where w’ = W w • Since linear is insufficient, we must use a nonlinear function to describe the features – We use the strategy of neural networks – by using a nonlinear activation function h =g ( W T x + c ) 28
Deep Learning Srihari Activation Function • In linear regression we used a vector of weights w and scalar bias b f ( x ; w , b ) = x T w + b – to describe an affine transformation from an input vector to an output scalar • Now we describe an affine transformation from a vector x to a vector h, so an entire vector of bias parameters is needed • Activation function g is typically chosen to be applied element-wise h i =g ( x T W : , i +c i ) 29
Deep Learning Srihari Default Activation Function Rectified Liner Unit (ReLU) • Activation: g ( z ) = max{0 ,z } – Applying this to the output of a linear transformation yields a nonlinear transformation – However function remains close A principle of CS: to linear Build complicated systems from • Piecewise linear with two pieces minimal components. A Turing Machine • Therefore preserve properties that Memory needs only 0 make linear models easy to and 1 states. optimize with gradient-based We can build Universal methods Function approximator • Preserve many properties that from ReLUs make linear models generalize well
Deep Learning Srihari Specifying the Network using ReLU • Activation: g ( z ) = max{0 ,z } • We can now specify the complete network as f ( x ; W, c,w,b ) =f (2) ( f (1) ( x )) = w T max {0 ,W T x + c }+ b
Deep Learning Srihari We can now specify XOR Solution f ( x ; W, c,w,b )= ⎡ ⎤ ⎡ ⎤ ⎡ ⎤ • Let 1 1 0 1 ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ W = ⎥ , c = ⎥ , w = ⎥ , b = 0 w T max { 0,W T x + c }+ b ⎢ ⎢ ⎢ 1 1 − 1 − 2 ⎣ ⎦ ⎣ ⎦ ⎣ ⎦ • Now walk through how model processes a batch of inputs ⎡ ⎤ 0 0 ⎢ ⎥ ⎢ ⎥ 0 1 • Design matrix X of all four points: ⎢ ⎥ X = ⎢ ⎥ ⎡ ⎤ ⎢ ⎥ 0 0 1 0 ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ • First step is XW : 1 1 ⎢ 1 1 ⎥ ⎢ ⎥ ⎡ ⎤ ⎣ ⎦ XW = ⎢ ⎥ 0 − 1 ⎢ ⎥ ⎢ ⎥ 1 1 ⎢ ⎥ ⎢ ⎥ In this space all points lie 1 0 ⎢ ⎥ • Adding c : ⎢ 2 2 ⎥ XW + c = ⎢ ⎥ ⎣ ⎦ along a line with slope 1. Cannot ⎢ ⎥ 1 0 be implemented by a linear model ⎢ ⎥ ⎢ 2 1 ⎥ • Compute h Using ReLU ⎡ ⎤ ⎣ ⎦ ⎢ 0 0 ⎥ ⎢ ⎥ 1 0 ⎢ ⎥ max{0, XW + c } = ⎢ ⎥ Has changed relationship among examples. ⎢ ⎥ 1 0 ⎢ ⎥ They no longer lie on a single line. ⎢ ⎥ 2 1 ⎣ ⎦ A linear model suffices • Finish by multiplying by w : ⎡ ⎤ 0 ⎢ ⎥ • Network has obtained ⎢ ⎥ 1 ⎢ ⎥ f ( x ) = ⎢ ⎥ ⎢ 1 ⎥ ⎢ ⎥ 0 ⎢ ⎥ correct answer for all 4 examples ⎣ ⎦ 32
Deep Learning Srihari Learned representation for XOR • Two points that must have When x 1 =0 , output has to output 1 have been increase with x 2 When x 1 =1 , output has to collapsed into one decrease with x 2 • Points x = [0,1] T and x = [1,0] T have been mapped into h = [0,1] T When h 1 =0 , output is constant 0 • Described in linear model with h 2 When h 1 =1 , output is constant 1 – For fixed h 2 , output with h 2 When h 1 =2, output is constant 0 increases in h 1 with h 2 33
Deep Learning Srihari About the XOR example • We simply specified the solution – Then showed that it achieves zero error • In real situations there might be billions of parameters and billions of training examples – So one cannot simply guess the solution • Instead gradient descent optimization can find parameters that produce very little error – The solution described is at the global minimum • Gradient descent could converge to this solution • Convergence depends on initial values • Would not always find easily understood integer solutions 34
Deep Learning Srihari Topics • Overview 1. Example: Learning XOR 2. Gradient-Based Learning 3. Hidden Units 4. Architecture Design 5. Backpropagation and Other Differentiation 6. Historical Notes 2
Deep Learning Srihari Topics in Gradient-based Learning • Overview 1. Cost Functions 1. Learning Conditional Distributions with Max Likelihood 2. Learning Conditional Statistics 2. Output Units 1. Linear Units for Gaussian Output Distributions 2. Sigmoid Units for Bernoulli Output Distributions 3. Softmax Units for Multinoulli Output Distributions 4. Other Output Types 3
Deep Learning Srihari Overview of Gradient-based Learning 4
Deep Learning Srihari Standard ML Training vs NN Training • Neural Network training not different from ML models with gradient descent. Need 1. optimization procedure, e.g., gradient descent 2. cost function, e.g., MLE 3. model family, e.g., linear with basis functions • Difference: nonlinearity causes non-convex loss – Use iterative gradient-based optimizers that merely drives cost to low value, rather than • Exact linear equation solvers used for linear regression or • convex optimization algorithms used for logistic regression or SVMs 5
Deep Learning Srihari Convex vs Non-convex Linear Regression with Basis Functions: • Convex methods: 2 E D (w) = 1 N { } ∑ t n − w T ϕ ( x n ) 2 n = 1 – Converge from any initial parameters – Robust-- but can encounter numerical problems • SGD with non-convex: – Sensitive to initial parameters – For feedforward networks, important to initialize • Weights to small values, Biases to zero or small positives – SGD can also train Linear Regression and SVM Especially with large training sets – Training neural net no similar to other models • Except computing gradient is more complex 6
Deep Learning Srihari Cost Functions 7
Deep Learning Srihari Cost Functions for Deep Learning • Important aspect of design of deep neural networks is the cost function – They are similar to those for parametric models such as linear models • Parametric model: logistic regression p ( C 1 | φ ) = y ( φ ) = σ ( θ T φ ) – Binary Training data defines a likelihood p ( y |x ; θ ) N data set { ϕ n , t n } , t n ε { 0,1 } , ϕ n = ϕ ( x n ) 1 − t n , y n = σ ( θ T x n ) { } ∏ t n p ( t | θ ) = y n 1 − y n n = 1 – and we use the principle of maximum likelihood N { } ∑ J ( θ ) = − ln p ( t | θ ) = − t n ln y n + (1 − t n )ln(1 − y n ) n = 1 • Cost function: cross-entropy between training data t n and the model’s prediction y n • Gradient of the error function is N ( ) ∑ ∇ J ( θ ) = y n − t n φ n 8 n = 1 Using d σ (a)/da = σ (1- σ )
Deep Learning Srihari Learning Conditional Distributions with maximum likelihood • Specifying the model p ( y |x ) automatically determines a cost function log p ( y |x ) – Equivalently described as the cross-entropy between the training data and the model distribution J ( θ ) = − E x,y ∼ ˆ p data log p model ( y | x ) – Gaussian case: ⎛ ⎞ 1 exp − 1 ⎟ • If p model ( y | x ) =N ( y | f ( x ; θ ) , I ) ⎜ ⎟ = 2 || y − f ( x ; θ || 2 ⎜ ⎟ ⎜ ⎟ ⎜ ⎝ ⎠ 2 π • then we recover the mean squared error cost 2 + const J ( θ ) = − 1 2 E x , y ∼ ˆ p data y − f ( x ; θ ) • upto a scaling factor ½ and a term independent of θ – const depends on the variance of Gaussian which we chose not 9 to parameterize
Deep Learning Srihari Desirable Property of Gradient • Recurring theme in neural network design is: – Gradient must be large and predictable enough to serve as good guide to the learning algorithm • Functions that saturate (become very flat) undermine this objective – Because the gradient becomes very small • Happens when activation functions producing output of hidden/output units saturate 10
Deep Learning Srihari Keeping the Gradient Large • Negative log-likelihood helps avoid saturation problem for many models – Many output units involve exp functions that saturate when its argument is very negative – Log function in Negative log likelihood cost function undoes exp of some units 11
Deep Learning Srihari Cross Entropy and Gradient • A property of cross-entropy cost used for MLE is that it does not have a minimum value – For discrete output variables, they cannot represent probability of zero or one but come arbitrarily close • Logistic Regression is an example – For real-valued output variables it becomes possible to assign extremely high density to correct training set outputs, e.g, variance parameter of Gaussian output, and cross-entropy approaches negative infinity • Regularization modifies learning problem so model cannot reap unlimited reward this way 12
Deep Learning Srihari Learning Conditional Statistics • Instead of learning a full probability distribution, learn just one conditional statistic of y given x – E.g., we may have a predictor f ( x ; θ ) which gives the mean of y • Think of neural network as being powerful to determine any function f – This function is limited only by • boundedness and • continuity • rather than by having a specific parameteric form – From this point of view, cost function is a functional rather than a function 13
Deep Learning Srihari Cost Function vs Cost Functional • Cost function is a functional, not a function – A functional is a mapping from functions to real nos. • We can think of learning as a task of choosing a function rather than a set of parameters • Cost Functional has a Minimum occur at a function we desire – E.g., Design the cost functional to have a Minimum of that lies on function that maps x to the expected value of y given x 14
Deep Learning Srihari Optimization via Calculus of Variations • Solving the optimization problem requires a mathematical tool: calculus of variations – E.g., Minimum of Cost functional is: • function that maps x to the expected value of y given x • Only necessary to understand that calculus of variations can be used to derive two results 15
Deep Learning Srihari First Result from Calculus of Variations • Solving the optimization problem 2 f * = arg min E x,y ∼ ˆ p data y - f(x) f yields ⎢ ⎤ ⎡ f *( x ) = E y ∼ p data ( y|x ) y ⎥ ⎣ ⎦ • which means if we could train infinitely many samples from the true data generating distribution – minimizing MSE gives a function that predicts the mean of y for each value of x 16
Deep Learning Srihari Second Result from Calculus of Variations • A different cost function is f * = arg min E x , y ~ p data ||y - f(x) || 1 f – yields a function that minimizes the median of y for each each x – Referred to as mean absolute error • MSE/median saturate: produce small gradients – This is one reason cross-entropy cost is more popular than mean square error and mean absolute error • Even when it is not necessary to estimate the entire distribution p ( y |x ) 17
Deep Learning Srihari Output Units 18
Deep Learning Srihari Output Units • Choice of cost function is tightly coupled with choice of output unit – Most of the time we use cross-entropy between data distribution and model distribution • Choice of how to represent the output then determines the form of the cross-entropy function Cross-entropy in logistic regression θ = { w , b } J ( θ ) = − ln p ( t | θ ) N { } ∑ = − t n ln y n + (1 − t n )ln(1 − y n ) n = 1 y n = σ ( θ T x n ) 19
Deep Learning Srihari Role of Output Units • Any output unit is also usable as a hidden unit • Our focus is units as output, not internally – Revisit it when discussing hidden units • A feedforward network provides a hidden set of features h = f ( x ; θ ) • Role of output layer is to provide some additional transformation from the features to the task that network must perform 20
Deep Learning Srihari Types of output units 1. Linear units: no non-linearity – for Gaussian Output distributions 2. Sigmoid units – for Bernoulli Output Distributions 3. Softmax units – for Multinoulli Output Distributions 4. Other Output Types – Not direct prediction of y but provide parameters of distribution over y 21
Deep Learning Srihari Linear Units for Gaussian Output Distributions • Linear unit: simple output based on affine transformation with no nonlinearity – Given features h , a layer of linear output units produces a vector y = W T h + b ˆ ˆ y • Linear units are often used to produce mean of a conditional Gaussian distribution P ( y |x) = N ( y ; ˆ y,I ) • Maximizing the output is equivalent to MSE • Can be used to learn the covariance of a 22 Gaussian too
Deep Learning Srihari Sigmoid Units for Bernoulli Output Distributions • Task of predicting value of binary variable y – Classification problem with two classes • Maximum likelihood approach is to define a Bernoulli distribution over y conditioned on x • Neural net needs to predict p ( y =1 | x ) – which lies in the interval [0,1] • Constraint needs careful design { } { } P ( y = 1 |x) = max 0,min 1, w T h + b – If we use • We would define a valid conditional distribution, but cannot train it effectively with gradient descent • A gradient of 0: learning algorithm cannot be guided 23
Deep Learning Srihari Sigmoid and Logistic Regression • Using sigmoid always gives a strong gradient – Sigmoid output units combined with maximum likelihood ( ) y = σ w T h + b ˆ • where σ ( x ) is the logistic sigmoid function: 1 ( ) = σ x 1 + exp( − x ) • Sigmoid output unit has two components: z = w T h + b 1. A linear layer to compute 2. Use sigmoid activation function to convert z into a probability 24
Deep Learning Srihari Probability distribution using Sigmoid • Describe probability distribution over y using z z = w T h + b y is output, z is input ! – Construct unnormalized probability distribution P • Assuming unnormalized log probability is linear in y and z log ! P ( y ) = yz ! P ( y ) = exp( yz ) • Normalizing yields a Bernoulli distribution controlled by σ exp( yz ) P ( y ) = 1 ∑ exp( y ' z ) y ' = 0 = σ ((2y-1)z) – Probability distributions based on exponentiation and normalization are common throughout statistical modeling • z variable defining such a distribution over binary 25 variables is called a logit
Deep Learning Srihari Max Likelihood Loss Function • Given binary y and some z , an normalized probability distribution over y is log ! P ( y ) = yz exp( yz ) P ( y ) = = σ ((2 y − 1) z ) 1 ! ∑ P ( y ) = exp( yz ) exp( yz ) y ' = 0 • We can use this approach in maximum likelihood learning – Loss for max likelihood learning is –log P ( y | x ) J ( θ ) = − log P ( y | x ) = − log σ ((2 y − 1) z ) ζ is the softplus function = ζ ((1 - 2 y ) z ) • This is for a single sample
Deep Learning Srihari Softplus function • Sigmoid saturates when its argument is very positive or very negative – i.e., function is insensitive to small changes in input • Another function is the softplus function ζ ( x ) = log(1+ exp( x )) – Its range is (0, ∞ ) . It arises in expressions involving sigmoids. • Its name comes from its being a smoothed or 27 softened version of x + = max(0 , x )
Deep Learning Srihari Properties of Sigmoid & Softplus Last equation provides extra justification for the name ‘softplus’ Smoothed version of positive part function x + =max{0, x } The positive part function is the counterpart of the negative part function x - =max{0,- x } 28
Deep Learning Srihari Loss Function for Bernoulli MLE J ( θ ) = − log P ( y | x ) = − log σ ((2 y − 1) z ) = ζ ((1 - 2 y ) z ) – By rewriting the loss in terms of the softplus function, we can see that it saturates only when (1-2 y ) z <<0 . – Saturation occurs only when model already has the right answer • i.e., when y =1 and z >>0 or y =0 and z <<0 • When z has the wrong sign (1-2 y ) z can be simplified to |z| – As |z| becomes large while z has the wrong sign, softplus asymptotes towards simply returning argument |z| & derivative wrt z asymptotes to sign( z ) , so, in the limit of extremely incorrect z softplus does not shrink the gradient at all – This is a useful property because gradient-based learning can act quickly to correct a mistaken z
Deep Learning Srihari Cross-Entropy vs Softplus Loss J ( θ ) = − log P ( y | x ) N { } 1 − y n ∏ y n p ( y | θ ) = σ ( θ T x n ) 1 − σ ( θ T x n ) = − log σ ((2 y − 1) z ) z = θ T x + b n = 1 J ( θ ) = − ln p ( y | θ ) = ζ ((1 - 2 y ) z ) N { } ( ) + (1 − y n )ln(1 − σ ( θ T x n )) ∑ = − y n ln σ ( θ T x n ) n = 1 – Cross-entropy loss can saturate anytime σ ( z ) saturates • Sigmoid saturates to 0 when z becomes very negative and saturates to 1 when z becomes very positive – Gradient can shrink to too small to be useful for learning, whether model has correct or incorrect answer – We have provided an alternative implementation of logistic regression! 30
Deep Learning Srihari Softmax units for Multinoulli Output • Any time we want a probability distribution over a discrete variable with n values we may us the softmax function – Can be seen as a generalization of sigmoid function used to represent probability distribution over a binary variable • Softmax most often used for output of classifier to represent distribution over n classes – Also inside the model itself when we wish to choose between one of n options 31
Deep Learning Srihari From Sigmoid to Softmax • Binary case: we wished to produce a single no. y = P ( y = 1| x ) ˆ • Since (i) this number needed to lie between 0 and 1 and (ii) because we wanted its logarithm to be well-behaved for a gradient-based optimization of log-likelihood, we chose instead to predict a number z = log ! P ( y = 1| x ) z = w T h + b • Exponentiating and normalizing, gave us a Bernoulli distribution controlled by the sigmoidal transformation of z log ! P ( y ) = yz exp( yz ) P ( y ) = = σ ((2 y − 1) z ) 1 ! ∑ P ( y ) = exp( yz ) exp( yz ) y ' = 0 • Case of n values: need to produce vector ˆ y • with values y i = P ( y = i | x ) ˆ 32
Deep Learning Srihari Softmax definition ˆ y • We need to produce a vector with values y i = P ( y = i | x ) ˆ • We need elements of lie in [0,1] and they sum to 1 y ˆ • Same approach as with Bernoulli works for Multinoulli distribution • First a linear layer predicts unnormalized log probabilities z =W T h + b z i = log ˆ – where P ( y = i | x ) • Softmax can then exponentiate and normalize z ˆ y to obtain the desired exp( z i ) softmax( z ) i = • Softmax is given by: 33 ∑ exp( z j ) j
Softmax Regression Deep Learning Srihari Generalization of Logistic Regression to multivalued output Softmax definition y = softmax( z ) i exp( z i ) = ∑ exp( z j ) j Network Computes In matrix z =W T x + b multiplication notation An example 34
Deep Learning Srihari Intuition of Log-likelihood Terms exp( z i ) softmax( z ) i = • The exp within softmax works ∑ exp( z j ) j very well when training using log-likelihood – Log-likelihood can undo the exp of softmax ∑ log softmax( z ) i = z i − log exp( z j ) j – Input z i always has a direct contribution to cost • Because this term cannot saturate, learning can proceed even if second term becomes very small – First term encourages z i to be pushed up – Second term encourages all z to be pushed down 35
Deep Learning Srihari Intuition of second term of likelihood • Log likelihood is ∑ logsoftmax( z ) i = z i − log exp( z j ) j • Consider second term: ∑ log exp( z j ) j • It can be approximated by max j z j – Based on the idea that exp( z k ) is insignificant for any z k noticeably less that max j z j • Intuition gained: – Cost penalizes most active incorrect prediction – If the correct answer already has the largest input to ∑ softmax, then -z i term and log exp( z j ) ≈ max j z j = z i j terms will roughly cancel. This example will then contribute little to overall training cost 36 • Which will be dominated by other incorrect examples
Deep Learning Srihari Generalization to Training Set • So far we discussed only a single example • Overall, unregularized maximum likelihood will drive the model to learn parameters that drive the softmax to predict a fraction of counts of each outcome observed in training set ∑ m 1 y ( j ) = i , x ( j ) = x j = 1 softmax( z ( x ; θ )) i ≈ ∑ m 1 x ( j ) = x j = 1 37
Deep Learning Srihari Softmax and Objective Functions • Objective functions that do not use a log to undo the exp of softmax fail to learn when argument of exp becomes very negative, causing gradient to vanish • Squared error is a poor loss function for softmax units – Fail to train model change its output even when the model makes highly incorrect predictions 38
Deep Learning Srihari Saturation of Sigmoid and Softmax • Sigmoid has a single output that saturates – When input is extremely negative or positive • Like sigmoid, softmax activation can saturate – In case of softmax there are multiple output values • These output values can saturate when the differences between input values become extreme – Many cost functions based on softmax also saturate 39
Deep Learning Srihari Softmax & Input Difference • Softmax invariant to adding the same scalar to all inputs: softmax( z ) = softmax( z +c) • Using this property we can derive a numerically stable variant of softmax softmax( z ) = softmax( z – max i z i ) • Reformulation allows us to evaluate softmax – With only small numerical errors even when z contains extremely large/small numbers – It is driven by amount that its inputs deviate from max i z i 40
Deep Learning Srihari Saturation of Softmax • An output softmax( z ) i saturates to 1 when the corresponding input is maximal ( z i = max i z i ) and z i is much greater than all the other inputs • The output can also saturate to 0 when is not maximal and the maximum is much greater • This is a generalization of the way the sigmoid units saturate – They can cause similar difficulties in learning if the loss function is not designed to compensate for it 41
Deep Learning Srihari Other Output Types • Linear, Sigmoid and Softmax output units are the most common • Neural networks can generalize to any kind of output layer • Principle of maximum likelihood provides a guide for how to design a good cost function for any output layer – If we define conditional distribution p ( y |x ) , principle of maximum likelihood suggests we use log p ( y |x ) for our cost function 42
Deep Learning Srihari Determining Distribution Parameters • We can think of the neural network as representing a function f ( x ; θ ) • Outputs are not direct predictions of value of y • Instead f ( x ; θ )= ω provides the parameters for a distribution over y • Our loss function can then be interpreted as -log p ( y ; ω ( x )) 43
Deep Learning Srihari Ex: Learning a Distribution Parameter • We wish to learn the variance of a conditional Gaussian of y given x • Simple case: variance σ 2 is constant – Has closed-form expression: empirical mean of squared difference between observations y and their expected value – Computationally more expensive approach • Does not require writing special-case code • Include variance as one of the properties of distribution p ( y |x ) that is controlled by ω = f ( x ; θ ) • Negative log-likelihood -log p ( y ; ω ( x )) will then provide 44 cost function with appropriate terms to learn variance
Deep Learning Srihari Topics in Deep Feedforward Networks • Overview 1. Example: Learning XOR 2. Gradient-Based Learning 3. Hidden Units 4. Architecture Design 5. Backpropagation and Other Differentiation 6. Historical Notes 2
Deep Learning Srihari Topics in Hidden Units 1. ReLU and their generalizations 2. Logistic sigmoid and Hyperbolic tangent 3. Other hidden units 3
Deep Learning Srihari Choice of hidden unit • Previously discussed design choices for neural networks that are common to most parametric learning models trained with gradient optimization • We now look at how to choose the type of hidden unit in the hidden layers of the model • Design of hidden units is an active research area that does not have many definitive guiding theoretical principles 4
Deep Learning Srihari Choice of hidden unit • ReLU is an excellent default choice • But there are many other types of hidden units available • When to use which kind (though ReLU is usually an acceptable choice)? • We discuss motivations behind choice of hidden unit – Impossible to predict in advance which will work best – Design process is trial and error 5 • Evaluate performance on a validation set
Deep Learning Srihari Is Differentiability necessary? • Some hidden units are not differentiable at all input points – Rectified Linear Function g ( z )=max{0, z } is not differentiable at z= 0 • May seem like it invalidates for use in gradient- based learning • In practice gradient descent still performs well enough for these models to be used in ML tasks 6
Deep Learning Srihari Differentiability ignored • Neural network training – not usually arrives at a local minimum of cost function – Instead reduces value significantly • Not expecting training to reach a point where gradient is 0 , – Accept minima to correspond to points of undefined gradient • Hidden units not differentiable are usually non-differentiable at only a small no. of points 7
Deep Learning Srihari Left and Right Differentiability • A function g ( z ) has a left derivative defined by the slope immediately to the left of z • A right derivative defined by the slope of the function immediately to the right of z • A function is differentiable at z = a only if both – the left derivative and – The right derivative are equal Function is not continuous: No derivative at marked point However it has a right derivative at all points with δ + f ( a )=0 at all points 8
Deep Learning Srihari Software Reporting of Non-differentiability • In the case of g( z )=max{0, z } , the left derivative at z = 0 is 0 and right derivative is 1 • Software implementations of neural network training usually return: – one of the one-sided derivatives rather than reporting that derivative is undefined or an error • Justified in that gradient-based optimization is subject to numerical anyway • When a function is asked to evaluate g (0) , it is very unlikely that the underlying value was truly 0 , instead it was a small value ε that was rounded to 0 9
Deep Learning Srihari What a Hidden unit does • Accepts a vector of inputs x and computes an affine transformation z = W T x + b • Computes an element-wise non-linear function g ( z ) • Most hidden units are distinguished from each other by the choice of activation function g ( z ) – We look at: ReLU, Sigmoid and tanh, and other hidden units 10
Deep Learning Srihari Rectified Linear Unit & Generalizations • Rectified linear units use the activation function g ( z ) = max{0 ,z } – They are easy to optimize due to similarity with linear units • Only difference with linear units that they output 0 across half its domain • Derivative is 1 everywhere that the unit is active • Thus gradient direction is far more useful than with activation functions with second-order effects 11
Deep Learning Srihari Use of ReLU • Usually used on top of an affine transformation h =g ( W T x + b ) • Good practice to set all elements of b to a small value such as 0.1 – This makes it likely that ReLU will be initially active for most training samples and allow derivatives to pass through 12
Deep Learning Srihari Generalizations of ReLU • Perform comparably to ReLU and occasionally perform better • ReLU cannot learn on examples for which the activation is zero. • Generalizations guarantee that they receive gradient everywhere 13
Deep Learning Srihari Three generalizations of ReLU • Three methods based on using a non-zero slope α i when z i <0: h i =g ( z , α ) i =max(0, z i )+ α i min(0, z i ) 1. Absolute-value rectification: fixes α i =-1 to obtain g ( z )=| z | • 2. Leaky ReLU: fixes α i to a small value like 0.01 • 3. Parametric ReLU or PReLU: • treats α i as a parameter 14
Deep Learning Srihari Maxout Units • Maxout units further generalize ReLUs • Instead of applying element-wise function g ( z ) , maxout units divide z into groups of k values • Each maxout unit then outputs the maximum element of one of these groups: g(z) i =max j ε G( i ) z j – where G( i ) is the set of indices into the inputs for group i , {( i- 1) k +1 ,..,ik } • This provides a way of learning a piecewise linear function that responds to multiple directions in the input x space 15
Deep Learning Srihari Maxout as Learning Activation • A maxout unit can learn piecewise linear, convex function with upto k pieces – Thus seen as learning the activation function itself rather than just the relationship between units • With large enough k , approximate any convex function – A maxout layer with two pieces can learn to implement the same function of the input x as a traditional layer using ReLU or its generalizations 16
Deep Learning Srihari Learning Dynamics of Maxout • Parameterized differently • Learning dynamics different even in case of implementing same function of x as one of the other layer types – Each maxout unit parameterized by k weight vectors instead of one • So Requires more regularization than ReLU • Can work well without regularization if training set is large and no. of pieces per unit is kept low 17
Deep Learning Srihari Other benefits of maxout • Can gain statistical and computational advantages by requiring fewer parameters • If the features captured by n different linear filters can be summarized without losing information by taking max over each group of k features, then next layer can get by with k times fewer weights • Because of multiple filters, their redundancy helps them avoid catastrophic forgetting – Where network forgets how to perform tasks they were trained to perform 18
Deep Learning Srihari Principle of Linearity • ReLU based on principle that models are easier to optimize if behavior closer to linear – Principle applies besides deep linear networks • Recurrent networks can learn from sequences and produce a sequence of states and outputs • When training them need to propagate information through several steps – Which is much easier when some linear computations (with some directional derivatives being of magnitude near 1) are involves 19
Deep Learning Linearity in LSTM Srihari • LSTM: best performing recurrent architecture – Propagates information through time via summation • A straightforward kind of linear activation LSTM : an ANN that contains LSTM blocks in addition to LSTM regular network units Block ∑ y = w i x i Input gate : when its output is close to zero, it zeros the input ∏ y = x i Forget gate : when close to zero block forgets whatever value ( ) ∑ y = σ w i x i it was remembering Output gate : when unit should Conditional Input Forget Output output its value Input gate gate gate 20 Determine when inputs are allowed to flow into block
Deep Learning Srihari Logistic Sigmoid • Prior to introduction of ReLU, most neural networks used logistic sigmoid activation g ( z )= σ ( z ) • Or the hyperbolic tangent g ( z )=tanh( z ) • These activation functions are closely related because tanh( z )=2 σ (2 z )-1 • Sigmoid units are used to predict probability that a binary variable is 1 21
Deep Learning Srihari Sigmoid Saturation • Sigmoidals saturate across most of domain – Saturate to 1 when z is very positive and 0 when z is very negative – Strongly sensitive to input when z is near 0 – Saturation makes gradient-learning difficult • ReLU and Softplus increase for input >0 Sigmoid can still be used When cost function undoes the Sigmoid in the output layer 22
Deep Learning Srihari Sigmoid vs tanh Activation • Hyperbolic tangent typically performs better than logistic sigmoid • It resembles the identity function more closely tanh(0)=0 while σ (0)= ½ • Because tanh is similar to identity near 0 , ( ) y = w T tanh U T tanh V T x ( ) training a deep neural network ˆ resembles training a linear model y = w T U T V T x ˆ so long as the activations can be kept small 23
Deep Learning Srihari Sigmoidal units still useful • Sigmoidal more common in settings other than feed-forward networks • Recurrent networks, many probabilistic models and autoencoders have additional requirements that rule out piecewise linear activation functions • They make sigmoid units appealing despite saturation 24
Recommend
More recommend
