A Generative Al Engineer has created a RAG application to look up answers to questions about a
series of fantasy novels that are being asked on the author’s web forum. The fantasy novel texts are
chunked and embedded into a vector store with metadata (page number, chapter number, book
title), retrieved with the user’s query, and provided to an LLM for response generation. The
Generative AI Engineer used their intuition to pick the chunking strategy and associated
configurations but now wants to more methodically choose the best values. Which TWO strategies should the Generative AI Engineer take to optimize their chunking strategy
and parameters? (Choose two.)
Correct Answer: C, E
Explanation:
To optimize a chunking strategy for a Retrieval-Augmented Generation (RAG) application, the
Generative AI Engineer needs a structured approach to evaluating the chunking strategy, ensuring
that the chosen configuration retrieves the most relevant information and leads to accurate and
coherent LLM responses. Here's why C and E are the correct strategies: Strategy C: Evaluation Metrics (Recall, NDCG) Define an evaluation metric: Common evaluation metrics such as recall, precision, or NDCG
(Normalized Discounted Cumulative Gain) measure how well the retrieved chunks match the user's
query and the expected response. Recall measures the proportion of relevant information retrieved. NDCG is often used when you want to account for both the relevance of retrieved chunks and the
ranking or order in which they are retrieved. Experiment with chunking strategies: Adjusting chunking strategies based on text structure (e.g.,
splitting by paragraph, chapter, or a fixed number of tokens) allows the engineer to experiment with various ways of slicing the text. Some chunks may better align with the user's query than others. Evaluate performance: By using recall or NDCG, the engineer can methodically test various chunking
strategies to identify which one yields the highest performance. This ensures that the chunking
method provides the most relevant information when embedding and retrieving data from the
vector store. Strategy E: LLM-as-a-Judge Metric Use the LLM as an evaluator: After retrieving chunks, the LLM can be used to evaluate the quality of
answers based on the chunks provided. This could be framed as a "judge" function, where the LLM
compares how well a given chunk answers previous user queries. Optimize based on the LLM's judgment: By having the LLM assess previous answers and rate their
relevance and accuracy, the engineer can collect feedback on how well different chunking
configurations perform in real-world scenarios. This metric could be a qualitative judgment on how closely the retrieved information matches the
user's intent. Tune chunking parameters: Based on the LLM's judgment, the engineer can adjust the chunk size or
structure to better align with the LLM's responses, optimizing retrieval for future queries.
By combining these two approaches, the engineer ensures that the chunking strategy is
systematically evaluated using both quantitative (recall/NDCG) and qualitative (LLM judgment)
methods. This balanced optimization process results in improved retrieval relevance and,
consequently, better response generation by the LLM.
Question 2
A Generative AI Engineer is designing a RAG application for answering user questions on technical
regulations as they learn a new sport. What are the steps needed to build this RAG application and deploy it?
Correct Answer: B
Explanation:
The Generative AI Engineer needs to follow a methodical pipeline to build and deploy a Retrieval
Augmented Generation (RAG) application. The steps outlined in option B accurately reflect this
process: Ingest documents from a source: This is the first step, where the engineer collects documents (e.g.,
technical regulations) that will be used for retrieval when the application answers user questions.
Index the documents and save to Vector Search: Once the documents are ingested, they need to be embedded using a technique like embeddings (e.g., with a pre-trained model like BERT) and stored
in a vector database (such as Pinecone or FAISS). This enables fast retrieval based on user queries.
User submits queries against an LLM: Users interact with the application by submitting their queries.
These queries will be passed to the LLM. LLM retrieves relevant documents: The LLM works with the vector store to retrieve the most relevant
documents based on their vector representations. LLM generates a response: Using the retrieved documents, the LLM generates a response that is
tailored to the user's question. Evaluate model: After generating responses, the system must be evaluated to ensure the retrieved
documents are relevant and the generated response is accurate. Metrics such as accuracy, relevance,
and user satisfaction can be used for evaluation. Deploy it using Model Serving: Once the RAG pipeline is ready and evaluated, it is deployed using a
model-serving platform such as Databricks Model Serving. This enables real-time inference and
response generation for users. By following these steps, the Generative AI Engineer ensures that the RAG application is both
efficient and effective for the task of answering technical regulation questions.
Question 3
A Generative AI Engineer just deployed an LLM application at a digital marketing company that
assists with answering customer service inquiries. Which metric should they monitor for their customer service LLM application in production?
Correct Answer: A
Explanation:
When deploying an LLM application for customer service inquiries, the primary
focus is on measuring the operational efficiency and quality of the responses. Here's why A is
the correct metric: Number of customer inquiries processed per unit of time: This metric
tracks the throughput of the customer service system, reflecting how many customer
inquiries the LLM application can handle in a given time period (e.g., per minute or hour).
High throughput is crucial in customer service applications where quick response times are
essential to user satisfaction and business efficiency. Real-time performance monitoring:
Monitoring the number of queries processed is an important part of ensuring that the model
is performing well under load, especially during peak traffic times. It also helps ensure the
system scales properly to meet demand. Why other options are not ideal: B . Energy usage
per query: While energy efficiency is a consideration, it is not the primary concern for a
customer-facing application where user experience (i.e., fast and accurate responses) is
critical. C . Final perplexity scores for the training of the model: Perplexity is a metric for
model training, but it doesn't reflect the real-time operational performance of an LLM in
production. D . HuggingFace Leaderboard values for the base LLM: The HuggingFace
Leaderboard is more relevant during model selection and benchmarking. However, it is not a
direct measure of the model's performance in a specific customer service application in
production. Focusing on throughput (inquiries processed per unit time) ensures that the LLM application is
meeting business needs for fast and efficient customer service responses.
Question 4
A Generative AI Engineer is building a Generative AI system that suggests the best matched
employee team member to newly scoped projects. The team member is selected from a very large
team. The match should be based upon project date availability and how well their employee profile
matches the project scope. Both the employee profile and project scope are unstructured text. How should the Generative Al Engineer architect their system?
Correct Answer: D
Explanation:
Problem Context: The problem involves matching team members to new
projects based on two main factors: Availability: Ensure the team members are available
during the project dates. Profile-Project Match: Use the employee profiles (unstructured
text) to find the best match for a project’s scope (also unstructured text). The two main
inputs are the employee profiles and project scopes, both of which are unstructured. This
means traditional rule-based systems (e.g., simple keyword matching) would be inefficient,
especially when working with large datasets. Explanation of Options: Let's break down the
provided options to understand why D is the most optimal answer. Option A suggests
embedding project scopes into a vector store and then performing retrieval using team
member profiles. While embedding project scopes into a vector store is a valid technique, it
skips an important detail: the focus should primarily be on embedding employee profiles
because we're matching the profiles to a new project, not the other way around. Option B
involves using a large language model (LLM) to extract keywords from the project scope and
perform keyword matching on employee profiles. While LLMs can help with keyword
extraction, this approach is too simplistic and doesn’t leverage advanced retrieval techniques
like vector embeddings, which can handle the nuanced and rich semantics of unstructured
data. This approach may miss out on subtle but important similarities. Option C suggests
calculating a similarity score between each team member's profile and project scope. While
this is a good idea, it doesn’t specify how to handle the unstructured nature of data
efficiently. Iterating through each member’s profile individually could be computationally
expensive in large teams. It also lacks the mention of using a vector store or an efficient retrieval mechanism. Option D is the correct approach. Here’s why: Embedding team profiles into a vector store: Using a vector store allows for efficient similarity
searches on unstructured data. Embedding the team member profiles into vectors captures their
semantics in a way that is far more flexible than keyword-based matching. Using project scope for retrieval: Instead of matching keywords, this approach suggests using vector
embeddings and similarity search algorithms (e.g., cosine similarity) to find the team members
whose profiles most closely align with the project scope. Filtering based on availability: Once the best-matched candidates are retrieved based on profile
similarity, filtering them by availability ensures that the system provides a practically useful result.
This method efficiently handles large-scale datasets by leveraging vector embeddings and similarity
search techniques, both of which are fundamental tools in Generative AI engineering for handling
unstructured text. Technical References: Vector embeddings: In this approach, the unstructured text (employee profiles and project scopes) is
converted into high-dimensional vectors using pretrained models (e.g., BERT, Sentence-BERT, or
custom embeddings). These embeddings capture the semantic meaning of the text, making it easier
to perform similarity-based retrieval. Vector stores: Solutions like FAISS or Milvus allow storing and retrieving large numbers of vector
embeddings quickly. This is critical when working with large teams where querying through
individual profiles sequentially would be inefficient. LLM Integration: Large language models can assist in generating embeddings for both employee
profiles and project scopes. They can also assist in fine-tuning similarity measures, ensuring that the
retrieval system captures the nuances of the text data. Filtering: After retrieving the most similar profiles based on the project scope, filtering based on
availability ensures that only team members who are free for the project are considered. This system is scalable, efficient, and makes use of the latest techniques in Generative AI, such as
vector embeddings and semantic search.
Question 5
A Generative AI Engineer is designing an LLM-powered live sports commentary platform. The
platform provides real-time updates and LLM-generated analyses for any users who would like to
have live summaries, rather than reading a series of potentially outdated news articles. Which tool below will give the platform access to real-time data for generating game analyses based
on the latest game scores?
Correct Answer: C
Explanation:
Problem Context: The engineer is developing an LLM-powered live sports commentary platform that
needs to provide real-time updates and analyses based on the latest game scores. The critical
requirement here is the capability to access and integrate real-time data efficiently with the platform for immediate analysisandreporting. Explanation of Options: Option A: DatabricksIQ:WhileDatabricksIQoffersintegration and data processing capabilities, it is
more aligned withdataanalyticsratherthanreal-time feature serving, which is crucial for immediate
updates necessaryinalivesportscommentarycontext. Option B: FoundationModelAPIs:TheseAPIsfacilitate interactions with pre-trained models and
could be partofthesolution,butontheirown,they do not provide mechanisms to access real-time
game scores. Option C: FeatureServing:Thisisthecorrectanswer as feature serving specifically refers to the real-
time provisionofdata(features)tomodelsforprediction. This would be essential for an LLM that
generates analysesbasedonlivegamedata,ensuring that the commentary is current and based on
the latest eventsinthesport. Option D: AutoML:Thistoolautomatestheprocess of applying machine learning models to real-
world problems, butitdoesnotdirectlyprovidereal-time data access, which is a critical requirement
for the platform. Thus, Option C (FeatureServing)isthemostsuitable tool for the platform as it directly supports the
real-time data needsofanLLM-poweredsportscommentary system, ensuring that the analyses and
updates are basedonthelatestavailableinformation.
Demo Practice Mode
You are viewing only the questions marked as Demo.