[Sep 25, 2025] Valid DSA-C03 Test Answers & DSA-C03 Exam PDF [Q81-Q101]

4/5 - (1 vote)

[Sep 25, 2025] Valid DSA-C03 Test Answers & DSA-C03 Exam PDF

Valid SnowPro Advanced DSA-C03 Dumps Ensure Your Passing

QUESTION 81
A marketing analyst at ‘NovaRetail’ suspects that a new advertising campaign has increased the average purchase amount. They have historical purchase data in a Snowflake table called ‘purchase_historf. To validate their hypothesis using the Central Limit Theorem (CLT), they perform the following steps: 1. Calculate the population mean (?) of purchase amounts from the historical data’. 2. Draw 500 random samples of size 50 from the table. 3. Calculate the sample mean (x?) for each sample. Which of the following steps are essential for correctly applying the Central Limit Theorem to perform a z-test to determine whether the new advertising campaign has significantly increased the average purchase amount?

Calculate the standard deviation of the population (?) from the historical data and estimate the standard error of the mean as ? / sqrt(50).

Check if the original population distribution (purchase amounts) is approximately normally distributed.

Ensure that the samples are drawn independently and randomly.

Calculate the standard deviation of the sample means and use it as an estimate for the standard error of the mean.

Verify that the sample size (n=50) is sufficiently large to approximate normality of the sample mean distribution based on the CLT. This implicitly assumes population size is significantly larger than the sample size.

QUESTION 82
You have a Snowpark DataFrame named ‘product_reviews’ containing customer reviews for different products. The DataFrame includes columns like ‘product_id’ , ‘review_text’ , and ‘rating’. You want to perform sentiment analysis on the ‘review_text’ to identify the overall sentiment towards each product. You decide to use Snowpark for Python to create a user-defined function (UDF) that utilizes a pre-trained sentiment analysis model hosted externally. You need to ensure secure access to this model and efficient execution. Which of the following represents the BEST approach, considering security and performance?

Create an inline Python UDF that directly calls the external sentiment analysis API with hardcoded API keys within the UDF code.

Create a Snowpark Pandas UDF that calls the external sentiment analysis API. Use Snowflake secrets management to store the API key and retrieve it within the UDF.

Create a Java UDF that utilizes a library to call the sentiment analysis API. Pass the API key as a parameter to the UDF each time it is called.

Create an external function in Snowflake that calls a serverless function (e.g., AWS Lambda, Azure Function) that performs the sentiment analysis. Use Snowflake’s network policies to restrict access to the serverless function and secrets management to handle API keys.

Create an external function in Snowflake that calls a serverless function. Configure the API gateway in front of the serverless function to enforce authentication via Mutual TLS (mTLS) using Snowflake-managed certificates.

QUESTION 83
You’ve created a Python UDF in Snowflake that uses the ‘numpy’ and libraries to perform complex statistical calculations on time-series data’. The UDF is deployed successfully, but when you execute it on a large dataset, you observe significant performance bottlenecks. Analyzing the execution plan reveals that the UDF is being executed serially for each row of the input data, preventing Snowflake from leveraging its parallel processing capabilities. What strategies can you employ to improve the performance and enable parallel execution of the UDF in Snowflake?

Increase the Snowflake warehouse size to provide more resources for serial execution.

Modify the UDF to accept a Pandas DataFrame as input instead of individual row values. Ensure your UDF is vectorized to process the entire DataFrame at once.

Rewrite the UDF using Snowflake’s Java UDF functionality instead of Python, as Java is inherently faster for numerical computations.

Use the ‘snowflake.snowpark’ library to create a distributed Pandas DataFrame and perform computations directly within the Snowflake engine in a parallel manner.

Decompose the UDF into smaller, more manageable functions and register each as a separate UDF, hoping Snowflake will parallelize the execution of these smaller UDFs automatically.

QUESTION 84
You’re working on a fraud detection system for an e-commerce platform. You have a table ‘TRANSACTIONS with a ‘TRANSACTION AMOUNT column. You want to bin the transaction amounts into several risk categories (‘Low’, ‘Medium’, ‘High’, ‘Very High’) using explicit boundaries. You want the bins to be inclusive of the lower boundary and exclusive of the upper boundary (e.g., [0, 100), [100, 500), etc.). Which of the following SQL statements using the ‘WIDTH BUCKET function correctly bins the transaction amounts into these categories, assuming these boundaries: 0, 100, 500, 1000, and infinity, and assigns appropriate labels?

