You are building a fraud detection model using transaction data stored in Snowflake. The dataset includes features like transaction amount, merchant category, location, and time. Due to regulatory requirements, you need to ensure personally identifiable information (PII) is handled securely and compliantly during the data collection and preprocessing phases. Which of the following combinations of Snowflake features and techniques would be MOST suitable for achieving this goal?

• A. Use Snowflake's masking policies to redact PII columns before any data is accessed for model training. Ensure role-based access control is configured so that only authorized personnel can access the unmasked data for specific purposes.
• B. Encrypt the entire database containing the transaction data to protect PII from unauthorized access.
• C. Use Snowflake's data sharing capabilities to share the transaction data with a third-party machine learning platform for model development, without any PII masking or redaction.
• D. Apply differential privacy techniques on aggregated data derived from the transaction data, before using it for model training. Combine this with Snowflake's row access policies to restrict access to sensitive transaction records based on user roles and data attributes.
• E. Create a view that selects only the non-PII columns for model training. Grant access to this view to the data science team.

A data scientist is building a churn prediction model using Snowflake data'. They want to load a large dataset (50 million rows) from a Snowflake table 'customer_data' into a Pandas DataFrame for feature engineering. They are using the Snowflake Python connector. Given the code snippet below and considering performance and memory usage, which approach would be the most efficient for loading the data into the Pandas DataFrame? Assume you have a properly configured connection and cursor 'cur'. Furthermore, assume that the 'customer id' column is the primary key and uniquely identifies each customer. You are also aware that network bandwidth limitations exist within your environment. ```python import snowflake.connector import pandas as pd # Assume conn and cur are already initialized # conn = snowflake.connector.connect(...) # cur = conn.cursor() query = "SELECT FROM customer data```

• A. ```python cur.execute(query) df = pd.DataFrame(cur.fetchall(), columns=[col[0] for col in cur.description])
• B. ```python cur.execute(query) results = cur.fetchmany(size=1000000) df_list = 0 while results: df_list.append(pd.DataFrame(results, for col in cur.description])) results = cur.fetchmany(size=1000000) df = pd.concat(df_list, ignore_index=True)
• C. ```python import snowflake.connector import pandas as pd import pyarrow import pyarrow.parquet # Enable Arrow result format conn.cursor().execute("ALTER SESSION SET PYTHON USE ARROW RESULT FORMAT-TRUE") cur.execute(query) df =
• D. ```python with conn.cursor(snowflake.connector.DictCursor) as cur: cur.execute(query) df = pd.DataFrame(cur.fetchall())
• E. ```python cur.execute(query) df = pd.read_sql(query, conn)

You are performing exploratory data analysis on a dataset of customer transactions in Snowflake to prepare for a linear regression model that predicts transaction value based on several customer-related features (e.g., age, location, number of previous transactions). You suspect a non-linear relationship between 'customer_age' and 'transaction_value'. Which of the following Snowflake SQL techniques is MOST appropriate for exploring and potentially transforming the 'customer_age' variable to better fit a linear regression model?

• A. Implement a Box-Cox transformation in Snowpark Python, select a suitable transformation parameter based on the data, and apply the transformation on 'customer_age' feature.
• B. Calculate the Pearson correlation coefficient between 'customer_age' and 'transaction_value' using the function. If the correlation is low, discard the 'customer_age' variable.
• C. Use the window function to bin 'customer_age' into quartiles and treat each quartile as a categorical variable in the linear regression model.
• D. Apply a logarithmic transformation to 'customer_age' if a scatter plot of 'customer_age' vs 'transaction_value' shows a curve that flattens out as 'customer_age' increases.
• E. Create polynomial features by adding 'customer_ageA2' and 'customer_ageA3' as new columns to the table, without checking for interaction effects.

You are building a machine learning model using Snowflake data to predict customer churn. Your dataset includes a 'CUSTOMER TYPE column with the following possible values: 'New', 'Returning', and 'VIP'. You need to perform one-hot encoding on this column. Which of the following Snowflake SQL queries correctly implements one-hot encoding for the 'CUSTOMER TYPE column, creating separate binary columns for each customer type ('IS NEW', 'IS RETURNING', 'IS VIP')?

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

You are tasked with developing a multi-class image classification model to categorize product images stored in Snowflake external stage. The categories are 'Electronics', 'Clothing', 'Furniture', 'Books', and 'Food'. You plan to use a pre-trained Convolutional Neural Network (CNN) model and fine-tune it using your dataset. However, you're facing challenges in efficiently loading and preprocessing the image data within the Snowflake environment before feeding it to your model. Which of the following approaches would be MOST efficient for image data loading and preprocessing in Snowflake, minimizing data movement and leveraging Snowflake's scalability, for a large dataset exceeding 1 TB of images?

• A. Download all the images from the external stage to a local machine, preprocess them using a standard Python library like OpenCV, and then upload the processed data back into Snowflake as a table for model training.
• B. Utilize Snowflake's external function integration with AWS Lambda to preprocess images as they are uploaded to S3, storing the preprocessed data back in S3 and creating an external table pointing to the preprocessed data.
• C. Write a Python User-Defined Function (UDF) that loads each image from the external stage directly into memory, performs preprocessing (resizing, normalization), and returns the processed image data. The UDF is then called in a SQL query to process the image data.
• D. Create a Snowflake Stream to continuously ingest new images into a Snowflake table. Use a task to periodically trigger a Python UDF that preprocesses the newly ingested images and stores them in another table for model training.
• E. Use Snowflake's Snowpark to read images from the external stage into a Snowpark DataFrame. Then, implement image preprocessing using Snowpark DataFrame operations, such as resizing and normalization, within the DataFrame transformations before sending the data to the model.