DSA-C03 PDF Dumps Jan 04, 2026 Recently Updated Questions [Q30-Q54]

NO.30 You are building a customer churn prediction model for a telecommunications company. You have a ‘CUSTOMER DATA’ table with a ‘MONTHLY SPENDING’ column that represents the customer’s monthly bill amount. You want to binarize this column to create a feature indicating whether a customer is a ‘High Spender’ or ‘Low Spender’. You decide that customers spending more than $75 are ‘High Spenders’. Which of the following Snowflake SQL statements is the most efficient and correct way to achieve this, considering performance and readability, while avoiding potential NULL values in the resulting binarized column?

Option A

Option B

Option C

Option D

Option E

NO.31 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.32 You have deployed a custom model using Snowpark within Snowflake. The model is designed to predict customer churn, and you’ve wrapped it in a User-Defined Function (UDF) for easy use. The UDF takes several customer features as input and returns a churn probability. However, you notice the UDF’s performance is slow, especially when scoring large batches of customers. Which of the following strategies would be most effective in optimizing the performance of your model deployment within Snowflake? Assume the UDF is already using vectorization techniques.

Increase the warehouse size used by Snowflake. This provides more resources for the UDF execution.

Re-write the UDF in SQL instead of Snowpark to avoid the overhead of the Snowpark API.

Utilize a vectorized UDF that can process multiple rows in a single call, further leveraging Snowflake’s parallel processing capabilities. Ensure it supports the correct data types for both input and output. Consider using a Pandas UDF if Python is the underlying language.

Cache the results of the UDF using Snowflake’s result caching feature. This will avoid re-executing the UDF for the same input values.

Implement row-level security on the input data. This enhances security and implicitly improves query performance because the model only processes authorized data.

NO.33 You are building a machine learning model to predict loan defaults. You have a dataset in Snowflake with the following features: ‘income’ (annual income in USD), ‘loan_amount’ (loan amount in USD), and ‘credit_score’ (FICO score). You need to normalize these features before training your model. The data has outliers in both ‘income’ and ‘loan_amount’, and ‘credit_score’ has a roughly normal distribution but you still want to standardize it to have a mean of 0 and standard deviation of 1. You want to perform these normalizations using only SQL in Snowflake (no UDFs). Which of the following SQL transformations are most suitable?

Option A

Option B

Option C

Option D

Option E

NO.34 You are tasked with training a logistic regression model in Snowflake using Snowpark Python to predict customer churn. Your data is stored in a table named ‘CUSTOMER DATA’ with columns like ‘CUSTOMER D’, ‘FEATURE 1’, ‘FEATURE 2’, ‘FEATURE 3’, and ‘CHURN FLAG’ (boolean representing churn). You plan to use stratified k-fold cross-validation to ensure each fold has a representative proportion of churned and non-churned customers. Which of the following code snippets demonstrates the correct way to perform stratified k-fold cross-validation with Snowpark ML? (Assume ‘snowpark_session’ is a valid Snowpark session object).

NO.35 You are tasked with identifying fraudulent transactions from unstructured log data stored in Snowflake. The logs contain various fields, including timestamps, user IDs, and transaction details embedded within free-text descriptions. You plan to use a supervised learning approach, having labeled a subset of transactions as ‘fraudulent’ or ‘not fraudulent.’ Which of the following methods best describes the extraction and processing of this data for training a machine learning model within Snowflake?

Use regular expressions within a Snowflake UDF to extract relevant information (e.g., amount, item description) from the log descriptions. Convert extracted data into numerical features using one-hot encoding within the UDF. Then, train a model using the extracted numerical features directly within Snowflake using SQL extensions for machine learning.

Extract the entire log description field and train a word embedding model (e.g., Word2Vec) on the entire dataset. Average the word vectors for each transaction’s log description to create a document vector. Train a classification model (e.g., Random Forest) on these document vectors within Snowflake.

