Free NCA-GENM practice questions

A diffusion model is conditioned on a text prompt by injecting CLIP text embeddings at multiple layers of the U-Net denoiser. Which mechanism directly uses those embeddings to steer the spatial features of the latent during denoising?

• ACross-attention layers in the U-Net, where queries come from the spatial feature map and keys and values come from the projected text embeddingscheck_circle Correct
• BSelf-attention within the U-Net residual blocks, which relates every spatial position to every other spatial position in the same layer
• CClassifier-free guidance, which blends two separate forward passes through the denoiser at inference time to amplify prompt alignment
• DAdaptive layer normalisation, which modulates feature statistics using a global pooled representation of the text embedding

Why A is correct: Cross-attention is the standard conditioning mechanism in latent diffusion models: spatial queries attend to token-level keys and values derived from the text embedding, allowing every spatial region to be guided by the relevant textual context.

Why B is wrong: Self-attention relates spatial positions to each other within the feature map, not to an external conditioning signal such as a text embedding, so it cannot directly inject the CLIP representation.

Why C is wrong: Classifier-free guidance is a sampling-time weighting strategy that scales the difference between conditional and unconditional predictions; it relies on cross-attention conditioning already being present and is not itself the mechanism that injects the embeddings.

Why D is wrong: Adaptive layer normalisation is used in some architectures such as DiT to inject timestep or class conditioning via scale and shift parameters, but it is not the primary mechanism used to inject token-level CLIP text embeddings in the U-Net backbone.

A practitioner wants to suppress artefacts such as blurry textures and extra limbs from generated images without rewriting the positive prompt. Which technique encodes an undesirable description into an embedding that steers the denoising trajectory away from those features?

• AIncreasing the classifier-free guidance scale, which amplifies the positive prompt signal uniformly across all denoising steps
• BApplying a negative prompt, whose CLIP text embedding is used as the unconditional branch in classifier-free guidance to push the output away from the described attributescheck_circle Correct
• CFine-tuning the denoising U-Net with DreamBooth on clean example images to reduce the prior probability of undesired features
• DUsing ControlNet with a depth map input to constrain the structural layout and prevent malformed geometry at inference time

Why A is wrong: Raising the guidance scale strengthens adherence to the positive prompt but does not encode or target specific undesired features; it can actually increase oversaturation and other artefacts at very high values.

Why B is correct: During classifier-free guidance the model computes both a conditional score and an unconditional score. When a negative prompt is supplied, its CLIP embedding replaces the null token as the unconditional input, causing the guidance direction to move away from that embedding and thereby suppressing the described artefacts.

Why C is wrong: DreamBooth fine-tuning modifies model weights to learn a specific concept and requires additional training; it is not the inference-time technique that uses an embedding to steer away from particular outputs in a single generation pass.

Why D is wrong: ControlNet enforces spatial structure from an auxiliary conditioning signal such as a depth map; it constrains layout but does not encode a textual description of undesired features or use the unconditional guidance branch to suppress them.

An engineer conditions a diffusion model on both a reference photograph and a text description to guide the style and content of a generated image. The image is first encoded into a dense embedding by a vision encoder, and that embedding is concatenated with the CLIP text embedding before being passed to the denoiser. What type of conditioning does this represent?

• AUnimodal text conditioning, because the vision encoder output is a derived representation of a pre-existing text-captioned dataset rather than an independent signal
• BLatent inpainting, because the reference photograph is encoded into the latent space and merged with the noisy latent during each denoising step
• CMultimodal context conditioning, where embeddings from separate modalities are combined to jointly steer the denoiser through its cross-attention or concatenation pathwaycheck_circle Correct
• DTextual inversion, where the reference photograph is optimised into a new pseudo-token embedding added to the text vocabulary

Why A is wrong: The system processes a real image through a vision encoder at inference time to produce an image embedding, which is a distinct modality from the text prompt; treating both inputs as a single text-derived signal mischaracterises the architecture.

Why B is wrong: Latent inpainting specifically masks a region of the reference image's latent and denoises only that region; here the full reference image embedding is used as a conditioning signal rather than as a partial latent to be completed.

Why C is correct: When embeddings from two different modalities, an image and a text description, are merged and supplied together as context for the denoiser, the system performs multimodal conditioning. Each modality contributes information that the cross-attention or concatenation mechanism can use to control different aspects of the output.

