Describe features of generative AI workloads on Azure practice questions

Max tokens

Why it fails: Max tokens sets a hard stop on the number of tokens generated, effectively controlling the length of the product description (e.g., capping it at 100 tokens). It has no influence on the probability distribution used to select each token, so it cannot make the text more deterministic or reduce randomness. Even with a low max tokens, the model will still freely sample from a diverse distribution, so this option does not address the requirement.

Presence penalty

Why it fails: Top-p, or nucleus sampling, limits sampling to the smallest set of tokens whose cumulative probability exceeds a threshold like 0.9, pruning the tail of the distribution but leaving the relative probabilities of those remaining tokens unchanged. While lowering top-p can reduce randomness, it acts differently than temperature: it cuts off rare tokens rather than sharpening the distribution of all tokens. For focused, consistent output, temperature is the more direct and commonly recommended parameter in Azure OpenAI.

Frequency penalty

Why it fails: Frequency penalty applies a penalty to tokens that have already appeared, reducing their probability of being selected again across the generated sequence. It is specifically designed to discourage repetitive phrasing, and while it can affect the flow of text, it does not globally control the randomness or creativity of the sampling process. Consequently, it cannot make the overall output more deterministic or focused.

Set frequency penalty to 1

Why it fails: A frequency penalty of 1 adjusts the logits by subtracting a coefficient proportional to how many times a token has already appeared in the generated sequence, which dampens repetition. However, this penalty only biases the resulting probability distribution; it does not force the model to pick a deterministic token. Because the next token is still sampled from that modified distribution, two runs can still produce different continuations.

Set top_p to 1

Why it fails: top_p, known as nucleus sampling, filters the candidate token set to the smallest group whose cumulative probability mass exceeds the threshold; setting it to 1 therefore applies no filtering and keeps every token in the vocabulary eligible. With any nonzero temperature, sampling from that full set remains stochastic, so repeated requests can yield different tokens. Low top_p values can reduce randomness, but top_p=1 maximizes the sampling space and is the opposite of a determinism control.

Set max_tokens to the expected output length

Why it fails: max_tokens is a length-control parameter that caps the number of tokens the API will generate and truncates the response at that boundary if reached. It has no effect on the logits or the sampling process, so every generated token remains a random draw from the probability distribution. In fact, an insufficient max_tokens can make outputs appear even more inconsistent because different completions can be cut off at different points.

A

Why it fails: Temperature controls the randomness of token selection; increasing it makes outputs more creative but does not specifically reduce repetition.

B

Why it fails: Top_p (nucleus sampling) also controls randomness by limiting token selection to a cumulative probability; it does not directly target repetition.

D

Why it fails: Max_tokens sets the maximum number of tokens in the output and does not affect the diversity or repetition of the content.

Frequency penalty

Why it fails: Frequency penalty applies a proportional reduction to the score of every token that has already been used in the generated response, with the penalty growing each time the token reappears. It is designed to discourage repetitive phrasing and encourage lexical diversity, but it does not alter the overall shape of the probability distribution for the next token across the entire vocabulary. As a result, even a strong frequency penalty leaves the model's inherent randomness unchanged—it only shifts likelihood away from repeated tokens.

Presence penalty

Why it fails: Presence penalty adds a fixed, one-time penalty to any token that appears at least once in the generated text, regardless of how many times it has occurred, which nudges the model toward introducing new topics or concepts. It works by biasing the sampling process away from previously used tokens, not by changing the sharpness or entropy of the probability distribution. Thus, while it affects content and thematic progression, it does not control how predictable or surprising the next token is in the way that temperature does.

Fine-tuning the model on the example posts

Why it fails: Fine-tuning is a supervised training process that takes a base model and continues updating its weights on the provided example posts using backpropagation and gradient descent. By optimizing the model's parameters to minimize loss on those examples, the model learns the specific tone, vocabulary, and stylistic patterns of the brand, enabling more consistent and generalizable output than inference-time techniques.

Grounding the model with a knowledge base of brand guidelines

Why it fails: Grounding—often implemented with Retrieval-Augmented Generation (RAG)—retrieves brand guidelines from a knowledge base and injects them into the prompt at inference time. Although this gives the model relevant contextual facts, it does not alter the model's parameters or permanently adjust its stylistic behavior; generated responses still depend on the base model's innate prose style and may fail to imitate the brand's voice consistently.

Implementing a content filter to enforce brand rules

Why it fails: Content filters are safety mechanisms that classify, block, or rewrite generated outputs based on policy rules—they operate after or during decoding to prevent prohibited content. They cannot teach the model a new positive style or make it produce brand-specific phrasing, because filters only restrict or modify outputs; they have no mechanism to steer the model's learned linguistic style toward the provided examples.

