Bidirectional LSTM in NLP - Model Metrics & Evaluation

Metrics & Evaluation - Bidirectional LSTM

Which metric matters for Bidirectional LSTM and WHY

Bidirectional LSTM models are often used for tasks like text classification, named entity recognition, or sentiment analysis. The key metrics to check are accuracy for overall correctness, precision and recall to understand how well the model finds relevant items and avoids mistakes, and F1 score to balance precision and recall. These metrics help us know if the model understands the sequence data well from both directions.

Confusion Matrix Example

    Actual \ Predicted | Positive | Negative
    -------------------|----------|---------
    Positive           |    80    |   20    
    Negative           |    10    |   90    
  

Here, True Positives (TP) = 80, False Negatives (FN) = 20, False Positives (FP) = 10, True Negatives (TN) = 90. Total samples = 200.

Precision = 80 / (80 + 10) = 0.89

Recall = 80 / (80 + 20) = 0.80

F1 Score = 2 * (0.89 * 0.80) / (0.89 + 0.80) ≈ 0.84

Precision vs Recall Tradeoff with Examples

Imagine a Bidirectional LSTM used for spam detection in emails:

• High Precision: The model marks emails as spam only when very sure. This means fewer good emails are wrongly marked as spam (low false positives).
• High Recall: The model catches almost all spam emails, but might mark some good emails as spam (higher false positives).

Depending on what matters more (missing spam or wrongly blocking good emails), you choose to optimize precision or recall.

Good vs Bad Metric Values for Bidirectional LSTM

Good: Accuracy above 85%, Precision and Recall both above 80%, and F1 score balanced near 80% or higher. This means the model correctly understands sequences from both directions and makes reliable predictions.

Bad: Accuracy near 50-60%, Precision or Recall very low (below 50%), or large difference between precision and recall. This shows the model struggles to learn meaningful patterns or is biased.

Common Pitfalls in Metrics for Bidirectional LSTM

• Accuracy Paradox: High accuracy but poor recall or precision, especially with imbalanced classes.
• Data Leakage: Training data accidentally includes future information, inflating metrics.
• Overfitting: Very high training accuracy but low test accuracy means the model memorizes instead of generalizing.

Self Check

Your Bidirectional LSTM model has 98% accuracy but only 12% recall on the positive class (e.g., fraud detection). Is it good for production?

Answer: No, because the model misses most positive cases (low recall). Even with high accuracy, it fails to find important examples. For tasks like fraud detection, high recall is critical to catch as many frauds as possible.

Key Result

Precision, recall, and F1 score are key to evaluate Bidirectional LSTM models, balancing correct detection and missed cases.

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