Why D is wrong: Textual inversion is a training-time personalisation technique that learns a new token to represent a concept from example images; here the image is simply encoded and used directly at inference time rather than being learned as a vocabulary token.

A pipeline ingests 16-bit greyscale medical images and feeds them into a convolutional network. Before training, each pixel value is divided by 65535 so the resulting tensor contains values in the range 0 to 1. What is the primary reason for this operation?

• ATo normalise input values so that large pixel magnitudes do not cause unstable gradients during back-propagation, improving training convergence.check_circle Correct
• BTo reduce the spatial resolution of the image so that fewer parameters are needed in the first convolutional layer.
• CTo convert the integer pixel values into a floating-point representation that is compatible with the network's activation functions and loss computation.
• DTo apply zero-mean standardisation so that each channel has a mean of zero and a standard deviation of one before entering the network.

Why A is correct: Scaling inputs to a small, bounded range keeps weight gradients in a workable magnitude, preventing exploding gradients and accelerating convergence - the canonical motivation for input normalisation.

Why B is wrong: Dividing pixel values by a constant does not alter the spatial dimensions of the tensor; downsampling requires pooling or strided convolutions, not scalar division.

Why C is wrong: Casting to float is a necessary step, but the division itself is not required for the cast; the primary motivation is gradient stability from bounded inputs, not merely the numeric type.

Why D is wrong: Dividing by the maximum value scales to the unit interval but does not produce zero-mean output; standardisation requires subtracting the dataset mean and dividing by its standard deviation.

An audio classification model must process raw waveform recordings. A data engineer proposes converting each recording to a mel-frequency spectrogram before passing it to a 2-D convolutional network. What does this conversion accomplish in terms of the tensor representation fed to the network?

• AIt encodes the waveform as a 1-D sequence of amplitude samples that the convolutional layers treat as a single-channel time-series.
• BIt transforms the time-domain signal into a 2-D frequency-versus-time tensor whose values represent energy in perceptually scaled frequency bands, suitable for image-like convolution.check_circle Correct
• CIt compresses the audio into a fixed-length dense vector using a pre-trained acoustic encoder, removing the need for further spatial feature extraction.
• DIt converts the waveform into a sequence of discrete tokens by quantising amplitude values, matching the input format expected by transformer-based language models.

Why A is wrong: A raw waveform is already a 1-D amplitude sequence; converting to a spectrogram produces a 2-D frequency-time representation, not a 1-D sequence.

Why B is correct: A mel spectrogram applies the Short-Time Fourier Transform followed by mel filterbank projection, yielding a 2-D matrix of log-energy values indexed by mel-scaled frequency and time. This format exposes both temporal and spectral structure and can be processed by 2-D convolutional filters the same way an image is.

Why C is wrong: A spectrogram is computed by a deterministic signal-processing transform, not by a learned encoder. It produces a variable-length 2-D array rather than a fixed-length embedding vector.

Why D is wrong: Amplitude quantisation into discrete tokens is used in codebook-based audio codecs such as EnCodec, not in mel-spectrogram extraction. Mel spectrograms are continuous-valued, not token sequences.

When preparing text for a transformer-based language model, a developer must choose between passing raw one-hot character vectors and using a learned dense embedding layer. Which statement best describes the practical advantage of learned dense embeddings over raw one-hot vectors for this purpose?

• ADense embeddings guarantee that semantically related tokens are always placed at equal distances from each other in the embedding space before any training begins.
• BDense embeddings eliminate the need for tokenisation because they operate directly on raw character byte values without any vocabulary mapping.
• CDense embeddings reduce the input dimensionality from the vocabulary size to a much smaller continuous space, and the learned geometry encodes semantic relationships between tokens.check_circle Correct
• DDense embeddings convert token indices into fixed sinusoidal signals that provide the model with absolute position information across the input sequence.

Why A is wrong: Embeddings are randomly initialised before training; semantic relationships emerge through gradient updates on task data, they are not guaranteed at initialisation.

Why B is wrong: An embedding layer still requires a tokenisation step to map input text to integer indices; it replaces the one-hot lookup but does not remove the tokenisation or vocabulary mapping requirement.

Why C is correct: One-hot vectors have dimensionality equal to the vocabulary size and are completely orthogonal, encoding no similarity between tokens. A learned embedding projects each token into a low-dimensional continuous space where the training objective shapes the geometry so that related tokens cluster together, enabling the network to generalise across synonyms and related concepts.

