Neural Networks: An Introduction
 Summary
 Quick intro
 Modeling one neuron
 Neural Network architectures
 Representational power
 References
Summary
 The takeaway is that you should not be using smaller networks because you are afraid of overfitting. Instead, you should use as big of a neural network as your computational budget allows, and use other regularization techniques to control overfitting.
Quick intro
Linear classification: scores $s = W x$, where $W$ was a matrix and $x$ was an input feature vector.
A two layer neural network:
 Compute $s = W_2 \max(0, W_1 x)$.
 The function $max(0,)$ is a nonlinearity that is applied elementwise. There are several choices we could make for the nonlinearity (which we’ll study below), but this one is a common choice and simply thresholds all activations that are below zero to zero.
 The matrix $W_2$ would then be of size [10x100], so that we again get 10 numbers out that we interpret as the class scores.
 Notice that the nonlinearity is critical computationally
 The parameters $W_2, W_1$ are learned with stochastic gradient descent, and their gradients are derived with chain rule (and computed with backpropagation).
A threelayer neural network:
 Compute $s = W_3 \max(0, W_2 \max(0, W_1 x))$, where all of \(W_3, W_2, W_1\) are parameters to be learned.
 The sizes of the intermediate hidden vectors are hyperparameters of the network.
Modeling one neuron
Biological motivation and connections. See (http://cs231n.github.io/neuralnetworks1/#bio) Due to all these and many other simplifications, be prepared to hear groaning sounds from anyone with some neuroscience background if you draw analogies between Neural Networks and real brains. See this review (pdf), or more recently this review if you are interested.
Single neuron as a linear classifier A single neuron can be used to implement a binary classifier (e.g. binary Softmax or binary SVM classifiers).
Commonly used activation functions
Every activation function (or nonlinearity) takes a single number and performs a certain fixed mathematical operation on it. There are several activation functions you may encounter in practice:
Sigmoid. The sigmoid nonlinearity has the mathematical form \(\sigma(x) = 1 / (1 + e^{x})\) and is shown in the image above on the left. As alluded to in the previous section, it takes a realvalued number and “squashes” it into range between 0 and 1. In particular, large negative numbers become 0 and large positive numbers become 1. The sigmoid function has seen frequent use historically since it has a nice interpretation as the firing rate of a neuron: from not firing at all (0) to fullysaturated firing at an assumed maximum frequency (1). In practice, the sigmoid nonlinearity has recently fallen out of favor and it is rarely ever used. It has two major drawbacks:
 Sigmoids saturate and kill gradients. A very undesirable property of the sigmoid neuron is that when the neuron’s activation saturates at either tail of 0 or 1, the gradient at these regions is almost zero. Recall that during backpropagation, this (local) gradient will be multiplied to the gradient of this gate’s output for the whole objective. Therefore, if the local gradient is very small, it will effectively “kill” the gradient and almost no signal will flow through the neuron to its weights and recursively to its data. Additionally, one must pay extra caution when initializing the weights of sigmoid neurons to prevent saturation. For example, if the initial weights are too large then most neurons would become saturated and the network will barely learn.
 Sigmoid outputs are not zerocentered. This is undesirable since neurons in later layers of processing in a Neural Network (more on this soon) would be receiving data that is not zerocentered. This has implications on the dynamics during gradient descent, because if the data coming into a neuron is always positive (e.g. \(x > 0\) elementwise in \(f = w^Tx + b\))), then the gradient on the weights \(w\) will during backpropagation become either all be positive, or all negative (depending on the gradient of the whole expression \(f\)). This could introduce undesirable zigzagging dynamics in the gradient updates for the weights. However, notice that once these gradients are added up across a batch of data the final update for the weights can have variable signs, somewhat mitigating this issue. Therefore, this is an inconvenience but it has less severe consequences compared to the saturated activation problem above.
Tanh. The tanh nonlinearity is shown on the image above on the right. It squashes a realvalued number to the range [1, 1]. Like the sigmoid neuron, its activations saturate, but unlike the sigmoid neuron its output is zerocentered. Therefore, in practice the tanh nonlinearity is always preferred to the sigmoid nonlinearity. Also note that the tanh neuron is simply a scaled sigmoid neuron, in particular the following holds: \( \tanh(x) = 2 \sigma(2x) 1 \).
ReLU. The Rectified Linear Unit has become very popular in the last few years. It computes the function \(f(x) = \max(0, x)\). In other words, the activation is simply thresholded at zero (see image above on the left). There are several pros and cons to using the ReLUs:
 (+) It was found to greatly accelerate (e.g. a factor of 6 in Krizhevsky et al.) the convergence of stochastic gradient descent compared to the sigmoid/tanh functions. It is argued that this is due to its linear, nonsaturating form.
 (+) Compared to tanh/sigmoid neurons that involve expensive operations (exponentials, etc.), the ReLU can be implemented by simply thresholding a matrix of activations at zero.
 () Unfortunately, ReLU units can be fragile during training and can “die”. For example, a large gradient flowing through a ReLU neuron could cause the weights to update in such a way that the neuron will never activate on any datapoint again. If this happens, then the gradient flowing through the unit will forever be zero from that point on. That is, the ReLU units can irreversibly die during training since they can get knocked off the data manifold. For example, you may find that as much as 40% of your network can be “dead” (i.e. neurons that never activate across the entire training dataset) if the learning rate is set too high. With a proper setting of the learning rate this is less frequently an issue.
