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?

• A. 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.
• B. 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.
• C. 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.
• D. 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.
• E. 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.

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

• A. 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)
• B. Calculated as 'applicant_age / applicant_income'.
• C. Calculated as 'applicant_income I loan_amount'.
• D. Calculated as 'loan_amount I applicant_age' .
• E. Calculated as 'applicant_age applicant_age'.

You are tasked with deploying a fraud detection model in Snowflake using the Model Registry. The model is trained on a dataset that is updated daily. You need to ensure that your deployed model uses the latest approved version and that you can easily roll back to a previous version if any issues arise. Which of the following approaches would provide the most robust and maintainable solution for model versioning and deployment, considering minimal downtime during updates and rollback?

• A. Use Snowflake Tasks to periodically refresh a table containing the latest model weights. The UDF directly queries this table for predictions.
• B. Register each new model version in the Snowflake Model Registry and promote the desired version to 'PRODUCTION' stage. Update a single UDF that dynamically fetches the model based on the 'PRODUCTION' stage metadata.
• C. Deploy a new Snowflake UDF referencing the model file directly in cloud storage every time the model is retrained. Rely on cloud storage versioning for rollback.
• D. Store all model versions within a single model registry entry without versioning, overwriting the existing file with each new training run.
• E. Create multiple Snowflake UDFs, each corresponding to a different model version. Manually switch the active UDF by updating application code when a new model is deployed.

A data scientist is analyzing sales data in Snowflake to identify seasonal trends. The 'SALES TABLE' contains columns 'SALE DATE' (DATE) and 'SALE _ AMOUNT' (NUMBER). They want to calculate the average daily sales amount for each month and year in the dataset. Which of the following SQL queries will correctly achieve this, while also handling potential NULL values in 'SALE AMOUNT?

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

You are developing a real-time fraud detection system using Snowpark and deploying it as a Streamlit application connected to Snowflake. The system ingests transaction data continuously and applies a pre-trained machine learning model (stored as a binary file in Snowflake's internal stage) to score each transaction for fraud. You need to ensure the model loading process is efficient, and you're aiming to optimize performance by only loading the model once when the application starts, not for every single transaction. Which combination of approaches will BEST achieve this in a reliable and efficient manner, considering the Streamlit application's lifecycle and potential concurrency issues?

• A. Use the 'st.cache_data' decorator in Streamlit to cache the loaded model and Snowpark session. Load the model directly from the stage within the cached function. This approach handles concurrency and ensures the model is only loaded once per session.
• B. Leverage the 'snowflake.snowpark.Session.read_file' to load the model binary directly into a Snowpark DataFrame and then convert to a Pandas DataFrame. Then, use the 'pickle' library for deserialization.
• C. Load the model outside of the Streamlit application's execution context (e.g., in a separate script) and store it in a global variable. Access this global variable within the Streamlit application. This approach requires careful handling of concurrency.
• D. Use Python's built-in 'threading.Lock' to serialize access to the model loading code and the Snowpark session, preventing concurrent access from multiple Streamlit user sessions. Store the loaded model in a module-level variable.
• E. Load the model within a try-except block and set the Snowpark session as a singleton that will guarantee model loads once for the entire application.