Set the temperature parameter to 0

Why it fails: Setting temperature to 0 in Azure OpenAI forces the model toward a mostly deterministic token-selection strategy, but it only alters sampling randomness; it does not change the set of outputs the model can produce. A malicious or unsafe code snippet can still appear as the highest-probability continuation, so determinism is not a safety guarantee. Since no content moderation service is invoked, this configuration alone cannot block harmful code.

Enable content filters

Why it fails: Content filters are the service-level safety mechanism in Azure OpenAI, backed by Azure AI Content Safety classifiers that scan both prompt and completion for prohibited content categories. When enabled and configured, they can reject or redact completions that attempt to deliver malicious code, making this the direct mitigation for unsafe output. Unlike sampling or prompt controls, content filters provide an enforced policy boundary before the user receives the result.

Set max_tokens to a low value

Why it fails: The max_tokens parameter sets an upper bound on the number of tokens generated, which can truncate a response but does not evaluate whether those tokens are harmful. Short but dangerous code fragments, such as an SQL injection payload or a malicious function, fit easily within any reasonable token budget. This parameter only manages generation length and processing cost, not safety or content policy.

Training an AI model from scratch on domain-specific data

Why it fails: Training an AI model from scratch on domain-specific data is a completely different process: it involves updating model weights through years of research and expensive compute, requiring large labeled datasets that reflect the target domain. In contrast, grounding connects an existing pre-trained model to specific knowledge at inference time by retrieving relevant documents and injecting them as context, without any retraining or weight updates. This option describes a resource-intensive model development approach, whereas grounding is a lightweight, runtime-only technique.

Removing biases from a trained language model

Why it fails: Removing biases from a trained language model is a fairness and alignment goal, achieved through techniques like fine-tuning on debiased datasets, iterative unlearning, or applying adversarial classifiers. These methods modify the model's internal weights to change its predictive behavior. Grounding is different: it leaves the model's weights untouched and instead improves factual accuracy at inference time by providing retrieved, verified context from a knowledge base. Bias removal targets social harms, while grounding targets factual correctness, so they address distinct problems.

Converting text responses into speech output

Why it fails: Converting text responses into speech output is a text-to-speech (TTS) capability, which addresses the modality of the final output rather than the factual accuracy of the underlying content. TTS uses neural vocoders or acoustic models to synthesize audio, but it does not retrieve or verify any facts from an external knowledge base. Grounding, on the other hand, is concerned with the source and reliability of the textual information before it is spoken, so this option is unrelated to the concept of grounding.

B. Azure Computer Vision

Why it fails: Azure Computer Vision is an image and video analysis service that uses convolutional neural networks to detect objects, read text via OCR, and generate short auto-generated captions for visual content. It cannot accept a product's keywords and produce extended marketing copy; its text outputs are limited to describing what is present in an image. The service operates on pixels and visual features, not on open-ended language generation.

C. Language Understanding (LUIS)

Why it fails: Language Understanding (LUIS) is designed for conversational intent recognition and entity extraction, not text generation. When a user sends an utterance, LUIS returns structured JSON containing the intent name and extracted entities—it never composes new natural language output. Its architecture is based on classification models, so it has no way to synthesize a novel product description from keywords.

D. Azure Machine Learning

Why it fails: Azure Machine Learning is a robust MLOps platform for orchestrating experimentation, training, and deployment of custom models, but it ships no pre-trained text-generation model out of the box. To generate product descriptions through Azure ML alone, the team would have to source or create a dataset, train or fine-tune a transformer model, set up inference endpoints, and manage scaling—a substantial engineering effort. Because Azure OpenAI Service already offers production-ready generative models, Azure ML is overkill and not the fastest path for this scenario.

B. GPT-3 for text and Custom Vision for images

Why it fails: GPT-3 can generate text, so the conversational half of the pairing is somewhat plausible, but Custom Vision is a supervised image classification and object detection service, not a generative model. Custom Vision learns to assign labeled categories or draw bounding boxes around objects in existing images, and it cannot create a new image from a text description. Therefore, this combination fails the image-generation requirement even though the text side works.

C. BERT for text and OCR for images

Why it fails: BERT is an encoder-only transformer pretrained for language understanding tasks such as sentiment analysis, named entity recognition, and extractive question answering, but it has no decoder that can generate free-form text. OCR (optical character recognition) extracts text from images or documents, which is the inverse of image generation—it reads text from images rather than creating images from text. This pairing offers neither conversational text generation nor image generation, making it entirely incompatible with the chatbot requirements.

