snowflake-ml-python 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

snowflake/ml/registry/model_registry.py

@@ -29,19 +29,13 @@ from snowflake.ml._internal.utils import (
     table_manager,
     uri,
 )
-from snowflake.ml.dataset import dataset
 from snowflake.ml.model import (
     _api as model_api,
     deploy_platforms,
     model_signature,
     type_hints as model_types,
 )
-from snowflake.ml.registry import (
-    _artifact_manager,
-    _initial_schema,
-    _schema_version_manager,
-    artifact,
-)
+from snowflake.ml.registry import _initial_schema, _schema_version_manager
 from snowflake.snowpark._internal import utils as snowpark_utils
 
 if TYPE_CHECKING:
@@ -142,7 +136,6 @@ def _create_registry_views(
     registry_table_name: str,
     metadata_table_name: str,
     deployment_table_name: str,
-    artifact_table_name: str,
     statement_params: Dict[str, Any],
 ) -> None:
     """Create views on underlying ModelRegistry tables.
@@ -154,7 +147,6 @@ def _create_registry_views(
         registry_table_name: Name for the main model registry table.
         metadata_table_name: Name for the metadata table used by the model registry.
         deployment_table_name: Name for the deployment event table.
-        artifact_table_name: Name for the artifact table.
         statement_params: Function usage statement parameters used in sql query executions.
     """
     fully_qualified_schema_name = table_manager.get_fully_qualified_schema_name(database_name, schema_name)
