snowflake-ml-python 1.8.3__py3-none-any.whl → 1.8.5__py3-none-any.whl

snowflake/ml/monitoring/explain_visualize.py

@@ -0,0 +1,424 @@
+from typing import Any, Union, cast, overload
+
+import altair as alt
+import numpy as np
+import pandas as pd
+
+import snowflake.snowpark.dataframe as sp_df
+from snowflake import snowpark
+from snowflake.ml._internal.exceptions import error_codes, exceptions
+from snowflake.ml.model import model_signature, type_hints
+from snowflake.ml.model._signatures import snowpark_handler
+
+DEFAULT_FIGSIZE = (1400, 500)
+DEFAULT_VIOLIN_FIGSIZE = (1400, 100)
+MAX_ANNOTATION_LENGTH = 20
+MIN_DISTANCE = 10  # Increase minimum distance between labels for more spreading in plot_force
+
+
+@overload
+def plot_force(
+    shap_row: snowpark.Row,
+    features_row: snowpark.Row,
+    base_value: float = 0.0,
+    figsize: tuple[float, float] = DEFAULT_FIGSIZE,
+    contribution_threshold: float = 0.05,
+) -> alt.LayerChart:
+    ...
+
+
+@overload
+def plot_force(
+    shap_row: pd.Series,
+    features_row: pd.Series,
+    base_value: float = 0.0,
+    figsize: tuple[float, float] = DEFAULT_FIGSIZE,
+    contribution_threshold: float = 0.05,
+) -> alt.LayerChart:
+    ...
+
+
+def plot_force(
+    shap_row: Union[pd.Series, snowpark.Row],
+    features_row: Union[pd.Series, snowpark.Row],
+    base_value: float = 0.0,
+    figsize: tuple[float, float] = DEFAULT_FIGSIZE,
+    contribution_threshold: float = 0.05,
+) -> alt.LayerChart:
+    """
+    Create a force plot for SHAP values with stacked bars based on influence direction.
+
+    Args:
+        shap_row: pandas Series or snowpark Row containing SHAP values for a specific instance
+        features_row: pandas Series or snowpark Row containing the feature values for the same instance
+        base_value: base value of the predictions. Defaults to 0, but is usually the model's average prediction
+        figsize: tuple of (width, height) for the plot
+        contribution_threshold:
+            Only features with magnitude greater than contribution_threshold as a percentage of the
+            total absolute SHAP values will be plotted. Defaults to 0.05 (5%)
+
+    Returns:
+        Altair chart object
+
+    Raises:
+        SnowflakeMLException: If the contribution threshold is not between 0 and 1,
+            or if no features with significant contributions are found.
+    """
+    if not (0 < contribution_threshold and contribution_threshold < 1):
+        raise exceptions.SnowflakeMLException(
+            error_code=error_codes.INVALID_ARGUMENT,
+            original_exception=ValueError("contribution_threshold must be between 0 and 1."),
+        )
+
+    if isinstance(shap_row, snowpark.Row):
+        shap_row = pd.Series(shap_row.as_dict())
+    if isinstance(features_row, snowpark.Row):
+        features_row = pd.Series(features_row.as_dict())
+
+    # Create a dataframe for plotting
+    positive_label = "Positive"
+    negative_label = "Negative"
+    plot_df = pd.DataFrame(
+        [
+            {
+                "feature": feature,
+                "feature_value": features_row.iloc[index],
+                "feature_annotated": f"{feature}: {features_row.iloc[index]}"[:MAX_ANNOTATION_LENGTH],
+                "influence_value": shap_row.iloc[index],
+                "bar_direction": positive_label if shap_row.iloc[index] >= 0 else negative_label,
+            }
+            for index, feature in enumerate(features_row.index)
+        ]
+    )
+
+    # Calculate cumulative positions for the stacked bars
+    shap_sum = np.sum(shap_row)
+    current_position_pos = shap_sum
+    current_position_neg = shap_sum
+    positions = []
+
+    total_abs_value_sum = np.sum(plot_df["influence_value"].abs())
+    max_abs_value = plot_df["influence_value"].abs().max()
+    spacing = max_abs_value * 0.07  # Use 2% of max value as spacing between bars
+
+    # Sort by absolute value to have largest impacts first
+    plot_df = plot_df.reindex(plot_df["influence_value"].abs().sort_values(ascending=False).index)
+    for _, row in plot_df.iterrows():
+        # Skip features with small contributions
+        row_influence_value = row["influence_value"]
+        if abs(row_influence_value) / total_abs_value_sum < contribution_threshold:
+            continue
+
+        if row_influence_value >= 0:
+            start = current_position_pos - spacing
+            end = current_position_pos - row_influence_value - spacing
+            current_position_pos = end
+        else:
+            start = current_position_neg + spacing
+            end = current_position_neg + abs(row_influence_value) + spacing
+            current_position_neg = end
+
+        positions.append(
+            {
+                "start": start,
+                "end": end,
+                "avg": (start + end) / 2,
+                "influence_value": row_influence_value,
+                "feature_value": row["feature_value"],
+                "feature_annotated": row["feature_annotated"],
+                "bar_direction": row["bar_direction"],
+                "bar_y": 0,
+                "feature": row["feature"],
+            }
+        )
+
+    if len(positions) == 0:
+        raise exceptions.SnowflakeMLException(
+            error_code=error_codes.INVALID_ARGUMENT,
+            original_exception=ValueError(
+                "No features with significant contributions found. Try lowering the contribution_threshold,"
+                "and verify the input is non-empty."
+            ),
+        )
+
+    position_df = pd.DataFrame(positions)
+
+    # Create force plot using Altair
+    blue_color = "#1f77b4"
+    red_color = "#d62728"
+    width, height = figsize
+    bars: alt.Chart = (
+        alt.Chart(position_df)
+        .mark_bar(size=10)
+        .encode(
+            x=alt.X("start:Q", title="Feature Impact"),
+            x2=alt.X2("end:Q"),
+            y=alt.Y("bar_y:Q", axis=None),
+            color=alt.Color(
+                "bar_direction:N",
+                scale=alt.Scale(domain=[positive_label, negative_label], range=[red_color, blue_color]),
+                legend=alt.Legend(title="Influence Direction"),
+            ),
+            tooltip=["feature", "influence_value", "feature_value"],
+        )
+        .properties(title="Feature Influence (SHAP values)", width=width, height=height)
+    ).interactive()
+
+    arrow: alt.Chart = (
+        alt.Chart(position_df)
+        .mark_point(shape="triangle", filled=True, fillOpacity=1)
+        .encode(
+            x=alt.X("start:Q"),
+            y=alt.Y("bar_y:Q", axis=None),
+            angle=alt.Angle("bar_direction:N", scale=alt.Scale(domain=["Positive", "Negative"], range=[90, -90])),
+            color=alt.Color(
+                "bar_direction:N", scale=alt.Scale(domain=["Positive", "Negative"], range=["#1f77b4", "#d62728"])
+            ),
+            size=alt.SizeValue(300),
+            tooltip=alt.value(None),
+        )
+    )
+
+    # Add a vertical line at the base value
+    zero_line: alt.Chart = alt.Chart(pd.DataFrame({"x": [base_value]})).mark_rule(strokeDash=[3, 3]).encode(x="x:Q")
+
+    # Calculate label positions to avoid overlap and ensure labels are spread apart horizontally
+
+    # Sort by bar center (avg) for label placement
+    sorted_positions = sorted(positions, key=lambda x: x["avg"])
+
+    # Improved label spreading algorithm:
+    # Calculate the minimum and maximum x positions (avg) for the bars
+    min_x = min(pos["avg"] for pos in sorted_positions)
+    max_x = max(pos["avg"] for pos in sorted_positions)
+    n_labels = len(sorted_positions)
+    # Calculate the minimum required distance between labels
+    spread_width = max_x - min_x
+    if n_labels > 1:
+        space_per_label = spread_width / (n_labels - 1)
+        # If space_per_label is less than min_distance, use min_distance instead
+        effective_distance = max(space_per_label, MIN_DISTANCE)
+    else:
+        effective_distance = 0
+
+    # Start from min_x - offset, and assign label_x for each label from left to right
+    offset = -effective_distance  # Start a bit to the left
+    label_positions = []
+    label_lines = []
+    placed_label_xs: list[float] = []
+    for i, pos in enumerate(sorted_positions):
+        if i == 0:
+            label_x = min_x + offset
+        else:
+            label_x = placed_label_xs[-1] + effective_distance
+        placed_label_xs.append(label_x)
+        label_positions.append(
+            {
+                "label_x": label_x,
+                "label_y": 1,  # Place labels below the bars
+                "feature_annotated": pos["feature_annotated"],
+                "feature_value": pos["feature_value"],
+            }
+        )
+        # Draw a diagonal line from the bar to the label
+        label_lines.append(
+            {
+                "x": pos["avg"],
+                "x2": label_x,
+                "y": 0,
+                "y2": 1,
+            }
+        )
+
+    label_positions_df = pd.DataFrame(label_positions)
+    label_lines_df = pd.DataFrame(label_lines)
+
+    # Draw diagonal lines from bar to label
+    label_connectors = (
+        alt.Chart(label_lines_df)
+        .mark_rule(strokeDash=[2, 2], color="grey")
+        .encode(
+            x="x:Q",
+            x2="x2:Q",
+            y=alt.Y("y:Q", axis=None),
+            y2="y2:Q",
+        )
+    )
+
+    # Place labels at adjusted positions
+    feature_labels = (
+        alt.Chart(label_positions_df)
+        .mark_text(align="center", baseline="line-bottom", dy=0, fontSize=11)
+        .encode(
+            x=alt.X("label_x:Q"),
+            y=alt.Y("label_y:Q", axis=None),
+            text=alt.Text("feature_annotated:N"),
+            color=alt.value("grey"),
+            tooltip=["feature_value"],
+        )
+    )
+
+    return cast(alt.LayerChart, bars + feature_labels + zero_line + arrow + label_connectors)
+
+
+def plot_influence_sensitivity(
+    shap_values: type_hints.SupportedDataType,
+    feature_values: type_hints.SupportedDataType,
+    figsize: tuple[float, float] = DEFAULT_FIGSIZE,
+) -> Any:
+    """
+    Create a SHAP dependence scatter plot for a specific feature. If a DataFrame is provided, a select box
+    will be displayed to select the feature. This is only supported in Snowflake notebooks.
+    If Streamlit is not available and a DataFrame is passed in, an ImportError will be raised.
+
+    Args:
+        feature_values: pandas Series or 2D array containing the feature values for a specific feature
+        shap_values: pandas Series or 2D array containing the SHAP values for the same feature
+        figsize: tuple of (width, height) for the plot
+
+    Returns:
+        Altair chart object
+
+    Raises:
+        ValueError: If the types of feature_values and shap_values are not the same
+
+    """
+
+    use_streamlit = False
+    feature_values_df = _convert_to_pandas_df(feature_values)
+    shap_values_df = _convert_to_pandas_df(shap_values)
+
+    if len(shap_values_df.shape) > 1:
+        feature_values, shap_values, st = _prepare_feature_values_for_streamlit(feature_values_df, shap_values_df)
+        use_streamlit = True
+    elif feature_values_df.shape[0] != shap_values_df.shape[0]:
+        raise ValueError("Feature values and SHAP values must have the same number of rows.")
+
+    scatter = _create_scatter_plot(feature_values, shap_values, figsize)
+    return st.altair_chart(scatter) if use_streamlit else scatter
+
+
+def _prepare_feature_values_for_streamlit(
+    feature_values_df: pd.DataFrame, shap_values: pd.DataFrame
+) -> tuple[pd.Series, pd.Series, Any]:
+    try:
+        from IPython import get_ipython
+        from snowbook.executor.python_transformer import IPythonProxy
+
+        assert isinstance(
+            get_ipython(), IPythonProxy
+        ), "Influence sensitivity plots for a DataFrame are not supported outside of Snowflake notebooks."
+    except ImportError:
+        raise RuntimeError(
+            "Influence sensitivity plots for a DataFrame are not supported outside of Snowflake notebooks."
+        )
+
+    import streamlit as st
+
+    feature_columns = feature_values_df.columns
+    chosen_ft: str = st.selectbox("Feature:", feature_columns)
+    feature_values = feature_values_df[chosen_ft]
+    shap_values = shap_values.iloc[:, feature_columns.get_loc(chosen_ft)]
+    return feature_values, shap_values, st
+
+
+def _create_scatter_plot(feature_values: pd.Series, shap_values: pd.Series, figsize: tuple[float, float]) -> alt.Chart:
+    unique_vals = np.sort(np.unique(feature_values.values))
+    max_points_per_unique_value = float(np.max(np.bincount(np.searchsorted(unique_vals, feature_values.values))))
+    points_per_value = len(feature_values.values) / len(unique_vals)
+    is_categorical = float(max(max_points_per_unique_value, points_per_value)) > 10
+
+    kwargs = (
+        {
+            "x": alt.X("feature_value:N", title="Feature Value"),
+            "color": alt.Color("feature_value:N").legend(None),
+            "xOffset": "jitter:Q",
+        }
+        if is_categorical
+        else {"x": alt.X("feature_value:Q", title="Feature Value")}
+    )
+
+    # Create a dataframe for plotting
+    plot_df = pd.DataFrame({"feature_value": feature_values, "shap_value": shap_values})
+
+    width, height = figsize
+
+    # Create scatter plot
+    scatter = (
+        alt.Chart(plot_df)
+        .transform_calculate(jitter="random()")
+        .mark_circle(size=60, opacity=0.7)
+        .encode(
+            y=alt.Y("shap_value:Q", title="SHAP Value"),
+            tooltip=["feature_value", "shap_value"],
+            **kwargs,
+        )
+        .properties(title="SHAP Dependence Scatter Plot", width=width, height=height)
+    )
+
+    return cast(alt.Chart, scatter)
+
+
+def plot_violin(
+    shap_df: type_hints.SupportedDataType,
+    feature_df: type_hints.SupportedDataType,
+    figsize: tuple[float, float] = DEFAULT_VIOLIN_FIGSIZE,
+) -> alt.Chart:
+    """
+    Create a violin plot per feature showing the distribution of SHAP values.
+
+    Args:
+        shap_df: 2D array containing SHAP values for multiple features
+        feature_df: 2D array containing the corresponding feature values
+        figsize: tuple of (width, height) for the plot
+
+    Returns:
+        Altair chart object
+    """
+
+    shap_df_pd = _convert_to_pandas_df(shap_df)
+    feature_df_pd = _convert_to_pandas_df(feature_df)
+
+    # Assert that the input dataframes are 2D
+    assert len(shap_df_pd.shape) == 2, f"shap_df must be 2D, but got shape {shap_df_pd.shape}"
+    assert len(feature_df_pd.shape) == 2, f"feature_df must be 2D, but got shape {feature_df_pd.shape}"
+
+    # Prepare data for plotting
+    plot_data = pd.DataFrame(
+        {
+            "feature_name": feature_df_pd.columns.repeat(shap_df_pd.shape[0]),
+            "shap_value": shap_df_pd.transpose().values.flatten(),
+        }
+    )
+
+    # Order the rows by the absolute sum of SHAP values per feature
+    feature_abs_sum = shap_df_pd.abs().sum(axis=0)
+    sorted_features = feature_abs_sum.sort_values(ascending=False).index
+    column_sort_order = [feature_df_pd.columns[shap_df_pd.columns.get_loc(col)] for col in sorted_features]
+
+    # Create the violin plot
+    width, height = figsize
+    violin = (
+        alt.Chart(plot_data)
+        .transform_density(density="shap_value", groupby=["feature_name"], as_=["shap_value", "density"])
+        .mark_area(orient="vertical")
+        .encode(
+            y=alt.Y("density:Q", title=None).stack("center").impute(None).axis(labels=False, grid=False, ticks=True),
+            x=alt.X("shap_value:Q", title="SHAP Value"),
+            row=alt.Row("feature_name:N", sort=column_sort_order).spacing(0),
+            color=alt.Color("feature_name:N", legend=None),
+            tooltip=["feature_name", "shap_value"],
+        )
+        .properties(width=width, height=height)
+    ).interactive()
+
+    return cast(alt.Chart, violin)
+
+
+def _convert_to_pandas_df(
+    data: type_hints.SupportedDataType,
+) -> pd.DataFrame:
+    if isinstance(data, sp_df.DataFrame):
+        return snowpark_handler.SnowparkDataFrameHandler.convert_to_df(data)
+
+    return model_signature._convert_local_data_to_df(data)

