Practice Questions with Worked Solutions

The distinction that earns the marks: lexical ambiguity gives one structure and several meanings; structural ambiguity gives unambiguous words and several groupings; contextual ambiguity leaves both fixed and the meaning still undetermined.

Verified: 03_ambiguity_tokenize.py reports 18 WordNet senses for "bank" and finds exactly 2 parses for the telescope sentence.

"man" is the verb (to man, to staff) and "the old" is the subject — a nominalised adjective meaning "old people".

[The old]ₙₚ [man the boats]ᵥₚ — "Old people staff the boats."

It is a garden-path sentence: the reader commits early to the old man as a noun phrase and cannot cheaply revise. A parser fails for the same reason you do.

* is greedy: it consumes as much as possible and gives back only what it must. *? is lazy: it consumes as little as possible.

On <b>bold</b> and <i>italic</i>:

One character, completely different behaviour — and the most common cause of a regex that "works on one example".

Verified: 01_setup_regex.py.

\w matches [A-Za-z0-9_] only — not . or -. So the match starts after the dot in asha. and stops at the dot in .ac.

Fix:

r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"

Why this bug survives into production: the output is still a list of plausible-looking email addresses. Nothing raises an error, and the failure is only visible if you compare against ground truth — which is why 01_setup_regex.py scores its patterns rather than printing them.

Abbreviations contain full stops that do not end sentences — Dr., U.S.A., p.m., Rs., B.Sc., decimal points, ellipses.

The lab measures it:

The right tool is a trained tokeniser (nltk.sent_tokenize, spaCy) which has learned which full stops are terminal. A regex is right for a pattern you can write down; sentence boundaries are not one.

1. ran → Porter leaves it. A stemmer chops suffixes and ran has none; the change is internal. A lemmatiser looks it up in WordNet.

2. better → good requires a dictionary of irregular forms. No amount of string surgery finds it.

3. university and universal collapse to one stem — two unrelated words become one feature. That is over-stemming, a genuine precision loss.

Verified: 03_ambiguity_tokenize.py.

WordNetLemmatizer.lemmatize() defaults to POS = noun. Asked for the singular of the noun was, it applied the plural rule and stripped the s, producing a string that is not an English word at all.

lemmatize("was", "v") returns be, which is correct.

This is the most common silent mistake in NLP coursework. Every tutorial that calls lemmatize(w) without a tag is asking the wrong question of every verb in the text. Tag first, then lemmatise.

It also qualifies the usual claim: "lemmatization always returns a real word" is only true when the tag is right.

Left recursion. To parse an NP, recursive descent applies the rule and must first parse an NP, which applies the rule again… it recurses without consuming any input and never terminates.

The answer is "left recursion", not "ambiguity" — which is the trap in this question.

Fix by rewriting: NP -> N NP', NP' -> PP NP' | ε.

Requires Chomsky Normal Form — every rule is A → B C or A → w.

for i in 0..n-1:                       # length-1 spans
    table[i][i+1] = {A : A -> w_i}

for length in 2..n:
    for i in 0..n-length:
        j = i + length
        for k in i+1..j-1:             # every split point
            for each rule A -> B C:
                if B in table[i][k] and C in table[k][j]:
                    add A to table[i][j]

accept if S in table[0][n]

Complexity: three nested loops over length, i and k give O(n³), times the grammar size, so O(n³·|G|). Space is O(n²).

It finds all parses, because a cell holds every non-terminal deriving that span — which is what makes it dynamic programming rather than search.

Domain shift. en_core_web_sm was trained on OntoNotes, which is mostly American news. Indian state names are rare in it, so the model has no learned representation and falls back on surface cues — Tamil Nadu has the shape of a two-token personal name.

The cities were correct, which localises the failure: the model has seen major Indian cities and not the states.

The lab adds nine lines of EntityRuler patterns and recovers the wrong labels.

The model is not broken. It is being used outside its training distribution, and the errors are systematic rather than random — which means they are predictable and fixable. A bigger model is not the answer.

Documents 0 and 2 are paraphrases — "the model learns weights from the training data by gradient descent" and "parameters are fitted to observations by iteratively minimising a loss". They share almost no strings.

Documents 0 and 3 (about the monsoon) share the, and, are — function words and nothing else.

The similarity is entirely an artefact of English grammar. A representation that ranks by function words is not measuring meaning.

TF-IDF narrows the gap (0.0766 vs 0.1802) because IDF discounts words that appear in every document — but it does not reverse the ordering, and no count-based representation can. weights and parameters are different strings and nothing in the counts says otherwise.

This is exactly the failure word embeddings were invented for.

Verified: 07_parsing_ner_similarity.py.

Remember by direction: CBOW collapses context into a word; skip-gram fans a word out into its context.

Why skip-gram is better on rare words: each occurrence generates several training pairs (one per context word), so a word seen five times still produces meaningful gradient. CBOW averages the context and a rare centre word contributes to only one prediction.

The naive objective requires a softmax over the whole vocabulary at every training step — hundreds of thousands of exponentials per example, which is computationally impossible at corpus scale.

Negative sampling replaces it with a binary task: for each true (word, context) pair, draw k random "negative" pairs and train a classifier to tell them apart.

Negatives are drawn from the unigram distribution raised to the 3/4 power, which up-samples rare words relative to their frequency.

