Oracle Cloud Infrastructure Generative AI Professional 1Z0-1127-25 (1Z0-1127-25) — Questions 76–150

Explicitly instructing the LLM to answer only based on the provided context directly addresses the root cause of hallucinations in a RAG pipeline: the model's tendency to rely on its parametric knowledge rather than the retrieved documents. This system prompt acts as a behavioral constraint, forcing the model to ground its responses in the supplied context, which is the most effective and widely recommended mitigation strategy.

OCI Data Science Model Deployment provides a managed environment for hosting custom generative AI models with REST API endpoints and built-in authentication via OCI IAM. It integrates natively with OCI Monitoring and OCI Logging to track data drift and operational metrics without requiring additional infrastructure setup, minimizing operational overhead.

Few-shot prompting includes several demonstrations of the desired task, helping the model understand the expected output format and reasoning.

When few-shot examples are too similar, the model overfits to a narrow pattern, reducing its ability to generalize to the diverse reasoning paths required by the task. This is a known limitation of in-context learning: the model treats the examples as a template rather than as diverse demonstrations. Using more diverse examples exposes the model to a wider range of reasoning patterns, improving robustness.

The Chat API does not automatically manage conversation history; the developer must provide previous messages. The model itself retains state only within the provided context.

RAG addresses hallucinations by grounding the model's output in retrieved documents that contain factual information. Knowledge cutoff, bias, and context length constraints are separate issues that RAG may partially help with, but its primary purpose is to reduce factual errors.

Dedicated AI Clusters provide isolated, low-latency inference for custom models. Shared infrastructure is multi-tenant and may have higher latency. On-demand tokens and serving endpoints without a cluster do not offer dedicated resources.

RAG retrieves relevant, current documents at inference time, providing up-to-date context without modifying the model parameters.

The fine-tuning job creation request includes parameters such as 'baseModelId' and 'trainingDataset' (pointing to the dataset in Object Storage). The model deployment endpoint and cluster are separate steps.

A system message or preamble override sets the overall behavior and tone of the assistant for the entire conversation. Temperature controls randomness; max tokens limits length; stop sequences end generation — none are suitable for defining a persistent tone.

Cohere's document-grounded generation requires the preamble to instruct the model to answer based solely on the documents, and the conversation history must include the documents in the correct format.

Increasing TARGET ACCURACY to 99 directly raises the recall threshold for approximate search, forcing the vector index to retrieve more candidates during the search phase. This improves recall without changing the index structure or query parallelism, so query performance (latency) is only minimally impacted compared to switching index types or drastically altering neighbor partitions.

RAG (Retrieval-Augmented Generation) allows the LLM to retrieve relevant document sections at inference time, so knowledge stays current without retraining. The other options either require expensive retraining for each update or lack document grounding.

Prompt engineering allows the company to inject security constraints directly into the instruction without requiring additional training data or infrastructure. By crafting a prompt that explicitly requests secure code (e.g., 'Generate code that follows OWASP Top 10 best practices and avoids SQL injection, XSS, and buffer overflows'), the model can leverage its existing knowledge to produce safer outputs. This approach is immediate, cost-effective, and does not depend on the size or quality of the small secure code dataset.

Fine-tuning on a curated dataset of secure code examples can teach the model to avoid common vulnerability patterns while retaining its general coding ability. RAG with security docs could also help, but fine-tuning directly addresses the model's behavior more comprehensively.

T-Few is parameter-efficient and may require more data. Increasing dataset size or using data augmentation is a likely improvement.

High BLEU and low ROUGE indicate that the generated text has high precision (many n-grams match reference) but low recall (missing many reference n-grams). This often occurs when the output is short or overly cautious.

Using the OCI OpenSearch document update API to replace embeddings for changed documents is efficient and targeted, ensuring immediate consistency.

LLMs can produce hallucinations (factual errors), have a knowledge cutoff date, and can exhibit bias from training data. They do not inherently lack creativity, and context length is a limitation but not a 'lack of understanding'.

Top_p (nucleus sampling) directly impacts consistency by controlling the cumulative probability threshold for token selection. A lower Top_p (e.g., 0.1) restricts the model to only the most probable tokens, reducing randomness and making outputs more deterministic across repeated prompts. This parameter, along with Temperature, is a primary lever for managing output variability in LLMs.

Temperature sampling with a higher temperature (>1) increases the probability of less likely tokens, promoting creativity and diversity.

WebBaseLoader is a LangChain document loader that fetches a web page from a URL and extracts its text content. PDFLoader loads PDFs, TextLoader loads local text files, and CSVLoader loads CSV files.

Self-consistency generates multiple reasoning paths (e.g., using chain-of-thought) and then takes a majority vote or averages results, which directly matches the need for multiple paths and aggregation.

A/B testing helps compare prompt variants, and establishing evaluation criteria ensures objective measurement of improvements. The other options are either irrelevant or counterproductive.

