DSA-C03 Free Exam Questions & Answers PDF Updated on Aug-2025 [Q157-Q175]

NO.157 You have deployed a machine learning model in Snowflake to predict customer churn. The model was trained on data from the past year. After six months of deployment, you notice the model’s recall for identifying churned customers has dropped significantly. You suspect model decay. Which of the following Snowflake tasks and monitoring strategies would be MOST appropriate to diagnose and address this model decay?

Create a Snowflake Task that automatically retrains the model weekly with the most recent six months of data. Monitor the model’s performance metrics using Snowflake’s query history to track the accuracy of the predictions.

Establish a Snowflake pipe to continuously ingest feedback data (actual churn status) into a feedback table. Write a stored procedure to calculate performance metrics (e.g., recall, precision) on a sliding window of recent data. Create a Snowflake Alert that triggers when recall falls below a defined threshold.

Use Snowflake’s data sharing feature to share the model’s predictions with a separate analytics team. Let them monitor the overall customer churn rate and notify you if it changes significantly.

Back up the original training data to secure storage. Ingest all new data as it comes in. Retrain a new model and compare its performance with the backed-up training data.

Implement a Shadow Deployment strategy in Snowflake. Route a small percentage of incoming data to both the existing model and a newly trained model. Compare the predictions from both models using a UDF that calculates the difference in predicted probabilities. Trigger an alert if the differences exceed a certain threshold.

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

NO.159 You are working with a large dataset in Snowflake and need to build a machine learning model using scikit-learn in Python. You want to leverage Snowflake’s compute resources for feature engineering to speed up the process. Which of the following approaches correctly combines Snowflake’s SQL capabilities with scikit-learn for feature engineering and model training, while minimizing data transfer between Snowflake and the Python environment?

Write a complex SQL query in Snowmake to perform all feature engineering, then load the resulting features into a Pandas DataFrame and train the scikit-learn model.

Use the Snowflake Python Connector to execute individual SQL queries for each feature engineering step. Load the resulting features step-by-step into a Pandas DataFrame and train the scikit-learn model.

Implement the feature engineering steps directly in Python using Pandas and scikit-learn, then load the raw data into a Pandas DataFrame and apply the transformations. Finally, train the scikit-learn model.

Create Snowflake User-Defined Functions (UDFs) in Python for complex feature engineering calculations. Call these UDFs within a SQL query to apply the feature engineering to the Snowflake data. Load the resulting features into a Pandas DataFrame and train the scikit-learn model.

Use Snowflake external functions to invoke a remote service (e.g., AWS Lambda) for feature engineering. Pass data from Snowflake to the remote service, receive the engineered features back, and load them into a Pandas DataFrame for model training.

NO.160 A data science team is tasked with deploying a pre-built anomaly detection model in Snowflake to identify fraudulent transactions. They need to use Snowflake ML functions and a Snowflake Native App (that houses the model) to achieve this. The Snowflake Native App is installed and available. The transaction data is stored in a table called ‘TRANSACTIONS. Which of the following steps are essential to successfully deploy and use this pre-built model within a User Defined Function (UDF) for real-time scoring, assuming the app provides a function named ‘ANOMALY SCORE?

Create a UDF that calls the ‘ANOMALY _ SCORE function provided by the Snowflake Native App, passing the relevant transaction features as arguments.

Grant the USAGE privilege on the Snowflake Native App to the role executing the UDF. This ensures the UDF can access the app’s functionality.

Ensure the ‘TRANSACTIONS’ table is shared with the Snowflake Native App’s container so the model can directly access the data.

Train the pre-built anomaly detection model using Snowflake’s ML functions (e.g., ‘CREATE MODELS) with the ‘TRANSACTIONS’ data before creating the UDE

Create an external function in API Integration instead of UDF.

NO.161 You are building a fraud detection model for an e-commerce platform. One of the features is ‘purchase_amount’, which ranges from $1 to $10,000. The data has a skewed distribution with many small purchases and a few very large ones. You need to normalize this feature for your model, which uses gradient descent. Which normalization technique(s) would be most suitable in Snowflake, considering the data characteristics and the need to handle potential future outliers?

