DSA-C03 Exam Questions Get Updated [2026] with Correct Answers [Q122-Q140]

QUESTION 122
You are training a regression model to predict house prices using a Snowflake dataset. The dataset contains various features, including ‘number of_bedrooms’, , and You want to use time-based partitioning for your training, validation, and holdout sets. However, you also need to ensure that the dataset is properly shuffled within each time partition to mitigate potential bias introduced by the order of data entry. Which of the following strategies is MOST EFFECTIVE and EFFICIENT for partitioning your data into train, validation, and holdout sets in Snowflake, while also ensuring random shuffling within each partition, and addressing potential data leakage issues?

Create separate views for train, validation, and holdout sets, filtering by ‘sale_date’ . Shuffle the entire dataset using ‘ORDER BY RANDOM()’ before creating the views to ensure randomness across all sets. This does not address shuffling within parition.

Create a new column ‘split_group’ using a CASE statement based on ‘sale_date’ to assign each row to ‘train’, ‘validation’, or ‘holdout’. Then, create temporary tables for each split using ‘CREATE TABLE AS SELECT FROM WHERE split_group = ORDER BY RANDOM()’. This can be very slow because of global RANDOM sort and leakage issues with using full dataset for randomness.

Use Snowflake’s SAMPLE clause with a ‘REPEATABLE seed for each split (train, validation, holdout), filtering by ‘sale_date’. Add an ‘ORDER BY RANDOM()’ clause within each ‘SAMPLE query to shuffle the data within each split. This approach does not guarantee non-overlapping sets and can introduce sampling bias.

Create a user-defined function (UDF) in Python that takes a ‘sale_date’ as input and returns either ‘train’, ‘validation’, or ‘holdout’ based on pre-defined date ranges. Apply this UDF to each row, creating a ‘split_group’ column. Then, create temporary tables for each split using ‘CREATE TABLE AS SELECT … FROM . WHERE split_group = … ORDER BY RANDOM()’. UDF overhead and global RANDOM sort make it very slow.

Create a new column ‘split_group’ using a CASE statement based on ‘sale_date’ to assign each row to ‘train’, ‘validation’, or ‘holdout’. Calculate a random number within each ‘split_group’ by using OVER (PARTITION BY split_group ORDER BY RANDOM())’. Then create temporary tables for each split using ‘CREATE TABLE AS SELECT FROM WHERE split_group = QUALIFY ROW NUMBER() OVER (ORDER BY RANDOM()) (SELECT COUNT( ) FROM transactions WHERE split_group — …) (respective split percentage);’

QUESTION 123
You are evaluating a binary classification model’s performance using the Area Under the ROC Curve (AUC). You have the following predictions and actual values. What steps can you take to reliably calculate this in Snowflake, and which snippet represents a crucial part of that calculation? (Assume tables ‘predictions’ with columns ‘predicted_probability’ (FLOAT) and ‘actual_value’ (BOOLEAN); TRUE indicates positive class, FALSE indicates negative class). Which of the below code snippet should be used to calculate the ‘True positive Rate’ and ‘False positive Rate’ for different thresholds

Calculate AUC directly within a Snowpark Python UDF using scikit-learn’s function. This avoids data transfer overhead, making it highly efficient for large datasets. No further SQL is needed beyond querying the predictions data.

The AUC cannot be reliably calculated within Snowflake due to limitations in SQL functionality for statistical analysis.

Using only SQL, Create a temporary table with calculated True Positive Rate (TPR) and False Positive Rate (FPR) at different probability thresholds. Then, approximate the AUC using the trapezoidal rule.

Export the ‘predicted_probability’ and ‘actual_value’ columns to a local Python environment and calculate the AUC using scikit-learn.

The best way to calculate AUC is to randomly guess the probabilities and see how it performs.

QUESTION 124
You are tasked with optimizing the hyperparameter tuning process for a complex deep learning model within Snowflake using Snowpark Python. The model is trained on a large dataset stored in Snowflake, and you need to efficiently explore a wide range of hyperparameter values to achieve optimal performance. Which of the following approaches would provide the MOST scalable and performant solution for hyperparameter tuning in this scenario, considering the constraints and capabilities of Snowflake?

