2026 Valid DSA-C03 Exam Updates – 2026 Study Guide [Q96-Q115]

Q96. You’re developing a Python UDTF in Snowflake to perform sentiment analysis on customer reviews. The UDTF uses a pre-trained transformer model from Hugging Face. The code is as follows:

When deploying this UDTF, you encounter a ‘ModuleNotFoundError: No module named ‘transformers” error. Considering best practices for managing dependencies in Snowflake UDTFs, what is the most effective way to resolve this issue?

Install the ‘transformers’ library directly on the Snowflake compute nodes using Snowpark’s ‘add_packageS method at the session level:

Create a Conda environment containing the ‘transformers’ library, package it into a zip file, upload it to a Snowflake stage, and specify the stage path in the ‘imports’ parameter when registering the UDTF.

Include the ‘transformers’ library in the same Python file as the UDTF definition. This is acceptable for smaller libraries.

Use the ‘snowflake-ml-python’ library and its dependency management features to automatically resolve and deploy the ‘transformers’ dependency.

Upload all the dependencies of Transformers (manually downloaded libraries) to the internal stage.

Q97. A telecom company, ‘ConnectPlus’, observes that the individual call durations of its customers are heavily skewed towards shorter calls, following an exponential distribution. A data science team aims to analyze call patterns and requires to perform hypothesis testing on the average call duration. Which of the following statements regarding the applicability of the Central Limit Theorem (CLT) in this scenario are correct if the sample size is sufficiently large?

The CLT is not applicable because the population distribution (call durations) is heavily skewed.

The CLT is applicable, and the distribution of sample means of call durations will approximate a normal distribution, regardless of the skewness of the individual call durations.

The CLT is applicable only if the sample size is extremely large (e.g., greater than 10,000), due to the exponential distribution’s heavy tail.

The CLT is applicable, and the sample mean will converge to the population median.

The CLT is applicable as long as the sample size is reasonably large (typically n > 30), and the distribution of sample means will be approximately normal. The specific minimum sample size depends on the severity of the skewness.

Q98. You are working with a dataset containing timestamps representing website user activity. The timestamps are stored as strings in the format ‘YYYY-MM-DD HH:MI:SS.SSSSSS’ in a Snowflake table named ‘website_activity’. You need to extract the hour of the day from these timestamps and encode it as a cyclical feature using sine and cosine transformations. This is to capture the cyclical nature of user activity throughout the day (e.g., 23:00 and 00:00 are close in time). Which of the following Snowflake SQL code snippets correctly implements this cyclical encoding and creates the ‘hour_sin’ and ‘hour_cos’ columns?

Q99. You are developing a real-time fraud detection system using Snowflake and an external function. The system involves scoring incoming transactions against a pre-trained TensorFlow model hosted on Google Cloud A1 Platform Prediction. The transaction data resides in a Snowflake stream. The goal is to minimize latency and cost. Which of the following strategies are most effective to optimize the interaction between Snowflake and the Google Cloud A1 Platform Prediction service via an external function, considering both performance and cost?

Invoke the external function for each individual transaction in the Snowflake stream, sending the transaction data as a single request to the Google Cloud A1 Platform Prediction service.

Implement a caching mechanism within the external function (e.g., using Redis on Google Cloud) to store frequently accessed model predictions, thereby reducing the number of calls to the Google Cloud A1 Platform Prediction service. This requires managing cache invalidation.

Batch multiple transactions from the Snowflake stream into a single request to the external function. The external function then sends the batched transactions to the Google Cloud A1 Platform Prediction service in a single request. This increases throughput but might introduce latency.

Use a Snowflake pipe to automatically ingest the data from the stream, and then trigger a scheduled task that periodically invokes a stored procedure to train the model externally.

Implement asynchronous invocation of the external function from Snowflake using Snowflake’s task functionality. This allows Snowflake to continue processing transactions without waiting for the response from the Google Cloud A1 Platform Prediction service, but requires careful monitoring and handling of asynchronous results.

Q100. You are building a data science pipeline in Snowflake to predict customer churn. The pipeline includes a Python UDF that uses a pre- trained scikit-learn model stored as a binary file in a Snowflake stage. The UDF needs to load this model for prediction. You’ve encountered an issue where the UDF intermittently fails, seemingly related to resource limits when multiple concurrent queries invoke the UDF. Which of the following strategies would best optimize the UDF for concurrency and resource efficiency, minimizing the risk of failure?

