snowflake-ml-python 1.8.1__py3-none-any.whl → 1.8.2__py3-none-any.whl

snowflake/ml/model/_client/ops/service_ops.py

@@ -9,7 +9,7 @@ import time
 from typing import Any, Dict, List, Optional, Tuple, Union, cast
 
 from snowflake import snowpark
-from snowflake.ml._internal import file_utils
+from snowflake.ml._internal import file_utils, platform_capabilities as pc
 from snowflake.ml._internal.utils import service_logger, sql_identifier
 from snowflake.ml.model._client.service import model_deployment_spec
 from snowflake.ml.model._client.sql import service as service_sql, stage as stage_sql
@@ -57,30 +57,30 @@ class ServiceOperator:
         self._session = session
         self._database_name = database_name
         self._schema_name = schema_name
-        self._workspace = tempfile.TemporaryDirectory()
         self._service_client = service_sql.ServiceSQLClient(
             session,
             database_name=database_name,
             schema_name=schema_name,
         )
-        self._stage_client = stage_sql.StageSQLClient(
-            session,
-            database_name=database_name,
-            schema_name=schema_name,
-        )
-        self._model_deployment_spec = model_deployment_spec.ModelDeploymentSpec(
-            workspace_path=pathlib.Path(self._workspace.name)
-        )
+        if pc.PlatformCapabilities.get_instance().is_inlined_deployment_spec_enabled():
+            self._workspace = None
+            self._model_deployment_spec = model_deployment_spec.ModelDeploymentSpec()
+        else:
+            self._workspace = tempfile.TemporaryDirectory()
+            self._stage_client = stage_sql.StageSQLClient(
+                session,
+                database_name=database_name,
+                schema_name=schema_name,
+            )
+            self._model_deployment_spec = model_deployment_spec.ModelDeploymentSpec(
+                workspace_path=pathlib.Path(self._workspace.name)
+            )
 
     def __eq__(self, __value: object) -> bool:
         if not isinstance(__value, ServiceOperator):
             return False
         return self._service_client == __value._service_client
 