Using a simple ‘for’ loop to iterate through a predefined set of hyperparameter combinations, training the model for each combination within a Snowpark Python UDF, and storing the results in a Snowflake table.

Leveraging a distributed hyperparameter tuning framework like Ray Tune or Dask-ML within Snowpark Python, utilizing Snowflake’s compute resources for parallel training and evaluation of different hyperparameter configurations.

Employing Scikit-learn’s ‘GridSearchCV’ or ‘RandomizedSearchCV’ within a single Snowpark Python UDF, processing the entire dataset and hyperparameter search sequentially.

Implementing a custom hyperparameter optimization algorithm using Snowpark Python UDFs, manually distributing the hyperparameter search across multiple Snowflake virtual warehouses, and aggregating the results in a central table.

Using ‘Hyperopt’ within a Snowpark Python UDF, relying on its sequential optimization approach without any form of parallelization or distribution of the workload.

QUESTION 125
You are using Snowpark Feature Store to manage features for your machine learning models. You’ve created several Feature Groups and now want to consume these features for training a model. To optimize retrieval, you want to use point-in-time correctness. Which of the following actions/configurations are essential to ensure point-in-time correctness when retrieving features using Snowpark Feature Store?

Ensure that all source tables used by the Feature Groups have Change Data Capture (CDC) enabled.

When creating Feature Groups, specify a ‘timestamp_key’ that represents the event timestamp of the data in the source tables.

Use the method on the Feature Store client, providing a dataframe containing the ‘primary_keyS and the desired for each record.

Create an associated Stream on the source tables used for Feature Groups

Explicitly specify a in the call.

QUESTION 126
You’ve deployed a fraud detection model in Snowflake using Snowpark. You are monitoring its performance and notice a significant decrease in recall, while precision remains high. This means the model is missing many fraudulent transactions. The training data was initially balanced, but you suspect that recent changes in user behavior have skewed the distribution of fraudulent vs. non-fraudulent transactions in production. Which of the following actions are MOST appropriate to address this issue and improve the model’s performance, considering best practices for model retraining within the Snowflake ecosystem?

Retrain the model using the original training data. Since the precision is high, the model’s fundamental logic is still sound. A larger training dataset isn’t necessary.

Retrain the model using a dataset that includes recent production data, being sure to re-balance the dataset to maintain a roughly equal number of fraudulent and non-fraudulent transactions. Prioritize transactions from the last month.

Adjust the model’s classification threshold to be more sensitive, even if it means accepting a slightly lower precision. This can be done directly within Snowflake using a SQL UDF that transforms the model’s output probabilities.

Implement a data drift monitoring system in Snowflake to automatically detect changes in the input features of the model. Trigger an automated retraining pipeline when significant drift is detected. This retraining should include recent production data with updated labels, but only if label data collection can be automated.

Immediately shut down the model to prevent further inaccurate classifications. Investigate why the recall is low before any retraining is performed.

QUESTION 127
You are tasked with deploying a real-time fraud detection model in Snowflake. The model requires very low latency (under 100ms) to prevent fraudulent transactions. The input data is streamed into a Snowflake table. You are considering using either a Scalar or Vectorized Python UDF for scoring. Which of the following approaches and considerations are MOST critical for achieving the desired performance and reliability? Assume the model itself is computationally inexpensive. Select all that apply.

Use a Scalar UDF because it has lower overhead per invocation compared to a Vectorized UDF when processing individual transactions.

Use a Vectorized UDF with a small ‘MAX BATCH_SIZE to minimize latency while still leveraging vectorization benefits.

Pre-load the model into a static variable within the UDF code, ensuring it’s only loaded once per worker node.

Utilize Snowflake’s Materialized Views to pre-compute frequently used features, reducing the amount of data the UDF needs to process.

Configure Snowflake’s Auto-Suspend feature to aggressively suspend the warehouse when idle, to minimize costs.

