Experience Snowflake with notebooks¶

Example usage¶

Snowpark Python comes pre-installed in the Snowflake Notebooks environment. The following example uses the Snowpark library in a notebook to read in a CSV file and a Snowflake table and display its contents as output.

1. In your notebook, add a Python cell, either using a keyboard shortcut or by selecting + Python. Snowflake Notebooks and Snowpark both support Python 3.9.

2. Set up a Snowpark session. In notebooks, the session context variable is preconfigured. You can use the get_active_session method to get the session context variable:

   from snowflake.snowpark.context import get_active_session
   session = get_active_session()
   

   Copy

3. Use Snowpark to load a CSV file into a Snowpark DataFrame from a stage location. This example uses a stage called tastybyte_stage.

   df = session.read.options({"infer_schema":True}).csv('@TASTYBYTE_STAGE/app_order.csv')
   

   Copy

4. Load an existing Snowflake table, app_order, into the Snowpark DataFrame.

   df = session.table("APP_ORDER")
   

   Copy

5. Display the Snowpark DataFrame.

   df
   

   Copy

Snowpark limitations¶

• A Snowflake Notebook creates a Snowpark session, so you can use most of the methods available in a Snowpark session class. However, because a notebook runs inside Snowflake rather than in your local development environment, you cannot use the following methods:

  • session.add_import

  • session.add_packages

  • session.add_requirements

• Some Snowpark Python operations don’t work with SPROCs. For a complete list of operations, see Limitations.

Example usage¶

Streamlit comes pre-installed with the Snowflake Notebooks environment. The example in this section creates an interactive data app using Streamlit.

1. Import necessary libraries

   import streamlit as st
   import pandas as pd
   

   Copy

2. First create some sample data for the app.

   species = ["setosa"] * 3 + ["versicolor"] * 3 + ["virginica"] * 3
   measurements = ["sepal_length", "sepal_width", "petal_length"] * 3
   values = [5.1, 3.5, 1.4, 6.2, 2.9, 4.3, 7.3, 3.0, 6.3]
   df = pd.DataFrame({"species": species,"measurement": measurements,"value": values})
   df
   

   Copy

3. Set up your interactive slider from the Streamlit library.

   st.markdown("""# Interactive Filtering with Streamlit! :balloon:
               Values will automatically cascade down the notebook cells""")
   value = st.slider("Move the slider to change the filter value 👇", df.value.min(), df.value.max(), df.value.mean(), step = 0.3 )
   

   Copy

4. Finally, display a filtered table based on the slider value.

   df[df["value"]>value].sort_values("value")
   

   Copy

You can interact with the app in real time from the notebook. See the filtered table change based on the value you set on the slider.

Streamlit support in Notebooks¶

When you use the st.map or st.pydeck_chart Streamlit commands, Mapbox provides the map tiles when rendering map content. Mapbox is a third-party application and is subject to Snowflake’s External Offerings Terms.

The following Streamlit elements are not supported in Notebooks:

• st.file_uploader

• st.camera_input

• st.bokeh_chart

• st.set_page_config

  The page_title and page_icon properties of the st.set_page_config command are not supported.

• st.components.v1.iframe

• st.components.v1.declare_component

• The following experimental features:

  • st.experimental_set_query_params

  • st.experimental_get_query_params

• Anchor links

Example usage¶

To use Snowpark ML, install the snowflake-ml-python library for your notebook:

1. From the notebook, select Packages.

2. Locate the snowflake-ml-python library and select the library to install it.

Here is an example of how you can use the Snowpark ML library for preprocessing your data:

import snowflake.ml.modeling.preprocessing as pp

# Initialize a StandardScaler object with input and output column names
scaler = pp.StandardScaler(
    input_cols=feature_names_input,
    output_cols=feature_names_input
)

# Fit the scaler to the dataset
scaler.fit(upsampled_data)

# Transform the dataset using the fitted scaler
scaled_features = scaler.transform(upsampled_data)
scaled_features

Here is an example of how you can use the Snowpark ML library for model training and inference:

from snowflake.ml.modeling.ensemble import RandomForestClassifier

# Initialize a RandomForestClassifier object with input, label, and output column names
model = RandomForestClassifier(
    input_cols=feature_names_input,
    label_cols=label,
    output_cols=output_label,
)

# Train the RandomForestClassifier model using the training set
model.fit(training)

# Predict the target variable for the testing set using the trained model
results = model.predict(testing)

Example usage¶

To use the Snowflake ML registry, install the snowflake-ml-python library for your notebook:

1. From your notebook, select Packages at the top.

2. Search for the snowflake-ml-python package and select the library to install it.

Here is an example of how you can use the Snowflake ML Registry to log a model:

from snowflake.ml.registry import Registry
# Create a registry and log the model
native_registry = Registry(session=session, database_name=db, schema_name=schema)

# Let's first log the very first model we trained
model_ver = native_registry.log_model(
    model_name=model_name,
    version_name='V0',
    model=regressor,
    sample_input_data=X, # to provide the feature schema
)

# Add evaluation metric
model_ver.set_metric(metric_name="mean_abs_pct_err", value=mape)

# Add a description
model_ver.comment = "This is the first iteration of our Diamonds Price Prediction model. It is used for demo purposes."

# Show Models
native_registry.get_model(model_name).show_versions()

Example usage¶

Snowpark pandas is available in Snowpark Python version 1.17 and later. Snowpark Python comes pre-installed with the Snowflake Notebooks environment.

1. To install Modin, select modin from Packages and ensure that the version is 0.28.1 or later.

2. To set the pandas version, select pandas from Packages and ensure that the version is 2.2.1.

In a Python cell, import Snowpark Python and Modin:

import modin.pandas as pd
import snowflake.snowpark.modin.plugin

Copy

1. Create a Snowpark session:

   from snowflake.snowpark.context import get_active_session
   session = get_active_session()
   

   Copy

2. Start using the Snowpark Python API:

   # Create a Snowpark Pandas DataFrame with sample data.
   df = pd.DataFrame([[1, 'Big Bear', 8],[2, 'Big Bear', 10],[3, 'Big Bear', None],
                       [1, 'Tahoe', 3],[2, 'Tahoe', None],[3, 'Tahoe', 13],
                       [1, 'Whistler', None],['Friday', 'Whistler', 40],[3, 'Whistler', 25]],
                       columns=["DAY", "LOCATION", "SNOWFALL"])
   # Drop rows with null values.
   df.dropna()
   # Compute the average daily snowfall across locations.
   df.groupby("LOCATION").mean()["SNOWFALL"]
   

   Copy