-    @property
-    def workspace_path(self) -> pathlib.Path:
-        return pathlib.Path(self._workspace.name)
-
     def create_service(
         self,
         *,
@@ -119,19 +119,21 @@ class ServiceOperator:
 
         image_repo_database_name = image_repo_database_name or database_name or self._database_name
         image_repo_schema_name = image_repo_schema_name or schema_name or self._schema_name
-        # create a temp stage
-        stage_name = sql_identifier.SqlIdentifier(
-            snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.STAGE)
-        )
-        self._stage_client.create_tmp_stage(
-            database_name=database_name,
-            schema_name=schema_name,
-            stage_name=stage_name,
-            statement_params=statement_params,
-        )
-        stage_path = self._stage_client.fully_qualified_object_name(database_name, schema_name, stage_name)
-
-        self._model_deployment_spec.save(
+        if self._workspace:
+            # create a temp stage
+            stage_name = sql_identifier.SqlIdentifier(
+                snowpark_utils.random_name_for_temp_object(snowpark_utils.TempObjectType.STAGE)
+            )
+            self._stage_client.create_tmp_stage(
+                database_name=database_name,
+                schema_name=schema_name,
+                stage_name=stage_name,
+                statement_params=statement_params,
+            )
+            stage_path = self._stage_client.fully_qualified_object_name(database_name, schema_name, stage_name)
+        else:
+            stage_path = None
+        spec_yaml_str_or_path = self._model_deployment_spec.save(
             database_name=database_name,
             schema_name=schema_name,
             model_name=model_name,
@@ -154,12 +156,14 @@ class ServiceOperator:
             force_rebuild=force_rebuild,
             external_access_integrations=build_external_access_integrations,
         )
-        file_utils.upload_directory_to_stage(
-            self._session,
-            local_path=self.workspace_path,
-            stage_path=pathlib.PurePosixPath(stage_path),
-            statement_params=statement_params,
-        )
+        if self._workspace:
+            assert stage_path is not None
+            file_utils.upload_directory_to_stage(
+                self._session,
+                local_path=pathlib.Path(self._workspace.name),
+                stage_path=pathlib.PurePosixPath(stage_path),
+                statement_params=statement_params,
+            )
 
         # check if the inference service is already running/suspended
         model_inference_service_exists = self._check_if_service_exists(
@@ -176,8 +180,11 @@ class ServiceOperator:
 
         # deploy the model service
         query_id, async_job = self._service_client.deploy_model(
-            stage_path=stage_path,
-            model_deployment_spec_file_rel_path=model_deployment_spec.ModelDeploymentSpec.DEPLOY_SPEC_FILE_REL_PATH,
+            stage_path=stage_path if self._workspace else None,
+            model_deployment_spec_file_rel_path=(
+                model_deployment_spec.ModelDeploymentSpec.DEPLOY_SPEC_FILE_REL_PATH if self._workspace else None
+            ),
+            model_deployment_spec_yaml_str=None if self._workspace else spec_yaml_str_or_path,
             statement_params=statement_params,
         )
 

snowflake/ml/model/_client/service/model_deployment_spec.py

@@ -16,7 +16,7 @@ class ModelDeploymentSpec:
 
     DEPLOY_SPEC_FILE_REL_PATH = "deploy.yml"
 
-    def __init__(self, workspace_path: pathlib.Path) -> None:
+    def __init__(self, workspace_path: Optional[pathlib.Path] = None) -> None:
         self.workspace_path = workspace_path
 
     def save(
@@ -43,7 +43,7 @@ class ModelDeploymentSpec:
         max_batch_rows: Optional[int],
         force_rebuild: bool,
         external_access_integrations: Optional[List[sql_identifier.SqlIdentifier]],
-    ) -> None:
+    ) -> str:
         # create the deployment spec
         # models spec
         fq_model_name = identifier.get_schema_level_object_identifier(
@@ -105,9 +105,12 @@ class ModelDeploymentSpec:
             service=service_dict,
         )
 
+        # Anchors are not supported in the server, avoid that.
+        yaml.SafeDumper.ignore_aliases = lambda *args: True  # type: ignore[method-assign]
+        if self.workspace_path is None:
+            return yaml.safe_dump(model_deployment_spec_dict)
         # save the yaml
         file_path = self.workspace_path / self.DEPLOY_SPEC_FILE_REL_PATH
         with file_path.open("w", encoding="utf-8") as f:
-            # Anchors are not supported in the server, avoid that.
-            yaml.SafeDumper.ignore_aliases = lambda *args: True  # type: ignore[method-assign]
             yaml.safe_dump(model_deployment_spec_dict, f)
+        return str(file_path.resolve())

snowflake/ml/model/_client/sql/service.py

@@ -73,13 +73,17 @@ class ServiceSQLClient(_base._BaseSQLClient):
     def deploy_model(
         self,
         *,
-        stage_path: str,
-        model_deployment_spec_file_rel_path: str,
+        stage_path: Optional[str] = None,
+        model_deployment_spec_yaml_str: Optional[str] = None,
+        model_deployment_spec_file_rel_path: Optional[str] = None,
         statement_params: Optional[Dict[str, Any]] = None,
     ) -> Tuple[str, snowpark.AsyncJob]:
-        async_job = self._session.sql(
-            f"CALL SYSTEM$DEPLOY_MODEL('@{stage_path}/{model_deployment_spec_file_rel_path}')"
-        ).collect(block=False, statement_params=statement_params)
+        assert model_deployment_spec_yaml_str or model_deployment_spec_file_rel_path
+        if model_deployment_spec_yaml_str:
+            sql_str = f"CALL SYSTEM$DEPLOY_MODEL('{model_deployment_spec_yaml_str}')"
+        else:
+            sql_str = f"CALL SYSTEM$DEPLOY_MODEL('@{stage_path}/{model_deployment_spec_file_rel_path}')"
+        async_job = self._session.sql(sql_str).collect(block=False, statement_params=statement_params)
         assert isinstance(async_job, snowpark.AsyncJob)
         return async_job.query_id, async_job
 

snowflake/ml/model/_model_composer/model_composer.py

@@ -44,6 +44,7 @@ class ModelComposer:
         stage_path: str,
         *,
         statement_params: Optional[Dict[str, Any]] = None,
+        save_location: Optional[str] = None,
     ) -> None:
         self.session = session
         self.stage_path: Union[pathlib.PurePosixPath, parse.ParseResult] = None  # type: ignore[assignment]