D. Language Understanding (LUIS) and Face API

Why it fails: LUIS is a natural-language understanding service that extracts intents and entities from user utterances, but it does not generate the free-form conversational replies a chatbot needs for customer interaction. Face API detects and analyzes faces in existing photos—returning attributes like age, emotion, and landmarks—but it cannot synthesize or generate images from text. Both services are discriminative analyzers, not generative generators, so this option misses both core capabilities.

Model deployment

Why it fails: Deploying a model through Azure OpenAI involves provisioning an endpoint with a chosen model version, region, and scaling and capacity options, which makes the model available to client applications. Deployment decisions affect latency, availability, throughput, and quota, but they have no bearing on whether a particular output is harmful or inappropriate. Content filters are applied uniformly at inference time for every request, regardless of which deployment handles it, so filtering works independently of deployment configuration.

Token limit

Why it fails: The token limit parameter (max_tokens) caps the maximum number of tokens or words that Azure OpenAI is allowed to generate, which directly controls response length, latency, and associated cost. It does not assess the semantic meaning of the text being produced, so a harmful sentence could still appear in full before the limit is reached. Lowering the token limit might truncate an undesirable response, but it cannot classify or block content as unsafe, making it purely a length-control mechanism.

Prompt engineering

Why it fails: Prompt engineering focuses on crafting system messages, few-shot examples, and careful instructions to steer the model toward desirable tone, style, and topic boundaries. While a well-designed prompt can reduce the likelihood of off-topic or unsafe outputs, it cannot guarantee that the model will always follow those constraints, especially against adversarial or novel inputs. Azure OpenAI's content filters add a deterministic, policy-based enforcement layer that does not rely on the model's instruction-following capability, so prompt engineering alone is insufficient to block inappropriate content.

Fine-tuning the model with a custom dataset

Why it fails: Fine-tuning trains the model on specific data to improve performance on a task. However, it does not inherently filter out objectionable content; the model might still generate harmful text if the fine-tuning data contains such patterns.

Increasing the token limit per response

Why it fails: Raising the token limit only extends response length; it cannot filter offensive language, stereotypes or violence, so brand guidelines remain unenforced. It is tempting because token limits genuinely solve truncated or cut-off completions in long-form generation, which is the right fix when output length, not content safety, is the constraint.

Using prompt engineering techniques

Why it fails: Prompt engineering (e.g., adding instructions like 'do not use bad language') can help guide the model, but it is not a guaranteed safety mechanism. The model may still generate inappropriate content if the instruction is not perfectly followed. Content filtering is the official safeguard.

Increase the temperature parameter to 1.0 to force more creative responses

Why it fails: Increasing the temperature parameter to 1.0 raises the randomness of token sampling, making the model more creative and disperse in its outputs — the opposite of what is needed for factually grounded answers. Higher temperature increases the probability of selecting lower-ranked, less likely tokens, which directly amplifies the chance of generating incorrect or irrelevant information; to reduce hallucinations, you would lower temperature toward 0 and provide relevant context.

Fine-tune the model on the knowledge base documents using supervised learning

Why it fails: Fine-tuning the model on the knowledge base with supervised learning teaches the model patterns from those documents but does not create a hard guarantee that it will only answer from that learned material. The model still generates next tokens probabilistically, so when faced with a question that is only loosely related to the training data, it can produce plausible but fabricated facts — fine-tuning adjusts weights for style/behavior, not for verifiable retrieval at inference time.

Use prompt engineering with a system message that tells the model to never make up facts

Why it fails: Using a system message that instructs the model to 'never make up facts' is a soft, heuristic constraint rather than a deterministic safeguard. Because the model has no internal fact-checking mechanism, it will still rely on its parametric knowledge and can fill gaps with confident-sounding fabrications when no external context is supplied; the instruction does not provide the grounding needed to suppress hallucination.

Max tokens

Why it fails: Max tokens is a hard cap on the number of tokens the model can generate in a single response, so it only controls the length of the output, not the underlying probability distribution. Because it does not alter the relative likelihood of choosing any token at each step, it can neither increase creativity nor add diversity; it merely truncates the generated sequence once the token limit is reached. Limiting max tokens can actually force a cut-off mid-sentence, but that is a practical constraint, not a semantic or stylistic control.

Top probability

Why it fails: Top probability (often called nucleus sampling) restricts the pool of next-token candidates to the smallest set whose cumulative probability exceeds the given p-value, such as 0.9. Lowering p makes the model choose only from the most likely tokens, which reduces randomness and yields more predictable text; raising p includes more long-tail tokens, but the effect saturates as p approaches 1. This parameter is a truncation of the candidate set, not a scaling of token scores, so it changes the sampling budget rather than directly controlling the overall creativity level the way temperature does.