Leaky ReLU. Leaky ReLUs are one attempt to fix the “dying ReLU” problem. Instead of the function being zero when x < 0, a leaky ReLU will instead have a small negative slope (of 0.01, or so). That is, the function computes \(f(x) = \mathbb{1}(x < 0) (\alpha x) + \mathbb{1}(x>=0) (x) \) where \(\alpha\) is a small constant. Some people report success with this form of activation function, but the results are not always consistent. The slope in the negative region can also be made into a parameter of each neuron, as seen in PReLU neurons, introduced in Delving Deep into Rectifiers, by Kaiming He et al., 2015. However, the consistency of the benefit across tasks is presently unclear.
Maxout. Other types of units have been proposed that do not have the functional form \(f(w^Tx + b)\) where a nonlinearity is applied on the dot product between the weights and the data. One relatively popular choice is the Maxout neuron (introduced recently by Goodfellow et al.) that generalizes the ReLU and its leaky version. The Maxout neuron computes the function \(\max(w_1^Tx+b_1, w_2^Tx + b_2)\). Notice that both ReLU and Leaky ReLU are a special case of this form (for example, for ReLU we have \(w_1, b_1 = 0\)). The Maxout neuron therefore enjoys all the benefits of a ReLU unit (linear regime of operation, no saturation) and does not have its drawbacks (dying ReLU). However, unlike the ReLU neurons it doubles the number of parameters for every single neuron, leading to a high total number of parameters.
This concludes our discussion of the most common types of neurons and their activation functions. As a last comment, it is very rare to mix and match different types of neurons in the same network, even though there is no fundamental problem with doing so.
TLDR: “What neuron type should I use?” Use the ReLU nonlinearity, be careful with your learning rates and possibly monitor the fraction of “dead” units in a network. If this concerns you, give Leaky ReLU or Maxout a try. Never use sigmoid. Try tanh, but expect it to work worse than ReLU/Maxout.
Neural Network architectures
Representational power
One way to look at Neural Networks with fullyconnected layers is that they define a family of functions that are parameterized by the weights of the network. A natural question that arises is: What is the representational power of this family of functions? In particular, are there functions that cannot be modeled with a Neural Network?
It turns out that Neural Networks with at least one hidden layer are universal approximators. That is, it can be shown (e.g. see Approximation by Superpositions of Sigmoidal Function from 1989 (pdf), or this intuitive explanation from Michael Nielsen) that given any continuous function \(f(x)\) and some \(\epsilon > 0\), there exists a Neural Network \(g(x)\) with one hidden layer (with a reasonable choice of nonlinearity, e.g. sigmoid) such that \( \forall x, \mid f(x)  g(x) \mid < \epsilon \). In other words, the neural network can approximate any continuous function.
If one hidden layer suffices to approximate any function, why use more layers and go deeper? The answer is that the fact that a twolayer Neural Network is a universal approximator is, while mathematically cute, a relatively weak and useless statement in practice. In one dimension, the “sum of indicator bumps” function \(g(x) = \sum_i c_i \mathbb{1}(a_i < x < b_i)\) where \(a,b,c\) are parameter vectors is also a universal approximator, but noone would suggest that we use this functional form in Machine Learning. Neural Networks work well in practice because they compactly express nice, smooth functions that fit well with the statistical properties of data we encounter in practice, and are also easy to learn using our optimization algorithms (e.g. gradient descent). Similarly, the fact that deeper networks (with multiple hidden layers) can work better than a singlehiddenlayer networks is an empirical observation, despite the fact that their representational power is equal.
As an aside, in practice it is often the case that 3layer neural networks will outperform 2layer nets, but going even deeper (4,5,6layer) rarely helps much more. This is in stark contrast to Convolutional Networks, where depth has been found to be an extremely important component for a good recognition system (e.g. on order of 10 learnable layers). One argument for this observation is that images contain hierarchical structure (e.g. faces are made up of eyes, which are made up of edges, etc.), so several layers of processing make intuitive sense for this data domain.
The full story is, of course, much more involved and a topic of much recent research. If you are interested in these topics we recommend for further reading:
 Deep Learning book in press by Bengio, Goodfellow, Courville, in particular Chapter 6.4.
 Do Deep Nets Really Need to be Deep?
 FitNets: Hints for Thin Deep Nets
Additional References

deeplearning.net tutorial with Theano

ConvNetJS demos for intuitions

Michael Nielsen’s tutorials
References
[1] Neural Networks Part 1: Setting up the Architecture
[2] Neural Networks Part 2: Setting up the Data and the Loss
[3] Neural Networks Part 3: Learning and Evaluation