Google Cloud Professional Machine Learning Engineer (PMLE) practice questions

A retail team runs a Gemini-based product description generator on Vertex AI. Traffic is steady at roughly 40 requests per second during business hours, and the same handful of category prompts repeat constantly because most products share templated instructions. Average latency has crept up and the monthly bill is dominated by input tokens. Which change to the Gemini request configuration will most directly cut both the per-call cost and the latency of these repeated calls?

• AEnable context caching for the repeated prompt prefix so the shared instruction tokens are stored and billed at a reduced rate on each call.check_circle Correct
• BRaise the temperature parameter so the model commits to an answer sooner and returns fewer retried generations per request.
• CSwitch the endpoint from streaming to non-streaming responses so the full output arrives in one network round trip per request.
• DIncrease the maxOutputTokens limit so each call finishes generation in a single pass instead of being truncated and retried.

Why A is correct: Context caching stores the large repeated prefix once and reuses it, so the shared instruction tokens are billed at the lower cached rate and are not re-processed, which lowers both cost and latency for the repeating prompts.

Why B is wrong: Temperature only changes how random the sampling is; it does not reduce the tokens billed or shorten the prompt, so it leaves both the input-token cost and the latency of these repeated calls untouched.

Why C is wrong: Non-streaming can feel different to a client but it does not reduce the number of tokens processed; it often raises perceived latency because nothing returns until generation finishes, so it does not address the input-token cost driver.

Why D is wrong: A higher output limit permits longer, more expensive completions rather than cheaper ones; the bottleneck here is repeated input tokens, so raising the output ceiling adds cost and latency instead of cutting them.

An insurer wants to extract named fields such as policy number, claimant name, and total amount from millions of scanned claim PDFs that follow a small set of fixed layouts. The team needs structured key-value output, high accuracy on these specific forms, and the lowest ongoing per-document cost rather than free-form reasoning. Which Google Cloud approach best fits this requirement?

• APrompt a general Gemini model with each page image and ask it to return the fields as JSON, relying on its multimodal reasoning over the scans.
• BTrain a Document AI custom extractor on the known layouts so it returns the policy fields as structured key-value pairs per document.check_circle Correct
• CUse the Vision API text detection feature to read all characters, then write rules to locate each field by its position on the page.
• DTranslate every document with the Translate API first to normalise the text, then apply a keyword search to pull out the required values.

Why A is wrong: Gemini can read documents, but per-document inference on millions of pages is costly and its general reasoning is less consistent for fixed-layout field extraction than a model trained on those forms, so it does not meet the accuracy-and-cost goal best.

Why B is correct: Document AI custom extractors are purpose-built to learn fixed layouts and emit structured key-value entities with high accuracy at a predictable per-page price, which directly satisfies the structured-output, accuracy, and low-cost requirements.

Why C is wrong: Vision text detection returns raw characters without document structure, so brittle position rules are needed to recover key-value pairs; this tempts teams who think OCR alone is enough but it lacks the form understanding Document AI provides.

Why D is wrong: Translate changes language and does nothing to detect layout or extract structured fields, so it is the wrong service entirely for a same-language field-extraction task even though it sounds like a preprocessing step.

A support team needs Gemini to answer customer questions strictly from their internal policy documents, which run to tens of thousands of pages and are revised weekly. The team has little machine-learning expertise, wants answers to reflect the latest revisions without retraining, and must keep responses grounded in the source text. Which approach should the team adopt to meet these constraints?

• AFine-tune a Gemini model on the full policy corpus each week so the latest wording is absorbed into the model weights before queries arrive.
• BPaste the entire policy corpus into a single very large prompt for every question so the model always sees the complete current text.
• CBuild a retrieval-augmented generation pipeline that fetches the relevant policy passages and passes them to Gemini as grounding context at query time.check_circle Correct
• DSelect a larger model from Model Garden and raise its temperature so it draws on broader knowledge when policies change.

Why A is wrong: Weekly fine-tuning on a huge corpus is expensive, demands ML skill the team lacks, and bakes facts into weights that still go stale between runs, so it fails the low-effort, always-current, and grounded requirements.

Why B is wrong: Tens of thousands of pages exceed practical context limits and would make each call slow and costly; stuffing the whole corpus per query is tempting because it is simple but it does not scale and wastes tokens on irrelevant material.

Why C is correct: Retrieval-augmented generation injects the current source passages into the prompt at query time, so updated documents are reflected immediately without retraining and answers stay grounded in the retrieved text, matching every stated constraint.

Why D is wrong: A bigger model and higher temperature add capacity and randomness but neither grounds answers in the internal documents nor reflects weekly revisions, so the responses can drift from the authoritative source text.