매달, 우리는 1000명 이상의 사람들이 시험 준비를 잘하고 시험을 잘 통과할 수 있도록 도와줍니다.
SnowPro® Specialty: Gen AI Certification Exam 온라인 연습
최종 업데이트 시간: 2025년12월09일
당신은 온라인 연습 문제를 통해 Snowflake GES-C01 시험지식에 대해 자신이 어떻게 알고 있는지 파악한 후 시험 참가 신청 여부를 결정할 수 있다.
시험을 100% 합격하고 시험 준비 시간을 35% 절약하기를 바라며 GES-C01 덤프 (최신 실제 시험 문제)를 사용 선택하여 현재 최신 350개의 시험 문제와 답을 포함하십시오.
정답:
Explanation:
To execute Snowflake Cortex AI functions such as 'SNOWFLAKE.CORTEX.COMPLETE, 'SNOWFLAKE.CORTEX.CLASSIFY_TEXT, and (or their 'AL' prefixed counterparts), the role used by the application in this case) must be granted the 'SNOWFLAKE.CORTEX USER database role. Additionally, for the application to access any database or schema objects (like tables for data input/output or storing the Streamlit app itself), the 'USAGE privilege must be granted on those specific database and schema objects. option B, ‘CREATE SNOWFLAKE.ML.DOCUMENT_INTELLIGENCE, is a privilege specific to creating Document AI model builds and is not required for general Cortex LLM functions.
Option D, 'ACCOUNTADMIN', grants excessive privileges and is not a best practice for application roles.
Option E, 'CREATE COMPUTE POOL', is a privilege related to Snowpark Container Services for creating compute pools, which is not directly required for running a Streamlit in Snowflake application that consumes Cortex LLM functions.
정답:
Explanation:
'AI_COMPLETE Structured OutputS (and its predecessor 'COMPLETE Structured Outputs’) specifically allows supplying a JSON schema as the ‘response_format’ argument to ensure completion responses follow a predefined structure. This significantly reduces the need for post-processing and enables seamless integration with systems requiring deterministic responses. The JSON schema object defines the structure, data types, and constraints, including required fields. While prompting the model to 'Respond in JSON' can improve accuracy for complex tasks, the 'response_format’ argument is the direct mechanism for enforcing the schema.
Option A is a form of prompt engineering, which can help but does not guarantee strict adherence as ‘response_format’ does.
Option B controls randomness and length, not output structure.
Option D is less efficient for extracting multiple related fields compared to a single structured output call.
Option E's ‘guardrails' are for filtering unsafe or harmful content, not for enforcing output format.
정답:
Explanation:
To provide a stateful, conversational experience with the 'COMPLETE (SNOWFLAKE.CORTEX)' function, all previous user prompts and model responses must be passed as part of the argument. This argument accepts an array of objects, where each object represents a turn and contains a ‘role' ('system', 'user', or 'assistant') and a ‘content' key, presented in chronological order. In Streamlit, st.session_states is the standard and recommended mechanism for storing and managing data across reruns of the application, making it ideal for maintaining chat history.
Option A is inefficient and incorrect because ‘COMPLETE does not inherently manage history from external tables.
Option B is incorrect as ‘COMPLETE does not retain state between calls; history must be explicitly managed.
Option D is less effective than structured history, as it loses the semantic role distinction and can be less accurate for LLMs.
Option E describes a non-existent parameter for the 'COMPLETE' function.
정답:
Explanation:
To execute Snowflake Cortex AI functions such as ‘SNOWFLAKE.CORTEX.COMPLETE and 'SNOWFLAKE.CORTEX.CLASSIFY_TEXT, the role used by the developer must be granted the 'SNOWFLAKE.CORTEX_USER database role. This role provides the necessary permissions to call these specific AI functions. Additionally, for a Streamlit application to run and perform operations within a designated database and schema (e.g., accessing tables, stages, or storing outputs), the role requires the ‘USAGE privilege on that database and schema.
Option B ('CREATE SNOWFLAKE.ML.DOCUMENT INTELLIGENCE') is a privilege specifically for creating DocumentAI model builds, not for using general Cortex LLM functions.
Option D (EXECUTE TASK) is required for creating and running tasks, typically in automated data pipelines, which is distinct from direct LLM function execution within a Streamlit app.
Option E is an application role necessary for AI Observability to log and view application traces for debugging and performance evaluation, but it is not a core requirement for merely executing LLM functions.
정답:
Explanation:
To provide a stateful, conversational experience with the 'COMPLETE (SNOWFLAKE.CORTEX)' function, all previous user prompts and model responses in the conversation must be passed as part of the argument. This argument is an array of objects, with each object representing a turn in the conversation and containing a ‘role’ ('system', 'user', or 'assistant') and a ‘content' key, presented in chronological order.
Option A is less effective as it loses the structured conversational context that roles provide.
Option C is incorrect because 'COMPLETE' does not retain any state from one call to the next; conversational history must be explicitly managed and passed.
Option D describes a non-existent parameter for the ‘COMPLETE function.
Option E, while fine-tuning is a Snowflake Cortex capability, it is used to customize a model for a specific task over time, not for real-time maintenance of dynamic conversational context in a multi-turn chat.
정답:
Explanation:
For a multi-turn conversational AI application built with Streamlit, maintaining the conversation history is fundamental. Streamlit's st.session_state' is the primary way to store and manage state across reruns of the application, which is crucial for remembering past interactions in a chat interface. The typical approach involves initializing 'st.session_state.messages’ to an empty list and appending messages for each turn.
Option A is incorrect because is a database role specific to Document AI, not general Cortex LLM functions.
Option C is not a fundamental step for running a Streamlit application in Snowflake (SiS) itself, as SiS directly hosts the Streamlit app; while models can be served via SPCS, the application itself doesn't inherently require it for basic operation.
Option D is related to cross-region inference for LLM functions, which controls where inference requests are processed, not a fundamental step for local execution or conversational state management.
Option E suggests a configuration ("ON ERROR':'SKIP") that is primarily used with Snowflake ML functions like Anomaly Detection and Time-Series Forecasting to prevent overall training failure for individual series, and is not a direct option for handling errors in ‘TRY_COMPLETE in this manner; 'TRY_COMPLETE itself returns NULL on error.
정답:
Explanation:
For optimizing RAG pipeline performance and relevance: ‘This statement is incorrect. Snowflake's documentation explicitly recommends splitting text into smaller chunks (no more than 512 tokens) for Cortex Search to achieve optimal retrieval and downstream LLM response quality. This holds true even with models that have larger context windows like ‘snowflake-arctic-embed-l-v2.0-8k', because smaller chunks lead to more precise retrieval.
* B: Deploying custom models like a Hugging Face ‘sentenceTransformeN on Snowpark Container Services (SPCS) with GPU compute pools (e.g., *GPU or *GPU NV_M') is optimized for intensive GPU usage scenarios like LLMs/VLMs. This can provide lower latency and higher throughput for embedding generation in very high-volume, custom scenarios, offering more control than managed functions. ‘ This statement is correct. Snowflake's documentation clearly states that for best search results with Cortex Search, it is recommended to split the text in the search column into chunks of no more than 512 tokens. This strategy typically results in higher retrieval and better quality responses from downstream LLMs.
* This statement is incorrect. Snowflake explicitly advises executing queries that call Cortex AI SQL functions (including ‘EMBED_TEXT') with a *smaller* warehouse (no larger than MEDIUM), as larger warehouses do not increase performance for these specific functions.
* *E:" This statement is incorrect. Cortex Search powers RAG applications by leveraging *semantic search*, which combines both vector and keyword search capabilities, to provide customized, contextualized responses. Relying solely on keyword search would generally yield less contextual relevance for LLM responses than a hybrid approach.
정답:
Explanation:
To optimize a fine-tuned model's performance and minimize inference latency:
* Smaller models (like *llama3-8b' with an 8k context window, supporting 6k for prompt and 2k for completion) generally have lower latency for both training and inference. While exceeding the context window results in truncation which can negatively impact quality, for specific tasks, a smaller, fine-tuned model can achieve the required accuracy with better performance.
* B: Deploying a fine-tuned model to a Snowpark Container Services (SPCS) compute pool with GPU instances (e.g., or is crucial for leveraging GPU acceleration. This is explicitly optimized for intensive GPU usage scenarios like LLMsA/LMs, which significantly reduces inference latency and increases throughput.
* It is important to ensure that prompt and completion pairs do not *exceed* the context window to prevent truncation and negative impact on model quality. However, *precisely filling* the context window is not a requirement or an optimization strategy; the focus should be on providing relevant and high-quality data within the model's limits.
* 'D:" Setting ‘max_epochs’ to 1 reduces the *training time*. However, training time does not directly improve *inference* latency for the deployed model. Inference latency depends on the model's architecture, deployment hardware, and runtime optimizations. Furthermore, too few epochs can lead to a poorly performing model, failing the accuracy requirement.
* E: This describes using the ‘AI CLASSIFY managed function for zero-shot classification, which is an alternative to fine-tuning. While it might avoid the latency associated with fine-tuning *training*, the question is specifically about optimizing the performance of a *fine-tuned model* for a specialized task, implying that fine-tuning is chosen for its potential to achieve higher accuracy for that niche use case compared to zero-shot approaches.
정답:
Explanation:
To address latency in multi-turn conversations within Cortex Analyst, implementing an LLM summarization agent to condense conversation history is the key strategy. Cortex Analyst utilizes such an agent to manage arbitrarily long conversation histories, preventing longer inference times, non-determinism, and performance degradation that would occur if the full history were passed to every LLM call.
Option A is incorrect because Snowflake recommends executing queries that call Cortex AI SQL functions, including those underlying Cortex Analyst, with smaller warehouses (no larger than MEDIUM), as larger warehouses do not increase performance for these functions.
Option C is a manual approach to context management, whereas Cortex Analyst incorporates an automated summarization agent for this purpose.
Option D is problematic because while a smaller model might reduce general inference latency, Cortex Analyst specifically chose Llama 3.1 70B as its summarization agent due to its superior accuracy (96.5% good rating by LLM judge) over Llama 3.1 8B (5% error rate) for this task, indicating that a smaller, less capable model could degrade summarization quality.
Option E is incorrect as ‘verified_queries’ are for specific, pre-defined questions and do not handle the dynamic, contextual nature of multi-turn conversations or the summarization of past turns.
정답:
Explanation:
Option A is correct because custom instructions provide unique business context to the LLM, enabling greater control over the generated SQL queries to align with specific business needs or formatting.
Option C is also correct because by providing business context to the LLM via custom instructions, the model can better handle domain-specific terminology or complex business logic, improving accuracy.
Option B is incorrect; a ‘verified_querv’ provides a *pre-written and verified SQL query* for a specific question. If a user's question is similar to a verified query, Cortex Analyst typically uses that query, potentially overriding or prioritizing it over general 'custom_instructions’ for that specific scenario, as verified queries are explicit answers. The sources imply that verified queries are a direct solution for known questions, while custom instructions provide general guidance.
Option D is incorrect for Cortex Analyst; the credit rate usage is based on the number of messages processed, not the number of tokens, so the length of custom instructions doesn't directly affect cost via token count.
Option E is incorrect as ‘custom_instructions’ are for guiding SQL generation, not for defining or extending the semantic model's structure (logical tables, dimensions).
정답:
Explanation:
Custom instructions in Cortex Analyst provide unique business context to the LLM to control SQL query generation. These instructions are provided in natural language within the semantic model YAML. This means the engineer should describe the desired behavior (grouping by ‘customer_segment’ and presenting as a percentage) in plain English for the LLM to interpret and apply, making option C correct.
Option A is incorrect because ‘custom_instructionS guide the LLM's *generation* process, not directly inject SQL snippets.
Option B is incorrect as custom instructions are part of the YAML, not a separate Python file.
Option D is incorrect; while Copilot's custom instructions have a 2,000 character limit, the source does not specify such a limit for Cortex Analyst's semantic model ‘custom_instructionS, and the ‘task_description’ for 'CLASSIFY _ TEXT is limited to about 50 words.
Option E is incorrect; the ‘custom_instructions’ in the semantic model are part of the shared model definition, not user-specific in the way Snowflake Copilot's custom instructions are.
정답:
Explanation:
To enforce overarching, consistent behavior in SQL query generation regardless of user input, the ‘custom_instructions’ field in the semantic model YAML is the most appropriate mechanism. It allows providing unique business context and directives directly to the LLM that Cortex Analyst uses, enabling greater control over the generated SQL.
Option A (verified queries) is good for specific questions but would require an exhaustive and potentially unmanageable list to cover *all* user inputs for general rules.
Option C (logical table-level filters) can apply ‘WHERES’ clauses but doesn't inherently enforce a specific date format across all date columns consistently without further explicit definition for each time dimension, and the source doesn't detail a filter mechanism for global date format enforcement.
Option D ('task_description’ in "CLASSIFY _ TEXT) is for task-specific classification and not for controlling SQL generation by Cortex Analyst.
Option E (custom UDFs for post- processing) is an external step to Cortex Analyst's core text-to-SQL generation and adds unnecessary complexity, losing the benefit of Cortex Analyst's managed nature, and is not a direct configuration *within* Cortex Analyst to influence SQL generation.
정답:
Explanation:
Cortex Analyst offers solutions to improve literal usage, including semantic search over sample values in the semantic model and semantic search using Cortex Search Services. For dimensions with high cardinality (many distinct values), creating a Cortex Search Service on the underlying column and specifying it in the field of the dimension within the semantic model is the recommended approach. This allows for high-quality "fuzzy" search to find literal values needed for Cortex Analyst's SQL queries.
Option A is less effective for high-cardinality dimensions because only a fixed-size set of sample values is presented to the LLM, regardless of how many are provided.
Option C is not the intended use for the 'description’ field and could exceed context window limits.
Option D, while a possible technical solution, bypasses the integrated and optimized Cortex Search functionality designed for this purpose.
Option E is explicitly contradicted by the scenario, which indicates the LLM struggles, and the available solutions are designed to address this limitation.
정답:
Explanation:
To configure onboarding questions, a Verified Query Repository (VQR) must be defined in the semantic model, and the specific questions must be included as ‘verified_queries’. Therefore, option A is correct. For each desired question to function as an onboarding question, the flag must be set to ‘true' within its VQR entry, which ensures these questions are returned regardless of user input similarity. This makes option B correct. Verified SQL queries in the VQR must use the names of logical tables and columns defined in the semantic model, not the underlying physical column names, so option C is incorrect. Cortex Analyst will return all questions marked as onboarding questions, even if there are more than five, if the feature is configured in Customizable Mode, making option D incorrect. The task_description’ is an optional argument in functions like ‘CLASSIFY_TEXT’ and is not used by Cortex Analyst to generate onboarding questions via LLMs; onboarding questions are drawn from the VQR.
정답:
Explanation:
Cortex Analyst's 'Suggested Questions' feature operates in different modes. If a semantic model does not include a Verified Query Repository (VQR), Cortex Analyst uses Large Language Models (LLMs) to generate up to three suggested questions, which may not always be answerable. Therefore, option A is incorrect because it returns a blank list, and option D is incorrect because the LLM-generated questions are not guaranteed to be answerable. When a semantic model has a VQR defined, Cortex Analyst suggests up to five questions from the VQR based on their similarity to the user's input, making option B correct. Furthermore, in Customizable Mode, if verified queries in the VQR are marked with
, Cortex Analyst will return all of these flagged questions, regardless of their quantity or similarity to user input, making option E correct and option C incorrect.