@@ -54,10 +55,29 @@ class ModelComposer:
             # The stage path is a user stage path
             self.stage_path = pathlib.PurePosixPath(stage_path)
 
-        self._workspace = tempfile.TemporaryDirectory()
-        self._packager_workspace = tempfile.TemporaryDirectory()
+        # Set up workspace based on save_location if provided, otherwise use temporary directory
+        self.save_location = save_location
+        if save_location:
+            # Use the save_location directory directly
+            self._workspace_path = pathlib.Path(save_location)
+            self._workspace_path.mkdir(exist_ok=True)
+            # ensure that the directory is empty
+            if any(self._workspace_path.iterdir()):
+                raise ValueError(f"The directory {self._workspace_path} is not empty.")
+            self._workspace = None
+
+            self._packager_workspace_path = self._workspace_path / ModelComposer.MODEL_DIR_REL_PATH
+            self._packager_workspace_path.mkdir(exist_ok=True)
+            self._packager_workspace = None
+        else:
+            # Use a temporary directory
+            self._workspace = tempfile.TemporaryDirectory()
+            self._workspace_path = pathlib.Path(self._workspace.name)
+
+            self._packager_workspace_path = self._workspace_path / ModelComposer.MODEL_DIR_REL_PATH
+            self._packager_workspace_path.mkdir(exist_ok=True)
 
-        self.packager = model_packager.ModelPackager(local_dir_path=str(self._packager_workspace_path))
+        self.packager = model_packager.ModelPackager(local_dir_path=str(self.packager_workspace_path))
         self.manifest = model_manifest.ModelManifest(workspace_path=self.workspace_path)
 
         self.model_file_rel_path = f"model-{uuid.uuid4().hex}.zip"
@@ -65,16 +85,16 @@ class ModelComposer:
         self._statement_params = statement_params
 
     def __del__(self) -> None:
-        self._workspace.cleanup()
-        self._packager_workspace.cleanup()
+        if self._workspace:
+            self._workspace.cleanup()
 
     @property
     def workspace_path(self) -> pathlib.Path:
-        return pathlib.Path(self._workspace.name)
+        return self._workspace_path
 
     @property
-    def _packager_workspace_path(self) -> pathlib.Path:
-        return pathlib.Path(self._packager_workspace.name)
+    def packager_workspace_path(self) -> pathlib.Path:
+        return self._packager_workspace_path
 
     @property
     def model_stage_path(self) -> str:
@@ -167,6 +187,7 @@ class ModelComposer:
             conda_dependencies=conda_dependencies,
             pip_requirements=pip_requirements,
             artifact_repository_map=artifact_repository_map,
+            target_platforms=target_platforms,
             python_version=python_version,
             ext_modules=ext_modules,
             code_paths=code_paths,
@@ -175,9 +196,6 @@ class ModelComposer:
         )
         assert self.packager.meta is not None
 
-        file_utils.copytree(
-            str(self._packager_workspace_path), str(self.workspace_path / ModelComposer.MODEL_DIR_REL_PATH)
-        )
         self.manifest.save(
             model_meta=self.packager.meta,
             model_rel_path=pathlib.PurePosixPath(ModelComposer.MODEL_DIR_REL_PATH),

snowflake/ml/model/_packager/model_env/model_env.py

@@ -29,11 +29,13 @@ class ModelEnv:
         self,
         conda_env_rel_path: Optional[str] = None,
         pip_requirements_rel_path: Optional[str] = None,
+        prefer_pip: bool = False,
     ) -> None:
         if conda_env_rel_path is None:
             conda_env_rel_path = os.path.join(_DEFAULT_ENV_DIR, _DEFAULT_CONDA_ENV_FILENAME)
         if pip_requirements_rel_path is None:
             pip_requirements_rel_path = os.path.join(_DEFAULT_ENV_DIR, _DEFAULT_PIP_REQUIREMENTS_FILENAME)
