LSTM for text in NLP - Model Metrics & Evaluation

Metrics & Evaluation - LSTM for text

Which metric matters for LSTM text models and WHY

For LSTM models working with text, the main goal is often to correctly predict sequences or classify text. Common metrics include accuracy for classification tasks, and perplexity or cross-entropy loss for language modeling. Accuracy tells us how many text samples were correctly labeled. Perplexity measures how well the model predicts the next word, with lower values meaning better predictions. These metrics help us understand if the model is learning meaningful patterns in text.

Confusion matrix example for text classification

      | Predicted Positive | Predicted Negative |
      |--------------------|--------------------|
      | True Positive (TP): 80 | False Negative (FN): 20 |
      | False Positive (FP): 10 | True Negative (TN): 90 |

      Total samples = TP + FP + TN + FN = 80 + 10 + 90 + 20 = 200

      Precision = TP / (TP + FP) = 80 / (80 + 10) = 0.89
      Recall = TP / (TP + FN) = 80 / (80 + 20) = 0.80
      F1 Score = 2 * (Precision * Recall) / (Precision + Recall) = 2 * (0.89 * 0.80) / (0.89 + 0.80) ≈ 0.84
    

Precision vs Recall tradeoff with examples

In text tasks, the balance between precision and recall depends on the goal:

• Spam detection: High precision is important. We want to avoid marking good emails as spam (false positives).
• Sentiment analysis for customer feedback: High recall is important. We want to catch as many negative comments as possible, even if some are missed.

LSTM models can be tuned to favor precision or recall by adjusting thresholds or loss functions.

What good vs bad metric values look like for LSTM text models

Good metrics for text classification with LSTM:

• Accuracy above 85% on balanced data
• Precision and recall both above 80%
• F1 score close to precision and recall

Bad metrics might be:

• Accuracy near random chance (e.g., 50% for binary)
• Very high precision but very low recall (or vice versa), showing imbalance
• High loss or perplexity in language modeling, indicating poor prediction

Common pitfalls in evaluating LSTM text models

• Accuracy paradox: High accuracy can be misleading if classes are imbalanced (e.g., 90% accuracy by always predicting the majority class).
• Data leakage: If test data leaks into training, metrics look unrealistically good.
• Overfitting: Very low training loss but high test loss means the model memorizes training text but fails on new text.
• Ignoring class imbalance: Not using metrics like F1 or balanced accuracy can hide poor performance on minority classes.

Self-check question

Your LSTM text classification model has 98% accuracy but only 12% recall on the positive class (e.g., spam). Is it good for production? Why or why not?

Answer: No, it is not good. The high accuracy is likely due to many negative samples dominating the data. The very low recall means the model misses most positive cases (spam), which is critical to catch. This model would fail to identify most spam emails, making it unreliable in practice.

Key Result

For LSTM text models, balanced precision and recall with high accuracy and low loss indicate good performance.

Practice

1. What is the main advantage of using an LSTM model for text data?

easy

A. It converts text directly into images.

B. It removes all punctuation from the text.

C. It remembers the order of words in a sentence.

D. It translates text into multiple languages.

Solution

1. Step 1: Understand LSTM's role in text

   LSTM models are designed to remember sequences, which means they keep track of word order in sentences.

2. Step 2: Compare options with LSTM function

   Only It remembers the order of words in a sentence. correctly describes LSTM's ability to remember word order. Other options describe unrelated tasks.

3. Final Answer:

   It remembers the order of words in a sentence. -> Option C

4. Quick Check:

   LSTM remembers word order = B [OK]

Hint: LSTM = memory for word order in text [OK]

Common Mistakes:

• Thinking LSTM translates languages
• Confusing LSTM with image processing
• Assuming LSTM removes punctuation

2. Which of the following is the correct way to add an LSTM layer in Keras for text input?

easy

A. model.add(LSTM(128, input_shape=(timesteps, features)))

B. model.add(Dense(128, input_shape=(timesteps, features)))

C. model.add(Conv2D(128, kernel_size=3))

D. model.add(Embedding(128, input_shape=(timesteps, features)))

Solution