Min-Max scaling using the following SQL:

Z-score standardization using the following SQL:

Robust scaling using interquartile range (IQR) in a stored procedure with Python:

Power Transformer (e.g., Yeo-Johnson) implemented with Snowpark Python:

Unit Vector normalization (L2 Normalization) using SQL:

NO.162 A data scientist needs to analyze website session data stored in a Snowflake table named ‘WEB SESSIONS’. The table contains columns like ‘SESSION D’, ‘USER_ID, ‘PAGE_VIEWS’, ‘TIME SPENT_SECONDS’, and ‘TIMESTAMP. They want to identify potential bot traffic by analyzing the correlation between ‘PAGE VIEWS’ and ‘TIME SPENT SECONDS’. Which of the following Snowflake SQL queries is the MOST efficient and statistically sound way to calculate the Pearson correlation coefficient between these two columns, handling potential NULL values appropriately?

Option A

Option B

Option C

Option D

Option E

NO.163 A data scientist is tasked with predicting customer churn for a telecommunications company using Snowflake. The dataset contains call detail records (CDRs), customer demographic information, and service usage data’. Initial analysis reveals a high degree of multicollinearity between several features, specifically ‘total_day_minutes’, ‘total_eve_minutes’, and ‘total_night_minutes’. Additionally, the ‘state’ feature has a large number of distinct values. Which of the following feature engineering techniques would be MOST effective in addressing these issues to improve model performance, considering efficient execution within Snowflake?

Apply Principal Component Analysis (PCA) to reduce the dimensionality of the CDR features (‘total_day_minutes’, ‘total_eve_minutes’, ‘total_night_minutes’) and use one-hot encoding for the ‘state’ feature.

Create interaction features by multiplying ‘total_day_minutes’ with ‘customer_service_calls’ and applying a target encoding to the ‘state’ feature.

Use a variance threshold to remove highly correlated CDR features and create a feature representing the geographical region (e.g., ‘Northeast’, ‘Southwest’) based on the ‘state’ feature using a custom UDF.

Calculate the Variance Inflation Factor (VIF) for each CDR feature and drop the feature with the highest VIE Apply frequency encoding to the ‘state’ feature.

Apply min-max scaling to the CDR features to normalize them and use label encoding for the ‘state’ feature. Train a decision tree model, as it is robust to multicollinearity.

NO.164 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.

NO.165 A data scientist is developing a fraud detection model using Snowpark ML on Snowflake. They have a feature engineering pipeline implemented as a Snowpark DataFrame transformation. The pipeline includes several complex UDFs. The data scientist observes that the pipeline execution is slow. What are the most effective techniques to optimize the feature engineering pipeline’s performance in Snowpark?

Reduce the size of the input DataFrame by sampling the data.

Cache intermediate DataFrames using or ‘persist()’ to avoid recomputation of common transformations.

Rewrite Python UDFs as vectorized Python UDFs using the ‘pandas’ API within Snowpark to leverage batch processing.

Disable Snowpark’s lazy evaluation by executing on the DataFrame after each transformation.

Replace Python UDFs with Snowflake SQL UDFs where possible, as SQL UDFs often offer better performance due to Snowflake’s optimization capabilities.

NO.166 You are building a time-series forecasting model in Snowflake to predict the hourly energy consumption of a building. You have historical data with timestamps and corresponding energy consumption values. You’ve noticed significant daily seasonality and a weaker weekly seasonality. Which of the following techniques or approaches would be most appropriate for capturing both seasonality patterns within a supervised learning framework using Snowflake?

Using a simple moving average to smooth the data before applying a linear regression model.

Decomposing the time series using STL (Seasonal-Trend decomposition using Loess) and building separate models for the trend and seasonal components, then combining the predictions.

Creating lagged features (e.g., energy consumption from the previous hour, the same hour yesterday, and the same hour last week) and using these features as input to a regression model (e.g., Random Forest or Gradient Boosting).

Applying exponential smoothing directly to the original time series without feature engineering.

Using Fourier terms (sine and cosine waves) with frequencies corresponding to daily and weekly cycles as features in a regression model.