Why D is wrong: Sinusoidal positional encodings are a separate addition to token embeddings, not a property of the token embedding layer itself. The two components serve distinct purposes and are added together rather than merged into one.

A team fine-tunes an NVIDIA Riva ASR pipeline on domain-specific vocabulary but finds the word error rate remains high on rare technical terms even after acoustic model fine-tuning. Which component should they target next to reduce errors on those terms?

• AThe vocoder, because it synthesises output waveforms and controls pronunciation fidelity for technical terms.
• BThe mel spectrogram extractor, because adjusting the filterbank resolution improves how rare phonemes are represented in the feature space.
• CThe beam-search width parameter, because widening the search ensures more candidate tokens are explored per decoding step.
• DThe language model component, because it assigns probabilities to word sequences and can be updated with a custom vocabulary or n-gram model.check_circle Correct

Why A is wrong: Vocoders are a TTS component that converts mel spectrograms into audio waveforms; they have no role in ASR decoding or vocabulary coverage.

Why B is wrong: Mel spectrogram extraction is a fixed pre-processing step; changing filterbank parameters affects all phonemes equally and does not address vocabulary coverage gaps.

Why C is wrong: Increasing beam width can marginally improve recall of low-probability paths, but it does not introduce domain vocabulary knowledge and has diminishing returns well before fixing a vocabulary-coverage deficit.

Why D is correct: In a hybrid ASR system the language model scores candidate transcriptions; injecting domain vocabulary and phrase probabilities directly reduces substitution errors on rare terms the acoustic model already produces as phoneme sequences.

When evaluating the output quality of a fine-tuned ASR model, a practitioner computes word error rate (WER) on a held-out test set. Which mathematical relationship correctly defines WER?

• AThe number of insertions, deletions, and substitutions needed to transform the hypothesis transcript into the reference, divided by the number of words in the reference.check_circle Correct
• BThe ratio of correctly recognised words to the total number of words in the reference transcript, expressed as a percentage.
• CThe ratio of the BLEU score of the hypothesis transcript to the length of the reference transcript, scaled by a brevity penalty.
• DThe cosine similarity between the character-level embeddings of the hypothesis and reference transcripts, subtracted from 1.

Why A is correct: WER is computed via the minimum edit distance between hypothesis and reference word sequences. The three edit operations (insertions, deletions, substitutions) are summed and divided by the reference word count, giving a normalised error rate that can exceed 1.0 in practice.

Why B is wrong: This describes word accuracy, which is the complement of WER. WER focuses on errors rather than correct recognitions, so confusing the two leads to misinterpreting model improvement direction.

Why C is wrong: BLEU is an n-gram overlap metric used in machine translation evaluation, not in ASR. Applying it here conflates two different evaluation frameworks.

Why D is wrong: Cosine similarity over embeddings measures semantic closeness in a continuous vector space; WER is a discrete edit-distance metric and makes no use of neural embeddings or cosine arithmetic.

An engineer building a custom TTS voice with NVIDIA Riva needs to convert a sequence of predicted mel spectrogram frames into a natural-sounding audio waveform. Which component in the TTS pipeline is responsible for this conversion?

• AThe text normalisation module, which maps written forms to spoken forms before any acoustic processing begins.
• BThe vocoder, which takes mel spectrogram frames as input and synthesises a time-domain audio waveform as output.check_circle Correct
• CThe acoustic model, which predicts mel spectrogram frames from a sequence of linguistic features derived from the input text.
• DThe language model decoder, which selects the most probable phoneme sequence and renders it as a time-domain signal.

Why A is wrong: Text normalisation handles pre-processing of raw input text (expanding abbreviations, numerals, and so on) and operates entirely before the acoustic stage; it produces no audio output.

Why B is correct: In a two-stage TTS architecture such as NVIDIA Riva's, the acoustic model generates a mel spectrogram representation of the utterance, and a separate neural vocoder (such as HiFi-GAN) converts those spectral frames into a high-quality audio waveform. The vocoder is trained to invert the mel spectrogram back to the time domain, and its quality directly determines the naturalness of the synthesised voice.

Why C is wrong: The acoustic model produces mel spectrograms as its output; it does not convert them to a waveform. Confusing the two sequential stages is a common misconception in TTS pipeline architecture.