1. Step 1: Identify LSTM layer syntax in Keras

   The LSTM layer is added with LSTM(units, input_shape=(timesteps, features)). model.add(LSTM(128, input_shape=(timesteps, features))) matches this syntax.

2. Step 2: Check other options for correctness

   model.add(Dense(128, input_shape=(timesteps, features))) is a Dense layer, not LSTM. model.add(Conv2D(128, kernel_size=3)) is a Conv2D layer for images. model.add(Embedding(128, input_shape=(timesteps, features))) is an Embedding layer, not LSTM.

3. Final Answer:

   model.add(LSTM(128, input_shape=(timesteps, features))) -> Option A

4. Quick Check:

   LSTM layer syntax = D [OK]

Hint: LSTM layer uses LSTM(), not Dense or Conv2D [OK]

Common Mistakes:

• Using Dense instead of LSTM for sequence data
• Confusing Embedding with LSTM layer
• Applying Conv2D for text input

3. Given this code snippet, what will be the shape of the output from the LSTM layer?

model = Sequential()
model.add(Embedding(input_dim=1000, output_dim=64, input_length=10))
model.add(LSTM(32))
output = model.output_shape

medium

A. (None, 10, 32)

B. (None, 32)

C. (None, 64)

D. (10, 32)

Solution

1. Step 1: Understand Embedding and LSTM output shapes

   The Embedding layer outputs (batch_size, 10, 64). The LSTM with 32 units returns (batch_size, 32) by default (last output only).

2. Step 2: Match output shape with options

   (None, 32) matches (None, 32) where None is batch size. Other options are incorrect shapes.

3. Final Answer:

   (None, 32) -> Option B

4. Quick Check:

   LSTM output shape = (None, 32) [OK]

Hint: LSTM returns (batch, units) by default, not sequence [OK]

Common Mistakes:

• Assuming LSTM outputs full sequence by default
• Confusing embedding output with LSTM output
• Ignoring batch size dimension

4. Identify the error in this LSTM model code for text classification:

model = Sequential()
model.add(LSTM(64, input_shape=(100,)))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='adam', loss='binary_crossentropy')

medium

A. Optimizer 'adam' is not suitable for LSTM models

B. Dense layer activation should be 'relu' for binary classification

C. Loss function should be 'categorical_crossentropy' for binary output

D. Input shape should be 2D, e.g., (timesteps, features), not (100,)

Solution

1. Step 1: Check input shape for LSTM layer

   LSTM expects input shape as (timesteps, features). Here, (100,) is 1D, missing feature dimension.

2. Step 2: Validate other components

   Binary classification uses sigmoid activation and binary_crossentropy loss correctly. Adam optimizer is suitable.

3. Final Answer:

   Input shape should be 2D, e.g., (timesteps, features), not (100,) -> Option D

4. Quick Check:

   LSTM input shape must be 2D = A [OK]

Hint: LSTM input shape needs (timesteps, features) [OK]

Common Mistakes:

• Using 1D input shape for LSTM
• Changing activation incorrectly for binary tasks
• Mixing loss functions for binary classification

5. You want to build an LSTM model to classify movie reviews as positive or negative. Which approach best improves model understanding of word meaning before LSTM processing?

hard

A. Add an Embedding layer to convert words into dense vectors before the LSTM.

B. Use a Dense layer directly on raw text input before LSTM.

C. Apply a Conv2D layer to the text input before LSTM.

D. Skip preprocessing and feed raw text strings directly to LSTM.

Solution

1. Step 1: Understand preprocessing for text in LSTM models

   Embedding layers convert words into meaningful numeric vectors, helping LSTM understand word relationships.

2. Step 2: Evaluate other options

   Dense layers expect numeric input, not raw text. Conv2D is for images. Feeding raw strings to LSTM causes errors.

3. Final Answer:

   Add an Embedding layer to convert words into dense vectors before the LSTM. -> Option A

4. Quick Check:

   Embedding before LSTM = C [OK]

Hint: Use Embedding layer to convert words before LSTM [OK]

Common Mistakes:

• Feeding raw text directly to LSTM
• Using Dense or Conv2D layers on raw text
• Skipping word vector conversion