NO.167 A Snowflake table named ‘SALES DATA contains a ‘TRANSACTION DATE column stored as VARCHAR. The data in this column is inconsistent; some rows have dates in ‘YYYY-MM-DD’ format, others in ‘MM/DD/YYYY’ format, and some contain invalid date strings like ‘N/A’. You need to standardize all dates to ‘YYYY-MM-DD’ format and store them in a new column called FORMATTED DATE in a new table ‘STANDARDIZED_SALES DATA. Which of the following approaches, using Snowpark Python and SQL, most effectively handles these inconsistencies and minimizes errors during data transformation? Select all that apply:

Using a Snowpark Python UDF to parse each date string individually, handling different formats with conditional logic, and returning a formatted date string. This provides flexibility in handling diverse date formats.

Using a series of DATE” and ‘TO_VARCHAR SQL functions in Snowpark to attempt converting the date in different formats and then formatting the result to ‘YYYY-MM-DD’. Any conversion failing returns NULL.

Employing Snowpark’s error handling mechanism (e.g., ‘try…except’ blocks) within a loop to iteratively convert each date string, catching and logging errors, and storing valid dates in a new column.

Creating a view on top of ‘SALES_DATA’ that implements the conversion logic. This avoids creating a new physical table immediately and allows for experimentation with different conversion strategies before materializing the data.

Using a single ‘TO_DATE function with format parameter set to ‘AUTO’ combined with ‘TO_VARCHAR to format the date to ‘YYYY-MM-DD’.

NO.168 You are training a binary classification model in Snowflake to predict customer churn using Snowpark Python. The dataset is highly imbalanced, with only 5% of customers churning. You have tried using accuracy as the optimization metric, but the model performs poorly on the minority class. Which of the following optimization metrics would be most appropriate to prioritize for this scenario, considering the imbalanced nature of the data and the need to correctly identify churned customers, along with a justification for your choice?

Accuracy – as it measures the overall correctness of the model.

Log Loss (Binary Cross-Entropy) – as it penalizes incorrect predictions proportionally to the confidence of the prediction, suitable for probabilistic outputs.

Root Mean Squared Error (RMSE) – as it is commonly used for regression problems, not classification.

Area Under the Receiver Operating Characteristic Curve (AUC-ROC) – as it measures the ability of the model to distinguish between the two classes, irrespective of the class distribution.

F 1-Score – as it balances precision and recall, providing a good measure for imbalanced datasets.

NO.169 You are developing a Python stored procedure in Snowflake to predict sales for a retail company. You want to incorporate external data (e.g., weather forecasts) into your model. Which of the following methods are valid and efficient ways to access and use external data within your Snowflake Python stored procedure?

Directly call external APIs within the Python stored procedure using libraries like ‘requests’. Snowflake’s network policy must be configured to allow outbound connections.

Load the external data into a Snowflake table and then query the table from within the Python stored procedure using the Snowflake Connector for Pythom

Use a Snowflake external function to pre-process the external data and then pass the processed data as input parameters to the Python stored procedure.

Embed the external data directly into the Python stored procedure’s code as a dictionary or JSON object.

Use a Snowflake Pipe to continuously ingest external data from a cloud storage location and access the data within the stored procedure.

NO.170 You have deployed a fraud detection model in Snowflake that predicts the probability of a transaction being fraudulent. After a month, you observe that the model’s precision has significantly dropped. You suspect data drift. Which of the following actions would be MOST effective in identifying and quantifying the data drift in Snowflake, assuming you have access to the transaction data before and after deployment?

Create a UDF in Snowflake to calculate the Kolmogorov-Smirnov (KS) statistic for each feature between the training data and the recent transaction data. Then, create an alert if the KS statistic exceeds a predefined threshold for any feature.

Periodically sample a small subset of the recent transaction data and manually compare it with the training data using descriptive statistics (mean, standard deviation).

Retrain the model daily with the most recent transaction data without performing any explicit data drift analysis, relying on the model to adapt to the changes.

