snowflake-ml-python 1.7.4__py3-none-any.whl → 1.8.0__py3-none-any.whl

snowflake/ml/modeling/metrics/ranking.py

@@ -98,6 +98,7 @@ def precision_recall_curve(
         packages=[
             f"cloudpickle=={cloudpickle.__version__}",
             f"scikit-learn=={sklearn_release[0]}.{sklearn_release[1]}.*",
+            f"numpy=={np.__version__}",
             "snowflake-snowpark-python",
         ],
         statement_params=statement_params,
@@ -245,6 +246,7 @@ def roc_auc_score(
         packages=[
             f"cloudpickle=={cloudpickle.__version__}",
             f"scikit-learn=={sklearn_release[0]}.{sklearn_release[1]}.*",
+            f"numpy=={np.__version__}",
             "snowflake-snowpark-python",
         ],
         statement_params=statement_params,
@@ -348,6 +350,7 @@ def roc_curve(
         packages=[
             f"cloudpickle=={cloudpickle.__version__}",
             f"scikit-learn=={sklearn_release[0]}.{sklearn_release[1]}.*",
+            f"numpy=={np.__version__}",
             "snowflake-snowpark-python",
         ],
         statement_params=statement_params,

snowflake/ml/modeling/metrics/regression.py

@@ -83,6 +83,7 @@ def d2_absolute_error_score(
         packages=[
             f"cloudpickle=={cloudpickle.__version__}",
             f"scikit-learn=={sklearn_release[0]}.{sklearn_release[1]}.*",
+            f"numpy=={np.__version__}",
             "snowflake-snowpark-python",
         ],
         statement_params=statement_params,
@@ -180,6 +181,7 @@ def d2_pinball_score(
         packages=[
             f"cloudpickle=={cloudpickle.__version__}",
             f"scikit-learn=={sklearn_release[0]}.{sklearn_release[1]}.*",
+            f"numpy=={np.__version__}",
             "snowflake-snowpark-python",
         ],
         statement_params=statement_params,
@@ -295,6 +297,7 @@ def explained_variance_score(
         packages=[
             f"cloudpickle=={cloudpickle.__version__}",
             f"scikit-learn=={sklearn_release[0]}.{sklearn_release[1]}.*",
+            f"numpy=={np.__version__}",
             "snowflake-snowpark-python",
         ],
         statement_params=statement_params,

snowflake/ml/modeling/pipeline/pipeline.py

@@ -854,6 +854,7 @@ class Pipeline(base.BaseTransformer):
         # Create a fitted sklearn pipeline object by translating each non-estimator step in pipeline with with
         # a fitted column transformer.
         sksteps = []
+        i = 0
         for i, (name, trans) in enumerate(self._get_transformers()):
             if isinstance(trans, base.BaseTransformer):
                 trans = self._construct_fitted_column_transformer_object(
@@ -899,7 +900,23 @@ class Pipeline(base.BaseTransformer):
         if estimator_step:
             estimator_signatures = estimator_step[1].model_signatures
             for method, signature in estimator_signatures.items():
-                self._model_signature_dict[method] = ModelSignature(inputs=inputs_signature, outputs=signature.outputs)
+                # Add the inferred input signature to the model signature dictionary for each method
+                self._model_signature_dict[method] = ModelSignature(
+                    inputs=inputs_signature,
+                    outputs=(
+                        # If _drop_input_cols is True, do not include any input columns in the output signature
+                        []
+                        if self._drop_input_cols
+                        else [
+                            # Include input columns in the output signature if they are not already present
+                            # Those already present means they are overwritten by the output of the estimator
+                            spec
+                            for spec in inputs_signature
+                            if spec.name not in [_spec.name for _spec in signature.outputs]
+                        ]
+                    )
+                    + signature.outputs,  # Append the existing output signature
+                )
 
     @property
     def model_signatures(self) -> Dict[str, ModelSignature]:

snowflake/ml/modeling/preprocessing/k_bins_discretizer.py

@@ -341,7 +341,7 @@ class KBinsDiscretizer(base.BaseTransformer):
             is_permanent=False,
             name=udf_name,
             replace=True,
-            packages=["numpy"],
+            packages=[f"numpy=={np.__version__}"],
             session=dataset._session,
             statement_params=telemetry.get_statement_params(base.PROJECT, base.SUBPROJECT, self.__class__.__name__),
         )

snowflake/ml/modeling/preprocessing/polynomial_features.py

@@ -337,7 +337,7 @@ class PolynomialFeatures(BaseTransformer):
         transform_kwargs: BatchInferenceKwargsTypedDict = dict()   
                                 
         if isinstance(dataset, DataFrame):
-            expected_type_inferred = ""
+            expected_type_inferred = "float"
             # when it is classifier, infer the datatype from label columns
             if expected_type_inferred == "" and 'predict' in self.model_signatures:
                 # Batch inference takes a single expected output column type. Use the first columns type for now.
@@ -415,7 +415,7 @@ class PolynomialFeatures(BaseTransformer):
         # are specific to the type of dataset used. 
         transform_kwargs: BatchInferenceKwargsTypedDict = dict()
         if isinstance(dataset, DataFrame):
-            expected_dtype = ""
+            expected_dtype = "float"
             if False:  # is child of _BaseHeterogeneousEnsemble
                 # transform() method of HeterogeneousEnsemble estimators return responses of varying shapes
                 # from (n_samples, n_estimators) to (n_samples, n_estimators * n_classes) (and everything in between)

snowflake/ml/registry/_manager/model_manager.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 import pandas as pd
 from absl.logging import logging
 
-from snowflake.ml._internal import telemetry
+from snowflake.ml._internal import platform_capabilities, telemetry
 from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml._internal.human_readable_id import hrid_generator
 from snowflake.ml._internal.utils import sql_identifier
@@ -13,7 +13,7 @@ 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._packager.model_meta import model_meta
-from snowflake.snowpark import session
+from snowflake.snowpark import exceptions as snowpark_exceptions, session
 
 logger = logging.getLogger(__name__)
 
@@ -46,6 +46,7 @@ class ModelManager:
         metrics: Optional[Dict[str, Any]] = None,
         conda_dependencies: Optional[List[str]] = None,
         pip_requirements: Optional[List[str]] = None,
+        artifact_repository_map: Optional[Dict[str, str]] = None,
         target_platforms: Optional[List[model_types.SupportedTargetPlatformType]] = None,
         python_version: Optional[str] = None,
         signatures: Optional[Dict[str, model_signature.ModelSignature]] = None,
@@ -127,6 +128,7 @@ class ModelManager:
             metrics=metrics,
             conda_dependencies=conda_dependencies,
             pip_requirements=pip_requirements,
+            artifact_repository_map=artifact_repository_map,
             target_platforms=target_platforms,
             python_version=python_version,
             signatures=signatures,
@@ -149,6 +151,7 @@ class ModelManager:
         metrics: Optional[Dict[str, Any]] = None,
         conda_dependencies: Optional[List[str]] = None,
         pip_requirements: Optional[List[str]] = None,
+        artifact_repository_map: Optional[Dict[str, str]] = None,
         target_platforms: Optional[List[model_types.SupportedTargetPlatformType]] = None,
         python_version: Optional[str] = None,
         signatures: Optional[Dict[str, model_signature.ModelSignature]] = None,
@@ -163,11 +166,42 @@ 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)
 
-        stage_path = self._model_ops.prepare_model_stage_path(
-            database_name=database_name_id,
-            schema_name=schema_name_id,
-            statement_params=statement_params,
-        )
+        use_live_commit = platform_capabilities.PlatformCapabilities.get_instance().is_live_commit_enabled()
+        if use_live_commit:
+            logger.info("Using live commit model version")
+        else:
+            logger.info("Using non-live commit model version")
+
+        if use_live_commit:
+            # This step creates the live model version, and the files can be written directly to the stage
+            # after this.
+            try:
+                self._model_ops.add_or_create_live_version(
+                    database_name=database_name_id,
+                    schema_name=schema_name_id,
+                    model_name=model_name_id,
+                    version_name=version_name_id,
+                    statement_params=statement_params,
+                )
+            except (AssertionError, snowpark_exceptions.SnowparkSQLException) as e:
+                logger.info(f"Failed to create live model version: {e}, falling back to regular model version creation")
+                use_live_commit = False
+
+        if use_live_commit:
+            # using model version's stage path to write files directly to the stage
+            stage_path = self._model_ops.get_model_version_stage_path(
+                database_name=database_name_id,
+                schema_name=schema_name_id,
+                model_name=model_name_id,
+                version_name=version_name_id,
+            )
+        else:
+            # using a temp path to write files and then upload to the model version's stage
+            stage_path = self._model_ops.prepare_model_temp_stage_path(
+                database_name=database_name_id,
+                schema_name=schema_name_id,
+                statement_params=statement_params,
+            )
 
         platforms = None
         # User specified target platforms are defaulted to None and will not show up in the generated manifest.
@@ -175,6 +209,18 @@ class ModelManager:
             # Convert any string target platforms to TargetPlatform objects
             platforms = [model_types.TargetPlatform(platform) for platform in target_platforms]
 
+        if artifact_repository_map:
+            for channel, artifact_repository_name in artifact_repository_map.items():
+                db_id, schema_id, repo_id = sql_identifier.parse_fully_qualified_name(artifact_repository_name)
+
+                artifact_repository_map[channel] = sql_identifier.get_fully_qualified_name(
+                    db_id,
+                    schema_id,
+                    repo_id,
+                    self._database_name,
+                    self._schema_name,
+                )
+
         logger.info("Start packaging and uploading your model. It might take some time based on the size of the model.")
 
         mc = model_composer.ModelComposer(
@@ -187,6 +233,7 @@ class ModelManager:
             sample_input_data=sample_input_data,
             conda_dependencies=conda_dependencies,
             pip_requirements=pip_requirements,
+            artifact_repository_map=artifact_repository_map,
             target_platforms=platforms,
             python_version=python_version,
             user_files=user_files,
@@ -211,6 +258,7 @@ class ModelManager:
             model_name=model_name_id,
             version_name=version_name_id,
             statement_params=statement_params,
+            use_live_commit=use_live_commit,
         )
 
         mv = model_version_impl.ModelVersion._ref(

snowflake/ml/registry/registry.py

@@ -78,7 +78,7 @@ class Registry:
             session, database_name=self._database_name, schema_name=self._schema_name
         )
 
-        self.enable_monitoring = options.get("enable_monitoring", False) if options else False
+        self.enable_monitoring = options.get("enable_monitoring", True) if options else True
         if self.enable_monitoring:
             monitor_statement_params = telemetry.get_statement_params(
                 project=telemetry.TelemetryProject.MLOPS.value,
@@ -108,6 +108,7 @@ class Registry:
         metrics: Optional[Dict[str, Any]] = None,
         conda_dependencies: Optional[List[str]] = None,
         pip_requirements: Optional[List[str]] = None,
+        artifact_repository_map: Optional[Dict[str, str]] = None,
         target_platforms: Optional[List[model_types.SupportedTargetPlatformType]] = None,
         python_version: Optional[str] = None,
         signatures: Optional[Dict[str, model_signature.ModelSignature]] = None,
@@ -140,6 +141,13 @@ class Registry:
                 See https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container for more.
                 Models with pip requirements specified will not be executable in Snowflake Warehouse where all
                 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.
+                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.
             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.
             python_version: Python version in which the model is run. Defaults to None.
@@ -162,8 +170,12 @@ class Registry:
                 - relax_version: Whether to relax the version constraints of the dependencies when running in the
                     Warehouse. It detects any ==x.y.z in specifiers and replaced with >=x.y, <(x+1). Defaults to True.
                 - function_type: Set the method function type globally. To set method function types individually see
-                  function_type in model_options.
-                - method_options: Per-method saving options including:
+                    function_type in model_options.
+                - method_options: Per-method saving options. This dictionary has method names as keys and dictionary
+                    values with the desired options.
+
+                    The following are the available method options:
+
                     - case_sensitive: Indicates whether the method and its signature should be case sensitive.
                         This means when you refer the method in the SQL, you need to double quote it.
                         This will be helpful if you need case to tell apart your methods or features, or you have
@@ -206,6 +218,7 @@ class Registry:
             "metrics",
             "conda_dependencies",
             "pip_requirements",
+            "artifact_repository_map",
             "target_platforms",
             "python_version",
             "signatures",
@@ -221,6 +234,7 @@ class Registry:
         metrics: Optional[Dict[str, Any]] = None,
         conda_dependencies: Optional[List[str]] = None,
         pip_requirements: Optional[List[str]] = None,
+        artifact_repository_map: Optional[Dict[str, str]] = None,
         target_platforms: Optional[List[model_types.SupportedTargetPlatformType]] = None,
         python_version: Optional[str] = None,
         signatures: Optional[Dict[str, model_signature.ModelSignature]] = None,
@@ -255,6 +269,13 @@ class Registry:
                 See https://docs.snowflake.com/en/developer-guide/snowflake-ml/model-registry/container for more.
                 Models with pip requirements specified will not be executable in Snowflake Warehouse where all
                 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.
+                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.
             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.
             python_version: Python version in which the model is run. Defaults to None.
@@ -283,7 +304,11 @@ class Registry:
                     Warehouse. It detects any ==x.y.z in specifiers and replaced with >=x.y, <(x+1). Defaults to True.
                 - function_type: Set the method function type globally. To set method function types individually see
                   function_type in model_options.
-                - method_options: Per-method saving options including:
+                - method_options: Per-method saving options. This dictionary has method names as keys and dictionary
+                    values with the desired options. See the example below.
+
+                    The following are the available method options:
+
                     - case_sensitive: Indicates whether the method and its signature should be case sensitive.
                         This means when you refer the method in the SQL, you need to double quote it.
                         This will be helpful if you need case to tell apart your methods or features, or you have
@@ -294,6 +319,28 @@ class Registry:
 
         Returns:
             ModelVersion: ModelVersion object corresponding to the model just logged.
+
+        Example::
+
+            from snowflake.ml.registry import Registry
+
+            # create a session
+            session = ...
+
+            registry = Registry(session=session)
+
+            # Define `method_options` for each inference method if needed.
+            method_options={
+              "predict": {
+                "case_sensitive": True
+              }
+            }
+
+            registry.log_model(
+              model=model,
+              model_name="my_model",
+              method_options=method_options,
+            )
         """
         statement_params = telemetry.get_statement_params(
             project=_TELEMETRY_PROJECT,
@@ -315,6 +362,7 @@ class Registry:
             metrics=metrics,
             conda_dependencies=conda_dependencies,
             pip_requirements=pip_requirements,
+            artifact_repository_map=artifact_repository_map,
             target_platforms=target_platforms,
             python_version=python_version,
             signatures=signatures,

snowflake/ml/version.py

@@ -1 +1 @@
-VERSION="1.7.4"
+VERSION="1.8.0"