snowflake-ml-python 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

snowflake/ml/registry/model_registry.py

@@ -1,6 +1,7 @@
 import inspect
 import json
 import os
+import posixpath
 import sys
 import tempfile
 import types
@@ -8,7 +9,6 @@ import zipfile
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 from uuid import uuid1
 
-import cloudpickle as cp
 from absl import logging
 
 from snowflake import connector, snowpark
@@ -35,7 +35,7 @@ _DEFAULT_REGISTRY_NAME: str = "_SYSTEM_MODEL_REGISTRY"
 _DEFAULT_SCHEMA_NAME: str = "_SYSTEM_MODEL_REGISTRY_SCHEMA"
 _MODELS_TABLE_NAME: str = "_SYSTEM_REGISTRY_MODELS"
 _METADATA_TABLE_NAME: str = "_SYSTEM_REGISTRY_METADATA"
-_DEPLOYMENT_TABLE_NAME: str = "_SYSTEM_REGISRTRY_DEPLOYMENTS"
+_DEPLOYMENT_TABLE_NAME: str = "_SYSTEM_REGISTRY_DEPLOYMENTS"
 
 # Metadata operation types.
 _SET_METADATA_OPERATION: str = "SET"
@@ -84,9 +84,11 @@ def create_model_registry(
     """
 
     # These might be exposed as parameters in the future.
-    registry_table_name = _MODELS_TABLE_NAME
-    metadata_table_name = _METADATA_TABLE_NAME
-    deployment_table_name = _DEPLOYMENT_TABLE_NAME
+    database_name = identifier.get_inferred_name(database_name)
+    schema_name = identifier.get_inferred_name(schema_name)
+    registry_table_name = identifier.get_inferred_name(_MODELS_TABLE_NAME)
+    metadata_table_name = identifier.get_inferred_name(_METADATA_TABLE_NAME)
+    deployment_table_name = identifier.get_inferred_name(_DEPLOYMENT_TABLE_NAME)
     statement_params = telemetry.get_function_usage_statement_params(
         project=_TELEMETRY_PROJECT,
         subproject=_TELEMETRY_SUBPROJECT,
@@ -130,14 +132,14 @@ def _create_registry_database(
         database_name: Desired name of the model registry database.
         statement_params: Function usage statement parameters used in sql query executions.
     """
-    registry_databases = session.sql(f"SHOW DATABASES LIKE '{database_name}'").collect(
+    registry_databases = session.sql(f"SHOW DATABASES LIKE '{identifier.get_unescaped_names(database_name)}'").collect(
         statement_params=statement_params
     )
     if len(registry_databases) > 0:
         logging.warning(f"The database {database_name} already exists. Skipping creation.")
         return
 
-    session.sql(f'CREATE DATABASE "{database_name}"').collect(statement_params=statement_params)
+    session.sql(f"CREATE DATABASE {database_name}").collect(statement_params=statement_params)
 
 
 def _create_registry_schema(
@@ -154,31 +156,31 @@ def _create_registry_schema(
         statement_params: Function usage statement parameters used in sql query executions.
     """
     # The default PUBLIC schema is created by default so it might already exist even in a new database.
-    registry_schemas = session.sql(f"SHOW SCHEMAS LIKE '{schema_name}' IN DATABASE \"{database_name}\"").collect(
-        statement_params=statement_params
-    )
+    registry_schemas = session.sql(
+        f"SHOW SCHEMAS LIKE '{identifier.get_unescaped_names(schema_name)}' IN DATABASE {database_name}"
+    ).collect(statement_params=statement_params)
 
     if len(registry_schemas) > 0:
-        logging.warning(f'The schmea "{database_name}"."{schema_name}" already exists. Skipping creation.')
+        logging.warning(
+            f"The schema {_get_fully_qualified_schema_name(database_name, schema_name)}already exists. "
+            + "Skipping creation."
+        )
         return
 
-    session.sql(f'CREATE SCHEMA "{database_name}"."{schema_name}"').collect(statement_params=statement_params)
+    session.sql(f"CREATE SCHEMA {_get_fully_qualified_schema_name(database_name, schema_name)}").collect(
+        statement_params=statement_params
+    )
 
 
 def _get_fully_qualified_schema_name(database_name: str, schema_name: str) -> str:
-    return ".".join(
-        [
-            f"{identifier.quote_name_without_upper_casing(database_name)}",
-            f"{identifier.quote_name_without_upper_casing(schema_name)}",
-        ]
-    )
+    return ".".join([database_name, schema_name])
 
 
 def _get_fully_qualified_table_name(database_name: str, schema_name: str, table_name: str) -> str:
     return ".".join(
         [
             _get_fully_qualified_schema_name(database_name, schema_name),
-            f"{identifier.quote_name_without_upper_casing(table_name)}",
+            table_name,
         ]
     )
 
@@ -292,10 +294,10 @@ def _create_registry_views(
     )
 
     # Create views on most recent metadata items.
-    metadata_view_name_prefix = metadata_table_name + "_LAST_"
+    metadata_view_name_prefix = identifier.concat_names([metadata_table_name, "_LAST_"])
     metadata_view_template = formatting.unwrap(
-        """CREATE OR REPLACE VIEW "{database}"."{schema}"."{attribute_view}" COPY GRANTS AS
-            SELECT DISTINCT MODEL_ID, {select_expression} AS {final_attribute_name} FROM "{metadata_table}"
+        """CREATE OR REPLACE VIEW {database}.{schema}.{attribute_view} COPY GRANTS AS
+            SELECT DISTINCT MODEL_ID, {select_expression} AS {final_attribute_name} FROM {metadata_table}
             WHERE ATTRIBUTE_NAME = '{attribute_name}'"""
     )
 
@@ -303,7 +305,7 @@ def _create_registry_views(
     metadata_view_names = []
     metadata_select_fields = []
     for attribute_name in _LIST_METADATA_ATTRIBUTE:
-        view_name = f"{metadata_view_name_prefix}{attribute_name}"
+        view_name = identifier.concat_names([metadata_view_name_prefix, attribute_name])
         select_expression = f"(LAST_VALUE(VALUE) OVER (PARTITION BY MODEL_ID ORDER BY SEQUENCE_ID))['{attribute_name}']"
         sql = metadata_view_template.format(
             database=database_name,
@@ -316,14 +318,12 @@ def _create_registry_views(
         )
         session.sql(sql).collect(statement_params=statement_params)
         metadata_view_names.append(view_name)
-        metadata_select_fields.append(
-            f"{identifier.quote_name_without_upper_casing(view_name)}.{attribute_name} AS {attribute_name}"
-        )
+        metadata_select_fields.append(f"{view_name}.{attribute_name} AS {attribute_name}")
 
     # Create a special view for the registration timestamp.
     attribute_name = _METADATA_ATTRIBUTE_REGISTRATION
-    final_attribute_name = attribute_name + "_TIMESTAMP"
-    view_name = f"{metadata_view_name_prefix}{attribute_name}"
+    final_attribute_name = identifier.concat_names([attribute_name, "_TIMESTAMP"])
+    view_name = identifier.concat_names([metadata_view_name_prefix, attribute_name])
     create_registration_view_sql = metadata_view_template.format(
         database=database_name,
         schema=schema_name,
@@ -335,13 +335,11 @@ def _create_registry_views(
     )
     session.sql(create_registration_view_sql).collect(statement_params=statement_params)
     metadata_view_names.append(view_name)
-    metadata_select_fields.append(
-        f"{identifier.quote_name_without_upper_casing(view_name)}.{final_attribute_name} AS {final_attribute_name}"
-    )
+    metadata_select_fields.append(f"{view_name}.{final_attribute_name} AS {final_attribute_name}")
 
     metadata_views_join = " ".join(
         [
-            'LEFT JOIN "{view}" ON ("{view}".MODEL_ID = "{registry_table}".ID)'.format(
+            "LEFT JOIN {view} ON ({view}.MODEL_ID = {registry_table}.ID)".format(
                 view=view, registry_table=registry_table_name
             )
             for view in metadata_view_names
@@ -349,12 +347,12 @@ def _create_registry_views(
     )
 
     # Create view to combine all attributes.
-    registry_view_name = registry_table_name + "_VIEW"
+    registry_view_name = identifier.concat_names([registry_table_name, "_VIEW"])
     metadata_select_fields_formatted = ",".join(metadata_select_fields)
     session.sql(
-        f"""CREATE OR REPLACE VIEW {fully_qualified_schema_name}."{registry_view_name}" COPY GRANTS AS
-                SELECT "{registry_table_name}".*, {metadata_select_fields_formatted}
-                FROM "{registry_table_name}" {metadata_views_join}"""
+        f"""CREATE OR REPLACE VIEW {fully_qualified_schema_name}.{registry_view_name} COPY GRANTS AS
+                SELECT {registry_table_name}.*, {metadata_select_fields_formatted}
+                FROM {registry_table_name} {metadata_views_join}"""
     ).collect(statement_params=statement_params)
 
 
@@ -377,8 +375,9 @@ def _create_active_permanent_deployment_view(
 
     # Create a view on active permanent deployments
     # Active deployments are those whose last operation is not DROP.
+    active_deployments_view_name = identifier.concat_names([deployment_table_name, "_VIEW"])
     active_deployments_view_expr = f"""
-        CREATE OR REPLACE VIEW {fully_qualified_schema_name}."{deployment_table_name}_VIEW"
+        CREATE OR REPLACE VIEW {fully_qualified_schema_name}.{active_deployments_view_name}
         COPY GRANTS AS
         SELECT
             DEPLOYMENT_NAME,
@@ -417,14 +416,14 @@ class ModelRegistry:
             database_name: Desired name of the model registry database.
             schema_name: Desired name of the schema used by this model registry inside the database.
         """
-        self._name = database_name
-        self._schema = schema_name
-        self._registry_table = _MODELS_TABLE_NAME
-        self._registry_table_view = self._registry_table + "_VIEW"
-        self._metadata_table = _METADATA_TABLE_NAME
-        self._deployment_table = _DEPLOYMENT_TABLE_NAME
-        self._permanent_deployment_view = self._deployment_table + "_VIEW"
-        self._permanent_deployment_stage = self._deployment_table + "_STAGE"
+        self._name = identifier.get_inferred_name(database_name)
+        self._schema = identifier.get_inferred_name(schema_name)
+        self._registry_table = identifier.get_inferred_name(_MODELS_TABLE_NAME)
+        self._registry_table_view = identifier.concat_names([self._registry_table, "_VIEW"])
+        self._metadata_table = identifier.get_inferred_name(_METADATA_TABLE_NAME)
+        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._session = session
 
@@ -441,23 +440,39 @@ class ModelRegistry:
         # Check that the required tables exist and are accessible by the current role.
 
         query_result_checker.SqlResultValidator(
-            self._session, query=f"SHOW DATABASES LIKE '{self._name}'"
+            self._session, query=f"SHOW DATABASES LIKE '{identifier.get_unescaped_names(self._name)}'"
         ).has_dimensions(expected_rows=1).validate()
 
         query_result_checker.SqlResultValidator(
-            self._session, query=f"SHOW SCHEMAS LIKE '{self._schema}' IN DATABASE \"{self._name}\""
+            self._session,
+            query=f"SHOW SCHEMAS LIKE '{identifier.get_unescaped_names(self._schema)}' IN DATABASE {self._name}",
         ).has_dimensions(expected_rows=1).validate()
 
         query_result_checker.SqlResultValidator(
-            self._session, query=f"SHOW TABLES LIKE '{self._registry_table}' IN {self._fully_qualified_schema_name()}"
+            self._session,
+            query=formatting.unwrap(
+                f"""
+            SHOW TABLES LIKE '{identifier.get_unescaped_names(self._registry_table)}'
+            IN {self._fully_qualified_schema_name()}"""
+            ),
         ).has_dimensions(expected_rows=1).validate()
 
         query_result_checker.SqlResultValidator(
-            self._session, query=f"SHOW TABLES LIKE '{self._metadata_table}' IN {self._fully_qualified_schema_name()}"
+            self._session,
+            query=formatting.unwrap(
+                f"""
+            SHOW TABLES LIKE '{identifier.get_unescaped_names(self._metadata_table)}'
+            IN {self._fully_qualified_schema_name()}"""
+            ),
         ).has_dimensions(expected_rows=1).validate()
 
         query_result_checker.SqlResultValidator(
-            self._session, query=f"SHOW TABLES LIKE '{self._deployment_table}' IN {self._fully_qualified_schema_name()}"
+            self._session,
+            query=formatting.unwrap(
+                f"""
+            SHOW TABLES LIKE '{identifier.get_unescaped_names(self._deployment_table)}'
+            IN {self._fully_qualified_schema_name()}"""
+            ),
         ).has_dimensions(expected_rows=1).validate()
 
         # TODO(zzhu): Also check validity of views. Consider checking schema as well.
@@ -825,7 +840,7 @@ class ModelRegistry:
                 before setting the metadata attribute. False by default meaning that by default we will check.
 
         Raises:
-            DataError: Failed to set the meatdata attribute.
+            DataError: Failed to set the metadata attribute.
             KeyError: The target model doesn't exist
         """
         selected_models = self._list_selected_models(id=id, model_name=model_name, model_version=model_version)
@@ -955,13 +970,13 @@ class ModelRegistry:
         # Check if directory or file and adapt accordingly.
         # TODO: Unify and explicit about compression for both file and directory.
         if os.path.isfile(path):
-            self._session.file.put(path, f"{fully_qualified_model_stage_name}/data")
+            self._session.file.put(path, posixpath.join(fully_qualified_model_stage_name, "data"))
         elif os.path.isdir(path):
             with file_utils.zip_file_or_directory_to_stream(path, path) as input_stream:
                 self._session._conn.upload_stream(
                     input_stream=input_stream,
                     stage_location=fully_qualified_model_stage_name,
-                    dest_filename=f"{os.path.basename(path)}.zip",
+                    dest_filename=f"{posixpath.basename(path)}.zip",
                     dest_prefix="",
                     source_compression="DEFLATE",
                     compress_data=False,
@@ -1067,7 +1082,7 @@ class ModelRegistry:
         """
         # Explicitly not calling collect.
         return self._session.sql(
-            'SELECT * FROM "{database}"."{schema}"."{view}"'.format(
+            "SELECT * FROM {database}.{schema}.{view}".format(
                 database=self._name, schema=self._schema, view=self._registry_table_view
             )
         )
@@ -1124,7 +1139,9 @@ class ModelRegistry:
         try:
             del model_tags[tag_name]
         except KeyError:
-            raise connector.DataError(f"Model id {id} has not tag named {tag_name}. Full list of tags: {model_tags}")
+            raise connector.DataError(
+                f"Model {model_name}/{model_version} has no tag named {tag_name}. Full list of tags: {model_tags}"
+            )
 
         self._set_metadata_attribute(
             _METADATA_ATTRIBUTE_TAGS, model_tags, model_name=model_name, model_version=model_version
@@ -1227,7 +1244,7 @@ class ModelRegistry:
         result = self._get_metadata_attribute(
             _METADATA_ATTRIBUTE_DESCRIPTION, model_name=model_name, model_version=model_version
         )
-        return None if result is None else str(result)
+        return None if result is None else json.loads(result)
 
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
@@ -1453,6 +1470,8 @@ class ModelRegistry:
         pip_requirements: Optional[List[str]] = None,
         signatures: Optional[Dict[str, model_signature.ModelSignature]] = None,
         sample_input_data: Optional[Any] = None,
+        code_paths: Optional[List[str]] = None,
+        options: Optional[model_types.ModelSaveOption] = None,
     ) -> str:
         """Uploads and register a model to the Model Registry.
 
@@ -1472,6 +1491,8 @@ class ModelRegistry:
             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.
+            code_paths: Directory of code to import when loading and deploying the model.
+            options: Additional options when saving the model.
 
         Raises:
             TypeError: Raised when both signatures and sample_input_data is not presented. Will be captured locally.
@@ -1490,60 +1511,50 @@ class ModelRegistry:
             raise connector.DataError(f"Model {model_name}/{model_version} already exists. Unable to log the model.")
         with tempfile.TemporaryDirectory() as tmpdir:
             model = cast(model_types.SupportedModelType, model)
-            try:
-                if signatures:
-                    model_api.save_model(
-                        name=model_name,
-                        model_dir_path=tmpdir,
-                        model=model,
-                        signatures=signatures,
-                        metadata=tags,
-                        conda_dependencies=conda_dependencies,
-                        pip_requirements=pip_requirements,
-                    )
-                elif sample_input_data is not None:
-                    model_api.save_model(
-                        name=model_name,
-                        model_dir_path=tmpdir,
-                        model=model,
-                        metadata=tags,
-                        conda_dependencies=conda_dependencies,
-                        pip_requirements=pip_requirements,
-                        sample_input=sample_input_data,
-                    )
-                elif isinstance(model, base.BaseEstimator):
-                    model_api.save_model(
-                        name=model_name,
-                        model_dir_path=tmpdir,
-                        model=model,
-                        metadata=tags,
-                        conda_dependencies=conda_dependencies,
-                        pip_requirements=pip_requirements,
-                    )
-                else:
-                    raise TypeError("Either signature or sample input data should exist for native model packaging.")
-                return self._log_model_path(
-                    model_name=model_name,
-                    model_version=model_version,
-                    path=tmpdir,
-                    type="snowflake_native",
-                    description=description,
-                    tags=tags,  # TODO: Inherent model type enum.
+            if signatures:
+                model_metadata = model_api.save_model(
+                    name=model_name,
+                    model_dir_path=tmpdir,
+                    model=model,
+                    signatures=signatures,
+                    metadata=tags,
+                    conda_dependencies=conda_dependencies,
+                    pip_requirements=pip_requirements,
+                    code_paths=code_paths,
+                    options=options,
                 )
-            except (AttributeError, TypeError):
-                pass
-
-        with tempfile.NamedTemporaryFile(delete=True) as local_model_file:
-            cp.dump(model, local_model_file)
-            local_model_file.flush()
-
+            elif sample_input_data is not None:
+                model_metadata = model_api.save_model(
+                    name=model_name,
+                    model_dir_path=tmpdir,
+                    model=model,
+                    metadata=tags,
+                    conda_dependencies=conda_dependencies,
+                    pip_requirements=pip_requirements,
+                    sample_input=sample_input_data,
+                    code_paths=code_paths,
+                    options=options,
+                )
+            elif isinstance(model, base.BaseEstimator):
+                model_metadata = model_api.save_model(
+                    name=model_name,
+                    model_dir_path=tmpdir,
+                    model=model,
+                    metadata=tags,
+                    conda_dependencies=conda_dependencies,
+                    pip_requirements=pip_requirements,
+                    code_paths=code_paths,
+                    options=options,
+                )
+            else:
+                raise TypeError("Either signature or sample input data should exist for native model packaging.")
             return self._log_model_path(
                 model_name=model_name,
                 model_version=model_version,
-                path=local_model_file.name,
-                type=model.__class__.__name__,
+                path=tmpdir,
+                type=model_metadata.model_type,
                 description=description,
-                tags=tags,
+                tags=tags,  # TODO: Inherent model type enum.
             )
 
     @telemetry.send_api_usage_telemetry(
@@ -1565,22 +1576,13 @@ class ModelRegistry:
         restored_model = None
         with tempfile.TemporaryDirectory() as local_model_directory:
             self._session.file.get(remote_model_path, local_model_directory)
-            is_native_model_format = False
-            local_path = os.path.join(local_model_directory, os.path.basename(remote_model_path))
-            try:
-                if zipfile.is_zipfile(local_path):
-                    extracted_dir = os.path.join(local_model_directory, "extracted")
-                    with zipfile.ZipFile(local_path, "r") as myzip:
-                        if len(myzip.namelist()) > 1:
-                            myzip.extractall(extracted_dir)
-                            restored_model, _meta = model_api.load_model(model_dir_path=extracted_dir)
-                            is_native_model_format = True
-            except TypeError:
-                pass
-            if not is_native_model_format:
-                file_path = os.path.join(local_model_directory, os.path.basename(os.path.basename(remote_model_path)))
-                with open(file_path, mode="r+b") as model_file:
-                    restored_model = cp.load(model_file)
+            local_path = os.path.join(local_model_directory, posixpath.basename(remote_model_path))
+            if zipfile.is_zipfile(local_path):
+                extracted_dir = os.path.join(local_model_directory, "extracted")
+                with zipfile.ZipFile(local_path, "r") as myzip:
+                    if len(myzip.namelist()) > 1:
+                        myzip.extractall(extracted_dir)
+                        restored_model, _ = model_api.load_model(model_dir_path=extracted_dir)
 
         return restored_model
 

snowflake/ml/version.py

@@ -1 +1 @@
-VERSION="1.0.1"
+VERSION="1.0.3"

{snowflake_ml_python-1.0.1.dist-info → snowflake_ml_python-1.0.3.dist-info}/METADATA

@@ -1,11 +1,15 @@
 Metadata-Version: 2.1
 Name: snowflake-ml-python
-Version: 1.0.1
-Description-Content-Type: text/markdown
 Author: Snowflake, Inc
 Author-email: support@snowflake.com
 Home-page: https://github.com/snowflakedb/snowflake-ml-python
 License: Apache License, Version 2.0
+Description-Content-Type: text/markdown
+Summary: The machine learning client library that is used for interacting with Snowflake to build machine learning solutions.
+Project-URL: Changelog, https://github.com/snowflakedb/snowflake-ml-python/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://docs.snowflake.com/developer-guide/snowpark-ml
+Project-URL: Issues, https://github.com/snowflakedb/snowflake-ml-python/issues
+Project-URL: Source, https://github.com/snowflakedb/snowflake-ml-python
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Environment :: Other Environment
@@ -25,17 +29,15 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Requires-Python: >=3.8,<4
-Summary: The machine learning client library that is used for interacting with Snowflake to build machine learning solutions.
 Requires-Dist: absl-py>=0.15,<2
 Requires-Dist: anyio>=3.5.0,<4
 Requires-Dist: cloudpickle
-Requires-Dist: cryptography>=3.1.0,<39.0.0
 Requires-Dist: fsspec[http]>=2022.11,<=2023.1
 Requires-Dist: numpy>=1.23,<2
 Requires-Dist: packaging>=20.9,<24
 Requires-Dist: pandas>=1.0.0,<2
 Requires-Dist: pyyaml>=6.0,<7
-Requires-Dist: scikit-learn>=1.2.1,<2
+Requires-Dist: scikit-learn>=1.2.1,<1.3
 Requires-Dist: scipy>=1.9,<2
 Requires-Dist: snowflake-connector-python[pandas]>=3.0.3,<4
 Requires-Dist: snowflake-snowpark-python>=1.4.0,<2
@@ -52,6 +54,7 @@ Provides-Extra: tensorflow
 Requires-Dist: tensorflow>=2.9,<3; extra == 'tensorflow'
 Provides-Extra: torch
 Requires-Dist: torchdata>=0.4,<1; extra == 'torch'
+Version: 1.0.3
 
 # Snowpark ML
 
@@ -77,9 +80,7 @@ Snowpark MLOps complements the Snowpark ML Development API, and provides model m
 
 During PrPr, we are iterating on API without backward compatibility guarantees. It is better to recreate your registry everytime you update the package. This means, at this time, you cannot use the registry for production use.
 
-- [Documentation](http://docs.snowflake.com/developer-guide/snowpark/python/snowpark-ml-modeling)
-- [Issues](https://github.com/snowflakedb/snowflake-ml-python/issues)
-- [Source](https://github.com/snowflakedb/snowflake-ml-python/)
+- [Documentation](https://docs.snowflake.com/developer-guide/snowpark-ml)
 
 ## Getting started
 ### Have your Snowflake account ready
@@ -96,6 +97,47 @@ pip install snowflake-ml-python
 ```
 # Release History
 
+## 1.0.3 (2023-07-14)
+
+### Behavior Changes
+- Model Registry: When predicting a model whose output is a list of NumPy ndarray, the output would not be flattened, instead, every ndarray will act as a feature(column) in the output.
+
+### New Features
+- Model Registry: Added support save/load/deploy PyTorch models (`torch.nn.Module` and `torch.jit.ScriptModule`).
+
+### Bug Fixes
+
+- Model Registry: Fix an issue that when database or schema name provided to `create_model_registry` contains special characters, the model registry cannot be created.
+- Model Registry: Fix an issue that `get_model_description` returns with additional quotes.
+- Model Registry: Fix incorrect error message when attempting to remove a unset tag of a model.
+- Model Registry: Fix a typo in the default deployment table name.
+- Model Registry: Snowpark dataframe for sample input or input for `predict` method that contains a column with Snowflake `NUMBER(precision, scale)` data type where `scale = 0` will not lead to error, and will now correctly recognized as `INT64` data type in model signature.
+- Model Registry: Fix an issue that prevent model logged in the system whose default encoding is not UTF-8 compatible from deploying.
+- Model Registry: Added earlier and better error message when any file name in the model or the file name of model itself contains characters that are unable to be encoded using ASCII. It is currently not supported to deploy such a model.
+
+## 1.0.2 (2023-06-22)
+
+### Behavior Changes
+- Model Registry: Prohibit non-snowflake-native models from being logged.
+- Model Registry: `_use_local_snowml` parameter in options of `deploy()` has been removed.
+- Model Registry: A default `False` `embed_local_ml_library` parameter has been added to the options of `log_model()`. With this set to `False` (default), the version of the local snowflake-ml-python library will be recorded and used when deploying the model. With this set to `True`, local snowflake-ml-python library will be embedded into the logged model, and will be used when you load or deploy the model.
+
+### New Features
+- Model Registry: A new optional argument named `code_paths` has been added to the arguments of `log_model()` for users to specify additional code paths to be imported when loading and deploying the model.
+- Model Registry: A new optional argument named `options` has been added to the arguments of `log_model()` to specify any additional options when saving the model.
+- Model Development: Added metrics:
+  - d2_absolute_error_score
+  - d2_pinball_score
+  - explained_variance_score
+  - mean_absolute_error
+  - mean_absolute_percentage_error
+  - mean_squared_error
+
+### Bug Fixes
+
+- Model Development: `accuracy_score()` now works when given label column names are lists of a single value.
+
+
 ## 1.0.1 (2023-06-16)
 ### Behavior Changes