Limitations of classical methods in NLP - Model Metrics & Evaluation

Metrics & Evaluation - Limitations of classical methods

Which metric matters and WHY

For classical methods in NLP, metrics like accuracy, precision, and recall are important to understand how well the model handles language tasks. However, these methods often struggle with complex language patterns, so metrics alone may not tell the full story. We also look at F1 score to balance precision and recall, especially when classes are uneven.

Confusion matrix example

      Actual \ Predicted | Positive | Negative
      -------------------|----------|---------
      Positive           |    40    |   10
      Negative           |    15    |   35

      Total samples = 100
    

From this matrix, we calculate:

• Precision = 40 / (40 + 15) = 0.727
• Recall = 40 / (40 + 10) = 0.8
• F1 Score = 2 * (0.727 * 0.8) / (0.727 + 0.8) ≈ 0.761

Precision vs Recall tradeoff with examples

Classical NLP methods often face a tradeoff:

• High Precision: The model is very sure about its positive predictions but may miss some true positives. Useful when false alarms are costly, like spam filters.
• High Recall: The model finds most true positives but may include more false positives. Important in tasks like medical text analysis where missing key info is bad.

Classical methods may not balance this well because they rely on fixed rules or simple statistics, missing nuances in language.

Good vs Bad metric values for classical NLP methods

Good: Precision and recall above 0.7 show the model is fairly reliable on simple tasks.

Bad: Precision or recall below 0.5 means the model often misclassifies or misses important cases, common in complex language understanding.

Accuracy can be misleading if classes are imbalanced, so always check precision and recall.

Common pitfalls in metrics for classical methods

• Accuracy paradox: High accuracy but poor recall on minority classes.
• Data leakage: Using test data features during training inflates metrics falsely.
• Overfitting: Classical methods may memorize training data patterns, showing high training metrics but poor real-world performance.
• Ignoring context: Metrics may look okay but models fail on nuanced language, which metrics alone can't reveal.

Self-check question

Your classical NLP model has 98% accuracy but only 12% recall on detecting rare entities. Is it good for production? Why or why not?

Answer: No, it is not good. The low recall means the model misses most rare entities, which could be critical. High accuracy is misleading here because the rare entities are few, so the model mostly predicts the common class correctly but fails on important cases.

Key Result

Classical NLP methods often show decent accuracy but can have low recall and precision on complex tasks, limiting their usefulness.

Practice

1. Which of the following is a main limitation of classical NLP methods like bag-of-words?

easy

A. They ignore the order and context of words in a sentence.

B. They require very large datasets to work.

C. They always need deep neural networks to function.

D. They can understand sarcasm and irony easily.

Solution

1. Step 1: Understand classical NLP methods

   Classical methods like bag-of-words treat text as a collection of words without order or context.

2. Step 2: Identify the limitation

   This means they cannot capture meaning that depends on word order or surrounding words.

3. Final Answer:

   They ignore the order and context of words in a sentence. -> Option A

4. Quick Check:

   Classical methods miss context = C [OK]

Hint: Remember bag-of-words loses word order and context [OK]

Common Mistakes:

• Thinking classical methods need big data
• Believing classical methods use deep learning
• Assuming classical methods understand sarcasm

2. Which syntax correctly represents a classical method feature extraction for text using bag-of-words in Python?

easy

A. import spacy
nlp = spacy.load('en_core_web_sm')
doc = nlp(text)

B. import tensorflow as tf
model = tf.keras.Sequential()

C. from nltk.tokenize import word_tokenize
words = word_tokenize(text)

D. from sklearn.feature_extraction.text import CountVectorizer
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(texts)

Solution

1. Step 1: Identify classical method for feature extraction

   Bag-of-words uses CountVectorizer from sklearn to convert text to word counts.

2. Step 2: Match syntax to bag-of-words

   from sklearn.feature_extraction.text import CountVectorizer vectorizer = CountVectorizer() X = vectorizer.fit_transform(texts) shows correct import and usage of CountVectorizer for feature extraction.

3. Final Answer:

   from sklearn.feature_extraction.text import CountVectorizer vectorizer = CountVectorizer() X = vectorizer.fit_transform(texts) -> Option D

4. Quick Check:

   CountVectorizer syntax = A [OK]

Hint: CountVectorizer is sklearn's bag-of-words tool [OK]

Common Mistakes:

• Confusing tokenization with feature extraction
• Using deep learning imports for classical methods
• Mixing spaCy usage with bag-of-words

3. Given this code using bag-of-words, what is the shape of the output matrix X if texts = ['I love AI', 'love AI']?

medium

A. (2, 4)

B. (3, 2)

C. (2, 3)

D. (4, 2)

Solution

1. Step 1: Count unique words in texts

   Texts are ['I love AI', 'love AI']. Lowercased tokens: 'i love ai', 'love ai'. Unique tokens: 'ai', 'i', 'love' = 3 words.

2. Step 2: Check CountVectorizer default behavior

   CountVectorizer lowercases and tokenizes. Number of samples is 2. So shape is (2, 3).

3. Final Answer:

   (2, 3) -> Option C

4. Quick Check:

   2 samples, 3 features = B [OK]

Hint: Count unique words for shape: rows=samples, cols=unique words [OK]

Common Mistakes:

• Counting words instead of unique tokens
• Mixing rows and columns in shape
• Ignoring case sensitivity

4. Identify the error in this classical NLP code snippet using CountVectorizer:

from sklearn.feature_extraction.text import CountVectorizer
texts = ['Hello world', 'Hello']
vectorizer = CountVectorizer()
X = vectorizer.fit(texts)
print(X.toarray())

medium

A. fit() should be fit_transform() to get the matrix.

B. CountVectorizer cannot process lists of strings.

C. toarray() is not a method of the output.

D. Missing import for numpy.

Solution

1. Step 1: Check CountVectorizer usage

   fit() learns the vocabulary but does not transform texts to matrix. fit_transform() does both.

2. Step 2: Identify correct method to get matrix

   To get the document-term matrix, fit_transform() must be used. Using fit() alone returns the vectorizer object, which has no toarray() method.

3. Final Answer:

   fit() should be fit_transform() to get the matrix. -> Option A

4. Quick Check:

   fit_transform() needed for matrix [OK]

Hint: Use fit_transform() to get matrix, not just fit() [OK]

Common Mistakes:

• Using fit() instead of fit_transform()
• Assuming toarray() works on vectorizer
• Thinking CountVectorizer needs numpy import

5. Why might classical NLP methods like bag-of-words fail on sentiment analysis of complex sentences such as 'I don't think this movie was good'?

hard

A. They cannot tokenize contractions like "don't".

B. They treat words independently and miss negation and word order.

C. They always overfit on small datasets.

D. They require GPU acceleration to process negations.

Solution

1. Step 1: Understand classical method limitations

   Bag-of-words treats each word separately, ignoring order and context.

2. Step 2: Analyze sentence complexity

   Sentence has negation "don't" which flips sentiment. Without context, model may misinterpret sentiment.

3. Step 3: Identify why classical methods fail

   Because they ignore word order and negation, they fail to capture true sentiment.

4. Final Answer:

   They treat words independently and miss negation and word order. -> Option B

5. Quick Check:

   Miss negation and order = D [OK]

Hint: Negation needs context; classical methods miss it [OK]

Common Mistakes:

• Thinking classical methods need GPUs
• Believing classical methods can't tokenize contractions
• Confusing overfitting with context loss