Use a combination of regular expressions and natural language processing (NLP) techniques within Snowflake UDFs to extract key features such as transaction amounts, product categories, and sentiment scores from the log descriptions. Then, combine these extracted features with other structured data (e.g., user demographics) and train a classification model using these features. The NLP steps include tokenization, stop word removal, and TF-IDF vectorization.

Export the entire log data to an external machine learning platform (e.g., AWS SageMaker) and perform feature extraction, NLP processing, and model training there. Import the trained model back into Snowflake as a UDF for prediction.

Treat the unstructured log description as a categorical feature and directly apply one-hot encoding within Snowflake, then train a classification model. Due to high dimensionality perform PCA for dimensionality reduction before training.

NO.36 You’ve built a regression model in Snowflake to predict customer churn. You’ve calculated the R-squared score on your test data and found it to be 0.65. However, after deploying the model to production and monitoring its performance over several weeks, you notice the model’s predictive accuracy has significantly decreased. Which of the following factors could contribute to this performance degradation?
Select all that apply.

Data drift: The distribution of the input features in the production data has changed significantly compared to the training data.

Overfitting: The model learned the training data too well, capturing noise and specific patterns that do not generalize to new data.

Feature engineering inconsistencies: The feature engineering steps applied to the production data are different from those applied during training.

Increased data volume: The production data volume has increased significantly, causing resource contention and impacting model performance in Snowflake.

Bias Variance trade off : Model is having high bias.

NO.37 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.38 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.39 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

NO.40 You’re a data scientist analyzing sensor data from industrial equipment stored in a Snowflake table named ‘SENSOR READINGS’ The table includes ‘TIMESTAMP’ , ‘SENSOR ID’, ‘TEMPERATURE’, ‘PRESSURE’, and ‘VIBRATION’. You need to identify malfunctioning sensors based on outlier readings in ‘TEMPERATURE’ , ‘PRESSURE’ , and ‘VIBRATION’. You want to create a dashboard to visualize these outliers and present a business case to invest in predictive maintenance. Select ALL of the actions that are essential for both effectively identifying sensor outliers within Snowflake and visualizing the data for a business presentation. (Multiple Correct Answers)

Calculate Z-scores for ‘TEMPERATURE, ‘PRESSURE, and ‘VIBRATION’ for each ‘SENSOR_ID within a rolling window of the last 24 hours using Snowflake’s window functions. Define outliers as readings with Z-scores exceeding a threshold (e.g., 3).

Directly connect the ‘SENSOR_READINGS’ table to a visualization tool and create a 3D scatter plot with ‘TEMPERATURE, ‘PRESSURE, and ‘VIBRATION’ on the axes, without any pre-processing or outlier detection in Snowflake.

Implement a clustering algorithm (e.g., DBSCAN) within Snowflake using Snowpark Python to group similar sensor readings, identifying outliers as points that do not belong to any cluster or belong to very small clusters.

Create a Snowflake stored procedure to automatically flag outlier readings in a new column ‘IS OUTLIER based on a predefined rule set (e.g., IQR method or Z-score threshold), and then use this column to filter data for visualization in a dashboard.

Calculate basic statistical summaries (mean, standard deviation, min, max) for each sensor and each variable C TEMPERATURE, ‘PRESSURE, and ‘VIBRATION’) and use that information to filter down to the most important sensor, prior to using the other techniques.

NO.41 You have a table in Snowflake named ‘CUSTOMER DATA’ with columns ‘CUSTOMER D’, ‘PURCHASE AMOUNT’, and ‘RECENCY’. You want to perform feature scaling on ‘PURCHASE AMOUNT’ using Min-Max scaling and store the scaled values in a new column named ‘SCALED PURCHASE _ AMOUNT’. Which of the following Snowflake SQL code snippets correctly implements this feature scaling? Note: Assume there are no NULL values in PURCHASE AMOUNT and you have privileges to create temporary tables and UDFs if necessary.

Option A

Option B

Option C

Option D

Option E