Use Snowflake’s built-in profiling capabilities to generate summary statistics for the training data. Compare these summary statistics with the statistics generated for recent transaction data. If significant differences are observed, assume data drift.

Calculate the Jensen-Shannon Divergence between the probability distributions of predicted fraud scores on the training set and the current production data set.

NO.171 You have trained a classification model in Snowflake using Snowpark ML to predict customer churn. After deploying the model, you observe that the model performs well on the training data but poorly on new, unseen data’. You suspect overfitting. Which of the following strategies can be applied within Snowflake to detect and mitigate overfitting during model validation , considering the model is already deployed and receiving inference requests through a Snowflake UDF?

Calculate the Area Under the Precision-Recall Curve (AUPRC) using Snowflake SQL on both the training and validation datasets. A significant difference indicates overfitting. Then, retrain the model in Snowpark ML with added L1 or L2 regularization, adjusting the regularization strength based on validation set performance, and redeploy the UDF.

Monitor the UDF execution time in Snowflake. A sudden increase in execution time indicates overfitting. Use the ‘EXPLAIN’ command on the UDF’s underlying SQL query to identify performance bottlenecks and rewrite the query for optimization.

Implement k-fold cross-validation within the Snowpark ML training pipeline using Snowflake’s distributed compute. Track the mean and standard deviation of the performance metrics (e.g., accuracy, Fl-score) across folds. A high variance suggests overfitting. Use this information to tune hyperparameters or select a simpler model architecture before deployment.

Create shadow UDFs that score data using alternative models. Compare the performance metrics (such as accuracy, precision, recall) between the production UDF and shadow UDFs using Snowflake’s query capabilities. If shadow models consistently outperform the production model on certain data segments, retrain the production model incorporating those data segments with higher weights.

Since the model is already deployed, the only option is to collect inference requests and compare the distributions of predicted values in each batch with the predicted values on the training set. A large difference indicates overfitting; model must be retrained outside of the validation process.

NO.172 You have a regression model deployed in Snowflake predicting customer churn probability, and you’re using RMSE to monitor its performance. The current production RMSE is consistently higher than the RMSE you observed during initial model validation. You suspect data drift is occurring. Which of the following are effective strategies for monitoring, detecting, and mitigating this data drift to improve RMSE? (Select TWO)

Implement a process to continuously calculate and track the RMSE on a holdout dataset representing the most recent data, alerting you when the RMSE exceeds a predefined threshold.

Regularly re-train the model on the entire historical dataset to ensure it captures all possible data patterns.

Use Snowflake’s data lineage features to identify any changes in the upstream data sources feeding the model and assess their potential impact.

Randomly sample a large subset of the production data and manually compare it to the original training data to identify any differences.

Disable model monitoring, because the increased RMSE shows that the model is adapting to new patterns.

NO.173 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.

NO.174 You are evaluating a binary classification model built in Snowflake for predicting customer churn. You have access to the model’s predictions on a holdout dataset, and you want to use both the ROC curve and the confusion matrix to comprehensively assess its performance. Which of the following statements regarding the interpretation and use of ROC curves and confusion matrices are correct in this scenario?

The ROC curve visualizes the trade-off between true positive rate (sensitivity) and false negative rate (1 – specificity) at various threshold settings.

The area under the ROC curve (AUC) provides a single scalar value representing the overall discriminatory power of the model, with a higher AUC indicating better performance. An AUC of 0.5 indicates that the model performs no better than random chance.

The confusion matrix allows you to calculate precision, recall, F I-score, and accuracy, which are all useful for understanding the model’s performance in terms of correctly and incorrectly classified instances.

While the ROC curve is independent of the class distribution, the metrics derived from the confusion matrix (e.g., precision, recall) can be significantly affected by imbalanced datasets.

In Snowflake, you can generate ROC curves and confusion matrices directly using the ‘SYSTEM$PREDICT function with appropriate parameters and visualizing the results using a tool like Snowsight or Tableau.

NO.175 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?

Exam Study Guide & Braindumps

DSA-C03 Free Exam Questions & Answers PDF Updated on Aug-2025 [Q157-Q175]

Leave a Reply Cancel reply