Load the scikit-learn model inside the UDF function on every invocation to ensure the latest version is used.

Load the scikit-learn model outside the UDF function in the global scope of the module so that all invocations share the same loaded model instance. Use the ‘context.getExecutionContext(Y to track execution, making sure it is thread safe.

Utilize Snowflake’s session-level caching by storing the loaded model in ‘session.get(‘model’)’ to be reused across multiple UDF calls within the same session. Reload the model if ‘session.get(‘model’)’ is None.

Implement a global, lazy-loaded cache for the scikit-learn model within the UDF’s module. The model is loaded only once during the first invocation and shared across subsequent calls. Protect the loading process with a lock to prevent race conditions in concurrent environments.

Increase the memory allocated to the Snowflake warehouse to accommodate multiple UDF invocations.

Q101. You have a Snowflake table called ‘website visits’ with columns ‘user id’, ‘visit_date’, and You need to identify users who consistently spend a large amount of time on specific page URLs. You want to calculate the average time spent per user on each page URL and then find the top 10 page URLs where users, on average, spend the most time. Which of the following approaches is the MOST efficient and accurate for achieving this in Snowflake?

Q102. You are building a binary classification model in Snowflake to predict customer churn based on historical customer data, including demographics, purchase history, and engagement metrics. You are using the SNOWFLAKE.ML.ANOMALY package. You notice a significant class imbalance, with churn representing only 5% of your dataset. Which of the following techniques is LEAST appropriate to handle this class imbalance effectively within the SNOWFLAKE.ML framework for structured data and to improve the model’s performance on the minority (churn) class?

Using the ‘sample_weight’ parameter in the ‘SNOWFLAKE.ML.ANOMALY.FIT function to assign higher weights to the minority class instances during model training.

Applying a SMOTE (Synthetic Minority Over-sampling Technique) or similar oversampling technique to generate synthetic samples of the minority class before training the model outside of Snowflake, and then loading the augmented data into Snowflake for model training.

Adjusting the decision threshold of the trained model to optimize for a specific metric, such as precision or recall, using a validation set. This can be done by examining the probability outputs and choosing a threshold that maximizes the desired balance.

Downsampling the majority class to create a more balanced training dataset within Snowflake using SQL before feeding the data to the modeling function.

Using a clustering algorithm (e.g., K-Means) on the features and then training a separate binary classification model for each cluster to capture potentially different patterns of churn within different customer segments.

Q103. 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);’

Q104. You are working with a Snowflake table named ‘sensor readingS containing IoT sensor data’. The table has columns ‘sensor id’ , ‘timestamp’ , and ‘reading value’. You observe that the ‘reading value’ column contains a significant number of missing values (represented as NULL). To prepare this data for a time series analysis, you need to impute these missing values. You have decided to use the ‘LOCF’ (Last Observation Carried Forward) method, filling the NULL values with the most recent non-NULL value for each sensor. In addition to LOCF, you also want to handle the scenario where a sensor has NULL values at the beginning of its data stream (i.e., no previous observation to carry forward). For these initial NULLs, you want to use a fixed default value of 0. Which of the following approaches, using either Snowpark for Python or a combination of Snowpark and SQL, correctly implements this LOCF imputation with a default value?

All of the above

Q105. A data scientist is building a model in Snowflake to predict customer churn. They have a dataset with features like ‘age’, ‘monthly_spend’, ‘contract_length’, and ‘complaints’. The target variable is ‘churned’ (0 or 1). They decide to use a Logistic Regression model. However, initial performance is poor. Which of the following actions could MOST effectively improve the model’s performance, considering best practices for Supervised Learning in a Snowflake environment focused on scalable and robust deployment?

Increase the learning rate significantly to speed up convergence during training.

Implement feature scaling (e.g., StandardScaler or MinMaxScaler) on numerical features within Snowflake, before training the model. Leverage Snowflake’s user-defined functions (UDFs) for transformation and then train the model.

Reduce the number of features by randomly removing some columns, as this always prevents overfitting.

Fit a deep neural network with numerous layers directly within Snowflake without any data preparation, as this will automatically extract complex patterns.

Ignore missing values in the dataset as the Logistic Regression model will handle it automatically without skewing the results.