QUESTION 128
A data scientist is tasked with building a predictive maintenance model for industrial equipment. The data is collected from IoT sensors and stored in Snowflake. The raw sensor data is voluminous and contains noise, outliers, and missing values. Which of the following code snippets, executed within a Snowflake environment, demonstrates the MOST efficient and robust approach to cleaning and transforming this sensor data during the data collection phase, specifically addressing outlier removal and missing value imputation using robust statistics? Assume necessary libraries like numpy and pandas are available via Snowpark.

QUESTION 129
You are tasked with deploying a time series forecasting model within Snowflake using Snowpark Python. The model requires significant pre-processing and feature engineering steps that are computationally intensive. These steps include calculating rolling statistics, handling missing values with imputation, and applying various transformations. You aim to optimize the execution time of these pre- processing steps within the Snowpark environment. Which of the following techniques can significantly improve the performance of your data preparation pipeline?

Force single-threaded execution by setting to avoid overhead associated with parallel processing.

Utilize Snowpark’s vectorized UDFs and DataFrame operations to leverage Snowflake’s distributed computing capabilities.

Convert the Snowpark DataFrame to a Pandas DataFrame using and perform all pre-processing operations using Pandas functions before loading the processed data back to Snowflake.

Ensure that all data used is small enough to fit within the memory of the client machine running the Snowpark Python script, thus removing the need for distributed computing.

Write the feature engineering logic directly in SQL and create a view. Use the Snowpark DataFrame API to query the view, avoiding Python code execution within Snowpark.

QUESTION 130
You have trained a fraud detection model using scikit-learn and want to deploy it in Snowflake using the Snowflake Model Registry. You’ve registered the model as ‘fraud _ model’ in the registry. You need to create a Snowflake user-defined function (UDF) that loads and executes the model. Which of the following code snippets correctly creates the UDF, assuming the model is a serialized pickle file stored in a stage named ‘model_stage’?

Option A

Option B

Option C

Option D

Option E

QUESTION 131
You are working with a large dataset of sensor readings stored in a Snowflake table. You need to perform several complex feature engineering steps, including calculating rolling statistics (e.g., moving average) over a time window for each sensor. You want to use Snowpark Pandas for this task. However, the dataset is too large to fit into the memory of a single Snowpark Pandas worker. How can you efficiently perform the rolling statistics calculation without exceeding memory limits? Select all options that apply.

Use the ‘grouped’ method in Snowpark DataFrame to group the data by sensor ID, then download each group as a Pandas DataFrame to the client and perform the rolling statistics calculation locally. Then upload back to Snowflake.

Utilize the ‘window’ function in Snowpark SQL to define a window specification for each sensor and calculate the rolling statistics using SQL aggregate functions within Snowflake. Leverage Snowpark to consume the results of the SQL transformation.

Break the Snowpark DataFrame into smaller chunks using ‘sample’ and ‘unionAll’, process each chunk with Snowpark Pandas, and then combine the results.

Explore using Snowpark’s Pandas user-defined functions (UDFs) with vectorization to apply custom rolling statistics logic directly within Snowflake. UDFs allow you to use Pandas within Snowflake without needing to bring the entire dataset client-side.

Increase the memory allocation for the Snowpark Pandas worker nodes to accommodate the entire dataset.

QUESTION 132
You are tasked with deploying a fraud detection model in Snowflake using the Model Registry. The model is trained on a dataset that is updated daily. You need to ensure that your deployed model uses the latest approved version and that you can easily roll back to a previous version if any issues arise. Which of the following approaches would provide the most robust and maintainable solution for model versioning and deployment, considering minimal downtime during updates and rollback?

Store all model versions within a single model registry entry without versioning, overwriting the existing file with each new training run.

Use Snowflake Tasks to periodically refresh a table containing the latest model weights. The UDF directly queries this table for predictions.

Deploy a new Snowflake UDF referencing the model file directly in cloud storage every time the model is retrained. Rely on cloud storage versioning for rollback.

