You are building a model to predict loan defaults using data stored in Snowflake. As part of your feature engineering process within a Snowflake Notebook, you need to handle missing values in several columns: 'annual _ income', and You want to use a combination of imputation strategies: replace missing values with the median, 'annual_income' with the mean, and with a constant value of 0.5. You are leveraging the Snowpark DataFrame API. Which of the following code snippets correctly implements this imputation strategy?

• A. Option E
• B. Option C
• C. Option D
• D. Option B
• E. Option A

Explanation: Only visible for PrepAwayTest members. You can sign-up / login (it's free).

You have successfully deployed a machine learning model in Snowflake using Snowpark and are generating predictions. You need to implement a robust error handling mechanism to ensure that if the model encounters an issue during prediction (e.g., missing feature, invalid data type), the process doesn't halt and the errors are logged appropriately. You are using a User-Defined Function (UDF) to call the model. Which of the following strategies, when used IN COMBINATION, provides the BEST error handling and monitoring capabilities in this scenario?

• A. Wrap the prediction call in a 'SYSTEM$QUERY_PROFILE function to get detailed query execution statistics and identify potential performance bottlenecks.
• B. Use a 'TRY...CATCH' block within the UDF to catch exceptions, log the errors to a separate Snowflake table, and return a default prediction value (e.g., NULL) for the affected row.
• C. Implement a custom logging solution by writing error messages to an external file storage (e.g., AWS S3) using an external function called from within the UDE
• D. Rely solely on Snowflake's query history to identify failed predictions and debug the model, without any explicit error handling within the UDE
• E. Use Snowflake's event tables to capture errors and audit logs related to the UDF execution.

Explanation: Only visible for PrepAwayTest members. You can sign-up / login (it's free).

You are developing a model to predict equipment failure in a factory using sensor data stored in Snowflake. The data is partitioned by 'EQUIPMENT ID' and 'TIMESTAMP. After initial model training and cross-validation using the following code snippet:

You observe significant performance variations across different equipment groups when evaluating on out-of-sample data'. Which of the following strategies could you employ to address this issue within the Snowflake environment to improve the model's generalization ability across all equipment?

• A. Implement a hyperparameter search using 'SYSTEM$OPTIMIZE_MODEL' with a wider range of parameters for each 'EQUIPMENT_ID individually, creating a separate model for each 'EQUIPMENT ID.
• B. Implement cross-validation at the partition level by splitting 'TRAINING_DATX into train and test sets before creating the model, and then using the 'FIT' command to train on the train set and 'PREDICT to evaluate on the test set, repeating for each partition.
• C. Increase the overall size of the "TRAINING_DATR to include more historical data for all equipment, assuming this will balance the representation of each EQUIPMENT ID'
• D. Retrain the model with additional feature engineering to create interaction terms between 'EQUIPMENT_ID' and other relevant sensor features to capture equipment-specific patterns. For instance, you can one hot encode and add to model and include in 'INPUT DATA'.
• E. Create seperate models per equipment ID. For each equipment ID, split data into training and testing data. For each equipment ID, use 'SYSTEM$OPTIMIZE MODEL' to perform hyper parameter search individually. Train and Deploy the model at equipement ID Level.

Explanation: Only visible for PrepAwayTest members. You can sign-up / login (it's free).

You are developing a Python UDTF in Snowflake to perform time series forecasting. You need to incorporate data from an external REST API as part of your feature engineering process within the UDTF. However, you are encountering intermittent network connectivity issues that cause the UDTF to fail. You want to implement a robust error handling mechanism to gracefully handle these network errors and ensure that the UDTF continues to function, albeit with potentially less accurate forecasts when external data is unavailable. Which of the following approaches is the MOST appropriate and effective for handling these network errors within your Python UDTF?

• A. Use a combination of retry mechanisms (like the tenacity library) with exponential backoff around the API call. If the retry fails after a predefined number of attempts, then return pre-computed data or use a simplified model as the UDTF's output.
• B. Before making the API call, check the network connectivity using the 'ping' command. If the ping fails, skip the API call and return a default forecast value. This prevents the UDTF from attempting to connect to an unavailable endpoint.
• C. Implement a global exception handler within the UDTF that catches all exceptions, logs the error message to a Snowflake table, and returns a default forecast value when a network error occurs. Ensure the error logging table exists and has sufficient write permissions for the UDTF.
• D. Use the 'try...except' block specifically around the code that makes the API call. Within the 'except block, catch specific network-related exceptions (e.g., requests.exceptions.RequestException', 'socket.timeout'). Log the error to a Snowflake stage using the 'logging' module and retry the API call a limited number of times with exponential backoff.
• E. Configure Snowflake's network policies to allow outbound network access from the UDTF to the specific REST API endpoint. This will eliminate the network connectivity issues and prevent the UDTF from failing.

Explanation: Only visible for PrepAwayTest members. You can sign-up / login (it's free).

You are building a product recommendation system using Snowflake Cortex. You have a table 'PRODUCT DESCRIPTIONS' containing product IDs and textual descriptions. You want to generate vector embeddings for these descriptions to perform similarity searches. However, you need to control the cost and latency of the embedding generation process. Which of the following strategies and considerations are MOST important for optimizing performance and cost when generating vector embeddings in Snowflake Cortex using a UDF?

• A. Use the smallest available Cortex embedding model. Smaller models are always faster and cheaper, regardless of the dataset size.
• B. Use a larger Snowflake warehouse size. Increasing the warehouse size always linearly reduces embedding generation time and cost.
• C. Optimize the batch size passed to the embedding UDF. Experiment with different batch sizes to find the optimal trade-off between throughput and latency. Too large batches might cause memory issues, while too small batches increase overhead. Consider using a batch size of 64 or 128 as a starting point, adjusting based on your dataset and resource constraints.
• D. Partition the 'PRODUCT DESCRIPTIONS' table by product category and generate embeddings for each partition separately. This helps to distribute the workload and reduce the size of the data processed by each UOF call. This makes more sense and is faster to re-create the table.
• E. Cache the results of the embedding LJDF. Implement a caching mechanism (e.g., using a Snowflake table) to store the embeddings for frequently accessed product descriptions, avoiding redundant embedding calculations. use a materialized view.

Explanation: Only visible for PrepAwayTest members. You can sign-up / login (it's free).