Dedicated AI clusters provide guaranteed compute resources (GPUs) with no multi-tenant contention, ensuring low latency and high throughput for inference workloads. Using a base model avoids the additional overhead of fine-tuning inference, which can introduce latency due to custom weight loading and optimization steps. This combination is optimal for real-time summarization of customer feedback where response time and volume are critical.

ReAct explicitly interleaves reasoning (Thought) and actions (Action) before final output.

Explicit instruction to base answers solely on provided context, with a constraint to say if information is missing, directly reduces hallucinations.

The startup requires low latency and cost efficiency for a customer support chatbot. Instruct models like cohere.command are specifically fine-tuned to follow conversational instructions and generate concise, task-oriented responses, making them ideal for interactive chatbot applications. They balance performance and cost better than base models, which lack instruction-following capability, and embedding models, which are designed for semantic search rather than text generation.

OCI Data Science Model Deployment with GPU shapes is the best option because it provides managed, scalable, low-latency inference endpoints for LLMs. GPU shapes (e.g., VM.GPU.A10) are essential for the parallel matrix computations required by transformer-based models, and the deployment service supports auto-scaling and load balancing to maintain real-time response times.

Reinforcement Learning from Human Feedback (RLHF) directly addresses semantic correctness by fine-tuning the model using human-validated code examples. This process teaches the model to prefer outputs that are not only syntactically valid but also logically correct and aligned with developer intent, reducing semantically wrong code generation.

Lowering temperature reduces randomness, making outputs more deterministic and less prone to errors, while still allowing some variation.

Temperature controls randomness; frequency penalty reduces repetition of words/phrases; presence penalty encourages new topics.

Fine-tuning with a balanced, curated dataset directly addresses the root cause of bias by adjusting the model's internal weights to reduce reliance on biased patterns in the original training data. This approach preserves the model's generative performance for product descriptions because it retrains only on domain-specific, unbiased examples, unlike post-processing which merely filters outputs without correcting the underlying model behavior.

For clustering tasks, the 'clustering' input type optimizes the embeddings for that purpose. The other types are for different tasks.

Autoscaling with a minimum of 1 and maximum of 10 GPU instances allows the deployment to dynamically adjust capacity in response to variable traffic and spikes, ensuring cost-efficiency by scaling down during low demand and responsiveness by scaling up during peaks. OCI Data Science Model Deployment supports autoscaling policies that can be configured with GPU shapes, making it the optimal choice for a generative AI model requiring GPU acceleration.

The 429 (Too Many Requests) error indicates the API rate limit has been exceeded. In OCI Generative AI services, rate limits are enforced per tenancy and per region; the recommended action is to wait for the retry-after period and implement exponential backoff to avoid overwhelming the service.

Deploying a custom generative AI model via OCI Data Science Model Deployment requires packaging the model and its inference code into a standardized artifact format (e.g., pickle, ONNX). This artifact is the core input that the deployment runtime loads to serve predictions, making it an essential step in the workflow.

A is correct because RecursiveCharacterTextSplitter is the standard text splitter in LangChain for splitting documents into chunks while preserving semantic boundaries (e.g., paragraphs, sentences). It recursively splits on different separators (like newlines, spaces) to maintain context, which is critical for effective retrieval in a RAG pipeline.

OCI Generative AI expects a JSONL file where each line is a JSON object with 'prompt' and 'completion' fields. CSV, Parquet, and text files are not supported for fine-tuning.

OCI Object Storage is a supported source for training data when fine-tuning models in OCI Generative AI. The service can directly access data stored in Object Storage buckets via service-level integrations, allowing you to reference large datasets without local uploads.

Enabling reranking improves the relevance of retrieved documents by reordering them based on semantic match with the query. Without reranking, the initial vector search results may not be optimally ordered.

Chain-of-thought prompting explicitly instructs the model to think step by step, improving reasoning accuracy.

ReAct stands for Reason + Act. The model first reasons about the question, then decides on an action (e.g., a tool call) to gather information, iterating until a final answer is reached.

A dedicated AI cluster in OCI Generative AI is designed for real-time inference with low latency. When the cluster is configured for batch inference, it processes requests in batches rather than individually, which introduces queuing and processing delays that can easily exceed the 500ms target. This explains the observed 2-second latency, as batch mode prioritizes throughput over per-request response time.

OCI Generative AI Agents provides a managed RAG service that can ingest documents from Object Storage and answer questions based on the ingested knowledge base.

OCI OpenSearch with Approximate Nearest Neighbor (ANN) indexes is a best practice for vector storage and retrieval in RAG applications. ANN indexes enable efficient similarity search over high-dimensional embeddings, which is essential for retrieving relevant context from large document collections at low latency.

A is correct because the OCI Console provides a built-in chat interface that allows users to interact directly with Generative AI models without writing any code. This interface is part of the OCI Generative AI service's web-based console, enabling prompt testing and model evaluation through a graphical user interface.