Q106. You are a data scientist working with a Snowflake table named ‘CUSTOMER DATA’ that contains a ‘PHONE NUMBER’ column stored as VARCHAR. The ‘PHONE NUMBER’ column sometimes contains non-numeric characters like hyphens and parentheses, and in some rows the data is missing. You need to create a new table ‘CLEANED CUSTOMER DATA’ with a column named ‘CLEANED PHONE NUMBER that contains only the numeric part of the phone number (as VARCHAR) and replaces missing or invalid phone numbers with NULL. Which of the following Snowpark Python code snippets achieves this most efficiently, ensuring no errors occur during the data transformation, and considers Snowflake’s performance best practices?

Option A

Option B

Option C

Option D

Option E

Q107. You have deployed a regression model in Snowflake as an external function using AWS Lambda’. The external function takes several numerical features as input and returns a predicted value. You want to continuously monitor the model’s performance in production and automatically retrain it when the performance degrades below a predefined threshold. Which of the following methods represent VALID approaches for calculating and monitoring model performance within the Snowflake environment and triggering the retraining process?

Create a Snowflake Task that periodically executes a SQL query to calculate performance metrics (e.g., RMSE) by comparing predicted values from the external function with actual values stored in a separate table. Trigger a Python UDF, deployed as a Snowflake stored procedure, to initiate retraining if the RMSE exceeds the threshold.

Implement custom logging within the AWS Lambda function to capture prediction results and actual values. Configure AWS CloudWatch to monitor these logs and trigger an AWS Step Function that initiates a new training job and updates the Snowflake external function with the new model endpoint upon completion.

Utilize Snowflake’s Alerting feature, setting an alert rule based on the output of a SQL query that calculates performance metrics. Configure the alert action to invoke a webhook that triggers a retraining pipeline.

Build a Snowpark Python application deployed on Snowflake which periodically polls the external function’s performance by querying the function with a sample data set and comparing results to ground truth stored in Snowflake. Initiate retraining directly from the Snowpark application if performance degrades.

Create a view that joins the input features with the predicted output and the actual result. Configure model monitoring within the AWS Sagemaker to perform continuous validation of the model.

Q108. You’ve created a Python stored procedure in Snowflake to train a model. The procedure successfully trains the model, saves it using ‘joblib.dump’ , and then attempts to upload the model file to an internal stage. However, the upload fails intermittently with a FileNotFoundErroN. The stage is correctly configured, and the stored procedure has the necessary privileges. Which of the following actions are MOST likely to resolve this issue? (Select TWO)

Ensure that the Python packages used within the stored procedure (e.g., scikit-learn, joblib) are explicitly listed in the ‘imports’ clause of the ‘CREATE PROCEDURE statement.

Use the fully qualified path for the model file when calling ‘joblib.dump’. E.g., ‘joblib.dump(model, ‘/tmp/model.joblib’)’ instead of ‘joblib.dump(model, ‘model .joblib’)’.

Implement error handling within the Python code to catch the ‘FileNotFoundError’ and retry the file upload after a short delay using ‘time.sleep()’. The stored procedure should retry the upload a maximum of 3 times before failing.

Before uploading the model to the stage, explicitly create the directory within the stage using ‘snowflake.connector.connect()’ and executing a ‘CREATE DIRECTORY IF NOT EXISTS command on the stage. Then retry upload.

Before uploading the model to the stage, verify that the file exists using ‘os.path.exists()’ within the stored procedure. If the file does not exist, log an error and raise an exception.

Q109. A data science team is evaluating different methods for summarizing lengthy customer support tickets using Snowflake Cortex. The goal is to generate concise summaries that capture the key issues and resolutions. Which of the following approaches is/are appropriate for achieving this goal within Snowflake, considering the need for efficiency, cost-effectiveness, and scalability? (Select all that apply)

Using the ‘SNOWFLAKE.ML.PREDICT’ function with a summarization task-specific model provided by Snowflake Cortex, passing the full ticket text as input to generate a summary.

Creating a custom summarization model using a transformer-based architecture like BART or T5, training it on a large dataset of support tickets and summaries within Snowflake using Snowpark ML, and then deploying this custom model for generating summaries via a UDF.

Employing a SQL-based approach using string manipulation functions and keyword extraction techniques to identify important sentences and concatenate them to form a summary.

Calling the Snowflake Cortex ‘COMPLETE’ endpoint with a detailed prompt that instructs the model to summarize the support ticket, explicitly specifying the desired summary length and format.