Option A

Option B

Option C

Option D

Option E

QUESTION 85
You’re working with a large dataset containing customer purchase history. You want to identify customers whose purchase frequency deviates significantly from the average purchase frequency of all customers. The dataset is in a table named ‘purchase history’ with columns ‘customer id’ and ‘purchase date’. What combination of Snowflake functionalities will allow you to achieve this task efficiently?
Choose all that apply.

Use the window function to divide customers into quantiles based on their total purchase count.

Calculate the average purchase frequency across all customers using and group by ‘customer_id’.

Employ the ‘QUALIFY clause along with window functions to filter customers based on a condition related to their purchase frequency compared to the average.

Calculate the Z-score of each customer’s purchase frequency using ‘AVG(Y, ‘STDDEV()’ , and window functions, and then filter based on a Z-score threshold.

Create a UDF that computes the purchase frequency for a single user and apply it to all customers.

QUESTION 86
You’ve deployed a regression model in Snowflake to predict product sales. After a month, you observe that the RMSE on your validation dataset has increased significantly compared to the initial deployment. Analyzing the prediction errors, you notice a pattern: the model consistently underestimates sales for products with a recent surge in social media mentions. Which of the following actions would be MOST effective in addressing this issue and improving the model’s RMSE?

Increase the regularization strength of the model to prevent overfitting to the original training data.

Retrain the model using only the most recent data (e.g., last week) to adapt to the changing sales patterns.

Incorporate a feature representing the number of social media mentions for each product into the model and retrain.

Decrease the learning rate of the optimization algorithm during retraining to avoid overshooting the optimal weights.

Implement a moving average smoothing technique on the target variable (sales) before retraining the model.

QUESTION 87
A team is using Snowflake to build a supervised machine learning model for image classification. The images are stored in a Snowflake table, and the labels are in a separate table. The goal is to train a model using Snowpark Python. Which of the following code snippets represents the MOST efficient way to join the image data with its corresponding labels, pre-process the images (resize and normalize), and prepare the data for model training using Snowpark DataFrame transformations? Assume contains image data as binary, ‘label df contains the image labels, and ‘resize normalize udf’ is a UDF that handles resizing and normalization.

QUESTION 88
A data scientist is building a churn prediction model using Snowflake data’. They want to load a large dataset (50 million rows) from a Snowflake table ‘customer_data’ into a Pandas DataFrame for feature engineering. They are using the Snowflake Python connector. Given the code snippet below and considering performance and memory usage, which approach would be the most efficient for loading the data into the Pandas DataFrame? Assume you have a properly configured connection and cursor ‘cur’. Furthermore, assume that the ‘customer id’ column is the primary key and uniquely identifies each customer. You are also aware that network bandwidth limitations exist within your environment. “`python import snowflake.connector import pandas as pd # Assume conn and cur are already initialized # conn = snowflake.connector.connect(…) # cur = conn.cursor() query = “SELECT FROM customer data“`

“`python cur.execute(query) df = pd.DataFrame(cur.fetchall(), columns=[col[0] for col in cur.description])

“`python cur.execute(query) df = pd.read_sql(query, conn)

“`python cur.execute(query) results = cur.fetchmany(size=1000000) df_list = 0 while results: df_list.append(pd.DataFrame(results, for col in cur.description])) results = cur.fetchmany(size=1000000) df = pd.concat(df_list, ignore_index=True)

“`python with conn.cursor(snowflake.connector.DictCursor) as cur: cur.execute(query) df = pd.DataFrame(cur.fetchall())

“`python import snowflake.connector import pandas as pd import pyarrow import pyarrow.parquet # Enable Arrow result format conn.cursor().execute(“ALTER SESSION SET PYTHON USE ARROW RESULT FORMAT-TRUE”) cur.execute(query) df =

QUESTION 89
You are deploying a large language model (LLM) to Snowflake using a user-defined function (UDF). The LLM’s model file, ’11m model.pt’, is quite large (5GB). You’ve staged the file to Which of the following strategies should you employ to ensure successful deployment and efficient inference within Snowflake? Select all that apply.

Use the ‘PUT’ command with to compress the model file before staging it. Snowflake will automatically decompress it during UDF execution.

Increase the warehouse size to XLARGE or larger to provide sufficient memory for loading the large model into the UDF environment.

Leverage Snowflake’s Snowpark Container Services to deploy the LLM as a separate containerized application and expose it via a Snowpark API. Then call that endpoint from snowflake.

Use the ‘IMPORTS’ clause in the UDF definition to reference Ensure the UDF code loads the model lazily (i.e., only when it’s first needed) to minimize startup time and memory usage.

Split the large model file into smaller chunks and stage each chunk separately. Reassemble the model within the UDF code before inference.

QUESTION 90
You are analyzing sales data in Snowflake using Snowpark to identify seasonality. You have a table named ‘SALES DATA with columns ‘SALE DATE (TIMESTAMP NTZ) and ‘AMOUNT (NUMBER). You want to calculate the rolling average sales for each week over a period of 12 weeks using a Snowpark DataFrame. Which of the following Snowpark code snippets correctly implements this calculation?

QUESTION 91
You are working with a Snowflake table ‘CUSTOMER DATA containing customer information for a marketing campaign. The table includes columns like ‘CUSTOMER ID’, ‘FIRST NAME’, ‘LAST NAME, ‘EMAIL’, ‘PHONE NUMBER, ‘ADDRESS, ‘CITY, ‘STATE, ZIP CODE, ‘COUNTRY, ‘PURCHASE HISTORY, ‘CLICKSTREAM DATA, and ‘OBSOLETE COLUMN’. You need to prepare this data for a machine learning model focused on predicting customer churn. Which of the following strategies and Snowpark Python code snippets would be MOST efficient and appropriate for removing irrelevant fields and handling potentially sensitive personal information while adhering to data governance policies? Assume data governance requires removing personally identifiable information (PII) that isn’t strictly necessary for the churn model.

Dropping ‘FIRST NAME, UST NAME, ‘EMAIL’, ‘PHONE NUMBER, ‘ADDRESS’, ‘CITY, ‘STATE’, ZIP CODE, ‘COUNTRY and ‘OBSOLETE_COLUMN’ columns directly using ‘LAST_NAME’, ‘EMAIL’, ‘PHONE_NUMBER’, ‘ADDRESS’, ‘CITY’, ‘STATE’, ‘ZIP_CODE’, ‘COUNTRY’, without any further consideration.

Dropping columns ‘OBSOLETE_COLUMN’ directly. Then, for PII columns (‘FIRST_NAME, ‘LAST_NAME, ‘EMAIL’, ‘PHONE_NUMBER, ‘ADDRESS’, ‘CITY’, ‘STATE’ , , ‘COUNTRY), create a separate table with anonymized or aggregated data for analysis unrelated to the churn model. Use Keep all PII columns but encrypt them using Snowflake’s built-in encryption features to comply with data governance before building the model. Drop ‘OBSOLETE COLUMN’.

Drop ‘OBSOLETE_COLUMN’. For columns like and ‘LAST_NAME’ , consider aggregating into a single ‘FULL_NAME feature if needed for some downstream task. Apply hashing or tokenization techniques to sensitive PII columns like and ‘PHONE NUMBER using Snowpark UDFs, depending on the model’s requirements. Drop columns like ‘ADDRESS, ‘CITY, ‘STATE, ZIP_CODE, ‘COUNTRY as they likely do not contribute to churn prediction. Example hashing function:

Keeping all columns as is and providing access to Data Scientists without any changes, relying on role based security access controls only.

QUESTION 92
A financial institution wants to predict fraudulent transactions on credit card data stored in Snowflake. The dataset includes features like transaction amount, merchant ID, location, time of day, and user profile information. The target variable is ‘is_fraudulent’ (0 or 1). You have trained several binary classification models (Logistic Regression, Random Forest, and Gradient Boosting) using scikit-learn and persisted them using a Snowflake external function for inference. To optimize for both performance (inference speed) and accuracy, which of the following steps should you consider before deploying your model for real-time scoring using the external function? SELECT ALL THAT APPLY.

Implement feature selection techniques (e.g., using feature importance scores from Random Forest or Gradient Boosting) to reduce the number of features passed to the external function, improving inference speed.

Increase the batch size of requests sent to the external function to amortize the overhead of invoking the external function itself, even if it increases latency for individual transactions.

Normalize or standardize the input features in Snowflake using SQL before passing them to the external function to ensure consistent scaling and potentially improve model performance.

Evaluate the models on a representative held-out dataset within Snowflake using SQL queries (e.g., calculating AUC, precision, recall) to choose the model with the best balance of performance and accuracy before deploying it.

Replace the trained models with a simple rule-based system based solely on transaction amount. If the amount is greater than a threshold, flag it as fraudulent, as this will be faster than calling the external function.

QUESTION 93
You are using a Snowflake Notebook to build a churn prediction model. You have engineered several features, and now you want to visualize the relationship between two key features: and , segmented by the target variable ‘churned’ (boolean). Your goal is to create an interactive scatter plot that allows you to explore the data points and identify any potential patterns.
Which of the following approaches is most appropriate and efficient for creating this visualization within a Snowflake Notebook?

Leverage Snowflake’s native support for Streamlit within the notebook to create an interactive application. Query the data directly from Snowflake within the Streamlit app and use Streamlit’s plotting capabilities for visualization.

Create a static scatter plot using Matplotlib directly within the Snowflake Notebook by converting the data to a Pandas DataFrame. This involves pulling all relevant data into the notebook’s environment before plotting.

Use the ‘snowflake-connector-python’ to pull the data and use ‘seaborn’ to create static plots.

Write a stored procedure in Snowflake that generates the visualization data in a specific format (e.g., JSON) and then use a JavaScript library within the notebook to render the visualization.

Use the Snowflake Connector for Python to fetch the data, then leverage a Python visualization library like Plotly or Bokeh to generate an interactive plot within the notebook.

QUESTION 94
You are tasked with automating the retraining of a Snowpark ML model based on the performance metrics of the deployed model. You have a table ‘MODEL PERFORMANCE that stores daily metrics like accuracy, precision, and recall. You want to automatically trigger retraining when the accuracy drops below a certain threshold (e.g., 0.8). Which of the following approaches using Snowflake features and Snowpark ML is the MOST robust and cost-effective way to implement this automated retraining pipeline?

Create a Snowflake task that runs every hour, queries the ‘MODEL_PERFORMANCE table, and triggers a Snowpark ML model training script if the accuracy threshold is breached. The training script will overwrite the existing model.

Use a Snowflake stream on the ‘MODEL_PERFORMANCE table to detect changes in accuracy, and trigger a Snowpark ML model training function using a PIPE whenever the accuracy drops below the threshold.

Implement a Snowpark ML model training script that automatically retrains the model every day, regardless of the performance metrics. This script will overwrite the previous model.

Create a Dynamic Table that depends on the ‘MODEL PERFORMANCE table and materializes when the accuracy is below the threshold. This Dynamic Table refresh triggers a Snowpark ML model training stored procedure. This stored procedure saves the new model with a timestamp and updates a metadata table with the model’s details.

Implement an external service (e.g., AWS Lambda or Azure Function) that periodically queries the “MODEL_PERFORMANCE table using the Snowflake Connector and triggers a Snowpark ML model training script via the Snowflake API.

QUESTION 95
You are analyzing website traffic data stored in a Snowflake table named ‘WEB EVENTS. This table contains a ‘TIMESTAMP’ column representing when the event occurred and a ‘PAGE VIEWS column indicating the number of page views for that event. You need to identify the day with the highest number of page views and also the day with lowest number of page views along with average number of page views. How can you accomplish this using Snowflake SQL?

Option A

Option B

Option C

Option D

Option E

QUESTION 96
You are tasked with fine-tuning a Snowflake Cortex LLM model using your own labeled dataset to improve its performance on a specific sentiment analysis task related to customer reviews. You have already created a Snowflake stage ‘my_stage’ and uploaded your labeled data in CSV format to this stage. The labeled data contains two columns: ‘review_text’ and ‘sentiment’ (values: ‘positive’, ‘negative’, ‘neutral’). Which of the following SQL commands, or sequences of commands, is MOST appropriate to initiate the fine-tuning process using the ‘SNOWFLAKE.ML.FINETUNE LLM’ function? Assume you have already set the necessary permissions for your role to access the model and stage.

Option A

Option B

Option C

Option D

Option E

QUESTION 97
You are working with a Snowflake table named ‘CUSTOMER DATA’ that contains personally identifiable information (PII), including customer names, email addresses, and phone numbers. Your team needs to perform exploratory data analysis on this data to understand customer demographics and behavior. However, you must ensure that the PII is protected and that only authorized personnel can access the sensitive information. Which of the following strategies should you implement in Snowflake to achieve secure EDA?

Grant ‘SELECT privileges on the ‘CUSTOMER DATA’ table to all data scientists, and rely on them to avoid querying PII columns directly.

Create a view on top of that excludes the PII columns (e.g., name, email, phone). Grant ‘SELECT privileges on this view to data scientists. Also implement data masking policies on the ‘CUSTOMER DATA’ table for the PII columns and grant ‘SELECT on the table to specific roles requiring access to the masked values.

Use transient tables to store the customer data after PII is obfuscated, drop the table and reload new data daily.

Apply dynamic data masking to the entire ‘CUSTOMER_DATA’ table, masking all columns by default, and provide decryption keys only to authorized users.

Create a copy of the ‘CUSTOMER DATA table without the PII columns and grant ‘SELECT’ privileges on this copy to the data scientists. Use masking policies on the original table.

QUESTION 98
You’re developing a model to predict customer churn using Snowflake. Your dataset is large and continuously growing. You need to implement partitioning strategies to optimize model training and inference performance. You consider the following partitioning strategies: 1. Partitioning by ‘customer segment (e.g., ‘High-Value’, ‘Medium-Value’, ‘Low-Value’). 2. Partitioning by ‘signup_date’ (e.g., monthly partitions). 3. Partitioning by ‘region’ (e.g., ‘North America’, ‘Europe’, ‘Asia’). Which of the following statements accurately describe the potential benefits and drawbacks of these partitioning strategies within a Snowflake environment, specifically in the context of model training and inference?

Partitioning by ‘customer_segment’ is beneficial if churn patterns are significantly different across segments, allowing for training separate models for each segment. However, if any segment has very few churned customers, it may lead to overfitting or unreliable models for that segment.

Partitioning by ‘signup_date’ is ideal for capturing temporal dependencies in churn behavior and allows for easy retraining of models with the latest data. It also naturally aligns with a walk-forward validation approach. However, it might not be effective if churn drivers are independent of signup date.

Partitioning by ‘region’ is useful if churn is heavily influenced by geographic factors (e.g., local market conditions). It can improve query performance during both training and inference when filtering by region. However, it can create data silos, making it difficult to build a global churn model that considers interactions across regions. Furthermore, the ‘region’ column must have low cardinality.

Using clustering in Snowflake on top of partitioning will always improve query performance significantly and reduce compute costs irrespective of query patterns.

Implementing partitioning requires modifying existing data loading pipelines and may introduce additional overhead in data management. If the cost of partitioning outweighs the performance gains, it’s better to rely on Snowflake’s built-in micro-partitioning alone. Also, data skew in partition keys is a major concern.

QUESTION 99
You have a table ‘PRODUCT SALES in Snowflake with columns: ‘PRODUCT (INT), ‘SALE_DATE (DATE), ‘SALES_AMOUNT (FLOAT), and ‘PROMOTION FLAG’ (BOOLEAN). You need to perform the following data preparation steps using Snowpark SQLAPI:

Handling missing ‘SALES_AMOUNT values by imputing them with the average ‘SALES_AMOUNT’ for the same ‘PRODUCT_ID during the previous month. If there’s no data for the previous month, use the overall average for that

Converting ‘SALE_DATE to a quarterly representation (e.g., ‘2023-QI’).

Creating a new feature representing the percentage change in ‘SALES_AMOUNT compared to the previous day for the same ‘PRODUCT_ID. Handle the first day of each ‘PRODUCT by setting ‘SALES_GROWTH’ to O.

Creating a feature that returns 1 if there is a PROMOTION_FLAG of True and SALES_AMOUNT > 1000, and zero otherwise

All of the above.

QUESTION 100
You are developing a churn prediction model using Snowpark Python and Scikit-learn. After initial model training, you observe significant overfitting. Which of the following hyperparameter tuning strategies and code snippets, when implemented within a Snowflake Python UDF, would be MOST effective to address overfitting in a Ridge Regression model and how can you implement a reproducible model with minimal code?

Option A

Option B

Option C

Option D

Option E

QUESTION 101
You have deployed a sentiment analysis model on AWS SageMaker and want to integrate it with Snowflake using an external function. You’ve created an API integration object. Which of the following SQL statements is the most secure and efficient way to create an external function that utilizes this API integration, assuming the model expects a JSON payload with a ‘text’ field, the API integration is named ‘sagemaker_integration’ , the SageMaker endpoint URL is ‘https://your-sagemaker-endpoint.com/invoke’ , and you want the Snowflake function to be named ‘predict_sentiment’?