Gradient accumulation allows the model to simulate the effect of a larger batch size without increasing memory usage. Instead of computing gradients over a single large batch, the optimizer accumulates gradients over several smaller batches before performing a weight update. This technique effectively decouples the batch size from memory consumption, enabling training on large models or high-resolution inputs that would otherwise cause an out-of-memory error.

ROUGE, BLEU, and BERTScore are all used for summarization evaluation. Perplexity measures model confidence, and cosine similarity is for embedding comparison.

OCI APIs require request signing using an API signing key (an RSA key pair) for programmatic access. The developer must generate a key pair, upload the public key to the OCI console, and then use the private key to sign each HTTP request using the OCI Signature Version 1 algorithm (based on RFC 2104 HMAC-SHA256). This ensures authentication without transmitting secrets over the wire.

OCI Generative AI fine-tuning expects training data in JSONL format with specific fields.

The 'manage' verb on the 'genai-family' resource type grants full access (including use) to OCI Generative AI resources, and scoping the policy to 'compartment prod' restricts the permission to only that compartment. The requirement is to allow the 'DataScientists' group to use (which implies manage-level access for creating and running inference jobs) Generative AI resources specifically in the 'prod' compartment, not the entire tenancy.

The OCI Generative AI Playground provides an interactive web UI to test models and adjust parameters.

A/B testing involves running both prompt variants on the same inputs and comparing outputs against human-annotated ground truth. This provides quantitative evidence of which prompt performs better.

Setting a system prompt (or preamble) instructs the model on its role, tone, and constraints before the user message. This is the standard way to enforce persona and tone consistently.

Self-consistency generates multiple reasoning paths (e.g., with higher temperature) and selects the most consistent answer by majority vote, improving reliability.

RAG (Retrieval-Augmented Generation) allows the LLM to retrieve relevant document sections at inference time, so knowledge stays current without retraining. The other options either require expensive retraining for each update or lack document grounding.

Implementing a request queue (e.g., OCI Queue) decouples request ingestion from processing, allowing the service to buffer bursts of requests and process them asynchronously. This prevents timeouts by smoothing out the variable inference times caused by differing sequence lengths, as the queue absorbs spikes and the model processes at its own pace. Autoscaling based on CPU utilization is too slow for sudden spikes, but a queue provides immediate relief by not dropping requests.

ROUGE measures recall-oriented overlap between generated and reference summaries, suitable for summarization. BERTScore uses semantic similarity via embeddings. BLEU is for translation, perplexity for language modeling, and human evaluation is qualitative.

The policy is scoped to a specific compartment ID, but the user's compartment does not match that ID. For OCI IAM policies to grant access to resources like the Generative AI API, the policy must be written for the compartment where the resource resides or where the user operates. Since the user is in a different compartment, the policy does not apply, causing the API call to fail.

The desired granularity of retrieval determines how much context is returned per chunk. Fine-grained chunks (e.g., sentences) improve precision for specific answers, while coarse chunks (e.g., paragraphs) provide broader context. This directly impacts the relevance and completeness of the retrieved passages in a RAG pipeline.

Frequency penalty reduces the model's tendency to repeat tokens or phrases by penalizing tokens that have already appeared in the generated text.

Latency sensitivity, throughput consistency, and cost predictability are key factors. On-demand is variable cost with potential contention; dedicated offers fixed cost with reserved capacity. Model accuracy does not differ based on pricing model, and data residency is a compliance factor but not directly tied to pricing model choice.

Providing only a task instruction ('Write a poem') without specifying the rhyme scheme or giving examples leaves the model to choose its own structure. The other options give explicit formatting or examples.

Comparing inference statistics over time (Option A) is correct because model drift in generative AI is detected by monitoring changes in output distributions, token probabilities, or response patterns relative to baseline metrics. This allows you to identify when the model's behavior deviates from expected performance due to shifts in input data or underlying patterns.

Implementing a caching layer for frequently asked questions reduces redundant LLM invocations and vector store queries, directly lowering latency for repeated queries. This approach leverages in-memory caches like Redis or Memcached to serve precomputed responses, bypassing the retrieval and generation pipeline for cached items.

Dynamic batching groups requests of similar input lengths together, which reduces the variance in inference time by ensuring that each batch processes tokens of comparable size. This minimizes the padding overhead and keeps the per-request latency more predictable, directly addressing the high tail latency caused by variable-length sequences without altering the model architecture.

The error message indicates that the model endpoint is not found. In OCI Generative AI, when an administrator deletes an endpoint, subsequent requests to that endpoint's URL return a 404 Not Found error. This is the most likely reason because the endpoint resource no longer exists in the tenancy, and the request cannot be routed to any model.

Lowering temperature reduces randomness, increasing frequency penalty penalizes repeated tokens, and setting appropriate max tokens controls output length. Stop sequences define when generation stops, and presence penalty penalizes token presence overall.