Why D is wrong: Language model decoders are an ASR component used for hypothesis ranking; they are not part of a TTS pipeline and do not operate on mel spectrograms or produce waveforms.

A developer wants to swap the embedding model used in an NVIDIA AI Blueprint that implements retrieval-augmented generation. Which structural characteristic of AI Blueprints makes this kind of targeted substitution practical?

• ABlueprints are structured as reference architectures that wire together discrete NIM microservices, so the embedding NIM can be replaced or reconfigured without rewriting the surrounding pipeline.check_circle Correct
• BBlueprints package all AI logic as a single compiled binary, so the developer recompiles with a different embedding library flag.
• CBlueprints expose a single REST endpoint that proxies all model calls, so the developer redirects that endpoint to a different embedding service URL.
• DBlueprints rely on a shared CLIP backbone for all retrieval tasks, so the developer fine-tunes the CLIP model to change embedding behaviour.

Why A is correct: An AI Blueprint provides a reference architecture that combines NIM microservices as modular units, meaning any single service such as an embedding model can be swapped independently while the rest of the pipeline remains intact.

Why B is wrong: Blueprints are not compiled monoliths; this misrepresents the composable microservice architecture and confuses it with traditional software packaging.

Why C is wrong: While NIM microservices do expose REST endpoints, the single-proxy description mischaracterises how blueprint components are individually addressed and replaced.

Why D is wrong: CLIP is a vision-language model relevant to multimodal retrieval but is not a universal backbone for all RAG blueprints; this conflates a specific technique with the general blueprint architecture.

An engineering team has deployed a RAG blueprint and now needs to add a re-ranking step between the retriever and the generative model to improve answer relevance. Where in the blueprint architecture should this component be inserted?

• ABefore the document ingestion pipeline, so that retrieved chunks are ranked at index time rather than at query time.
• BBetween the vector store retrieval step and the context assembly step that feeds the generative NIM, as an additional NIM microservice in the query pipeline.check_circle Correct
• CInside the embedding NIM itself, by replacing the embedding model weights with a cross-encoder that produces ranked outputs directly.
• DAs a post-processing step after the generative NIM, so that multiple generated responses are ranked and the best one is returned to the user.

Why A is wrong: Re-ranking is a query-time operation that scores retrieved candidates against the user query; inserting it at ingestion time would not have access to the query context needed for relevance scoring.

Why B is correct: The two-stage RAG pattern retrieves a broad candidate set and then re-ranks it before building the prompt context. Inserting a re-ranker NIM after retrieval but before context assembly is the standard customisation point that the modular blueprint architecture is designed to accommodate.

Why C is wrong: Cross-encoders used for re-ranking are architecturally distinct from bi-encoder embedding models; merging them would remove the efficiency advantage of the two-stage retrieve-then-rank pattern.

Why D is wrong: Ranking generated responses after generation is a different technique known as output re-ranking or best-of-N sampling; it does not improve retrieval relevance and is not what re-ranking in a RAG context refers to.

A team is adapting an NVIDIA AI Blueprint that uses an agent workflow to automate multi-step research tasks. They want the agent to call an internal knowledge-base tool rather than a public search API. Which customisation approach is most consistent with how agent blueprints are designed?

• AReplace the underlying large language model NIM with a smaller model that has been fine-tuned on internal documents so tool calls are not needed.
• BEnable automatic speech recognition on the agent input layer so that voice queries bypass the public API and route directly to internal systems.
• CRegister the internal knowledge-base as a new tool definition within the agent configuration, pointing the tool executor at the internal endpoint instead of the public API.check_circle Correct
• DWrap the entire blueprint in a diffusion-based summarisation layer that condenses public API results to match the internal knowledge format.

Why A is wrong: Fine-tuning the base model encodes static knowledge but does not replace the benefit of dynamic tool retrieval; it also discards the agent's ability to call multiple tools and is disproportionate to the goal of swapping one tool endpoint.

Why B is wrong: ASR adds a multimodal input modality and is unrelated to which retrieval tool the agent calls; it does not change how the agent resolves tool endpoints.

Why C is correct: Agent blueprints expose a tool registry where each callable tool is described by a schema and an endpoint. Adding or replacing a tool definition is the intended customisation path: the agent LLM selects tools by name and description, so updating the registry entry redirects calls to the internal service without changing the rest of the workflow.

