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?

• A. Linear Regression, because it's computationally efficient and easy to understand, even though fraud detection is a classification problem.
• B. Support Vector Machine (SVM) with a radial basis function (RBF) kernel, as it can capture complex non-linear relationships without concern for interpretability.
• C. Naive Bayes, because it requires no hyperparameter tuning and works well on numerical data.
• D. 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.
• E. K-Nearest Neighbors (KNN), because it is simple to implement and doesn't require extensive training.

You are building a machine learning model using Snowpark for Python and have a feature column called 'TRANSACTION AMOUNT' in your 'transaction_df DataFrame. This column contains some missing values ('NULL). Your model is sensitive to missing data'. You want to impute the missing values using the median "TRANSACTION AMOUNT, but ONLY for specific customer segments (e.g., customers with a 'CUSTOMER TIER of 'Gold' or 'Platinum'). For other customer tiers, you want to impute with the mean. Which of the following Snowpark Python code snippets BEST achieves this selective imputation?

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

A data science team is using Snowpark ML to train a classification model. They want to log model metadata (e.g., training parameters, evaluation metrics) and artifacts (e.g., the serialized model file) for reproducibility and model governance purposes. Which of the following approaches is the most appropriate for integrating model logging and artifact management within the Snowpark ML workflow, minimizing operational overhead?

• A. Leverage the MLflow integration within Snowpark, utilizing its ability to track experiments, log parameters and metrics, and store model artifacts directly within Snowflake stages or external storage.
• B. Employ a separate, external model management platform (e.g., Databricks MLflow, SageMaker Model Registry) and configure Snowpark to interact with it via API calls during model training and deployment.
• C. Serialize the model object to a string and store it as a VARIANT column in a Snowflake table, alongside the model metadata.
• D. Use a custom Python function to manually write model metadata to a Snowflake table and store the model file in a Snowflake stage.
• E. Only track basic model performance metrics in a Snowflake table and rely on code versioning (e.g., Git) for model artifact management.

You are building a fraud detection model using Snowflake data'. The dataset 'TRANSACTIONS' contains billions of records and is partitioned by 'TRANSACTION DATE'. You want to use cross-validation to evaluate your model's performance on different subsets of the data and ensure temporal separation of training and validation sets. Given the following Snowflake table structure:

Which approach would be MOST appropriate for implementing time-based cross-validation within Snowflake to avoid data leakage and ensure robust model evaluation? (Assume using Snowpark Python to develop)

• A. Use 'SNOWFLAKE.ML.MODEL REGISTRY.CREATE MODEL' with default settings, which automatically handles temporal partitioning based on the insertion timestamp of the data.
• B. Utilize the 'SNOWFLAKE.ML.MODEL REGISTRY.CREATE MODEL' with the 'input_colS argument containing 'TRANSACTION DATE'. Snowflake will automatically infer the temporal nature of the data and perform time-based cross-validation.
• C. Implement a custom splitting function within Snowpark, creating sequential folds based on the 'TRANSACTION DATE column and use that with Snowpark ML's cross_validation. Ensure each fold represents a distinct time window without overlap.
• D. Create a UDF that assigns each row to a fold based on the 'TRANSACTION DATE column using a modulo operation. This is then passed to the 'cross_validation' function in Snowpark ML.
• E. Explicitly define training and validation sets based on date ranges within the Snowpark Python environment, performing iterative training and evaluation within the client environment before deploying a model to Snowflake. No built-in cross-validation used

You are using Snowpark Pandas to prepare data for a machine learning model. You have a Snowpark DataFrame named 'transactions df that contains transaction data, including 'transaction id', 'product id', 'customer id', and 'transaction_amount'. You want to create a new feature that represents the average transaction amount per customer. However, you are concerned about potential skewness in the 'transaction_amount' and want to apply a log transformation to reduce its impact before calculating the average. Which of the following steps using Snowpark Pandas would achieve this transformation and calculation most efficiently within Snowflake?

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