Text classification model in TensorFlow - Model Metrics & Evaluation

Metrics & Evaluation - Text classification model

Which metric matters for Text Classification and WHY

For text classification, the main metrics to check are accuracy, precision, recall, and F1 score. Accuracy tells us how many texts were correctly labeled overall. Precision shows how many predicted labels were actually correct. Recall tells us how many real labels the model found. F1 score balances precision and recall, which is important when classes are uneven or mistakes have different costs.

Confusion Matrix Example

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

      Total samples = 80 + 20 + 10 + 90 = 200

      Precision = TP / (TP + FP) = 80 / (80 + 10) = 0.89
      Recall = TP / (TP + FN) = 80 / (80 + 20) = 0.80
      Accuracy = (TP + TN) / Total = (80 + 90) / 200 = 0.85
      F1 Score = 2 * (Precision * Recall) / (Precision + Recall) = 2 * (0.89 * 0.80) / (0.89 + 0.80) ≈ 0.84
    

Precision vs Recall Tradeoff with Examples

Imagine a spam email filter:

• High Precision: Most emails marked as spam really are spam. This avoids losing important emails.
• High Recall: Most spam emails are caught, but some good emails might be wrongly marked as spam.

For spam filters, high precision is often more important to avoid missing good emails.

For medical text classification (e.g., detecting disease mentions), high recall is critical to catch all relevant cases, even if some false alarms happen.

Good vs Bad Metric Values for Text Classification

• Good: Accuracy above 85%, Precision and Recall above 80%, F1 score balanced and high.
• Bad: Accuracy high but recall very low (missing many true cases), or precision very low (many false alarms).
• Balanced metrics are better than just one high metric.

Common Metrics Pitfalls

• Accuracy Paradox: High accuracy can be misleading if classes are imbalanced (e.g., 95% accuracy by always predicting the majority class).
• Data Leakage: If test data leaks into training, metrics look unrealistically good.
• Overfitting: Very high training accuracy but low test accuracy means the model memorizes instead of learning.
• Ignoring Class Imbalance: Not using precision, recall, or F1 when classes are uneven hides poor performance on minority classes.

Self Check

Your text classification model has 98% accuracy but only 12% recall on the important class. Is it good for production?

Answer: No. The model misses 88% of the important cases, which is usually unacceptable. High accuracy alone is misleading if the important class is rare. You should improve recall to catch more true cases.

Key Result

For text classification, balanced precision and recall with a good F1 score are key to reliable model performance.

Practice

1. What is the main purpose of a text classification model in TensorFlow?

easy

A. To sort text into different categories based on content

B. To generate new text from a given input

C. To translate text from one language to another

D. To detect objects in images

Solution

1. Step 1: Understand the task of text classification

   Text classification means assigning labels or categories to text data based on its content.

2. Step 2: Match the task to the options

   To sort text into different categories based on content describes sorting text into categories, which matches text classification.

3. Final Answer:

   To sort text into different categories based on content -> Option A

4. Quick Check:

   Text classification = sorting text [OK]

Hint: Text classification means sorting text into groups [OK]

Common Mistakes:

• Confusing classification with text generation
• Thinking classification is for images
• Mixing up translation with classification

2. Which of the following is the correct way to add an embedding layer in a TensorFlow Sequential model for text classification?

easy

A. model.add(tf.keras.layers.Dense(64, input_dim=1000))

B. model.add(tf.keras.layers.Conv2D(64, kernel_size=3))

C. model.add(tf.keras.layers.Embedding(input_dim=1000, output_dim=64))

D. model.add(tf.keras.layers.LSTM(64, input_shape=(1000,)))

Solution

1. Step 1: Identify the embedding layer syntax

   The embedding layer in TensorFlow is added with tf.keras.layers.Embedding and requires input_dim and output_dim parameters.

2. Step 2: Check each option

   model.add(tf.keras.layers.Embedding(input_dim=1000, output_dim=64)) correctly uses Embedding with input_dim=1000 and output_dim=64. Others use Dense, Conv2D, or LSTM which are not embedding layers.