@@ -235,23 +227,6 @@ def _create_registry_views(
                 FROM {registry_table_name} {metadata_views_join}"""
     ).collect(statement_params=statement_params)
 
-    # Create artifact view. it joins artifact tables with registry table on model id.
-    artifact_view_name = identifier.concat_names([artifact_table_name, "_VIEW"])
-    session.sql(
-        f"""CREATE OR REPLACE TEMPORARY VIEW {fully_qualified_schema_name}.{artifact_view_name} COPY GRANTS AS
-                SELECT
-                    {registry_table_name}.NAME AS MODEL_NAME,
-                    {registry_table_name}.VERSION AS MODEL_VERSION,
-                    {artifact_table_name}.*
-                FROM {registry_table_name}
-                LEFT JOIN {artifact_table_name}
-                ON (ARRAY_CONTAINS(
-                    {artifact_table_name}.ID::VARIANT,
-                    {registry_table_name}.ARTIFACT_IDS)
-                )
-        """
-    ).collect(statement_params=statement_params)
-
 
 def _create_active_permanent_deployment_view(
     session: snowpark.Session,
@@ -337,11 +312,8 @@ fully integrated into the new registry.
         self._deployment_table = identifier.get_inferred_name(_DEPLOYMENT_TABLE_NAME)
         self._permanent_deployment_view = identifier.concat_names([self._deployment_table, "_VIEW"])
         self._permanent_deployment_stage = identifier.concat_names([self._deployment_table, "_STAGE"])
-        self._artifact_table = identifier.get_inferred_name(_initial_schema._ARTIFACT_TABLE_NAME)
-        self._artifact_view = identifier.concat_names([self._artifact_table, "_VIEW"])
         self._session = session
         self._svm = _schema_version_manager.SchemaVersionManager(self._session, self._name, self._schema)
-        self._artifact_manager = _artifact_manager.ArtifactManager(self._session, self._name, self._schema)
 
         # A in-memory deployment info cache to store information of temporary deployments
         # TODO(zhe): Use a temporary table to replace the in-memory cache.
@@ -359,7 +331,6 @@ fully integrated into the new registry.
             self._registry_table,
             self._metadata_table,
             self._deployment_table,
-            self._artifact_table,
             statement_params,
         )
 
@@ -399,9 +370,6 @@ fully integrated into the new registry.
         """Get the fully qualified name to the permanent deployment view."""
         return table_manager.get_fully_qualified_table_name(self._name, self._schema, self._permanent_deployment_view)
 
-    def _fully_qualified_artifact_view_name(self) -> str:
-        return table_manager.get_fully_qualified_table_name(self._name, self._schema, self._artifact_view)
-
     def _fully_qualified_schema_name(self) -> str:
         """Get the fully qualified name to the current registry schema."""
         return table_manager.get_fully_qualified_schema_name(self._name, self._schema)
@@ -858,7 +826,6 @@ fully integrated into the new registry.
         output_spec: Optional[Dict[str, str]] = None,
         description: Optional[str] = None,
         tags: Optional[Dict[str, str]] = None,
-        artifacts: Optional[List[artifact.Artifact]] = None,
     ) -> None:
         """Helper function to register model metadata.
 
@@ -878,10 +845,8 @@ fully integrated into the new registry.
             description: A description for the model. The description can be changed later.
             tags: Key-value pairs of tags to be set for this model. Tags can be modified
                 after model registration.
-            artifacts: A list of artifact references.
 
         Raises:
-            ValueError: Artifact ids not found in model registry.
             DataError: The given model already exists.
             DatabaseError: Unable to register the model properties into table.
         """
@@ -897,12 +862,6 @@ fully integrated into the new registry.
         new_model["CREATION_ROLE"] = self._session.get_current_role()
         new_model["CREATION_ENVIRONMENT_SPEC"] = {"python": ".".join(map(str, sys.version_info[:3]))}
 
-        if artifacts is not None:
-            for atf in artifacts:
-                if not self._artifact_manager.exists(atf.name if atf.name is not None else "", atf.version):
-                    raise ValueError(f"Artifact {atf.name}/{atf.version} not found in model registry.")
-            new_model["ARTIFACT_IDS"] = [art._id for art in artifacts]
-
         existing_model_nums = self._list_selected_models(model_name=model_name, model_version=model_version).count()
         if existing_model_nums:
             raise connector.DataError(
@@ -1356,42 +1315,6 @@ fully integrated into the new registry.
         else:
             return dict()
 
-    @telemetry.send_api_usage_telemetry(
-        project=_TELEMETRY_PROJECT,
-        subproject=_TELEMETRY_SUBPROJECT,
-    )
-    @snowpark._internal.utils.private_preview(version="1.0.10")
-    def log_artifact(
-        self,
-        artifact: artifact.Artifact,
-        name: str,
-        version: Optional[str] = None,
-    ) -> artifact.Artifact:
-        """Upload and register an artifact to the Model Registry.
-
-        Args:
-            artifact: artifact object.
-            name: name of artifact.
-            version: version of artifact.
-
-        Raises:
-            DataError: Artifact with same name and version already exists.
-
-        Returns:
-            Return a reference to the artifact.
-        """
-
-        if self._artifact_manager.exists(name, version):
-            raise connector.DataError(f"Artifact {name}/{version} already exists.")
-
-        artifact_id = self._get_new_unique_identifier()
-        return self._artifact_manager.add(
-            artifact=artifact,
-            artifact_id=artifact_id,
-            artifact_name=name,
-            artifact_version=version,
-        )
-
     # Combined Registry and Repository operations.
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
@@ -1410,7 +1333,6 @@ fully integrated into the new registry.
         pip_requirements: Optional[List[str]] = None,
         signatures: Optional[Dict[str, model_signature.ModelSignature]] = None,
         sample_input_data: Optional[Any] = None,
-        artifacts: Optional[List[artifact.Artifact]] = None,
         code_paths: Optional[List[str]] = None,
         options: Optional[model_types.BaseModelSaveOption] = None,
     ) -> Optional["ModelReference"]:
@@ -1431,19 +1353,15 @@ fully integrated into the new registry.
                 pip requirements.
             signatures: Signatures of the model, which is a mapping from target method name to signatures of input and
                 output, which could be inferred by calling `infer_signature` method with sample input data.
-            sample_input_data: Sample of the input data for the model. If artifacts contains a feature store
-                generated dataset, then sample_input_data is not needed. If both sample_input_data and dataset provided
-                , then sample_input_data will be used to infer model signature.
-            artifacts: A list of artifact ids, which are generated from log_artifact().
+            sample_input_data: Sample of the input data for the model.
             code_paths: Directory of code to import when loading and deploying the model.
             options: Additional options when saving the model.
 
         Raises:
             DataError: Raised when:
                 1) the given model already exists;
-                2) given artifacts does not exists in this registry.
             ValueError: Raised when:  # noqa: DAR402
-                1) Signatures, sample_input_data and artifact(dataset) are both not provided and model is not a
+                1) Signatures and sample_input_data are both not provided and model is not a
                     snowflake estimator.
             Exception: Raised when there is any error raised when saving the model.
 
@@ -1458,18 +1376,6 @@ fully integrated into the new registry.
 
         self._model_identifier_is_nonempty_or_raise(model_name, model_version)
 
-        if artifacts is not None:
-            for atf in artifacts:
-                if not self._artifact_manager.exists(atf.name if atf.name is not None else "", atf.version):
-                    raise connector.DataError(f"Artifact {atf.name}/{atf.version} does not exists.")
-
-        if sample_input_data is None and artifacts is not None:
-            for atf in artifacts:
-                if atf.type == artifact.ArtifactType.DATASET:
-                    ds = self.get_artifact(atf.name if atf.name is not None else "", atf.version)
-                    sample_input_data = ds.features_df()
-                    break
-
         existing_model_nums = self._list_selected_models(model_name=model_name, model_version=model_version).count()
         if existing_model_nums:
             raise connector.DataError(f"Model {model_name}/{model_version} already exists. Unable to log the model.")
@@ -1508,7 +1414,6 @@ fully integrated into the new registry.
             uri=uri.get_uri_from_snowflake_stage_path(stage_path),
             description=description,
             tags=tags,
-            artifacts=artifacts,
         )
 
         return ModelReference(registry=self, model_name=model_name, model_version=model_version)
@@ -1733,25 +1638,6 @@ fully integrated into the new registry.
         )
         return cast(snowpark.DataFrame, res)
 
-    @snowpark._internal.utils.private_preview(version="1.0.1")
-    def list_artifacts(self, model_name: str, model_version: Optional[str] = None) -> snowpark.DataFrame:
-        """List all artifacts that associated with given model name and version.
-
-        Args:
-            model_name: Name of model.
-            model_version: Version of model. If version is none then only filter on name.
-                Defaults to none.
-
-        Returns:
-            A snowpark dataframe that contains all artifacts that associated with the given model.
-        """
-        artifacts = self._session.sql(f"SELECT * FROM {self._fully_qualified_artifact_view_name()}").filter(
-            snowpark.Column("MODEL_NAME") == model_name
-        )
-        if model_version is not None:
-            artifacts = artifacts.filter(snowpark.Column("MODEL_VERSION") == model_version)
-        return cast(snowpark.DataFrame, artifacts)
-
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
         subproject=_TELEMETRY_SUBPROJECT,
@@ -1782,38 +1668,6 @@ fully integrated into the new registry.
             )
         return cast(snowpark.DataFrame, deployment)
 
-    @telemetry.send_api_usage_telemetry(
-        project=_TELEMETRY_PROJECT,
-        subproject=_TELEMETRY_SUBPROJECT,
-    )
-    @snowpark._internal.utils.private_preview(version="1.0.11")
-    def get_artifact(self, name: str, version: Optional[str] = None) -> Optional[artifact.Artifact]:
-        """Get artifact with the given (name, version).
-
-        Args:
-            name: Name of artifact.
-            version: Version of artifact.
-
-        Returns:
-            A reference to artifact if found, otherwise none.
-        """
-        artifacts = self._artifact_manager.get(
-            name,
-            version,
-        ).collect()
-
-        if len(artifacts) == 0:
-            return None
-
-        atf = artifacts[0]
-        if atf["TYPE"] == artifact.ArtifactType.DATASET.value:
-            ds = dataset.Dataset.from_json(atf["ARTIFACT_SPEC"], self._session)
-            ds._log(name=atf["NAME"], version=atf["VERSION"], id=atf["ID"])
-            return ds
-
-        assert f"Unrecognized artifact type: {atf['TYPE']}"
-        return None
-
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
         subproject=_TELEMETRY_SUBPROJECT,

snowflake/ml/version.py

@@ -1 +1 @@
-VERSION="1.4.1"
+VERSION="1.5.0"

{snowflake_ml_python-1.4.1.dist-info → snowflake_ml_python-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snowflake-ml-python
-Version: 1.4.1
+Version: 1.5.0
 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: 
@@ -371,7 +371,68 @@ be compatibility issues. Server-side functionality that `snowflake-ml-python` de
 
 # Release History
 
-## 1.4.1
+## 1.5.0
+
+### Bug Fixes
+
+- Registry: Fix invalid parameter 'SHOW_MODEL_DETAILS_IN_SHOW_VERSIONS_IN_MODEL' error.
+
+### Behavior Changes
+
+- Model Development: The behavior of `fit_transform` for all estimators is changed.
+  Firstly, it will cover all the estimator that contains this function,
+  secondly, the output would be the union of pandas DataFrame and snowpark DataFrame.
+
+#### Model Registry (PrPr)
+
+`snowflake.ml.registry.artifact` and related `snowflake.ml.model_registry.ModelRegistry` APIs have been removed.
+
+- Removed `snowflake.ml.registry.artifact` module.
+- Removed `ModelRegistry.log_artifact()`, `ModelRegistry.list_artifacts()`, `ModelRegistry.get_artifact()`
+- Removed `artifacts` argument from `ModelRegistry.log_model()`
+
+#### Dataset (PrPr)
+
+`snowflake.ml.dataset.Dataset` has been redesigned to be backed by Snowflake Dataset entities.
+
+- New `Dataset`s can be created with `Dataset.create()` and existing `Dataset`s may be loaded
+  with `Dataset.load()`.
+- `Dataset`s now maintain an immutable `selected_version` state. The `Dataset.create_version()` and
+  `Dataset.load_version()` APIs return new `Dataset` objects with the requested `selected_version` state.
+- Added `dataset.create_from_dataframe()` and `dataset.load_dataset()` convenience APIs as a shortcut
+  to creating and loading `Dataset`s with a pre-selected version.
+- `Dataset.materialized_table` and `Dataset.snapshot_table` no longer exist with `Dataset.fully_qualified_name`
+  as the closest equivalent.
+- `Dataset.df` no longer exists. Instead, use `DatasetReader.read.to_snowpark_dataframe()`.
+- `Dataset.owner` has been moved to `Dataset.selected_version.owner`
+- `Dataset.desc` has been moved to `DatasetVersion.selected_version.comment`
+- `Dataset.timestamp_col`, `Dataset.label_cols`, `Dataset.feature_store_metadata`, and
+  `Dataset.schema_version` have been removed.
+
+#### Feature Store (PrPr)
+
+`FeatureStore.generate_dataset` argument list has been changed to match the new
+`snowflake.ml.dataset.Dataset` definition
+
+- `materialized_table` has been removed and replaced with `name` and `version`.
+- `name` moved to first positional argument
+- `save_mode` has been removed as `merge` behavior is no longer supported. The new behavior is always `errorifexists`.
+
+### New Features
+
+- Registry: Add `export` method to `ModelVersion` instance to export model files.
+- Registry: Add `load` method to `ModelVersion` instance to load the underlying object from the model.
+- Registry: Add `Model.rename` method to `Model` instance to rename or move a model.
+
+#### Dataset (PrPr)
+
+- Added Snowpark DataFrame integration using `Dataset.read.to_snowpark_dataframe()`
+- Added Pandas DataFrame integration using `Dataset.read.to_pandas()`
+- Added PyTorch and TensorFlow integrations using `Dataset.read.to_torch_datapipe()`
+    and `Dataset.read.to_tf_dataset()` respectively.
+- Added `fsspec` style file integration using `Dataset.read.files()` and `Dataset.read.filesystem()`
+
+## 1.4.1 (2024-04-18)
 
 ### New Features