Register each new model version in the Snowflake Model Registry and promote the desired version to ‘PRODUCTION’ stage. Update a single UDF that dynamically fetches the model based on the ‘PRODUCTION’ stage metadata.

Create multiple Snowflake UDFs, each corresponding to a different model version. Manually switch the active UDF by updating application code when a new model is deployed.

QUESTION 133
You are a data scientist working for a retail company using Snowflake. You’re building a linear regression model to predict sales based on advertising spend across various channels (TV, Radio, Newspaper). After initial EDA, you suspect multicollinearity among the independent variables. Which of the following Snowflake SQL statements or techniques are MOST appropriate for identifying and addressing multicollinearity BEFORE fitting the model? Choose two.

Use ‘ on each independent variable to estimate its uniqueness. If uniqueness is low, multicollinearity is likely.

Calculate the Variance Inflation Factor (VIF) for each independent variable using a user-defined function (UDF) in Snowflake that implements the VIF calculation based on R-squared values from auxiliary regressions. This requires fitting a linear regression for each independent variable against all others.

Generate a correlation matrix of the independent variables using ‘CORR aggregate function in Snowflake SQL and examine the correlation coefficients. Values close to +1 or -1 suggest high multicollinearity.

Implement Principal Component Analysis (PCA) using Snowpark Python to transform the independent variables into uncorrelated principal components and then select only the components explaining a certain percentage of the variance.

Drop one of the independent variable randomly if they seem highly correlated.

QUESTION 134
You’re deploying a pre-trained model for fraud detection that’s hosted as a serverless function on Google Cloud Functions. This function requires two Snowflake tables: ‘TRANSACTIONS (containing transaction details) and ‘CUSTOMER PROFILES (containing customer information), to be joined and used as input for the model. The external function in Snowflake, ‘DETECT FRAUD’, should process batches of records efficiently. Which of the following approaches are most suitable for optimizing data transfer and processing between Snowflake and the Google Cloud Function?

Serialize the joined ‘TRANSACTIONS’ and ‘CUSTOMER_PROFILES data into a large CSV file, store it in a cloud storage bucket, and then pass the URL of the CSV file to the ‘DETECT FRAUD function.

Use Snowflake’s Java UDF functionality to directly connect to the Google Cloud Function’s database, bypassing the need for an external function or data transfer through HTTP.

Within the ‘DETECT FRAUD function, execute SQL queries directly against Snowflake using the Snowflake JDBC driver to fetch the necessary data from the “TRANSACTIONS’ and ‘CUSTOMER PROFILES’ tables.

Utilize Snowflake’s external functions feature to send batches of data from the joined ‘TRANSACTIONS’ and ‘CUSTOMER PROFILES tables to the ‘DETECT_FRAUD function in a structured format (e.g., JSON) using HTTP requests. Implement proper error handling and retry mechanisms.

Create a Snowflake pipe that automatically streams new transaction data to the Google Cloud Function whenever new records are inserted into the ‘TRANSACTIONS’ table, triggering the fraud detection model in real-time.

QUESTION 135
You are using Snowflake Cortex to analyze customer reviews. You have created a vector embedding for each review using a UDF that calls a remote LLM inference endpoint. Now you need to perform a similarity search to identify reviews that are similar to a given query review. Which of the following SQL queries leveraging vector functions in Snowflake is the MOST efficient and appropriate way to achieve this, assuming the ‘REVIEW EMBEDDINGS’ table has columns ‘review_id’ and ’embedding’ (a VECTOR column) and query_embedding’ is a pre-computed vector embedding?

Option A

Option B

Option C

Option D

Option E

QUESTION 136
You’re developing a fraud detection system in Snowflake. You’re using Snowflake Cortex to generate embeddings from transaction descriptions, aiming to cluster similar fraudulent transactions. Which of the following approaches are MOST effective for optimizing the performance and cost of generating embeddings for a large dataset of millions of transaction descriptions using Snowflake Cortex, especially considering the potential cost implications of generating embeddings at scale? Select two options.

Generate embeddings on the entire dataset every day to capture all potential fraudulent transactions and ensure the model is always up-to-date.