snowflake/ml/registry/_manager/model_manager.py

@@ -12,8 +12,10 @@ from snowflake.ml.model import model_signature, type_hints as model_types
 from snowflake.ml.model._client.model import model_impl, model_version_impl
 from snowflake.ml.model._client.ops import metadata_ops, model_ops, service_ops
 from snowflake.ml.model._model_composer import model_composer
+from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
 from snowflake.ml.model._packager.model_meta import model_meta
 from snowflake.snowpark import exceptions as snowpark_exceptions, session
+from snowflake.snowpark._internal import utils as snowpark_utils
 
 logger = logging.getLogger(__name__)
 
@@ -169,7 +171,10 @@ class ModelManager:
         database_name_id, schema_name_id, model_name_id = sql_identifier.parse_fully_qualified_name(model_name)
         version_name_id = sql_identifier.SqlIdentifier(version_name)
 
-        use_live_commit = platform_capabilities.PlatformCapabilities.get_instance().is_live_commit_enabled()
+        # TODO(SNOW-2091317): Remove this when the snowpark enables file PUT operation for snowurls
+        use_live_commit = (
+            not snowpark_utils.is_in_stored_procedure()  # type: ignore[no-untyped-call]
+        ) and platform_capabilities.PlatformCapabilities.get_instance().is_live_commit_enabled()
         if use_live_commit:
             logger.info("Using live commit model version")
         else:
@@ -212,8 +217,24 @@ class ModelManager:
             # Convert any string target platforms to TargetPlatform objects
             platforms = [model_types.TargetPlatform(platform) for platform in target_platforms]
         else:
+            # Default the target platform to warehouse if not specified and any table function exists
+            if options and (
+                options.get("function_type") == model_manifest_schema.ModelMethodFunctionTypes.TABLE_FUNCTION.value
+                or (
+                    any(
+                        opt.get("function_type") == "TABLE_FUNCTION"
+                        for opt in options.get("method_options", {}).values()
+                    )
+                )
+            ):
+                logger.info(
+                    "Logging a partitioned model with a table function without specifying `target_platforms`. "
+                    'Default to `target_platforms=["WAREHOUSE"]`.'
+                )
+                platforms = [model_types.TargetPlatform.WAREHOUSE]
+
             # Default the target platform to SPCS if not specified when running in ML runtime
-            if env.IN_ML_RUNTIME:
+            if not platforms and env.IN_ML_RUNTIME:
                 logger.info(
                     "Logging the model on Container Runtime for ML without specifying `target_platforms`. "
                     'Default to `target_platforms=["SNOWPARK_CONTAINER_SERVICES"]`.'

snowflake/ml/registry/registry.py

@@ -148,11 +148,11 @@ class Registry:
                 dependencies must be retrieved from Snowflake Anaconda Channel.
             artifact_repository_map: Specifies a mapping of package channels or platforms to custom artifact
                 repositories. Defaults to None. Currently, the mapping applies only to warehouse execution.
-                Note : This feature is currently in Private Preview; please contact your Snowflake account team
-                to enable it.
+                Note : This feature is currently in Public Preview.
                 Format: {channel_name: artifact_repository_name}, where:
-                   - channel_name: The name of the Conda package channel (e.g., 'condaforge') or 'pip' for pip packages.
-                   - artifact_repository_name: The name or URL of the repository to fetch packages from.
+                   - channel_name: Currently must be 'pip'.
+                   - artifact_repository_name: The identifier of the artifact repository to fetch packages from, e.g.
+                     `snowflake.snowpark.pypi_shared_repository`.
             resource_constraint: Mapping of resource constraint keys and values, e.g. {"architecture": "x86"}.
             target_platforms: List of target platforms to run the model. The only acceptable inputs are a combination of
                 {"WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"}. Defaults to None.
@@ -288,14 +288,15 @@ class Registry:
                 dependencies must be retrieved from Snowflake Anaconda Channel.
             artifact_repository_map: Specifies a mapping of package channels or platforms to custom artifact
                 repositories. Defaults to None. Currently, the mapping applies only to warehouse execution.
-                Note : This feature is currently in Private Preview; please contact your Snowflake account team to
-                enable it.
+                Note : This feature is currently in Public Preview.
                 Format: {channel_name: artifact_repository_name}, where:
-                   - channel_name: The name of the Conda package channel (e.g., 'condaforge') or 'pip' for pip packages.
-                   - artifact_repository_name: The name or URL of the repository to fetch packages from.
+                   - channel_name: Currently must be 'pip'.
+                   - artifact_repository_name: The identifier of the artifact repository to fetch packages from, e.g.
+                     `snowflake.snowpark.pypi_shared_repository`.
             resource_constraint: Mapping of resource constraint keys and values, e.g. {"architecture": "x86"}.
             target_platforms: List of target platforms to run the model. The only acceptable inputs are a combination of
-                {"WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"}. Defaults to None.
+                ["WAREHOUSE", "SNOWPARK_CONTAINER_SERVICES"]. Defaults to None. When None, the target platforms will be
+                both.
             python_version: Python version in which the model is run. Defaults to None.
             signatures: Model data signatures for inputs and outputs for various target methods. If it is None,
                 sample_input_data would be used to infer the signatures for those models that cannot automatically

snowflake/ml/utils/connection_params.py

@@ -113,6 +113,10 @@ def _load_from_snowsql_config_file(connection_name: str, login_file: str = "") -
 
     config = configparser.ConfigParser(inline_comment_prefixes="#")
 
+    snowflake_connection_name = os.getenv("SNOWFLAKE_CONNECTION_NAME")
+    if snowflake_connection_name is not None:
+        connection_name = snowflake_connection_name
+
     if connection_name:
         if not connection_name.startswith("connections."):
             connection_name = "connections." + connection_name
@@ -153,9 +157,11 @@ def SnowflakeLoginOptions(connection_name: str = "", login_file: Optional[str] =
       Ideally one should have a snowsql config file. Read more here:
       https://docs.snowflake.com/en/user-guide/snowsql-start.html#configuring-default-connection-settings
 
+      If snowsql config file does not exist, it tries auth from env variables.
+
     Args:
-        connection_name: Name of the connection to look for inside the config file. If `connection_name` is NOT given,
-            it tries auth from env variables.
+        connection_name: Name of the connection to look for inside the config file. If environment variable
+            SNOWFLAKE_CONNECTION_NAME is provided, it will override the input connection_name.
         login_file: If provided, this is used as config file instead of default one (_DEFAULT_CONNECTION_FILE).
 
     Returns:

snowflake/ml/version.py

@@ -1,2 +1,2 @@
 # This is parsed by regex in conda recipe meta file. Make sure not to break it.
-VERSION = "1.8.3"
+VERSION = "1.8.5"

{snowflake_ml_python-1.8.3.dist-info → snowflake_ml_python-1.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.8.3
+Version: 1.8.5
 Summary: The machine learning client library that is used for interacting with Snowflake to build machine learning solutions.
 Author-email: "Snowflake, Inc" <support@snowflake.com>
 License: 
@@ -236,13 +236,13 @@ License-File: LICENSE.txt
 Requires-Dist: absl-py<2,>=0.15
 Requires-Dist: anyio<5,>=3.5.0
 Requires-Dist: cachetools<6,>=3.1.1
-Requires-Dist: cloudpickle<3,>=2.0.0
+Requires-Dist: cloudpickle>=2.0.0
 Requires-Dist: cryptography
 Requires-Dist: fsspec[http]<2026,>=2024.6.1
 Requires-Dist: importlib_resources<7,>=6.1.1
 Requires-Dist: numpy<2,>=1.23
 Requires-Dist: packaging<25,>=20.9
-Requires-Dist: pandas<3,>=1.0.0
+Requires-Dist: pandas<3,>=2.1.4
 Requires-Dist: pyarrow
 Requires-Dist: pydantic<3,>=2.8.2
 Requires-Dist: pyjwt<3,>=2.0.0
@@ -250,27 +250,31 @@ Requires-Dist: pytimeparse<2,>=1.1.8
 Requires-Dist: pyyaml<7,>=6.0
 Requires-Dist: retrying<2,>=1.3.3
 Requires-Dist: s3fs<2026,>=2024.6.1
-Requires-Dist: scikit-learn<1.6,>=1.4
+Requires-Dist: scikit-learn<1.6
 Requires-Dist: scipy<2,>=1.9
-Requires-Dist: snowflake-connector-python[pandas]<4,>=3.12.0
+Requires-Dist: shap<1,>=0.46.0
+Requires-Dist: snowflake-connector-python[pandas]<4,>=3.15.0
 Requires-Dist: snowflake-snowpark-python!=1.26.0,<2,>=1.17.0
 Requires-Dist: snowflake.core<2,>=1.0.2
 Requires-Dist: sqlparse<1,>=0.4
 Requires-Dist: typing-extensions<5,>=4.1.0
 Requires-Dist: xgboost<3,>=1.7.3
 Provides-Extra: all
+Requires-Dist: altair<6,>=5; extra == "all"
 Requires-Dist: catboost<2,>=1.2.0; extra == "all"
 Requires-Dist: keras<4,>=2.0.0; extra == "all"
 Requires-Dist: lightgbm<5,>=4.1.0; extra == "all"
 Requires-Dist: mlflow<3,>=2.16.0; extra == "all"
 Requires-Dist: sentence-transformers<4,>=2.7.0; extra == "all"
 Requires-Dist: sentencepiece<0.2.0,>=0.1.95; extra == "all"
-Requires-Dist: shap<1,>=0.46.0; extra == "all"
+Requires-Dist: streamlit<2,>=1.30.0; extra == "all"
 Requires-Dist: tensorflow<3,>=2.17.0; extra == "all"
 Requires-Dist: tokenizers<1,>=0.15.1; extra == "all"
 Requires-Dist: torch<3,>=2.0.1; extra == "all"
 Requires-Dist: torchdata<1,>=0.4; extra == "all"
 Requires-Dist: transformers<5,>=4.39.3; extra == "all"
+Provides-Extra: altair
+Requires-Dist: altair<6,>=5; extra == "altair"
 Provides-Extra: catboost
 Requires-Dist: catboost<2,>=1.2.0; extra == "catboost"
 Provides-Extra: keras
@@ -281,8 +285,8 @@ Provides-Extra: lightgbm
 Requires-Dist: lightgbm<5,>=4.1.0; extra == "lightgbm"
 Provides-Extra: mlflow
 Requires-Dist: mlflow<3,>=2.16.0; extra == "mlflow"
-Provides-Extra: shap
-Requires-Dist: shap<1,>=0.46.0; extra == "shap"
+Provides-Extra: streamlit
+Requires-Dist: streamlit<2,>=1.30.0; extra == "streamlit"
 Provides-Extra: tensorflow
 Requires-Dist: tensorflow<3,>=2.17.0; extra == "tensorflow"
 Provides-Extra: torch
@@ -404,6 +408,51 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
+## 1.8.5
+
+### Bug Fixes
+
+- Registry: Fixed a bug when listing and deleting container services.
+- Registry: Fixed explainability issue with scikit-learn pipelines, skipping explain function creation.
+- Explainability: bump minimum streamlit version down to 1.30
+- Modeling: Make XGBoost a required dependency (xgboost is not a required dependency in snowflake-ml-python 1.8.4).
+
+### Breaking change
+
+- ML Job: Rename argument `num_instances` to `target_instances` in job submission APIs and
+  change type from `Optional[int]` to `int`
+
+### New Features
+
+- Registry: No longer checks if the snowflake-ml-python version is available in the Snowflake Conda channel when logging
+  an SPCS-only model.
+- ML Job: Add `min_instances` argument to the job decorator to allow waiting for workers to be ready.
+
+## 1.8.4 (2025-05-12)
+
+### Bug Fixes
+
+- Registry: Default `enable_explainability` to True when the model can be deployed to Warehouse.
+- Registry: Add `custom_model.partitioned_api` decorator and deprecate `partitioned_inference_api`.
+- Registry: Fixed a bug when logging pytroch and tensorflow models that caused
+  `UnboundLocalError: local variable 'multiple_inputs' referenced before assignment`.
+
+### Breaking change
+
+- ML Job: Updated property `id` to be fully qualified name; Introduced new property `name` to represent the ML Job name
+- ML Job: Modified `list_jobs()` to return ML Job `name` instead of `id`
+- Registry: Error in `log_model` if `enable_explainability` is True and model is only deployed to
+   Snowpark Container Services, instead of just user warning.
+
+### New Features
+
+- ML Job: Extend `@remote` function decorator, `submit_file()` and `submit_directory()` to accept `database` and
+  `schema` parameters
+- ML Job: Support querying by fully qualified name in `get_job()`
+- Explainability: Added visualization functions to `snowflake.ml.monitoring` to plot explanations in notebooks.
+- Explainability: Support explain for categorical transforms for sklearn pipeline
+- Support categorical type for `xgboost.DMatrix` inputs.
+
 ## 1.8.3
 
 ### Bug Fixes
@@ -417,6 +466,7 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
   as a list of strings
 - Registry: Support `ModelVersion.run_job` to run inference with a single-node Snowpark Container Services job.
 - DataConnector: Removed PrPr decorators
+- Registry: Default the target platform to warehouse when logging a partitioned model.
 
 ## 1.8.2