Developing a Python UDF that leverages a pre-trained summarization model from a library like ‘transformers’ and deploying it in Snowflake. Managing the model loading and inference within the UDF.

Q110. 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.

Q111. You are a data scientist working for a retail company. You’ve been tasked with identifying fraudulent transactions. You have a Snowflake table named ‘TRANSACTIONS’ with columns ‘TRANSACTION ID’, ‘AMOUNT’, ‘TRANSACTION DATE’, ‘CUSTOMER ID’, and ‘LOCATION’. You suspect outliers in transaction amounts might indicate fraud. Which of the following SQL queries is the MOST efficient and appropriate to identify potential outliers using the Interquartile Range (IQR) method, and incorporate necessary data type considerations for robust percentile calculations? Consider also the computational cost associated with each approach on a large dataset.

Option A

Option B

Option C

Option D

Option E

Q112. A retail company is using Snowflake to store sales data’. They have a table called ‘SALES DATA’ with columns: ‘SALE ID’, ‘PRODUCT D’, ‘SALE DATE’, ‘QUANTITY’ , and ‘PRICE’. The data scientist wants to analyze the trend of daily sales over the last year and visualize this trend in Snowsight to present to the business team. Which of the following approaches, using Snowsight and SQL, would be the most efficient and appropriate for visualizing the daily sales trend?

Use the Snowsight web UI to manually filter the ‘SALES_DATX table by ‘SALE_DATE for the last year and create a bar chart showing ‘SALE_ID count per day.

Write a SQL query that calculates the daily total sales amount CSUM(QUANTITY PRICEY) for the last year and use Snowsight’s charting options to generate a line chart with ‘SALE DATE on the x-axis and daily sales amount on the y-axis.

Export all the data from the ‘SALES DATA’ table to a CSV file and use an external tool like Python’s Matplotlib or Tableau to create the visualization.

Create a Snowflake view that aggregates the daily sales data, then use Snowsight to visualize the view data as a table without any chart.

Write a SQL query that uses ‘DATE TRUNC(‘day’, SALE DATE)’ to group sales by day and calculate the total sales (SUM(QUANTITY PRICE)). Use Snowsight’s line chart option with the truncated date on the x-axis and total sales on the y-axis, filtering by ‘SALE_DATE’ within the last year. Furthermore, use moving average with window function to smooth the data.

Q113. Which of the following statements about Z-tests and T-tests are generally true? Select all that apply.

A Z-test requires knowing the population standard deviation, while a T-test estimates it from the sample data.

A T-test is generally used when the sample size is large (n > 30) and the population standard deviation is known.

As the sample size increases, the T-distribution approaches the standard normal (Z) distribution.

Both Z-tests and T-tests assume that the data is non-normally distributed.

A T-test has fewer degrees of freedom compared to the Z-test, making it more robust to outliers.

Q114. A data scientist is tasked with building a real-time customer support system using Snowflake Cortex. The system needs to analyze incoming customer messages and categorize them into predefined issue types (e.g., billing, technical support, account management) for efficient routing to the appropriate support team. Considering the need for low latency and high accuracy, which of the following approaches would be the MOST suitable for implementing this categorization task using Snowflake Cortex, considering the costs and trade-offs involved?

Directly calling the Snowflake Cortex ‘COMPLETE’ endpoint with a detailed prompt for each incoming message, instructing it to categorize the message based on the predefined issue types.

Fine-tuning a pre-trained language model within Snowflake using the ‘CREATE SNOWFLAKE.ML.ANACONDA_MODEL’ command on a dataset of historical customer messages and their corresponding issue types, then deploying this fine-tuned model for real-time categorization via a user-defined function (UDF).

Leveraging the Snowflake Cortex built-in categorization task-specific model (e.g., using the ‘SNOWFLAKE.ML.PREDICT’ function with the appropriate model name) to categorize incoming messages without any fine-tuning.

Developing a custom Python UDF that uses a third-party LLM API (e.g., OpenAl) to categorize the messages and deploying it in Snowflake, handling API authentication and rate limiting within the UDF.

Creating a series of SQL ‘CASE’ statements to categorize the messages based on keyword matching within the message text. Use regular expressions for more complex pattern matching.

Q115. You have trained a linear regression model in Snowpark ML to predict house prices. After training, you want to assess the overall feature importance using the model’s coefficients. Consider the following Snowflake table containing the coefficients:

Which of the following statements are correct interpretations of these coefficients regarding feature impact?