Why D is wrong: Diffusion models generate images or audio and are not applicable to text summarisation; this option conflates multimodal generation techniques with agent tool customisation.

A data engineer needs to extract structured fields (product name, price, and availability) from thousands of unstructured product descriptions and load them into a database. Which prompting strategy most reliably produces machine-parseable output from an LLM for this pipeline?

• AZero-shot chain-of-thought prompting, asking the model to reason step-by-step before naming each field
• BEmbedding each product description and storing the vector, then using cosine similarity to retrieve the closest known structured record
• CFew-shot prompting with plain-text examples separated by delimiter lines, leaving the output format for the model to infer
• DStructured-output prompting with a JSON schema in the system prompt, constraining the model to emit a fixed key-value object per descriptioncheck_circle Correct

Why A is wrong: Chain-of-thought improves reasoning but produces verbose prose, not a consistent machine-parseable format. Downstream parsers would struggle with inconsistent output shapes across thousands of descriptions.

Why B is wrong: Embeddings plus similarity search retrieves similar items but does not extract fields from the source text. This is a search or clustering technique, not an extraction approach.

Why C is wrong: Few-shot examples guide style but do not enforce a schema. Without an explicit format constraint the model may vary its output structure across samples, breaking automated parsing.

Why D is correct: Structured-output prompting binds the model to a declared schema, guaranteeing field names and types. This is the standard approach for LLM-to-database pipelines where downstream code must parse every response identically.

An analyst wants to group ten thousand customer support tickets by topic without supplying labelled training data. Which LLM-based workflow is most appropriate for this unsupervised grouping task?

• AGenerate dense embeddings for each ticket with a text embedding model, then apply a clustering algorithm such as k-means or HDBSCAN to the embedding spacecheck_circle Correct
• BPrompt an LLM to classify each ticket against a fixed list of five predefined categories defined in the system prompt
• CUse an automatic speech recognition model to transcribe each ticket and then apply keyword frequency analysis
• DFine-tune a diffusion model on the ticket corpus to generate synthetic ticket variants, then cluster the synthetic outputs

Why A is correct: Dense embeddings map semantically similar tickets close together in vector space. Applying a clustering algorithm to those vectors groups tickets by meaning without requiring predefined labels, making this the canonical unsupervised topic-discovery pipeline.

Why B is wrong: Predefined-category classification is a supervised approach: it requires knowing the categories in advance and imposes them on the data. It cannot discover emergent topics absent from the fixed list.

Why C is wrong: Support tickets are already text, so ASR transcription adds no value. Keyword frequency is a bag-of-words method that ignores semantic meaning and handles polysemy and synonymy poorly compared to embedding-based approaches.

Why D is wrong: Diffusion models generate new content and are used for image or audio synthesis, not for clustering existing text. This approach would not group the original tickets and introduces unnecessary generation overhead.

A product team asks an LLM to summarise a 5,000-word market research report into a 200-word executive brief. After reviewing outputs, they find some summaries omit critical risk findings buried in the middle of the report. Which technique best mitigates this selective-omission problem while preserving brevity?

• ASwitch to a text-to-image model to render the report as an infographic, then summarise the visual output
• BAsk the model to first produce a bullet-point extraction of all risk findings, then use those bullets as explicit context when writing the final summarycheck_circle Correct
• CIncrease the summarisation temperature setting to 1.5 so the model explores a broader range of content
• DEmbed the report and retrieve the top-five most similar chunks to the query 'executive summary', then concatenate those chunks as the output

Why A is wrong: Text-to-image models generate images from descriptions; they do not read or comprehend long documents. Routing report text through an image model does not address content completeness in a written summary.

Why B is correct: A two-step chain - extract first, then summarise with extracted content in context - forces the model to surface mid-document facts before condensing. The extraction step acts as a structured retrieval pass, preventing salience bias that favours text near the start or end of the input.

Why C is wrong: Raising temperature increases randomness and diversity of word choices; it does not guarantee coverage of specific content sections. High temperature is more likely to introduce hallucinations than to improve completeness.

Why D is wrong: Retrieval via semantic similarity returns chunks relevant to the query term, but 'executive summary' as a query will likely surface introductory text rather than mid-document risk findings. This approach does not guarantee the completeness needed for an executive brief.