The one-line answer: the full softmax over the vocabulary is computationally impossible.

That the models are indistinguishable on this data, and that no ranking among them is defensible.

Only the gap to the baseline is far outside the spread.

This is the finding most lab reports get wrong. They rank six models on a single train/test split and declare a winner that a different random seed would reverse. A single split gives you one draw from the distribution whose width the cross-validation is measuring.

The correct report: "all six models reach roughly 0.82, indistinguishable within a fold spread of 0.0075, against a 0.50 baseline."

Verified: 10_sentiment_rnn.py.

The general principle: every preprocessing step discards information, and you must be able to say what it discards and for whom that matters. "It is standard practice" is not an answer.

A CNN over text is an n-gram detector with learned filters. That is genuinely useful for sentiment — where a few key phrases decide the label — which is why CNNs stayed competitive on sentiment long after RNNs won elsewhere.

Sentiment in a real review is redundant. "Terrible", "waste", "boring" and "awful" may all appear in one paragraph, so a weaker model that catches any one of them still classifies correctly.

The constructed dataset had exactly one decisive word per sentence and no redundancy, so missing it meant getting the example wrong.

Both numbers are real and they measure different things. Redundancy in real data masks differences between models — a general fact about benchmarking, not a fact about LSTMs. Reporting only the flattering number would be dishonest.

Verified: Neural Networks and Deep Learning's 09_rnn_lstm.py.

Perplexity = exp(cross-entropy loss), and it reads as "the model is as uncertain as if it were choosing uniformly among this many options".

Uniform guessing over an alphabet of size V gives perplexity V.

The lab's character model on Austen: 47 distinct characters, so 47 is the baseline. Perplexity fell from ~6.5 to ~2.7 — the model is effectively choosing among fewer than three characters.

Why perplexity rather than loss: the number means something on its own, against a baseline anyone can compute.

The masking is the entire architectural difference — both are stacks of the same block.

Why BERT cannot generate: it sees the whole sentence at once, so there is no "next" token in its objective.

Why GPT cannot use right context: its attention is causally masked so position t cannot attend past itself — which is what makes generation coherent.

The dot product of two random d_k-dimensional vectors has standard deviation growing as √d_k. Feed those raw scores to a softmax at large d_k and one weight approaches 1 while the rest approach 0 — the softmax saturates, its gradient vanishes, and the model stops learning.

The third column is the point: dividing by √d_k holds the score variance at 1 whatever the dimension.

Verified: Neural Networks and Deep Learning's 11_attention.py.

15% of tokens are picked. Of those:

Why the last two rows exist: [MASK] never appears at fine-tuning or inference time. If every masked position carried the literal [MASK] token, the model would learn "produce a good prediction only where I see [MASK]" and build no useful representation of any other position. The random and unchanged cases force a good representation everywhere.

Why 15%: too low and most positions supply no signal, so training is slow; too high and there is not enough context left to predict from. It is a tuned hyperparameter, not a law, and later work has questioned it.

The mask is in the same position in both. The disambiguating evidence is entirely to its RIGHT.

A left-to-right model cannot see it. Only a bidirectional model can, and masked-LM training is possible only when the model may look both ways — which is why BERT is an encoder.

Word2Vec cannot do this at all: it assigns bank one vector, for ever, and WordNet lists 18 senses for the word.

Why regulated domains stay extractive: abstractive models hallucinate — they produce text that is probable, not text that is supported.

An extractive summary of a medical report is at worst badly chosen; an abstractive one can state a dosage that appears nowhere in the source. That is the argument, and it is not hypothetical.

The check to run: for every noun phrase, number and date in the generated summary, search the source. Anything not there is a hallucination. Report the count — it is worth more than any ROUGE score, which only measures overlap and rewards copying.

Because news is deliberately front-loaded — the inverted pyramid puts the key facts in the first sentences — so "take the first three sentences" is a genuinely strong summarizer, and it is free.

The lab's measurement on a 22-sentence Reuters article: TextRank picked sentences 1, 3, 14; lead-3 picked 0, 1, 2 — they agree on one of three.

Many published systems beat lead-3 by very little. If your method cannot beat it, say so — that is a result about the data, and omitting the baseline is the most common flaw in summarization reports.

That on this FAQ there is nothing for a transformer to improve, and a report claiming embeddings were necessary would be wrong.

Why character n-grams win: exams and examination share the substrings exam, xam. Character n-grams recover much of the morphological robustness people reach for embeddings to get, at roughly zero cost.

The word-level failure is the instructive part:

An exact tie, broken by list order, and both matches came only from the function words are, the, when. Neither had anything to do with meaning.

Embeddings help when entries share vocabulary, queries paraphrase without sharing strings, or the FAQ grows large enough that keyword collisions become common. Report the baseline and let the numbers decide.

argmax always returns something. There is no "none of these" option in a maximum.

The lab asks "what is the wifi password", which is not in the FAQ, and the bot returns its nearest entry at similarity 0.3561 — confidently and wrongly.

The fix: compare the top similarity against a threshold and return "I don't know" below it. Tune the threshold on queries you know should fail.

A bot that says "I don't know" 20% of the time is useful. A bot that is confidently wrong 20% of the time is worse than no bot. The metric to report is the false-answer rate, not accuracy.