In my experience, there is no such relationship between number of inputs and number of hidden neurons that can be made to correctly classify a particular problem. In a back propagation neural network, the learning constant, number of hidden neurons, initial weights, number of hidden layers, momentum all affect the speed of training as well as the final outcome. All the factors require a trial and error method to determine the best number of hidden layers, number of hidden neurons in each layer, learning constant, etc. The only way is to check the mean square error that is obtained by changing the parameter values and try to minimize the error as far as possible.

Try reading this book - "Introduction to Artificial Neural Systems", by Jacek M. Zurada, West Publishing Company, 1999

Before discussing backpropagation, let's warm up with a fast matrix-based algorithm to compute the output from a neural network. We actually already briefly saw this algorithm near the end of the last chapter, but I described it quickly, so it's worth revisiting in detail. In particular, this is a good way of getting comfortable with the notation used in backpropagation, in a familiar context.

Let's begin with a notation which lets us refer to weights in the network in an unambiguous way. We'll use wljk to denote the weight for the connection from the kth neuron in the (l−1)th layer to the jth neuron in the lth layer. So, for example, the diagram below shows the weight on a connection from the fourth neuron in the second layer to the second neuron in the third layer of a network:

This notation is cumbersome at first, and it does take some work to master. But with a little effort you'll find the notation becomes easy and natural. One quirk of the notation is the ordering of the j and k indices. You might think that it makes more sense to use j to refer to the input neuron, and k to the output neuron, not vice versa, as is actually done. I'll explain the reason for this quirk below. 

We use a similar notation for the network's biases and activations. Explicitly, we use blj for the bias of the jth neuron in the lth layer. And we use alj for the activation of the jth neuron in the lth layer. The following diagram shows examples of these notations in use:

With these notations, the activation alj of the jth neuron in the lth layer is related to the activations in the (l−1)th layer by the equation (compare Equation (4) and surrounding discussion in the last chapter) alj=σ(∑kwljkal−1k+blj),(23)

where the sum is over all neurons k in the (l−1)th layer. To rewrite this expression in a matrix form we define a weight matrix wl for each layer, l. The entries of the weight matrix wl are just the weights connecting to the lth layer of neurons, that is, the entry in the jth row and kth column is wljk. Similarly, for each layer l we define a bias vector, bl. You can probably guess how this works - the components of the bias vector are just the values blj, one component for each neuron in the lth layer. And finally, we define an activation vector al whose components are the activations alj. 

The last ingredient we need to rewrite (23) in a matrix form is the idea of vectorizing a function such as σ. We met vectorization briefly in the last chapter, but to recap, the idea is that we want to apply a function such as σ to every element in a vector v. We use the obvious notation σ(v) to denote this kind of elementwise application of a function. That is, the components of σ(v) are just σ(v)j=σ(vj). As an example, if we have the function f(x)=x2 then the vectorized form of f has the effect

f([23])=[f(2)f(3)]=[49],(24)

that is, the vectorized f just squares every element of the vector.

With these notations in mind, Equation (23) can be rewritten in the beautiful and compact vectorized form

al=σ(wlal−1+bl).(25)

This expression gives us a much more global way of thinking about how the activations in one layer relate to activations in the previous layer: we just apply the weight matrix to the activations, then add the bias vector, and finally apply the σ function* *By the way, it's this expression that motivates the quirk in the wljk notation mentioned earlier. If we used j to index the input neuron, and k to index the output neuron, then we'd need to replace the weight matrix in Equation (25) by the transpose of the weight matrix. That's a small change, but annoying, and we'd lose the easy simplicity of saying (and thinking) "apply the weight matrix to the activations".. That global view is often easier and more succinct (and involves fewer indices!) than the neuron-by-neuron view we've taken to now. Think of it as a way of escaping index hell, while remaining precise about what's going on. The expression is also useful in practice, because most matrix libraries provide fast ways of implementing matrix multiplication, vector addition, and vectorization. Indeed, the code in the last chapter made implicit use of this expression to compute the behaviour of the network.

When using Equation (25) to compute al, we compute the intermediate quantity zl≡wlal−1+bl along the way. This quantity turns out to be useful enough to be worth naming: we call zl the weighted input to the neurons in layer l. We'll make considerable use of the weighted input zl later in the chapter. Equation (25) is sometimes written in terms of the weighted input, as al=σ(zl). It's also worth noting that zl has components zlj=∑kwljkal−1k+blj, that is, zlj is just the weighted input to the activation function for neuron j in layer l.

http://neuralnetworksanddeeplearning.com/chap2.html

page.mi.fu-berlin.de/rojas/neural/chapter/K7.pdf

https://www4.rgu.ac.uk/files/chapter3%20-%20bp.pdf

You can start with the following formulea:-

no of hidden nuerons= (the number of input features or neurons+ number of output nuerons)/2. 

then use trail and error ( reduce or increase the number of neurons) to check the performance results and the stability your network

The number of neurons in the hidden layer(s) depends on the association, not the number of inputs as such. And the association may require more than one hidden layer. Cf., for example, the tiling algorithm: http://lptms.u-psud.fr/membres/Mezard/Pdf/89_MN_JPA.pdf

There is not any gold algorithm to determine the number of hidden nodes and the number of hidden layers, since they depend on many factors (including inputs, outputs, association, among many others).

Although some Heuristics (formulas) are commonly used, the best procedure to determine them may be trial-and-error. If you decide to apply this alternative, I strongly suggest you to apply k-fold cross validation and repeat the procedure many times to avoid the effect of random initialization.

Actually there is, for Boolean functions-it's the tiling algorithm (cf. above). A lot is known theoretically-for more than twenty years in fact on this subject. 

Number of Neurons in the input layer is always equal to Number of Input parameters used in the model development.