Bidirectional LSTM in NLP

Introduction

Bidirectional LSTM helps a model understand information from both past and future in a sequence. This makes it better at tasks like language understanding.

When you want to understand the meaning of a sentence by looking at words before and after each word.

When analyzing time series data where future and past values both matter.

When building chatbots that need context from the whole conversation.

When doing speech recognition to better predict words based on surrounding sounds.

When working on text classification where context from both directions improves accuracy.

Syntax

NLP

from tensorflow.keras.layers import Bidirectional, LSTM

bidirectional_layer = Bidirectional(LSTM(units))

The Bidirectional wrapper takes a recurrent layer like LSTM and runs it forwards and backwards.

The units parameter sets how many memory cells the LSTM has.

Examples

This creates a bidirectional LSTM with 64 memory units in each direction.

NLP

Bidirectional(LSTM(64))

This returns the output for each time step, useful for stacking layers.

NLP

Bidirectional(LSTM(32, return_sequences=True))

This adds dropout to reduce overfitting during training.

NLP

Bidirectional(LSTM(128, dropout=0.2))

Sample Model

This example builds a simple model with a bidirectional LSTM layer to classify sequences. It trains on random data and prints predictions.

NLP

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Bidirectional, LSTM, Dense

# Sample data: 5 sequences, each with 10 words (integers)
x_train = np.random.randint(1, 1000, (5, 10))
y_train = np.array([0, 1, 0, 1, 0])  # Binary labels

