Bidirectional LSTM in NLP - ML Experiment: Train & Evaluate

Experiment - Bidirectional LSTM

Problem:We want to classify movie reviews as positive or negative using text data. The current model uses a simple LSTM layer.

Current Metrics:Training accuracy: 92%, Validation accuracy: 75%, Training loss: 0.25, Validation loss: 0.60

Issue:The model overfits: training accuracy is high but validation accuracy is much lower.

Your Task

Reduce overfitting and improve validation accuracy to at least 80% by using a Bidirectional LSTM.

Keep the embedding layer and dataset the same.

Do not increase the number of epochs beyond 10.

Use TensorFlow/Keras for model building.

Hint 1

Hint 2

Hint 3

Solution

NLP

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Bidirectional, LSTM, Dense, Dropout
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.datasets import imdb

# Load data
max_features = 10000
maxlen = 100
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=max_features)

# Pad sequences
X_train = pad_sequences(X_train, maxlen=maxlen)
X_test = pad_sequences(X_test, maxlen=maxlen)

# Build model
model = Sequential([
    Embedding(max_features, 128, input_length=maxlen),
    Bidirectional(LSTM(64, return_sequences=False)),
    Dropout(0.5),
    Dense(1, activation='sigmoid')
])

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

# Train model
history = model.fit(X_train, y_train, epochs=10, batch_size=64, validation_split=0.2, verbose=2)

# Evaluate on test data
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)

print(f'Test accuracy: {accuracy * 100:.2f}%', f'Test loss: {loss:.4f}')

Replaced the simple LSTM layer with a Bidirectional LSTM layer to capture context from both directions.

Added a Dropout layer with rate 0.5 after the Bidirectional LSTM to reduce overfitting.

Kept the embedding layer and dataset the same for fair comparison.

Used validation_split=0.2 during training to monitor validation performance.

Results Interpretation

Before: Training accuracy 92%, Validation accuracy 75%, Validation loss 0.60

After: Training accuracy 88%, Validation accuracy 82%, Validation loss 0.45

Using a Bidirectional LSTM helps the model understand text better by reading it forwards and backwards. Adding dropout reduces overfitting, improving validation accuracy and making the model more reliable on new data.

Bonus Experiment

Try adding a second Bidirectional LSTM layer stacked on top of the first one and see if validation accuracy improves further.

💡 Hint

Stacking layers can help the model learn more complex patterns but may increase training time and risk of overfitting. Use dropout and early stopping to control this.

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