8 of the 15 questions in this set, with the correct answer marked and every option explained.
1. A researcher explaining how modern large language models process an input sentence says the model weighs how relevant every other word in the sentence is to each word it's currently processing, rather than reading strictly left to right one word at a time in isolation. Which mechanism is the researcher describing?
✓Self-attention
Self-attention is exactly this: for each token, the model computes how relevant every other token in the sequence is and weighs their influence accordingly, which is what lets transformers capture relationships across a whole sequence rather than processing it strictly in isolated left-to-right steps.
✗Data augmentation
Data augmentation creates additional training examples by modifying existing data (e.g., cropping images); it's a data-preparation technique, not a mechanism for weighing relationships between tokens during processing.
✗Gradient descent
Gradient descent is the optimization algorithm used to update model weights during training; it doesn't describe how a model weighs relationships between words within a single input at inference time.
✗One-hot encoding
One-hot encoding is a way to represent categorical values as binary vectors; it has nothing to do with weighing relevance between words in a sequence.
2. Before text can be fed into a large language model, it must first be broken into the smaller units the model actually operates on -- which may be whole words, sub-word pieces, or even individual characters, depending on the scheme used. What is this process called?
✓Tokenization
Tokenization is precisely the process of breaking raw text into the discrete units -- tokens, which may be words, sub-words, or characters depending on the scheme -- that a language model actually processes as its input vocabulary.
✗Backpropagation
Backpropagation is the algorithm used to compute gradients during training so weights can be updated; it has nothing to do with converting text into model input units.
✗Regularization
Regularization refers to techniques that reduce overfitting during training (such as dropout or weight decay); it doesn't describe splitting text into tokens.
✗Quantization
Quantization reduces the numerical precision of a model's weights to shrink its size and speed up inference; it operates on the trained model's parameters, not on how raw text is split into input units.
3. A team needs a model that can take a short instruction and generate open-ended, freeform text as a continuation, such as writing a paragraph from a prompt. Which class of transformer model architecture is the standard fit for this generative task, as distinct from a model optimized for classification or embedding tasks?
✓A decoder-style model
Decoder-style (autoregressive) models are trained to predict the next token given everything generated so far, which is exactly what open-ended text generation from a prompt requires -- generating a continuation one token at a time.
✗An encoder-only model
Encoder-only models (like BERT-style architectures) are optimized for producing rich representations for tasks like classification, embedding, and question-answering -- not for freeform autoregressive text generation.
✗A convolutional neural network with no attention mechanism
A plain CNN without attention isn't the standard architecture for modern open-ended language generation -- transformer decoder architectures are the established fit for this task.
✗A k-nearest-neighbors classifier
k-NN is a simple similarity-based classification/regression algorithm; it has no mechanism for generating open-ended freeform text.
4. A researcher describes how a model like BERT was pretrained: portions of the input text were hidden, and the model learned to predict the missing pieces using the surrounding context, without needing humans to manually label each training example. Which broader concept does this training approach represent?
✓Self-supervision
Self-supervision is training where the labels come from the data itself -- here, masking parts of the text and having the model predict them from context -- rather than from separately human-annotated labels, which is exactly the approach described for BERT-style pretraining.
✗Reinforcement learning from a fixed reward table with no model updates
This describes learning from externally defined rewards, not learning by predicting masked content from surrounding context using the data's own structure as supervision.
✗Manual, fully human-labeled supervised learning for every training example
The scenario explicitly says no manual labeling was needed for each example -- that's the opposite of fully human-labeled supervised learning.
✗Unsupervised clustering with no prediction target at all
The model in the scenario does have a concrete prediction target (the masked tokens) derived from the data -- that's self-supervision, not clustering with no target.
5. A team has a general-purpose foundation model and wants it to reliably follow their company's specific tone and terminology across thousands of interactions, in a way that's baked into the model's weights rather than repeated in every prompt. They have a solid set of labeled example interactions to work with. Which approach best fits this specific goal?
✓Fine-tuning the model on the company's labeled example interactions
Fine-tuning updates the model's weights using domain-specific labeled examples, which is exactly what's needed to bake a company's tone and terminology into the model's default behavior rather than relying on repeating instructions in every prompt.
✗Increasing the model's output temperature for every request
Temperature controls output randomness per request; it doesn't teach the model any company-specific tone or terminology, and higher temperature would work against consistency.
✗Reducing the model's maximum context length
Shrinking context length limits how much text fits in a request; it has no effect on whether the model has learned the company's specific tone or terminology.
✗Randomly initializing the model's weights before every request
Randomly reinitializing weights would destroy the model's learned knowledge entirely -- it's the opposite of adapting a model to a specific style or domain.
6. A developer wants to compose a multi-step LLM workflow -- retrieve documents, format a prompt with the retrieved context, call the model, then parse the result -- using reusable Python components rather than hand-wiring each step. Which Python library is purpose-built for organizing and composing this kind of LLM workflow?
✓LangChain
LangChain is specifically designed to organize and compose LLM workflows -- chaining retrieval, prompt formatting, model calls, and output parsing together using reusable components, which is exactly the multi-step workflow described.
✗NumPy
NumPy is a numerical computing library for array operations; it has no built-in concept of LLM prompt chains, retrieval, or workflow orchestration.
✗Matplotlib
Matplotlib is a plotting and visualization library; it doesn't compose or orchestrate LLM workflow steps.
✗SQLite3
SQLite3 is a lightweight relational database library; it stores and queries data but has no facility for chaining LLM calls or retrieval steps together.
7. A developer wants to quickly pull a specific pretrained transformer model and its matching tokenizer from a public model repository, then run it locally with just a few lines of Python, without writing custom model-loading code from scratch. Which library and repository combination is the standard choice for this?
✓The Hugging Face transformers library and Hugging Face's model repository
Hugging Face's transformers library and its associated model repository are built specifically for this workflow: finding, pulling in, and running pretrained models and their matching tokenizers with minimal custom code.
✗A raw socket programming library with no model-loading utilities
Raw socket programming handles network communication at a low level; it provides no facility for loading pretrained transformer models or tokenizers.
Spreadsheet macros are designed for spreadsheet automation, not for loading and running pretrained transformer models from a model repository.
✗A basic file compression utility
A compression utility reduces file size; it has no model-loading or tokenizer-matching capability relevant to running a pretrained LLM.
8. A team has fine-tuned a model and now needs to deploy it so that production applications can send it inference requests reliably and with optimized throughput, rather than running inference through an ad hoc local script. Which NVIDIA tool is purpose-built for serving trained models in production with optimized performance?
✓Triton Inference Server
Triton Inference Server is NVIDIA's purpose-built tool for deploying trained models -- including fine-tuned LLMs -- to deliver optimized, reliable inference performance in production, which is exactly the production-serving need described.
✗A spreadsheet formula engine
A spreadsheet formula engine has no capability to serve a trained model for production inference requests.
✗A basic text editor with syntax highlighting
A text editor helps write code; it provides no model-serving or inference infrastructure for production use.
✗A version control system with no serving capability
Version control tracks code and file changes over time; it doesn't serve model inference requests in production.
7 more questions in the app
Practise the full 15-question set with a timer, scoring and progress tracking.