Frequency penalty

Why it fails: Frequency penalty adjusts the logit scores of tokens proportionally to how many times they have already appeared in the generated output, discouraging the model from repeating the same words or phrases. This targeted penalty can increase linguistic variety by mitigating repetitive loops, but it does not broadly loosen the model's token-selection behavior like temperature does. It is a corrective mechanism for repetition only; it leaves the probabilities of never-seen tokens untouched and thus is not a general creativity dial.

Completions API

Why it fails: The older Completions API is designed for single-turn, free-form text continuation from a standalone prompt. It does not manage a conversation history or track roles, so to simulate multi-turn dialogue you would have to manually concatenate every past user and assistant message into one giant string. That approach quickly grows unwieldy, loses clear context boundaries, and is why Chat Completions—with its structured message list—is the appropriate API for an assistant.

Embeddings API

Why it fails: The Embeddings API is fundamentally different: it transforms input text into a high-dimensional numerical vector that encodes semantic meaning. These vectors are used to measure similarity between texts, powering search, recommendations, or clustering, but they do not generate language or produce conversational replies. Calling this API would not return a coherent assistant response, so it is unsuitable for powering a chat assistant.

Fine-tuning

Why it fails: Fine-tuning is a training-time process, not an inference-time API. It adjusts a pre-trained model's weights using a custom dataset to specialize its behavior for specific tasks or domain language. After fine-tuning, you still need a dedicated inference endpoint such as the Chat Completions API to actually run conversations; fine-tuning itself cannot accept a user message and produce a reply, so it is the wrong choice for this production assistant.

Temperature parameter adjustment

Why it fails: The temperature parameter controls the sampling distribution over the model's predicted next-token probabilities at inference time. Low temperature values (e.g., 0.1) make outputs more deterministic by favoring high-probability tokens, while high values (e.g., 1.0) increase randomness and diversity. However, temperature only affects how 'risky' the model is during token selection; it does not alter the underlying learned style or guide the model toward a specific brand voice. Every sampled output still comes from the same pre-existing distribution, so lowering or raising temperature cannot teach the model to mimic the tone of the sample descriptions.

Prompt engineering with detailed instructions

Why it fails: Prompt engineering with detailed instructions can pass style guidance through system messages or include a few example texts to nudge the model toward a desired tone. This approach works only at inference time and relies on the model's ability to interpret and follow instructions; it does not update any model parameters. Complex or subtle brand voices are often inconsistently reproduced because the model may forget parts of the instruction or interpret it differently across prompts. In contrast, fine-tuning learns from many examples and encodes the style directly into the weights, making it far more reliable for consistent brand-voice adaptation.

Content filtering

Why it fails: Content filtering in Azure OpenAI is a safety system that runs in parallel with generation, classifying both prompts and completions for categories such as hate, sexual, violence, and self-harm. It does not modify the model's behavior or output style; it simply blocks or flags content that violates usage policies, returning a filter notice instead of text. Brand voice includes tone, word choice, and style, which are linguistic features unrelated to safety classifications. Therefore, enabling or adjusting content filters will not make the model generate text that matches the sample descriptions.

Frequency penalty

Why it fails: Frequency penalty reduces repetition of the same token by scaling its logit according to how often it has already appeared, so it discourages repeated words rather than flattening the probability distribution. It is tempting because it does curb verbatim loops in long outputs, but the stem asks for randomness, which temperature (or top_p) controls.

Top_p (nucleus sampling)

Why it fails: Raising top_p widens the nucleus, admitting more low-probability tokens, so it does increase randomness — but the question asks which parameter to increase, and top_p is the correct answer, not an incorrect option here. Temperature is the other valid control.

Presence penalty

Why it fails: Presence penalty applies a flat logit reduction to any token that has appeared at least once, encouraging new topics rather than randomising token selection. It suits prompts needing broader vocabulary coverage, but it cannot introduce the sampling randomness the team requires; temperature governs that.

Increase the top_p parameter

Why it fails: Increasing top_p (nucleus sampling) expands the cumulative probability mass from which tokens are sampled, including more low-probability options, which can add diversity in some cases. However, temperature is the primary parameter for adjusting randomness and creativity; top_p is a secondary sampling strategy that interacts with temperature but does not directly or reliably increase creative variety on its own. The question specifically targets the most direct control, which is temperature.

Increase the frequency_penalty parameter

