GRU for text in NLP - Model Metrics & Evaluation

Metrics & Evaluation - GRU for text

Which metric matters for GRU on text and WHY

For text tasks like sentiment or spam detection, accuracy shows overall correct guesses. But because text data can be unbalanced, precision and recall are key. Precision tells us how many predicted positives are truly positive, helping avoid false alarms. Recall shows how many real positives the model finds, important to catch all relevant cases. The F1 score balances precision and recall, giving a clear view of model quality.

Confusion Matrix Example

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

Here, TP=80, FN=20, FP=10, 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 Text Examples

Imagine a spam filter using a GRU model:

• High Precision: Few good emails are wrongly marked as spam. Users don't miss important messages.
• High Recall: Most spam emails are caught, but some good emails might be flagged wrongly.

Depending on what matters more (user trust or spam catching), you adjust the model threshold to favor precision or recall.

Good vs Bad Metric Values for GRU on Text

Good: Accuracy > 85%, Precision and Recall both above 80%, F1 score balanced near 0.8 or higher.

Bad: Accuracy high but recall very low (missing many positives), or precision very low (many false alarms). For example, 90% accuracy but 30% recall means many real positives are missed.

Common Metric Pitfalls

• Accuracy Paradox: High accuracy can be misleading if classes are imbalanced (e.g., 95% accuracy but model ignores rare positive class).
• Data Leakage: If test data leaks into training, metrics look unrealistically good.
• Overfitting Indicators: Very high training accuracy but low test accuracy means model memorizes text instead of learning patterns.

Self Check

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

Answer: No. Despite high accuracy, the model misses most positive cases. This means many spam emails go undetected, which is bad for user experience. You should improve recall before using it in production.

Key Result

For GRU models on text, balanced precision and recall with a strong F1 score best show true performance beyond accuracy.

Practice

1. What is the main advantage of using a GRU (Gated Recurrent Unit) in text processing tasks?

easy

A. It helps the model remember important information over time while ignoring less important details.

B. It increases the size of the input text automatically.

C. It converts text into images for better analysis.

D. It removes all punctuation from the text before processing.

Solution

1. Step 1: Understand GRU's role in memory

   GRU units are designed to keep important information from previous steps and forget irrelevant data, helping with sequence tasks like text.

2. Step 2: Compare options to GRU function

   Only It helps the model remember important information over time while ignoring less important details. correctly describes this memory feature; others describe unrelated or incorrect functions.

3. Final Answer:

   It helps the model remember important information over time while ignoring less important details. -> Option A

4. Quick Check:

   GRU memory feature = A [OK]

Hint: GRU remembers key info, forgets noise in sequences [OK]

Common Mistakes:

• Thinking GRU changes input size
• Confusing GRU with data preprocessing
• Assuming GRU outputs images

2. Which of the following is the correct way to define a GRU layer in Python using PyTorch for text input with embedding size 100 and hidden size 50?

easy

A. nn.GRU(hidden_size=100, input_size=50)

B. nn.GRU(50, 100)

C. nn.GRU(input_size=100, hidden_size=50)

D. nn.GRU(100)

Solution

1. Step 1: Recall PyTorch GRU parameters

   PyTorch GRU expects input_size first (embedding size), then hidden_size (number of features in hidden state).

2. Step 2: Match parameters to given sizes

   Embedding size is 100, hidden size is 50, so nn.GRU(input_size=100, hidden_size=50) is correct.

3. Final Answer:

   nn.GRU(input_size=100, hidden_size=50) -> Option C

4. Quick Check:

   input_size=100, hidden_size=50 = B [OK]

Hint: Input size first, hidden size second in nn.GRU() [OK]

Common Mistakes:

• Swapping input_size and hidden_size
• Using positional args incorrectly
• Omitting required parameters

3. Given the following PyTorch code snippet, what will be the shape of the output tensor after passing input through the GRU?

import torch
import torch.nn as nn

gru = nn.GRU(input_size=10, hidden_size=20, batch_first=True)
input = torch.randn(5, 7, 10)  # batch=5, seq_len=7, input_size=10
output, hidden = gru(input)
print(output.shape)

medium

A. (7, 5, 20)

B. (5, 7, 20)

C. (5, 20, 7)

D. (5, 7, 10)

Solution

1. Step 1: Understand GRU output shape with batch_first=true

   Output shape is (batch_size, sequence_length, hidden_size) when batch_first=true.

2. Step 2: Match given input sizes

   Input batch=5, seq_len=7, hidden_size=20, so output shape is (5, 7, 20).

3. Final Answer:

   (5, 7, 20) -> Option B

4. Quick Check:

   Output shape = (batch, seq_len, hidden_size) = A [OK]

Hint: With batch_first=true, output shape is (batch, seq_len, hidden) [OK]

Common Mistakes:

• Confusing batch and sequence dimensions
• Ignoring batch_first=true effect
• Assuming output shape equals input shape

4. You wrote this code to create a GRU for text classification but get a runtime error:

gru = nn.GRU(input_size=50, hidden_size=100)
input = torch.randn(32, 10, 100)  # batch=32, seq_len=10, input_size=100
output, hidden = gru(input)

What is the likely cause of the error?

medium

A. Input size 100 does not match GRU input_size 50

B. Batch size 32 is too large for GRU

C. Sequence length 10 is invalid for GRU

D. GRU requires input to be 2D tensor, not 3D

Solution

1. Step 1: Check GRU input_size vs input tensor last dimension

   GRU expects input_size=50, but input tensor last dimension is 100, causing mismatch.

2. Step 2: Understand tensor shape requirements

   GRU input shape should be (batch, seq_len, input_size). Here input_size dimension must match GRU's input_size parameter.

3. Final Answer:

   Input size 100 does not match GRU input_size 50 -> Option A

4. Quick Check:

   Input size mismatch = C [OK]

Hint: Match input tensor last dim to GRU input_size [OK]

Common Mistakes:

• Blaming batch size for error
• Thinking sequence length is invalid
• Assuming GRU only accepts 2D input

5. You want to build a GRU-based model to classify movie reviews as positive or negative. Your dataset has variable-length reviews. Which approach best handles variable-length sequences with a GRU in PyTorch?

hard

A. Convert text to images and use CNN instead of GRU.

B. Truncate all sequences to length 1 and feed to GRU.

C. Feed raw sequences directly without padding or packing.

D. Pad all sequences to the same length and use pack_padded_sequence before GRU.

Solution

1. Step 1: Understand variable-length sequence handling

   GRU requires fixed-length inputs or packed sequences to handle variable lengths efficiently.

2. Step 2: Use padding and packing for variable-length inputs

   Padding sequences to max length and using pack_padded_sequence lets GRU ignore padded parts during processing.

3. Final Answer:

   Pad all sequences to the same length and use pack_padded_sequence before GRU. -> Option D

4. Quick Check:

   Padding + pack_padded_sequence = D [OK]

Hint: Pad sequences and pack before GRU for variable lengths [OK]

Common Mistakes:

• Truncating sequences too short loses info
• Feeding raw variable-length sequences causes errors
• Switching to CNN ignores GRU benefits