model = Sequential([
    Embedding(input_dim=1000, output_dim=16, input_length=10),
    Bidirectional(LSTM(8)),
    Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

history = model.fit(x_train, y_train, epochs=3, verbose=2)

# Predict on the training data
predictions = model.predict(x_train)
print('Predictions:', predictions.flatten())

Important Notes

Bidirectional LSTM doubles the number of parameters because it runs two LSTMs.

Use return_sequences=True if you want to stack more recurrent layers.

Bidirectional LSTM works best when the entire sequence is available, not for streaming data.

Summary

Bidirectional LSTM reads sequences forward and backward to capture full context.

It improves performance on tasks like language understanding and time series analysis.

Use the Bidirectional wrapper around an LSTM layer in your model.

Practice

1. What is the main advantage of using a Bidirectional LSTM compared to a standard LSTM?

easy

A. It only reads the sequence backward for better performance.

B. It uses fewer parameters, making the model faster to train.

C. It processes the input sequence in both forward and backward directions to capture more context.

D. It replaces LSTM cells with simpler RNN cells.

Solution

1. Step 1: Understand LSTM directionality

   A standard LSTM reads the input sequence only in the forward direction, from start to end.

2. Step 2: Analyze Bidirectional LSTM behavior

   A Bidirectional LSTM reads the sequence both forward and backward, capturing information from past and future context.

3. Final Answer:

   It processes the input sequence in both forward and backward directions to capture more context. -> Option C

4. Quick Check:

   Bidirectional means forward + backward = C [OK]

Hint: Bidirectional means reading sequence both ways [OK]

Common Mistakes:

• Thinking it only reads backward
• Assuming it reduces parameters
• Confusing it with simpler RNNs

2. Which of the following is the correct way to add a Bidirectional LSTM layer in Keras?

easy

A. model.add(Bidirectional(LSTM(units=64)))

B. model.add(LSTM(Bidirectional(units=64)))

C. model.add(Bidirectional(units=64, LSTM()))

D. model.add(LSTM(units=64, bidirectional=True))

Solution

1. Step 1: Recall Keras Bidirectional syntax

   In Keras, the Bidirectional wrapper takes an RNN layer like LSTM as its argument.

2. Step 2: Check each option

   model.add(Bidirectional(LSTM(units=64))) correctly wraps LSTM inside Bidirectional. The other options misuse the syntax or parameters.

3. Final Answer:

   model.add(Bidirectional(LSTM(units=64))) -> Option A

4. Quick Check:

   Bidirectional wraps LSTM layer = A [OK]

Hint: Bidirectional wraps LSTM layer, not the other way [OK]

Common Mistakes:

• Putting Bidirectional inside LSTM
• Passing units to Bidirectional instead of LSTM
• Using bidirectional=True parameter in LSTM

3. Consider this code snippet using TensorFlow Keras:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Bidirectional, Dense

model = Sequential()
model.add(Bidirectional(LSTM(10, return_sequences=False), input_shape=(5, 8)))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='adam', loss='binary_crossentropy')

import numpy as np
x = np.random.random((2, 5, 8))
pred = model.predict(x)
print(pred.shape)

What will be the shape of pred?

medium

A. (2, 10)

B. (2, 1)

C. (5, 1)

D. (2, 20)

Solution

1. Step 1: Understand model output shape

   The Bidirectional LSTM with 10 units outputs 20 features (10 forward + 10 backward) per timestep. Since return_sequences=False, it outputs only the last timestep's features, shape (batch_size, 20).

2. Step 2: Dense layer output shape

   The Dense layer with 1 unit outputs shape (batch_size, 1). Input batch size is 2, so output shape is (2, 1).

3. Final Answer:

   (2, 1) -> Option B

4. Quick Check:

   Batch size 2, Dense 1 unit = (2, 1) [OK]

Hint: Dense(1) outputs shape (batch_size, 1) [OK]

Common Mistakes:

• Confusing return_sequences=True vs False
• Forgetting bidirectional doubles units
• Mixing batch and timestep dimensions

4. You wrote this code but get an error:

model = Sequential()
model.add(Bidirectional(LSTM(32), input_shape=(10, 16)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')

# Training data
X_train = np.random.random((100, 10, 16))
y_train = np.random.random((100,))

model.fit(X_train, y_train, epochs=5)

The error says: ValueError: Error when checking target: expected dense_1 to have shape (None, 1) but got array with shape (100,)
What is the fix?

medium

A. Change Dense layer units to 100.

B. Remove Bidirectional wrapper.

C. Set return_sequences=True in LSTM layer.

D. Change y_train shape to (100, 1) by reshaping it.

Solution

1. Step 1: Understand error message

   The model expects targets with shape (batch_size, 1) because Dense(1) outputs shape (None, 1). But y_train has shape (100,), missing the last dimension.

2. Step 2: Fix target shape

   Reshape y_train to (100, 1) to match model output shape. This fixes the mismatch error.

3. Final Answer:

   Change y_train shape to (100, 1) by reshaping it. -> Option D

4. Quick Check:

   Target shape matches output shape = B [OK]

Hint: Targets must match model output shape exactly [OK]

Common Mistakes:

• Changing model output units instead of target shape
• Setting return_sequences=True unnecessarily
• Removing Bidirectional without reason

5. You want to build a sentiment analysis model using a Bidirectional LSTM on text sequences of length 100. Which of these model designs best captures full context and outputs a fixed-size vector for classification?

hard

A. Embedding -> Bidirectional(LSTM with return_sequences=True) -> GlobalMaxPooling1D -> Dense

B. Embedding -> Bidirectional(LSTM with return_sequences=False) -> Dense

C. Embedding -> LSTM with return_sequences=False -> Dense

D. Embedding -> Bidirectional(LSTM with return_sequences=True) -> Dense

Solution

1. Step 1: Understand context capture

   Bidirectional LSTM reads sequences forward and backward, capturing full context.

2. Step 2: Fixed-size vector output

   Using return_sequences=True outputs a sequence, so applying GlobalMaxPooling1D converts it to a fixed-size vector summarizing important features.

3. Step 3: Compare options

   Embedding -> Bidirectional(LSTM with return_sequences=True) -> GlobalMaxPooling1D -> Dense uses Bidirectional LSTM with return_sequences=True plus pooling, best for full context and fixed vector. Embedding -> Bidirectional(LSTM with return_sequences=False) -> Dense skips pooling, output is last timestep only. Embedding -> LSTM with return_sequences=False -> Dense is unidirectional. Embedding -> Bidirectional(LSTM with return_sequences=True) -> Dense outputs sequence but no pooling, so Dense gets sequence input, causing shape issues.

4. Final Answer:

   Embedding -> Bidirectional(LSTM with return_sequences=True) -> GlobalMaxPooling1D -> Dense -> Option A

5. Quick Check:

   Pooling after bidirectional LSTM = A [OK]

Hint: Use pooling after return_sequences=True for fixed vector [OK]

Common Mistakes:

• Using return_sequences=False loses sequence info
• Skipping pooling leads to shape mismatch
• Using unidirectional LSTM loses backward context