Why it fails: Increasing the frequency_penalty applies a punitive adjustment proportional to how often a token has already appeared, reducing the likelihood of repeating the same tokens. This helps mitigate repetitive loops but does not directly increase the overall creativity or variety among different backstory concepts; it mainly cleans up output style. Since the goal is to generate more varied backstories, this penalty is not the primary mechanism to adjust.

Decrease the max_tokens parameter

Why it fails: Decreasing max_tokens only caps the maximum number of tokens the model can generate, truncating the output if it would otherwise be longer. It does not alter the token selection probabilities or the diversity of the content, so the backstory would simply be shorter and could end abruptly. This parameter controls length, not creativity, and thus would not increase variety.

Fine-tune the base model on the example descriptions

Why it fails: Fine-tuning is unsuitable here because adapting a model to a specific brand voice with a *small set* of examples does not provide sufficient data for effective fine-tuning, which typically requires a substantial, high-quality dataset to meaningfully alter model weights. This approach also constitutes retraining, which the question explicitly seeks to avoid "from scratch". It is tempting because fine-tuning *is* used to specialise models for particular tasks or domains, and would be appropriate if a large, diverse dataset were available to embed new knowledge or significantly shift the model's overall style.

Increase the temperature parameter to the maximum value

Why it fails: Raising the temperature parameter toward its maximum (e.g., 1.0 or higher for some models) increases the randomness of token sampling by flattening the probability distribution over the next token. This makes outputs more divergent, creative, and unpredictable, which is antithetical to the goal of reproducing a consistent brand voice. While a slightly higher temperature can add stylistic variation, maximum temperature would effectively destroy the pattern-matching fidelity that few-shot examples provide, so it would generate off-brand text, not matching descriptions.

Train a new model using Azure Machine Learning

Why it fails: Training a new model from scratch in Azure Machine Learning is a heavy, expensive, and time-consuming process that requires designing an architecture, curating a massive labeled dataset, and running large-scale training jobs. The question's target is to adapt an already capable model to a specific voice using only example descriptions, not to build a foundation model. Because Azure OpenAI's pre-trained models can already emulate styles via in-context learning, retraining a new model from zero introduces unnecessary cost, risk, and operational burden, and it does not leverage the intended tool.

The Chat Completions API

Why it fails: The Chat Completions API is the correct endpoint for generating long technical responses, but it reports token usage only after the model has completed processing, via the usage object that includes prompt_tokens, completion_tokens, and total_tokens. It provides no method to inspect token count before sending the prompt and no built-in cost-prediction interface, meaning developers must rely on an external tokenizer or trial and error to estimate costs upfront. It processes tokens but does not count them in advance.

The Embeddings API

Why it fails: The Embeddings API converts text into a numerical vector representation and reports token usage only after the service processes the input, in the API response's usage field. There is no pre-call endpoint or ability to preview token consumption from the Embeddings API itself. Moreover, embeddings are intended for semantic search and clustering, not for generating long technical text, so it would not fulfill the stated use case at all.

The Content Filter configuration

Why it fails: The Content Filter configuration is a safety mechanism that evaluates prompts and generated responses for categories such as hate, sexual, violence, and self-harm after a request is submitted. It either allows or blocks content based on severity scoring, but it performs no tokenization and returns no token counts, so it cannot be used for usage estimation or cost planning. It addresses compliance, not model economics.

Temperature

Why it fails: Temperature scales the logits before the softmax to control the randomness of token sampling: a lower temperature (e.g., 0.1) makes the distribution more peaked and deterministic, while a higher temperature (e.g., 1.0) increases randomness. However, temperature does not have a memory of which tokens were generated previously; it only reshapes the overall probability distribution over the vocabulary at each step. Therefore, lowering temperature may lead to more conservative outputs but cannot specifically penalize repeated tokens, making it ineffective as a repetition control.

Max tokens

Why it fails: Max tokens (max_tokens) caps the upper bound of tokens the model can generate in a single completion, effectively limiting response length. It does not alter the token selection probability distribution; even with a large max_tokens, the model may still repeat phrases indefinitely if other parameters favor that behavior. Thus, while it prevents excessively long outputs, it has no impact on the tendency to produce repeated code patterns.

Top P

Why it fails: Top P (nucleus sampling) restricts the candidate token pool to the smallest set whose cumulative probability exceeds the specified threshold (e.g., 0.95). This influences output diversity by cutting off the long tail of low-probability tokens, but it does not apply any explicit penalty to tokens that have already occurred. Because repetition is driven by high probability assigned to recently generated tokens, Top P alone cannot suppress recurrence without modifying the underlying token probabilities.