+        self.prefer_pip: bool = prefer_pip
         self.conda_env_rel_path = pathlib.PurePosixPath(pathlib.Path(conda_env_rel_path).as_posix())
         self.pip_requirements_rel_path = pathlib.PurePosixPath(pathlib.Path(pip_requirements_rel_path).as_posix())
         self.artifact_repository_map: Optional[Dict[str, str]] = None
@@ -113,7 +115,11 @@ class ModelEnv:
         if snowpark_ml_version:
             self._snowpark_ml_version = version.parse(snowpark_ml_version)
 
-    def include_if_absent(self, pkgs: List[ModelDependency], check_local_version: bool = False) -> None:
+    def include_if_absent(
+        self,
+        pkgs: List[ModelDependency],
+        check_local_version: bool = False,
+    ) -> None:
         """Append requirements into model env if absent. Depending on the environment, requirements may be added
         to either the pip requirements or conda dependencies.
 
@@ -121,7 +127,7 @@ class ModelEnv:
             pkgs: A list of ModelDependency namedtuple to be appended.
             check_local_version: Flag to indicate if it is required to pin to local version. Defaults to False.
         """
-        if self.pip_requirements and not self.conda_dependencies and pkgs:
+        if (self.pip_requirements or self.prefer_pip) and not self.conda_dependencies and pkgs:
             pip_pkg_reqs: List[str] = []
             warnings.warn(
                 (

snowflake/ml/model/_packager/model_meta/model_meta.py

@@ -49,6 +49,7 @@ def create_model_metadata(
     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.TargetPlatform]] = None,
     python_version: Optional[str] = None,
     task: model_types.Task = model_types.Task.UNKNOWN,
     **kwargs: Any,
@@ -69,6 +70,7 @@ def create_model_metadata(
         conda_dependencies: List of conda requirements for running the model. Defaults to None.
         pip_requirements: List of pip Python packages requirements for running the model. Defaults to None.
         artifact_repository_map: A dict mapping from package channel to artifact repository name.
+        target_platforms: List of target platforms to run the model.
         python_version: A string of python version where model is run. Used for user override. If specified as None,
             current version would be captured. Defaults to None.
         task: The task of the Model Version. It is an enum class Task with values TABULAR_REGRESSION,
@@ -101,12 +103,14 @@ def create_model_metadata(
         else:
             raise ValueError("`snowflake.ml` is imported via a way that embedding local ML library is not supported.")
 
+    prefer_pip = target_platforms == [model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
     env = _create_env_for_model_metadata(
         conda_dependencies=conda_dependencies,
         pip_requirements=pip_requirements,
         artifact_repository_map=artifact_repository_map,
         python_version=python_version,
         embed_local_ml_library=embed_local_ml_library,
+        prefer_pip=prefer_pip,
     )
 
     if embed_local_ml_library:
@@ -157,8 +161,9 @@ def _create_env_for_model_metadata(
     artifact_repository_map: Optional[Dict[str, str]] = None,
     python_version: Optional[str] = None,
     embed_local_ml_library: bool = False,
+    prefer_pip: bool = False,
 ) -> model_env.ModelEnv:
-    env = model_env.ModelEnv()
+    env = model_env.ModelEnv(prefer_pip=prefer_pip)
 
     # Mypy doesn't like getter and setter have different types. See python/mypy #3004
     env.conda_dependencies = conda_dependencies  # type: ignore[assignment]

snowflake/ml/model/_packager/model_packager.py

@@ -44,6 +44,7 @@ class ModelPackager:
         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.TargetPlatform]] = None,
         python_version: Optional[str] = None,
         ext_modules: Optional[List[ModuleType]] = None,
         code_paths: Optional[List[str]] = None,
@@ -77,6 +78,7 @@ class ModelPackager:
             artifact_repository_map=artifact_repository_map,
             python_version=python_version,
             task=task,
+            target_platforms=target_platforms,
             **options,
         ) as meta:
             model_blobs_path = os.path.join(self.local_dir_path, ModelPackager.MODEL_BLOBS_DIR)

snowflake/ml/model/_packager/model_runtime/_snowml_inference_alternative_requirements.py

@@ -1 +1 @@
-REQUIREMENTS = ['absl-py>=0.15,<2', 'aiohttp!=4.0.0a0, !=4.0.0a1', 'anyio>=3.5.0,<5', 'cachetools>=3.1.1,<6', 'cloudpickle>=2.0.0,<3', 'cryptography', 'fsspec>=2024.6.1,<2026', 'importlib_resources>=6.1.1, <7', 'numpy>=1.23,<2', 'packaging>=20.9,<25', 'pandas>=1.0.0,<3', 'pyarrow', 'pyjwt>=2.0.0, <3', 'pytimeparse>=1.1.8,<2', 'pyyaml>=6.0,<7', 'requests', 'retrying>=1.3.3,<2', 's3fs>=2024.6.1,<2026', 'scikit-learn>=1.4,<1.6', 'scipy>=1.9,<2', 'snowflake-connector-python>=3.12.0,<4', 'snowflake-snowpark-python>=1.17.0,<2,!=1.26.0', 'sqlparse>=0.4,<1', 'typing-extensions>=4.1.0,<5', 'xgboost>=1.7.3,<3']
+REQUIREMENTS = ['absl-py>=0.15,<2', 'aiohttp!=4.0.0a0, !=4.0.0a1', 'anyio>=3.5.0,<5', 'cachetools>=3.1.1,<6', 'cloudpickle>=2.0.0,<3', 'cryptography', 'fsspec>=2024.6.1,<2026', 'importlib_resources>=6.1.1, <7', 'numpy>=1.23,<2', 'packaging>=20.9,<25', 'pandas>=1.0.0,<3', 'pyarrow', 'pyjwt>=2.0.0, <3', 'pytimeparse>=1.1.8,<2', 'pyyaml>=6.0,<7', 'requests', 'retrying>=1.3.3,<2', 's3fs>=2024.6.1,<2026', 'scikit-learn>=1.4,<1.6', 'scipy>=1.9,<2', 'snowflake-connector-python>=3.12.0,<4', 'snowflake-snowpark-python>=1.17.0,<2,!=1.26.0', 'snowflake.core>=1.0.2,<2', 'sqlparse>=0.4,<1', 'typing-extensions>=4.1.0,<5', 'xgboost>=1.7.3,<3']

snowflake/ml/model/type_hints.py

@@ -147,6 +147,7 @@ class BaseModelSaveOption(TypedDict):
     embed_local_ml_library: Embedding local SnowML into the code directory of the folder.
     relax_version: Whether or not relax the version constraints of the dependencies if unresolvable in Warehouse.
         It detects any ==x.y.z in specifiers and replaced with >=x.y, <(x+1). Defaults to True.
+    save_location: Local directory path to save the model and metadata.
     """
 
     embed_local_ml_library: NotRequired[bool]
@@ -154,6 +155,7 @@ class BaseModelSaveOption(TypedDict):
     function_type: NotRequired[Literal["FUNCTION", "TABLE_FUNCTION"]]
     method_options: NotRequired[Dict[str, ModelMethodSaveOptions]]
     enable_explainability: NotRequired[bool]
+    save_location: NotRequired[str]
 
 
 class CatBoostModelSaveOptions(BaseModelSaveOption):

snowflake/ml/registry/_manager/model_manager.py

@@ -1,3 +1,4 @@
+import os
 from types import ModuleType
 from typing import Any, Dict, List, Optional, Tuple, Union
 
@@ -13,6 +14,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.ml.modeling._internal import constants
 from snowflake.snowpark import exceptions as snowpark_exceptions, session
 
 logger = logging.getLogger(__name__)
@@ -208,6 +210,14 @@ class ModelManager:
         if target_platforms:
             # Convert any string target platforms to TargetPlatform objects
             platforms = [model_types.TargetPlatform(platform) for platform in target_platforms]
+        else:
+            # Default the target platform to SPCS if not specified when running in ML runtime
+            if os.getenv(constants.IN_ML_RUNTIME_ENV_VAR):
+                logger.info(
+                    "Logging the model on Container Runtime for ML without specifying `target_platforms`. "
+                    'Default to `target_platforms=["SNOWPARK_CONTAINER_SERVICES"]`.'
+                )
+                platforms = [model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
 
         if artifact_repository_map:
             for channel, artifact_repository_name in artifact_repository_map.items():
@@ -223,8 +233,17 @@ class ModelManager:
 
         logger.info("Start packaging and uploading your model. It might take some time based on the size of the model.")
 
+        # Extract save_location from options if present
+        save_location = None
+        if options and "save_location" in options:
+            save_location = options.get("save_location")
+            logger.info(f"Model will be saved to local directory: {save_location}")
+
         mc = model_composer.ModelComposer(
-            self._model_ops._session, stage_path=stage_path, statement_params=statement_params
+            self._model_ops._session,
+            stage_path=stage_path,
+            statement_params=statement_params,
+            save_location=save_location,
         )
         model_metadata: model_meta.ModelMetadata = mc.save(
             name=model_name_id.resolved(),

snowflake/ml/registry/registry.py

@@ -75,7 +75,9 @@ class Registry:
             )
 
         self._model_manager = model_manager.ModelManager(
-            session, database_name=self._database_name, schema_name=self._schema_name
+            session,
+            database_name=self._database_name,
+            schema_name=self._schema_name,
         )
 
         self.enable_monitoring = options.get("enable_monitoring", True) if options else True
@@ -181,6 +183,7 @@ class Registry:
                 - target_methods: List of target methods to register when logging the model.
                   This option is not used in MLFlow models. Defaults to None, in which case the model handler's
                   default target methods will be used.
+                - save_location: Location to save the model and metadata.
                 - method_options: Per-method saving options. This dictionary has method names as keys and dictionary
                     values with the desired options.
 
@@ -317,6 +320,7 @@ class Registry:
                 - target_methods: List of target methods to register when logging the model.
                   This option is not used in MLFlow models. Defaults to None, in which case the model handler's
                   default target methods will be used.
+                - save_location: Location to save the model and metadata.
                 - method_options: Per-method saving options. This dictionary has method names as keys and dictionary
                     values with the desired options. See the example below.
 

snowflake/ml/version.py

@@ -1 +1 @@
-VERSION="1.8.1"
+VERSION="1.8.2"

{snowflake_ml_python-1.8.1.dist-info → snowflake_ml_python-1.8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.8.1
+Version: 1.8.2
 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: 
@@ -253,6 +253,7 @@ Requires-Dist: scikit-learn<1.6,>=1.4
 Requires-Dist: scipy<2,>=1.9
 Requires-Dist: snowflake-connector-python[pandas]<4,>=3.12.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
@@ -402,7 +403,38 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.8.1
+## 1.8.2
+
+### Bug Fixes
+
+### Behavior Change
+
+### New Features
+
+- ML Job now available as a PuPr feature
+- ML Job: Add ability to retrieve results for `@remote` decorated functions using
+  new `MLJobWithResult.result()` API, which will return the unpickled result
+  or raise an exception if the job execution failed.
+- ML Job: Pre-created Snowpark Session is now available inside job payloads using
+  `snowflake.snowpark.context.get_active_session()`
+- Registry: Introducing `save_location` to `log_model` using the `options` argument.
+  User's can provide the path to write the model version's files that get stored in Snowflake's stage.
+- Registry: Include model dependencies in pip requirements by default when logging in Container Runtime.
+
+```python
+reg.log_model(
+    model=...,
+    model_name=...,
+    version_name=...,
+    ...,
+    options={"save_location": "./model_directory"},
+)
+```
+
+- ML Job (PrPr): Add `instance_id` argument to `get_logs` and `show_logs` method to support multi node log retrieval
+- ML Job (PrPr): Add `job.get_instance_status(instance_id=...)` API to support multi node status retrieval
+
+## 1.8.1 (03-26-2025)
 
 ### Bug Fixes
 
@@ -422,7 +454,7 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
   for cost implications.
 - Registry: When creating a copy of a `ModelVersion` with `log_model`, raise an exception if unsupported arguments are provided.
 
-## 1.8.0
+## 1.8.0 (03-20-2025)
 
 ### Bug Fixes
 
@@ -723,7 +755,6 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 - Registry: Added support for handling Hugging Face model configurations with auto-mapping functionality.
 - Registry: Added support for `keras` 3.x model with `tensorflow` and `pytorch` backend
-- ML Job (PrPr): Support any serializable (pickleable) argument for `@remote` decorated functions
 
 ## 1.7.4 (01-28-2025)