A team is deploying a multimodal inference service on Kubernetes. Each pod requires one GPU for model execution. The NVIDIA device plugin is installed on the cluster. Which resource request configuration in the pod spec correctly reserves a single GPU for the container?

• ASet resources.requests to cpu: 0 and memory: 0, then annotate the pod with nvidia.com/gpu: 1 in the metadata section.
• BSet resources.limits to gpu: 1 using the standard Kubernetes resource name and omit the vendor prefix entirely.
• CSet resources.requests and resources.limits both to nvidia.com/gpu: 1 under the container spec.check_circle Correct
• DSet resources.requests to nvidia.com/gpu: 1 only, leaving resources.limits unset, so the pod can burst beyond one GPU when the node has capacity.

Why A is wrong: Kubernetes annotations are informational metadata and have no effect on resource scheduling. Extended resources like GPUs must appear in the resources block, not as annotations, to be recognised by the scheduler.

Why B is wrong: gpu is not a standard Kubernetes resource name. The NVIDIA device plugin registers GPUs under the vendor-prefixed extended resource nvidia.com/gpu; omitting the prefix means the scheduler cannot locate or allocate the device.

Why C is correct: The NVIDIA device plugin exposes GPUs as the extended resource nvidia.com/gpu. Kubernetes requires that extended resources be specified identically in both requests and limits, so setting both to 1 correctly reserves one GPU for the container.

Why D is wrong: Extended resources in Kubernetes do not support burst behaviour. The scheduler requires that limits equal requests for any extended resource; specifying only a request without a matching limit causes the pod to be rejected at admission.

A Kubernetes-hosted inference deployment serves a large language model. The horizontal pod autoscaler is configured, but pod count never increases even when GPU utilisation on existing pods reaches 95%. What is the most likely reason scaling is not triggered?

• AHorizontal pod autoscaling cannot scale deployments that request GPU resources; it is limited to CPU-only workloads.
• BThe deployment's readiness probe is failing, causing all current pods to be marked unready, which prevents the autoscaler from adding further pods.
• CThe cluster has no remaining GPU nodes to schedule additional pods onto, so the autoscaler scales up but the pending pods remain unscheduled.
• DThe horizontal pod autoscaler is configured against a CPU or memory metric, and GPU utilisation is exposed as a custom metric that has not been wired to the autoscaler.check_circle Correct

Why A is wrong: The horizontal pod autoscaler is not restricted to CPU workloads. It can scale any deployment; the issue lies in how the scaling metric is sourced and configured, not in the presence of GPU resource requests.

Why B is wrong: A failing readiness probe prevents a pod from receiving traffic but does not by itself block the autoscaler from adding pods. The autoscaler evaluates metric thresholds against ready pods; widespread unreadiness would be visible as a distinct symptom alongside the metric issue.

Why C is wrong: Insufficient GPU node capacity would manifest as pods in Pending state after a scale-out event, not as an absence of scaling. If scaling is not triggered at all, the root cause precedes scheduling and lies in how the autoscaler metric is configured.

Why D is correct: The horizontal pod autoscaler reads metrics from the Kubernetes metrics pipeline. GPU utilisation is not a built-in resource metric; it must be exposed via a custom or external metrics adapter such as the DCGM exporter feeding Prometheus. If only a CPU or memory metric is configured, GPU saturation is invisible to the autoscaler and no scale-out event fires.

An inference pod for a multimodal model takes 90 seconds to load its weights before it can serve requests. Traffic sent to the pod during this period results in errors. Which Kubernetes probe configuration best addresses this problem?

• AAdd a readiness probe with an initialDelaySeconds value longer than 90 seconds, so the pod is excluded from the service endpoints until the model is fully loaded.check_circle Correct
• BAdd a liveness probe with an initialDelaySeconds value longer than 90 seconds so the kubelet does not restart the pod before weights are loaded.
• CAdd a startup probe with an initialDelaySeconds value longer than 90 seconds; once the startup probe passes, traffic is automatically routed to the pod.
• DConfigure the pod's terminationGracePeriodSeconds to 90 seconds so Kubernetes waits for the weights to load before routing traffic.

Why A is correct: A readiness probe controls whether a pod is included in the service's endpoint slice. Until the readiness probe succeeds, Kubernetes removes the pod from all matching services and load balancers, preventing any traffic from reaching it. Setting initialDelaySeconds to a value that exceeds the model load time ensures the pod only receives requests once weights are fully in memory.

