Natural Language Processing · Practice tests · Updated November 2026
A Natural Language Processing (NLP) practice test checks how well you understand the way computers process text: preprocessing, tokenization, TF-IDF, word embeddings, transformers, large language models (LLMs), retrieval-augmented generation (RAG) and evaluation metrics such as BLEU, ROUGE and perplexity. There is no single official NLP certification, so a good practice test is built on the official documentation of tools such as NLTK, scikit-learn and Hugging Face Transformers. The Exametics NLP question bank has 3 tests and 120 questions, rebuilt in November 2026 to replace outdated items such as the deprecated Keras Tokenizer. This guide covers the topics, a 2–3 week plan and 10 free NLP practice questions with answers.
At a glance
| Topic | Natural language processing (NLP) |
| Official NLP certification | None: no single official exam |
| NLTK | 3.10.4 (21 October 2026), Python 3.10 to 3.14 |
| Hugging Face Transformers | 5.22.2 (6 November 2026) |
| Keras Tokenizer | Deprecated (TensorFlow API docs) |
| Exametics set | 3 practice tests, 120 questions |
- Expect concept questions on why a method works, not only what it is called.
- Classic methods (stemming, TF-IDF, word2vec) still appear next to transformers, LLMs and RAG.
Source: NLTK on PyPI, Transformers on PyPI and the TensorFlow API page for the Keras Tokenizer. Checked on 9 November 2026.
What a good NLP practice test covers
A good NLP practice test covers the whole text pipeline: cleaning text, turning it into numbers, modelling it with transformers and LLMs, grounding answers with retrieval, and measuring the results.
Text preprocessing and classic representation
The NLTK stemming guide says stemmers “remove morphological affixes from words, leaving only the word stem”. Its Porter stemmer example turns “flies” into “fli” and “denied” into “deni”, which shows that a stem does not have to be a real word.
A lemmatizer is different: it returns the base form of the word. The NLTK WordNet lemmatizer documentation shows that lemmatize() treats the word as a noun unless you pass another part of speech, and turns “dogs” into “dog”.
Classic representation means bag-of-words and TF-IDF. The scikit-learn TfidfVectorizer documentation describes it as equivalent to CountVectorizer followed by TfidfTransformer. Questions often hinge on its defaults:
- Lowercase: on by default, so “NLP” and “nlp” become the same token.
- Token pattern: keeps only tokens of 2 or more alphanumeric characters, so single-character words such as “I” and “a” are dropped.
- N-grams: single words only, because
ngram_rangedefaults to (1, 1). - Weighting: smoothed IDF and L2 normalization are on; sublinear TF scaling is off.
Tokenization and word embeddings
The Hugging Face tokenization guide names three subword algorithms in Transformers: byte pair encoding (BPE), Unigram and WordPiece. Subwords let a model represent unseen words from pieces it knows.
BPE starts from characters and keeps merging the most frequent adjacent pair. WordPiece, used by BERT-family models, picks the merge that most increases the likelihood of the training data. Unigram starts large and removes the tokens that matter least.
Embeddings turn tokens into dense vectors. The TensorFlow word2vec tutorial explains the two classic word2vec models. Continuous bag-of-words predicts the middle word from the words around it. Continuous skip-gram does the opposite: it predicts the words before and after the current word.
Transformers and large language models
The paper Attention Is All You Need (2017) describes a model “based solely on attention mechanisms, dispensing with recurrence and convolutions entirely”. Know scaled dot-product attention, multi-head attention, positional encodings and the decoder mask.
Positional encodings are added because, with no recurrence, the model has no other way to know word order. The decoder mask stops each position seeing later ones.
The Hugging Face LLM course sorts transformer models into three families, and many questions ask you to match a task to one of them:
| Model family | Example models | Best suited to |
|---|---|---|
| Encoder-only | BERT, DistilBERT, ModernBERT | Understanding the whole sentence: classification, named entity recognition, extractive question answering |
| Decoder-only | Llama, Gemma, SmolLM | Text generation |
| Encoder-decoder | BART, T5, Marian | Generating new text from an input: summarization, translation |
The BERT paper shows why encoders suit understanding tasks: BERT conditions on both left and right context. The Transformers generation guide says greedy search is the default strategy, sampling is turned on with do_sample=True, and beam search needs num_beams greater than 1.
Retrieval-augmented generation and evaluation metrics
The original RAG paper (Lewis and others, 2020) combines a “parametric memory”, a pre-trained sequence-to-sequence model, with a “non-parametric memory”, a dense vector index of Wikipedia. In practice: retrieve relevant passages, then generate an answer from them.
Evaluation questions check that you pick and read the right metric. The 2002 BLEU paper (PDF), the 2004 ROUGE paper (PDF) and the Hugging Face perplexity guide define the three you meet most:
| Metric | What it measures | Watch for |
|---|---|---|
| BLEU | Geometric mean of clipped n-gram precisions, usually up to 4-grams, multiplied by a brevity penalty | Precision-based; scores range from 0 to 1 |
| ROUGE (Recall-Oriented Understudy for Gisting Evaluation) | Overlapping n-grams, word sequences and word pairs against human-written summaries | Recall-oriented; built for summaries |
| Perplexity | Exponentiated average negative log-likelihood of a sequence; lower is better | Causal language models only; not well defined for masked models such as BERT |
Exametics practice tests
NLP Practice Tests: 3 tests, 120 questions
- 3 practice tests of 40 questions each, including a timed Exam Mode test
- Every answer explained, with a hint for each question
- Each question tagged with one of nine topic areas, from tokenization and embeddings to transformers, LLMs, RAG and evaluation metrics
- Rebuilt in November 2026: answer keys checked, outdated items such as the deprecated Keras Tokenizer replaced, code run with current NLTK and scikit-learn
- Lifetime access
30-day refund. Instant access after payment.
Who these NLP practice tests are for
These NLP practice tests are for aspiring NLP engineers, data scientists, students and developers preparing for an interview, a course exam or a project. They are a knowledge and interview-preparation bank, not a copy of any vendor exam.
Students and junior developers
If you are new to NLP, expect the basics to carry most marks: tokenization, stemming versus lemmatization, stop words, bag-of-words and TF-IDF. If your Python is still shaky, our Python interview preparation guide covers the language skills NLP code depends on.
Data scientists and mid-level engineers
At this level, questions move to embeddings, subword tokenizers, fine-tuning pre-trained models and choosing between encoder, decoder and encoder-decoder models. You should also be comfortable picking a metric for a task, such as ROUGE for summaries or perplexity for a causal language model. Our data scientist certification study guide shows where NLP fits in a wider data science skill set.
Senior and LLM-focused roles
Senior candidates are expected to explain trade-offs. Why use RAG instead of fine-tuning to add new facts? Why is a perplexity comparison unfair when two models use different tokenizers? Explained practice questions help you put these trade-offs into words.
Is there an official NLP certification?
No single official certification covers NLP on its own. The nearest vendor exam on Exametics is NVIDIA’s Generative AI LLMs associate exam (NCA-GENL), which focuses on LLMs and lists “Python natural language packages (spaCy, NumPy, vector databases, etc.)” among its topics.
| Item | NVIDIA NCA-GENL |
|---|---|
| Level | Associate (entry level) |
| Questions and time | 50–60 multiple-choice questions in 1 hour |
| Fee | US$125 |
| Validity | Two years; recertify by retaking the exam |
| Passing score | Not published on the exam page |
Source: NVIDIA Generative AI LLMs certification page. Checked on 9 November 2026.
Our NCA-GENL exam guide covers that exam in detail. If you want broader grounding first, our machine learning certification guide explains the core concepts that NLP builds on.
Next on your NLP path
- Machine Learning Fundamentals practice tests: firm up training, validation and overfitting, which every NLP model relies on.
- Generative AI Interview Prep practice tests: go deeper on LLMs, prompting and RAG for interviews.
- NVIDIA NCA-GENL practice tests: the next step if you want a vendor certification in LLMs.
How to prepare for an NLP practice test in 2–3 weeks
Two to three weeks is enough to review NLP if you already write Python. Work through one part of the pipeline at a time and save timed practice for the end. Before you start, try the 10 free practice questions below to find your weakest topics.
- Days 1–4: Preprocessing and classic representation Compare a stemmer and a lemmatizer on the same words. Build a TF-IDF matrix with scikit-learn, then change the token pattern and n-gram range.
- Days 5–8: Tokenizers and embeddings Tokenize rare words with a BPE and a WordPiece tokenizer. Learn how CBOW and skip-gram differ.
- Days 9–12: Transformers and LLMs Work through scaled dot-product attention on paper. Match tasks to model families, and generate text with greedy search, sampling and beam search.
- Days 13–16: RAG and evaluation Build a tiny RAG pipeline: embed documents, retrieve the top passages and pass them to a model. Score outputs with BLEU or ROUGE.
- Days 17–21: Timed practice and review Take the NLP practice tests, including the timed Exam Mode test. Read every explanation, even for questions you got right.
Tip
Check that your study material is current. If a tutorial imports keras.preprocessing.text.Tokenizer, it uses an API that TensorFlow now marks as deprecated; learn the TextVectorization layer, which the Keras TextVectorization documentation describes as a layer that maps text features to integer sequences.
Planning more than one exam?
NLP often sits next to machine learning and generative AI in job descriptions. The All-Access Pass covers every practice test on Exametics, including new exams as they are added, with lifetime access. It costs less than buying about six single practice tests.
Free NLP practice questions (10 with answers)
Try these 10 free NLP practice questions before you open the answers. They are original sample questions spread across the main topic areas, at mixed difficulty. The full Exametics question bank has 120 more in the same style, each with a hint.
Practice question 1 · Text preprocessing
NLTK’s Porter stemmer turns “flies” into “fli”. Which statement best explains the difference between stemming and lemmatization?
- A. Stemming uses a dictionary, while lemmatization uses suffix rules
- B. Stemming strips affixes by rule, so the stem need not be a real word; lemmatization returns the word’s base dictionary form
- C. Stemming and lemmatization always give the same output for English nouns
- D. Lemmatization removes stop words, while stemming lowercases text
Show answer
Answer: B. A stemmer removes affixes using rules, which is why “flies” becomes “fli”, a string that is not a word. A lemmatizer returns the lemma, the base form of the word: NLTK’s WordNet lemmatizer, for example, turns “dogs” into “dog”.
A is wrong because it reverses the two: the lemmatizer is the one that looks words up, for example in WordNet. C is wrong because the “flies” example already gives different outputs. D is wrong because removing stop words and lowercasing are separate preprocessing steps.
Practice question 2 · Tokenization
Why can a byte-level BPE tokenizer, such as the one GPT-2 uses, tokenize any input text without an unknown (<unk>) token?
- A. It stores every word in the training data as a single token
- B. It replaces rare words with the most similar known word
- C. It lowercases and strips accents before tokenizing
- D. Its base vocabulary is the 256 possible byte values, so any text can be built from them
Show answer
Answer: D. Byte-level BPE starts from the 256 byte values instead of all Unicode characters. Any text is a sequence of bytes, so the worst case is a word split into single bytes, never an unknown token.
A describes word-level tokenization, which is exactly the approach that does need an unknown token. B is wrong because BPE does not substitute words; it splits them into known pieces. C is wrong because lowercasing and stripping accents do not by themselves guarantee that every character is in the vocabulary.
Practice question 3 · Text representation
You fit scikit-learn’s TfidfVectorizer(), with every setting left at its default, on the single document "I love NLP". What does get_feature_names_out() return?
- A.
['I', 'love', 'NLP'] - B.
['i', 'love', 'nlp'] - C.
['love', 'nlp'] - D.
['love', 'NLP']
Show answer
Answer: C. By default the vectorizer lowercases text, and its token pattern keeps only tokens of two or more alphanumeric characters, so “I” is dropped. The vocabulary is returned in alphabetical order: love, nlp.
A is wrong on two counts: text is lowercased and single-character tokens are dropped. B keeps “i”, which the default token pattern discards. D keeps the capital letters, but lowercase is on by default.
Practice question 4 · Word embeddings
In word2vec, which description matches the continuous skip-gram model?
- A. It predicts the words before and after the current word, within a set window
- B. It predicts the middle word from the surrounding context words
- C. It counts how often each word appears in each document
- D. It predicts a masked word using a bidirectional transformer
Show answer
Answer: A. Skip-gram takes the current word and predicts the context words within a certain range around it.
B describes continuous bag-of-words (CBOW), the other word2vec model. C describes a count-based bag-of-words matrix, not a learned embedding. D describes masked language modelling, the pre-training task used by BERT, not word2vec.
Practice question 5 · Transformers and attention
In scaled dot-product attention, softmax(QKT / √dk)V, why are the dot products divided by √dk?
- A. To make the attention weights for each query sum to 1
- B. To stop each position from attending to later positions
- C. To keep the dot products from growing so large that the softmax has extremely small gradients
- D. To add information about the position of each token
Show answer
Answer: C. With large key dimensions, dot products grow large in magnitude and push the softmax into regions where its gradients are tiny. Dividing by the square root of dk counters this, as the original transformer paper explains.
A is wrong because the softmax already makes the weights sum to 1, scaled or not. B describes the decoder mask, which sets future positions to minus infinity before the softmax. D describes positional encodings, which are added to the input embeddings.
Practice question 6 · Pre-trained models
You need to tag people, organizations and places in support tickets (named entity recognition). Which model family is the usual fit?
- A. A decoder-only model, because it generates text one token at a time
- B. An encoder-only model such as BERT, because it builds a representation of each token using the whole sentence
- C. An encoder-decoder model such as T5, because NER is a translation task
- D. A word2vec model on its own, because each word has one fixed vector
Show answer
Answer: B. Encoder-only models suit tasks that need an understanding of the full sentence, including NER, and BERT is pre-trained to use both left and right context for every token.
A is wrong because decoder-only models are best suited to text generation and see only earlier tokens. C is wrong because NER labels existing tokens; encoder-decoder models suit tasks such as summarization and translation. D is wrong because a static word vector ignores context, so “Apple” the company and “apple” the fruit get the same vector.
Practice question 7 · Large language models
You call model.generate() in Hugging Face Transformers and leave do_sample and num_beams unset, and the model’s generation config does not set them either. Which decoding strategy runs?
- A. Greedy search, which picks the most likely next token at each step
- B. Beam search with four beams
- C. Multinomial sampling with temperature 1.0
- D. Top-k sampling with k = 50
Show answer
Answer: A. The Transformers documentation says greedy search is the default decoding strategy: it selects the next most likely token at each step. It tends to repeat itself in long outputs.
B is wrong because beam search needs num_beams greater than 1; with one beam it is the same as greedy search. C and D are wrong because sampling only runs when do_sample=True is set.
Practice question 8 · Retrieval-augmented generation
A chatbot built on an LLM gives out-of-date answers about your company’s policies, which change every month. Which approach adds the current policies with the least retraining?
- A. Raise the temperature so the model explores more answers
- B. Train a new tokenizer on the policy documents
- C. Increase the model’s context length and ask the same question
- D. Retrieve relevant policy passages from a vector index at query time and give them to the model with the question
Show answer
Answer: D. This is retrieval-augmented generation. The model’s weights are its parametric memory; the document index is a non-parametric memory you can update without retraining, and the answer is generated from the retrieved passages.
A is wrong because temperature changes how random the output is, not what the model knows. B is wrong because a new tokenizer changes how text is split, not the facts the model holds, and would need retraining. C is wrong because a longer context window does nothing unless the new policies are actually put into it.
Practice question 9 · Evaluation metrics
Why does the BLEU metric include a brevity penalty?
- A. Because long candidate translations would otherwise get artificially high scores
- B. Because clipped n-gram precision alone would let a very short candidate score highly, so short outputs must be penalized
- C. Because BLEU measures recall against the reference translations
- D. Because the brevity penalty converts the score into a percentage
Show answer
Answer: B. BLEU is built on clipped n-gram precision. A very short candidate that contains only a few safe words can have high precision, so BLEU multiplies the geometric mean of the precisions by a brevity penalty for candidates shorter than the references.
A is wrong because the BLEU paper says long candidates are already penalized by the modified n-gram precision. C is wrong because BLEU is precision-based; recall is the focus of ROUGE. D is wrong because the brevity penalty is a multiplying factor, not a unit change; BLEU ranges from 0 to 1.
Practice question 10 · Evaluation metrics
Which statement about perplexity is correct?
- A. It is the exponentiated average negative log-likelihood of a sequence, and lower is better
- B. It is the best metric for comparing BERT with GPT-style models
- C. It does not depend on the tokenizer, so any two models can be compared directly
- D. It measures n-gram overlap with a human reference
Show answer
Answer: A. Perplexity is the exponent of the average negative log-likelihood per token. A lower value means the model assigns higher probability to the text.
B is wrong because perplexity applies to causal (auto-regressive) language models and is not well defined for masked models such as BERT. C is wrong because the tokenization directly affects perplexity, so models with different tokenizers are not directly comparable. D describes reference-based metrics such as BLEU and ROUGE.
How did you score?
8 to 10 correct: you are ready for a full 40-question test, so try the timed Exam Mode test next. Under 8: each question above shows its topic area, so revise the topics you missed and try again. The NLP practice tests have 120 more questions like these, each with a hint and a full explanation.
Common mistakes in NLP practice tests and interviews
Most lost marks in NLP come from mixing up similar ideas or forgetting library defaults, not from missing advanced theory:
- Treating a stem as a word. Stems such as “fli” are not dictionary words. If you need real words, use a lemmatizer.
- Forgetting vectorizer defaults. TfidfVectorizer lowercases text and drops single-character tokens by default. That changes your vocabulary, and sometimes your results.
- Fine-tuning to add facts. When knowledge changes often, retrieval is easier to update than retraining.
- Comparing metrics unfairly. Perplexity across different tokenizers, or BLEU on a summarization task, gives numbers that do not mean what they seem.
- Learning from outdated code. Old tutorials still use the deprecated Keras Tokenizer.
NLP question dumps and copied answer banks
With no single official NLP exam, “NLP dumps” are copied question banks of unknown quality, and their answers are often wrong or out of date. If you are preparing for a vendor exam such as NCA-GENL, remember that sharing or using live exam content breaks the rules you accept before the exam and can cost you the certification.
Practice tests that explain every option build the reasoning that interviewers and exams test, which is the approach behind the 10 free practice questions above.
Natural Language Processing (NLP) practice test FAQs
Is there an official NLP certification?
No single official certification covers natural language processing on its own. The nearest vendor exam is NVIDIA’s Generative AI LLMs associate exam (NCA-GENL), which NVIDIA’s certification page lists with 50 to 60 questions in one hour and a focus on large language models.
Are there free NLP practice questions?
Yes. This guide includes 10 free NLP practice questions with answers and explanations, covering preprocessing, tokenization, embeddings, transformers, LLMs, RAG and evaluation metrics. For full timed practice, the Exametics NLP practice tests have 3 tests and 120 questions with every answer explained.
How many questions are in the Exametics NLP practice tests?
The Exametics Natural Language Processing (NLP) practice tests have 3 practice tests of 40 questions each, 120 questions in total, including a timed Exam Mode test. Every question has a hint and an explanation of why each option is right or wrong.
Is NLP hard to learn, and how long should I prepare for an NLP interview?
NLP is manageable if you already know Python and basic machine learning, because most questions build on a few core ideas: tokenization, vectors, attention and evaluation. Two to three weeks of focused review with hands-on examples and timed practice is a realistic plan for an interview or course exam.
Should I learn machine learning or NLP first?
Learn machine learning fundamentals first, because NLP models rely on the same ideas of training, validation, loss and overfitting. Then start NLP with preprocessing and TF-IDF before moving to transformers and large language models.
Is the Keras Tokenizer still used for NLP?
No. The TensorFlow API documentation marks tf.keras.preprocessing.text.Tokenizer as deprecated. For new Keras code, use the TextVectorization layer, which maps text to integer sequences inside the model.
Official documentation: NLTK, the Natural Language Toolkit, plus the documentation and papers linked in each section. Checked on 9 November 2026.
Take the full NLP practice test: 120 more questions
Practise with 3 NLP practice tests across nine topic areas, including a timed Exam Mode test, with every answer explained.
✓ Every answer explained · ✓ Timed exam mode · ✓ 30-day refund