NO.42 A marketing team uses Snowflake to store customer purchase data’. They want to segment customers based on their spending habits using a derived feature called The ‘PURCHASES’ table has columns ‘customer id’ (IN T), ‘purchase_date’ (DATE), and ‘purchase_amount’ (NUMBER). The team needs a way to handle situations where a customer might have missing months (no purchases in a particular month). They want to impute a 0 spend for those months before calculating the average. Which approach provides the most accurate and robust calculation, especially when considering users with sparse purchase history?

Calculate the average monthly spend directly from the ‘PURCHASES’ table without accounting for missing months: ‘AVG(purchase_amount) GROUP BY customer_id, date_trunc(‘month’,

Create a view containing all months for each customer, left join with the ‘PURCHASES’ table, impute 0 for null ‘purchase_amounts values, and then calculate the average spend. Requires creating a helper table for all the month.

Use a window function to calculate the average spend over a fixed window of the last 3 months, ignoring missing months in the calculation.

Calculate the total spend for each customer and divide by the number of months since their first purchase: / DATEDlFF(month, CURRENT DATE()) GROUP BY customer_id’.

Calculate the average spend only for customers with purchases in every month of the year. Ignore other customers in the analysis.

NO.43 You’ve built a machine learning model in scikit-learn and want to deploy it to Snowflake for real-time inference. You have the following options for deploying the model. Select all that apply and are considered a best practice for cost and time optimization:

Package the scikit-learn model using ‘joblib’ or ‘pickle’ , store it in a Snowflake stage, and create a Snowflake UDF (User-Defined Function) in Python to load the model from the stage and perform inference.

Use Snowflake’s Snowpark Python API to directly load the model from a stage and execute inference using Snowpark DataFrames, which will implicitly handle the distributed processing of the data.

Create a Snowflake external function that calls a cloud-based (AWS SageMaker, Azure Machine Learning, GCP Vertex A1) endpoint for inference, passing the input data to the endpoint and receiving the prediction back.

Implement a custom microservice that reads data from Snowflake, performs inference using the scikit-learn model, and writes the predictions back to Snowflake.

Migrate your entire Snowflake data warehouse to a different platform which better supports real-time ML inference.

NO.44 A retail company is using Snowflake to store transaction data’. They want to create a derived feature called ‘customer _ recency’ to represent the number of days since a customer’s last purchase. The transactions table ‘TRANSACTIONS has columns ‘customer_id’ (INT) and ‘transaction_date’ (DATE). Which of the following SQL queries is the MOST efficient and scalable way to derive this feature as a materialized view in Snowflake?

Option A

Option B

Option C

Option D

Option E

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

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

NO.47 You are building a data science pipeline in Snowflake to predict customer churn. The pipeline involves extracting data, transforming it using Dynamic Tables, training a model using Snowpark ML, and deploying the model for inference. The raw data arrives in a Snowflake stage daily as Parquet files. You want to optimize the pipeline for cost and performance. Which of the following strategies are MOST effective, considering resource utilization and potential data staleness?

Use a single, large Dynamic Table to perform all transformations in one step, relying on Snowflake’s optimization to handle dependencies and incremental updates.

Implement a series of smaller Dynamic Tables, each responsible for a specific transformation step, with well-defined refresh intervals tailored to the data’s volatility and the downstream model’s requirements.

Load all data into traditional Snowflake tables and use scheduled tasks with stored procedures written in Python to perform the transformations and model training.

Use a combination of Dynamic Tables for feature engineering and Snowpark ML for model training and deployment, ensuring proper dependency management and refresh intervals for each Dynamic Table based on data freshness requirements.

Schedule all data transformations and model training as a single large Snowpark Python script executed by a Snowflake task, ignoring data freshness requirements.

NO.48 A financial services company wants to predict loan defaults. They have a table ‘LOAN APPLICATIONS’ with columns ‘application_id’, applicant_income’, ‘applicant_age’ , and ‘loan_amount’. You need to create several derived features to improve model performance.
Which of the following derived features, when used in combination, would provide the MOST comprehensive view of an applicant’s financial stability and ability to repay the loan? Select all that apply

Calculated as ‘applicant_income I loan_amount’.

Calculated as ‘applicant_age applicant_age’.

Calculated as ‘loan_amount I applicant_age’ .

Calculated as ‘applicant_age / applicant_income’.

Requires external data from a credit bureau to determine total debt, then calculated as ‘total_debt / applicant_income’ (Assume credit bureau integration is already in place)

NO.49 You are building a multi-class classification model in Snowflake to predict the category of customer support tickets (e.g., ‘Billing’, ‘Technical Support’, ‘Sales Inquiry’, ‘Account Management’, ‘Feature Request’) based on the ticket’s text content. The initial model evaluation shows an overall accuracy of 75%, but the ‘Feature Request’ category has a significantly lower precision and recall compared to other categories. Which of the following strategies would be MOST effective in addressing this issue, considering the limitations and advantages of Snowflake’s data processing capabilities and typical machine learning practices?

Increase the threshold for classifying a ticket as ‘Feature Request’ to improve precision, even if it further reduces recall. This prioritizes accurate identification of feature requests over capturing all of them.

Oversample the ‘Feature Request’ category in the training dataset before training the model. This involves creating synthetic data points or duplicating existing data to balance the class distribution. This can be done using SQL and Snowflake’s internal stage for storing temporary data before training.

Apply a cost-sensitive learning approach during model training, assigning a higher misclassification cost to errors involving the ‘Feature Request’ category. This encourages the model to prioritize correctly classifying feature requests.

Engineer new features specifically designed to improve the model’s ability to distinguish ‘Feature Request’ tickets from other categories. This could involve creating sentiment scores for ‘innovation’ or using topic modeling to identify key themes related to feature requests.

All of the above.

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

NO.51 A financial institution aims to detect fraudulent transactions using a Supervised Learning model deployed in Snowflake. They have a dataset with transaction details, including amount, timestamp, merchant category, and customer ID. The target variable is ‘is_fraudulent’ (0 or 1). They are considering different Supervised Learning algorithms. Which of the following algorithms would be MOST suitable for this fraud detection task, considering the need for interpretability, scalability, and the potential for imbalanced classes, and what specific strategies can be employed within Snowflake to handle the class imbalance?

K-Nearest Neighbors (KNN), because it is simple to implement and doesn’t require extensive training.

Support Vector Machine (SVM) with a radial basis function (RBF) kernel, as it can capture complex non-linear relationships without concern for interpretability.

Decision Tree or Random Forest, combined with techniques like oversampling the minority class (fraudulent transactions) within Snowflake using SQL or UDFs to balance the dataset before training. These models provide reasonable interpretability and can handle non-linear relationships effectively.

Linear Regression, because it’s computationally efficient and easy to understand, even though fraud detection is a classification problem.

Naive Bayes, because it requires no hyperparameter tuning and works well on numerical data.

NO.52 You are tasked with performing exploratory data analysis on a table named containing daily sales transactions. The table includes columns like ‘transaction_date’, ‘product_id’, ‘quantity’ , and ‘price’. Your goal is to identify potential data quality issues and understand the distribution of sales. Which of the following SQL queries using Snowflake’s statistical functions and features would be MOST effective for quickly identifying outliers in the ‘quantity’ column, potential data skewness, and missing values?

Option A

Option B

Option C

Option D

Option E

NO.53 You are investigating website session durations stored in a Snowflake table named ‘WEB SESSIONS. You suspect that bot traffic is artificially inflating the average session duration. You have the following session durations (in seconds) in the ‘SESSION DURATION’ column: [10, 12, 15, 18, 20, 22, 25, 28, 30, 1000]. Given this data and the context of bot traffic, which measure of central tendency is MOST robust to the influence of the outlier (1000) in this dataset? Assuming you already have table and dataframe created for this analysis. (Choose ONE)

Mean

Median

Mode

Geometric Mean

Trimmed mean (e.g. 10% trimmed)

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

Free Cram & Latest Exams Dumps

DSA-C03 PDF Dumps Jan 04, 2026 Recently Updated Questions [Q30-Q54]

leave a comment Cancel reply

Recent Posts

Archives

Categories