Why B is wrong: A liveness probe determines whether the container should be restarted. Delaying it prevents premature restarts but does not prevent the service from routing traffic to the pod before the model is ready. Traffic errors during startup would persist.

Why C is wrong: A startup probe gates the activation of liveness and readiness probes; it does not itself control traffic routing. Traffic routing is governed by the readiness probe. Passing the startup probe alone does not add the pod to service endpoints.

Why D is wrong: terminationGracePeriodSeconds controls how long Kubernetes waits for a pod to shut down gracefully before sending a SIGKILL signal. It has no influence over startup behaviour or traffic routing to a newly created pod.

A media organisation wants to attach tamper-evident provenance data to every AI-generated image before publishing. Which open standard is designed specifically to carry cryptographically signed assertions about a content item's origin and editing history?

• AC2PA (Coalition for Content Provenance and Authenticity) Content Credentialscheck_circle Correct
• BEXIF metadata embedded in the image file header
• CCLIP embeddings stored alongside the image as a sidecar file
• DA perceptual hash digest appended to the filename

Why A is correct: C2PA defines a cryptographically signed manifest that records assertions about how content was created or modified, enabling downstream verification of origin and editing history.

Why B is wrong: EXIF stores camera and device data but carries no cryptographic signatures, so it can be stripped or forged without detection and does not constitute a provenance standard.

Why C is wrong: CLIP produces semantic similarity embeddings for retrieval and classification tasks; it has no signing mechanism and cannot provide tamper-evident provenance assertions.

Why D is wrong: Perceptual hashes measure visual similarity and can detect near-duplicates, but they carry no chain-of-custody record and are not signed, so they cannot prove origin or detect editorial changes.

A generative audio pipeline invisibly encodes a signal into every synthesised voice clip so that downstream tools can confirm the audio was machine-generated, even after MP3 compression and resampling. This technique is best described as what?

• ASpectrogram fingerprinting using a CNN classifier
• BInvisible audio watermarking embedded at generation timecheck_circle Correct
• CASR-based transcription alignment to flag unusual prosody
• DDiffusion-model latent tagging applied during the denoising loop

Why A is wrong: CNN-based spectrogram classifiers are used to detect synthetic audio after the fact, but they do not embed any signal at generation time and so cannot survive re-encoding as a persistent mark.

Why B is correct: Audio watermarking modifies the waveform in a perceptually inaudible way to carry a recoverable signal. Systems such as AudioSeal are designed to survive common degradations like lossy compression and resampling, allowing verification of AI origin.

Why C is wrong: Automatic Speech Recognition compares spoken words to transcripts; prosody analysis may reveal anomalies but nothing is encoded into the audio at generation time, so this is a detection approach, not a watermarking one.

Why D is wrong: Latent tagging modifies the latent space during image diffusion and is an analogous concept for visual content; it is not the standard term for audio watermarking and the mechanism differs significantly from waveform-level embedding.

A trust-and-safety team relies solely on a binary AI-image detector trained in 2023 to flag synthetic photographs. Which limitation should the team be most aware of when assessing its ongoing reliability?

• AThe detector cannot run on GPU hardware without recompilation, limiting throughput
• BBinary detectors always misclassify JPEG-compressed images as synthetic
• CDetection accuracy degrades on images produced by generators released after the detector's training cutoffcheck_circle Correct
• DPerceptual hashing prevents the detector from reading image pixels correctly

Why A is wrong: Hardware compatibility is an infrastructure concern unrelated to the fundamental accuracy challenge; it does not explain why a well-deployed detector would fail to catch new synthetic images.

Why B is wrong: This overstates a known sensitivity issue; compression artefacts can affect detector confidence but modern classifiers are calibrated against them, and the claim that compression always causes misclassification is inaccurate.

Why C is correct: Synthetic-media detectors learn statistical patterns from the specific generators included in their training data. When newer generators - especially those with improved architectures or fine-tuning pipelines - produce images with different artefact profiles, the detector's generalisation fails, leading to increased false-negative rates.

Why D is wrong: Perceptual hashing is a separate content-matching technique; it does not interact with or obstruct a pixel-based neural classifier and has no bearing on detection accuracy for synthetic media.