3. Final Answer:

   model.add(tf.keras.layers.Embedding(input_dim=1000, output_dim=64)) -> Option C

4. Quick Check:

   Embedding layer uses tf.keras.layers.Embedding [OK]

Hint: Embedding layer uses tf.keras.layers.Embedding with input/output dims [OK]

Common Mistakes:

• Using Dense or Conv2D instead of Embedding
• Missing input_dim or output_dim parameters
• Confusing LSTM with embedding layer

3. Given the following TensorFlow model code for text classification, what will be the shape of the output layer's predictions for a batch of 32 samples if there are 5 classes?

model = tf.keras.Sequential([
  tf.keras.layers.Embedding(input_dim=1000, output_dim=16, input_length=10),
  tf.keras.layers.GlobalAveragePooling1D(),
  tf.keras.layers.Dense(5, activation='softmax')
])

predictions = model(tf.random.uniform((32, 10), maxval=1000, dtype=tf.int32))

medium

A. (10, 5)

B. (32, 5)

C. (32, 10)

D. (5, 32)

Solution

1. Step 1: Analyze model output layer

   The last Dense layer has 5 units with softmax, so output shape per sample is (5,).

2. Step 2: Consider batch size

   Input batch size is 32, so output shape is (32, 5).

3. Final Answer:

   (32, 5) -> Option B

4. Quick Check:

   Batch size 32 x 5 classes = (32, 5) [OK]

Hint: Output shape = (batch size, number of classes) [OK]

Common Mistakes:

• Confusing sequence length with batch size
• Mixing up input and output shapes
• Ignoring batch dimension in output

4. You wrote this TensorFlow model for text classification but get a shape error during training:

model = tf.keras.Sequential([
  tf.keras.layers.Embedding(input_dim=5000, output_dim=32),
  tf.keras.layers.Dense(10, activation='relu'),
  tf.keras.layers.Dense(3, activation='softmax')
])

What is the likely cause of the error?

medium

A. Dense layers cannot follow Embedding layers

B. Using wrong activation function in the last layer

C. input_dim in Embedding is too small

D. Missing a Flatten or GlobalAveragePooling1D layer after Embedding

Solution

1. Step 1: Understand Embedding output shape

   Embedding outputs 3D tensor (batch, sequence_length, embedding_dim). Dense expects 2D input.

2. Step 2: Identify missing layer

   Without Flatten or GlobalAveragePooling1D, Dense layer gets wrong input shape causing error.

3. Final Answer:

   Missing a Flatten or GlobalAveragePooling1D layer after Embedding -> Option D

4. Quick Check:

   Embedding output must be flattened before Dense [OK]

Hint: Add pooling or flatten after Embedding before Dense layers [OK]

Common Mistakes:

• Assuming Dense accepts 3D input
• Changing activation won't fix shape error
• Believing Dense can't follow Embedding at all

5. You want to build a text classification model in TensorFlow that handles variable-length input sentences and classifies them into 4 categories. Which model design is best?

hard

A. Use Embedding layer, GlobalAveragePooling1D, then Dense with 4 units and softmax activation

B. Use Embedding layer, Flatten, then Dense with 4 units and sigmoid activation

C. Use Embedding layer, Conv2D, then Dense with 1 unit and softmax activation

D. Use Dense layers only without Embedding

Solution

1. Step 1: Handle variable-length input

   GlobalAveragePooling1D can convert variable-length sequences to fixed-size vectors.

2. Step 2: Choose output layer for multi-class classification

   Dense with 4 units and softmax activation outputs probabilities for 4 classes.

3. Final Answer:

   Use Embedding layer, GlobalAveragePooling1D, then Dense with 4 units and softmax activation -> Option A

4. Quick Check:

   Pooling + softmax = best for variable-length multi-class [OK]

Hint: Use pooling + softmax for variable-length multi-class text [OK]

Common Mistakes:

• Using Flatten breaks variable-length input handling
• Using sigmoid for multi-class instead of softmax
• Using Conv2D for text sequences incorrectly