Use a Snowflake Task to incrementally generate embeddings only for new transactions that have been added since the last embedding generation run.

Create a materialized view containing pre-computed embeddings for all transaction descriptions.

Generate embeddings using snowflake-cortex-embed-text function, using the OPENAI embedding model

Implement caching mechanism based on a hash of transaction description if transaction description does not change then no need to recompute the emebeddings again.

QUESTION 137
You are training a fraud detection model on a dataset containing millions of transactions. To ensure robust generalization, you’ve decided to implement a train-validation-holdout split using Snowflake’s capabilities. Given the following requirements: Temporal Split: The dataset contains a ‘transaction date’ column. You want to ensure that the validation and holdout sets contain transactions after the training data’. This is crucial because fraud patterns evolve over time. Stratified Sampling (Within Training): The training set should maintain the original proportion of fraudulent vs. non-fraudulent transactions. The column indicates if a transaction is fraudulent (1) or not (0). Deterministic Splits: You need a repeatable process to ensure consistency across model iterations. Which of the following SQL code snippets best achieves these requirements, considering performance and best practices within Snowflake?

Option A

Option B

Option C

Option D

Option E

QUESTION 138
You’ve developed a binary classification model using Snowpark ML to predict customer subscription renewal (0 for churn, 1 for renew). You want to visualize feature importance using a permutation importance technique calculated within Snowflake. You perform feature permutation and calculate the decrease in model performance (e.g., AUC) after each permutation. Suppose the following query represents the results of this process:

The ‘feature_importance_results’ table contains the following data:

Based on this output, which of the following statements are the MOST accurate interpretations regarding feature impact and model behavior?

The ‘contract_length’ feature is the most important feature for the model’s predictive performance; shuffling it causes the largest drop in AUC.

The ‘support_calls’ feature is the least important feature; removing it entirely from the model will have little impact on its AUC performance.

The ‘contract_length’ and ‘monthly_charges’ features are equally important.

Increasing the ‘contract_length’ for customers will always lead to a higher probability of renewal. However, there could be correlation between contract length and monthly charges.

Permutation importance only reveals the importance of features within the current model. Different models trained with different features or algorithms might have different feature rankings.

QUESTION 139
You are building a model deployment pipeline using a CI/CD system that connects to your Snowflake data warehouse from your external IDE (VS Code) and orchestrates model training and deployment. The pipeline needs to dynamically create and grant privileges on Snowflake objects (e.g., tables, views, warehouses) required for the model. Which of the following security best practices should you implement when creating and granting privileges within the pipeline?

Use the role within the pipeline script to create and grant all necessary privileges.

Create a custom role with minimal required privileges to perform only the necessary operations for the pipeline, and grant this role to a dedicated service account used by the pipeline.

Grant the ‘ SYSADMIN’ role to the service account used by the pipeline to ensure it has sufficient privileges.

Hardcode the credentials of a highly privileged user (e.g., a user with the SECURITYADMIN role) in the pipeline script for authentication.

Grant the ‘OWNERSHIP’ privilege on all objects to the service account so it can perform any operation.

QUESTION 140
You are working with a dataset in Snowflake containing customer reviews stored in a ‘REVIEWS’ table. The ‘SENTIMENT SCORE column contains continuous values ranging from -1 (negative) to 1 (positive). You need to create a new column, ‘SENTIMENT CATEGORY, based on the following rules: ‘Negative’: ‘SENTIMENT SCORE < -0.5 ‘Neutral’: -0.5 ‘SENTIMENT SCORE 0.5 ‘Positive’: ‘SENTIMENT SCORE > 0.5 You also want to binarize this ‘SENTIMENT CATEGORY column into three separate columns: ‘IS NEGATIVE, ‘IS NEUTRAL’, and ‘IS POSITIVE. Which of the following SQL statements correctly implements both the categorization and subsequent binarization?

Option A

Option B

Option C

Option D

Option E

Free valid test braindumps

DSA-C03 Exam Questions Get Updated [2026] with Correct Answers [Q122-Q140]

Leave a Reply Cancel reply