Fromthis brilliant article

num_units can be interpreted as the analogy of hidden layer from the feed forward neural network. The number of nodes in hidden layer of a feed forward neural network is equivalent to num_units number of LSTM units in a LSTM cell at every time step of the network.

See theimage there too!

The number of hidden units is a direct representation of the learning capacity of a neural network -- it reflects the number oflearned parameters. The value128 was likely selected arbitrarily or empirically. You can change that value experimentally and rerun the program to see how it affects the training accuracy (you can get better than 90% test accuracy witha lot fewer hidden units). Using more units makes it more likely to perfectly memorize the complete training set (although it will take longer, and you run the risk of over-fitting).

The key thing to understand, which is somewhat subtle in the famousColah's blog post (find"each line carries an entire vector"), is thatX is anarray of data (nowadays often called atensor) -- it is not meant to be ascalar value. Where, for example, thetanh function is shown, it is meant to imply that the function isbroadcast across the entire array (an implicitfor loop) -- and not simply performed once per time-step.

As such, thehidden units represent tangible storage within the network, which is manifest primarily in the size of theweights array. And because an LSTM actually does have a bit of it's own internal storage separate from the learned model parameters, it has to know how many units there are -- which ultimately needs to agree with the size of the weights. In the simplest case, an RNN has no internal storage -- so it doesn't even need to know in advance how many "hidden units" it is being applied to.

• A good answer to a similar questionhere.
• You can look atthe source for BasicLSTMCell in TensorFlow to see exactly how this is used.

Side note:This notation is very common in statistics and machine-learning, and other fields that process large batches of data with a common formula (3D graphics is another example). It takes a bit of getting used to for people who expect to see theirfor loops written out explicitly.

The argumentn_hidden ofBasicLSTMCell is the number of hidden units of the LSTM.

As you said, you should really read Colah'sblog post to understand LSTM, but here is a little heads up.

If you have an inputx of shape[T, 10], you will feed the LSTM with the sequence of values fromt=0 tot=T-1, each of size10.

At each timestep, you multiply the input with a matrix of shape[10, n_hidden], and get an_hidden vector.

Your LSTM gets at each timestept:

• the previous hidden stateh_{t-1}, of sizen_hidden (att=0, the previous state is[0., 0., ...])
• the input, transformed to sizen_hidden
• it willsum these inputs and produce the next hidden stateh_t of sizen_hidden

From Colah's blog post:

If you just want to have code working, just keep withn_hidden = 128 and you will be fine.

Since I had some problems to combine the information from the different sources I created the graphic below which shows a combination of the blog post (http://colah.github.io/posts/2015-08-Understanding-LSTMs/) and (https://jasdeep06.github.io/posts/Understanding-LSTM-in-Tensorflow-MNIST/) where I think the graphics are very helpful but an error in explaining the number_units is present.

Several LSTM cells form one LSTM layer. This is shown in the figure below. Since you are mostly dealing with data that is very extensive, it is not possible to incorporate everything in one piece into the model. Therefore, data is divided into small pieces as batches, which are processed one after the other until the batch containing the last part is read in. In the lower part of the figure you can see the input (dark grey) where the batches are read in one after the other from batch 1 to batch batch_size. The cells LSTM cell 1 to LSTM cell time_step above represent the described cells of the LSTM model (http://colah.github.io/posts/2015-08-Understanding-LSTMs/). The number of cells is equal to the number of fixed time steps. For example, if you take a text sequence with a total of 150 characters, you could divide it into 3 (batch_size) and have a sequence of length 50 per batch (number of time_steps and thus of LSTM cells). If you then encoded each character one-hot, each element (dark gray boxes of the input) would represent a vector that would have the length of the vocabulary (number of features). These vectors would flow into the neural networks (green elements in the cells) in the respective cells and would change their dimension to the length of the number of hidden units (number_units). So the input has the dimension (batch_size x time_step x features). The Long Time Memory (Cell State) and Short Time Memory (Hidden State) have the same dimensions (batch_size xnumber_units). The light gray blocks that arise from the cells have a different dimension because the transformations in the neural networks (green elements) took place with the help of the hidden units (batch_size x time_step xnumber_units). The output can be returned from any cell but mostly only the information from the last block (black border) is relevant (not in all problems) because it contains all information from the previous time steps.

An LSTM keeps two pieces of information as it propagates through time:

Ahidden state; which is the memory the LSTM accumulates using its(forget, input, and output) gates through time, andThe previous time-step output.

Tensorflow’snum_units is the size of the LSTM’s hidden state (which is also the size of the output if no projection is used).

To make the namenum_units more intuitive, you can think of it as the number of hidden units in the LSTM cell, or the number of memory units in the cell.

Look atthis awesome post for more clarity

I think it is confusing for TF users by the term "num_hidden". Actually it has nothing to do with the unrolled LSTM cells, and it just is the dimension of the tensor, which is transformed from the time-step input tensor to and fed into the LSTM cell.

This termnum_units ornum_hidden_units sometimes noted using the variable namenhid in the implementations, means that the input to the LSTM cell is a vector of dimensionnhid (or for a batched implementation, it would a matrix of shapebatch_size xnhid). As a result, the output (from LSTM cell) would also be of same dimensionality since RNN/LSTM/GRU cell doesn't alter the dimensionality of the input vector or matrix.

As pointed out earlier, this term was borrowed from Feed-Forward Neural Networks (FFNs) literature and has caused confusion when used in the context of RNNs. But, the idea is thateven RNNs can beviewed as FFNs at each time step. In this view, the hidden layer would indeed be containingnum_hidden units as depicted in this figure:

Source:Understanding LSTM

More concretely, in the below example thenum_hidden_units ornhid would be3 since thesize of hidden state (middle layer) is a3D vector.

I think this is a correctly answer for your question. LSTM always make confusion.

You can refer this blog for more detailAnimated RNN, LSTM and GRU

Most LSTM/RNN diagrams just show the hidden cells but never the units of those cells. Hence, the confusion. Each hidden layer has hidden cells, as many as the number of time steps.And further, each hidden cell is made up of multiple hidden units, like in the diagram below. Therefore, the dimensionality of a hidden layer matrix in RNN is (number of time steps, number of hidden units).

The Concept of hidden unit is illustrated in this imagehttps://i.sstatic.net/QBh06.jpg.

Following @SangLe answer, I made a picture (see sources for original pictures) showing cells as classically represented in tutorials (Source1: Colah's Blog) and an equivalent cell with 2 units (Source2: Raimi Karim 's post). Hope it will clarify confusion between cells/units and what really is the network architecture.

• tensorflow
• neural-network
• lstm
• recurrent-neural-network