snowflake-ml-python 1.10.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

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

@@ -10,10 +10,15 @@ class Model(BaseModel):
     version: str
 
 
+class InferenceEngineSpec(BaseModel):
+    inference_engine_name: str
+    inference_engine_args: Optional[list[str]] = None
+
+
 class ImageBuild(BaseModel):
-    compute_pool: str
-    image_repo: str
-    force_rebuild: bool
+    compute_pool: Optional[str] = None
+    image_repo: Optional[str] = None
+    force_rebuild: Optional[bool] = None
     external_access_integrations: Optional[list[str]] = None
 
 
@@ -27,6 +32,7 @@ class Service(BaseModel):
     gpu: Optional[str] = None
     num_workers: Optional[int] = None
     max_batch_rows: Optional[int] = None
+    inference_engine_spec: Optional[InferenceEngineSpec] = None
 
 
 class Job(BaseModel):
@@ -68,13 +74,13 @@ class ModelLogging(BaseModel):
 
 class ModelServiceDeploymentSpec(BaseModel):
     models: list[Model]
-    image_build: ImageBuild
+    image_build: Optional[ImageBuild] = None
     service: Service
     model_loggings: Optional[list[ModelLogging]] = None
 
 
 class ModelJobDeploymentSpec(BaseModel):
     models: list[Model]
-    image_build: ImageBuild
+    image_build: Optional[ImageBuild] = None
     job: Job
     model_loggings: Optional[list[ModelLogging]] = None

snowflake/ml/model/_model_composer/model_composer.py

@@ -1,17 +1,12 @@
 import pathlib
 import tempfile
 import uuid
-import warnings
 from types import ModuleType
 from typing import TYPE_CHECKING, Any, Optional, Union
 from urllib import parse
 
-from absl import logging
-from packaging import requirements
-
 from snowflake import snowpark
-from snowflake.ml import version as snowml_version
-from snowflake.ml._internal import env as snowml_env, env_utils, file_utils
+from snowflake.ml._internal import file_utils
 from snowflake.ml._internal.lineage import lineage_utils
 from snowflake.ml.data import data_source
 from snowflake.ml.model import model_signature, type_hints as model_types
@@ -19,7 +14,6 @@ from snowflake.ml.model._model_composer.model_manifest import model_manifest
 from snowflake.ml.model._packager import model_packager
 from snowflake.ml.model._packager.model_meta import model_meta
 from snowflake.snowpark import Session
-from snowflake.snowpark._internal import utils as snowpark_utils
 
 if TYPE_CHECKING:
     from snowflake.ml.experiment._experiment_info import ExperimentInfo
@@ -142,73 +136,10 @@ class ModelComposer:
         experiment_info: Optional["ExperimentInfo"] = None,
         options: Optional[model_types.ModelSaveOption] = None,
     ) -> model_meta.ModelMetadata:
-        # set enable_explainability=False if the model is not runnable in WH or the target platforms include SPCS
-        conda_dep_dict = env_utils.validate_conda_dependency_string_list(
-            conda_dependencies if conda_dependencies else []
-        )
-
-        enable_explainability = None
-
-        if options:
-            enable_explainability = options.get("enable_explainability", None)
-
-        # skip everything if user said False explicitly
-        if enable_explainability is None or enable_explainability is True:
-            is_warehouse_runnable = (
-                not conda_dep_dict
-                or all(
-                    chan == env_utils.DEFAULT_CHANNEL_NAME or chan == env_utils.SNOWFLAKE_CONDA_CHANNEL_URL
-                    for chan in conda_dep_dict
-                )
-            ) and (not pip_requirements)
-
-            only_spcs = (
-                target_platforms
-                and len(target_platforms) == 1
-                and model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES in target_platforms
-            )
-            if only_spcs or (not is_warehouse_runnable):
-                # if only SPCS and user asked for explainability we fail
-                if enable_explainability is True:
-                    raise ValueError(
-                        "`enable_explainability` cannot be set to True when the model is not runnable in WH "
-                        "or the target platforms include SPCS."
-                    )
-                elif not options:  # explicitly set flag to false in these cases if not specified
-                    options = model_types.BaseModelSaveOption()
-                    options["enable_explainability"] = False
-            elif (
-                target_platforms
-                and len(target_platforms) > 1
-                and model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES in target_platforms
-            ):  # if both then only available for WH
-                if enable_explainability is True:
-                    warnings.warn(
-                        ("Explain function will only be available for model deployed to warehouse."),
-                        category=UserWarning,
-                        stacklevel=2,
-                    )
 
         if not options:
             options = model_types.BaseModelSaveOption()
 
-        if not snowpark_utils.is_in_stored_procedure() and target_platforms != [  # type: ignore[no-untyped-call]
-            model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES  # no information schema check for SPCS-only models
-        ]:
-            snowml_matched_versions = env_utils.get_matched_package_versions_in_information_schema(
-                self.session,
-                reqs=[requirements.Requirement(f"{env_utils.SNOWPARK_ML_PKG_NAME}=={snowml_version.VERSION}")],
-                python_version=python_version or snowml_env.PYTHON_VERSION,
-                statement_params=self._statement_params,
-            ).get(env_utils.SNOWPARK_ML_PKG_NAME, [])
-
-            if len(snowml_matched_versions) < 1 and options.get("embed_local_ml_library", False) is False:
-                logging.info(
-                    f"Local snowflake-ml-python library has version {snowml_version.VERSION},"
-                    " which is not available in the Snowflake server, embedding local ML library automatically."
-                )
-                options["embed_local_ml_library"] = True
-
         model_metadata: model_meta.ModelMetadata = self.packager.save(
             name=name,
             model=model,

snowflake/ml/model/_model_composer/model_manifest/model_manifest.py

@@ -1,13 +1,11 @@
 import collections
 import logging
 import pathlib
-import warnings
 from typing import TYPE_CHECKING, Optional, cast
 
 import yaml
 
 from snowflake.ml._internal import env_utils
-from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml.data import data_source
 from snowflake.ml.model import type_hints
 from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
@@ -55,47 +53,8 @@ class ModelManifest:
         experiment_info: Optional["ExperimentInfo"] = None,
         target_platforms: Optional[list[type_hints.TargetPlatform]] = None,
     ) -> None:
-        if options is None:
-            options = {}
-
-        has_pip_requirements = len(model_meta.env.pip_requirements) > 0
-        only_spcs = (
-            target_platforms
-            and len(target_platforms) == 1
-            and target_platforms[0] == type_hints.TargetPlatform.SNOWPARK_CONTAINER_SERVICES
-        )
-
-        if "relax_version" not in options:
-            if has_pip_requirements or only_spcs:
-                logger.info(
-                    "Setting `relax_version=False` as this model will run in Snowpark Container Services "
-                    "or in Warehouse with a specified artifact_repository_map where exact version "
-                    " specifications will be honored."
-                )
-                relax_version = False
-            else:
-                warnings.warn(
-                    (
-                        "`relax_version` is not set and therefore defaulted to True. Dependency version constraints"
-                        " relaxed from ==x.y.z to >=x.y, <(x+1). To use specific dependency versions for compatibility,"
-                        " reproducibility, etc., set `options={'relax_version': False}` when logging the model."
-                    ),
-                    category=UserWarning,
-                    stacklevel=2,
-                )
-                relax_version = True
-            options["relax_version"] = relax_version
-        else:
-            relax_version = options.get("relax_version", True)
-            if relax_version and (has_pip_requirements or only_spcs):
-                raise exceptions.SnowflakeMLException(
-                    error_code=error_codes.INVALID_ARGUMENT,
-                    original_exception=ValueError(
-                        "Setting `relax_version=True` is only allowed for models to be run in Warehouse with "
-                        "Snowflake Conda Channel dependencies. It cannot be used with pip requirements or when "
-                        "targeting only Snowpark Container Services."
-                    ),
-                )
+        assert options is not None, "ModelParameterReconciler should have set options with relax_version"
+        relax_version = options["relax_version"]
 
         runtime_to_use = model_runtime.ModelRuntime(
             name=self._DEFAULT_RUNTIME_NAME,

snowflake/ml/model/inference_engine.py

@@ -0,0 +1,5 @@
+import enum
+
+
+class InferenceEngine(enum.Enum):
+    VLLM = "vllm"

snowflake/ml/model/models/huggingface_pipeline.py

@@ -258,7 +258,7 @@ class HuggingFacePipelineModel:
         # model_version_impl.create_service parameters
         service_name: str,
         service_compute_pool: str,
-        image_repo: str,
+        image_repo: Optional[str] = None,
         image_build_compute_pool: Optional[str] = None,
         ingress_enabled: bool = False,
         max_instances: int = 1,
@@ -282,7 +282,8 @@ class HuggingFacePipelineModel:
             comment: Comment for the model. Defaults to None.
             service_name: The name of the service to create.
             service_compute_pool: The compute pool for the service.
-            image_repo: The name of the image repository.
+            image_repo: The name of the image repository. This can be None, in that case a default hidden image
+                repository will be used.
             image_build_compute_pool: The name of the compute pool used to build the model inference image. It uses
             the service compute pool if None.
             ingress_enabled: Whether ingress is enabled. Defaults to False.
@@ -356,7 +357,7 @@ class HuggingFacePipelineModel:
                         else sql_identifier.SqlIdentifier(service_compute_pool)
                     ),
                     service_compute_pool_name=sql_identifier.SqlIdentifier(service_compute_pool),
-                    image_repo=image_repo,
+                    image_repo_name=image_repo,
                     ingress_enabled=ingress_enabled,
                     max_instances=max_instances,
                     cpu_requests=cpu_requests,

snowflake/ml/registry/_manager/model_manager.py

@@ -4,15 +4,14 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 import pandas as pd
 from absl.logging import logging
 
-from snowflake.ml._internal import env, platform_capabilities, 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
-from snowflake.ml.model import model_signature, target_platform, task, type_hints
+from snowflake.ml.model import model_signature, task, type_hints
 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.ml.registry._manager import model_parameter_reconciler
 from snowflake.snowpark import exceptions as snowpark_exceptions, session
@@ -221,37 +220,8 @@ class ModelManager:
                 statement_params=statement_params,
             )
 
-        platforms = None
-        # User specified target platforms are defaulted to None and will not show up in the generated manifest.
-        if target_platforms:
-            # Convert any string target platforms to TargetPlatform objects
-            platforms = [type_hints.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 = [target_platform.TargetPlatform.WAREHOUSE]
-
-            # Default the target platform to SPCS if not specified when running 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"]`.'
-                )
-                platforms = [target_platform.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
-
         reconciler = model_parameter_reconciler.ModelParameterReconciler(
+            session=self._model_ops._session,
             database_name=self._database_name,
             schema_name=self._schema_name,
             conda_dependencies=conda_dependencies,
@@ -259,6 +229,8 @@ class ModelManager:
             target_platforms=target_platforms,
             artifact_repository_map=artifact_repository_map,
             options=options,
+            python_version=python_version,
+            statement_params=statement_params,
         )
 
         model_params = reconciler.reconcile()
@@ -293,12 +265,12 @@ class ModelManager:
             pip_requirements=pip_requirements,
             artifact_repository_map=artifact_repository_map,
             resource_constraint=resource_constraint,
-            target_platforms=platforms,
+            target_platforms=model_params.target_platforms,
             python_version=python_version,
             user_files=user_files,
             code_paths=code_paths,
             ext_modules=ext_modules,
-            options=options,
+            options=model_params.options,
             task=task,
             experiment_info=experiment_info,
         )

snowflake/ml/registry/_manager/model_parameter_reconciler.py

@@ -1,9 +1,20 @@
 import warnings
 from dataclasses import dataclass
-from typing import Optional
+from typing import Any, Optional
 
+from absl.logging import logging
+from packaging import requirements
+
+from snowflake.ml import version as snowml_version
+from snowflake.ml._internal import env, env as snowml_env, env_utils
+from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml._internal.utils import sql_identifier
-from snowflake.ml.model import type_hints as model_types
+from snowflake.ml.model import target_platform, type_hints as model_types
+from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
+from snowflake.snowpark import Session
+from snowflake.snowpark._internal import utils as snowpark_utils
+
+logger = logging.getLogger(__name__)
 
 
 @dataclass
@@ -12,7 +23,7 @@ class ReconciledParameters:
 
     conda_dependencies: Optional[list[str]] = None
     pip_requirements: Optional[list[str]] = None
-    target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None
+    target_platforms: Optional[list[model_types.TargetPlatform]] = None
     artifact_repository_map: Optional[dict[str, str]] = None
     options: Optional[model_types.ModelSaveOption] = None
     save_location: Optional[str] = None
@@ -23,6 +34,7 @@ class ModelParameterReconciler:
 
     def __init__(
         self,
+        session: Session,
         database_name: sql_identifier.SqlIdentifier,
         schema_name: sql_identifier.SqlIdentifier,
         conda_dependencies: Optional[list[str]] = None,
@@ -30,7 +42,10 @@ class ModelParameterReconciler:
         target_platforms: Optional[list[model_types.SupportedTargetPlatformType]] = None,
         artifact_repository_map: Optional[dict[str, str]] = None,
         options: Optional[model_types.ModelSaveOption] = None,
+        python_version: Optional[str] = None,
+        statement_params: Optional[dict[str, str]] = None,
     ) -> None:
+        self._session = session
         self._database_name = database_name
         self._schema_name = schema_name
         self._conda_dependencies = conda_dependencies
@@ -38,20 +53,27 @@ class ModelParameterReconciler:
         self._target_platforms = target_platforms
         self._artifact_repository_map = artifact_repository_map
         self._options = options
+        self._python_version = python_version
+        self._statement_params = statement_params
 
     def reconcile(self) -> ReconciledParameters:
         """Perform all parameter reconciliation and return clean parameters."""
+
         reconciled_artifact_repository_map = self._reconcile_artifact_repository_map()
         reconciled_save_location = self._extract_save_location()
 
         self._validate_pip_requirements_warehouse_compatibility(reconciled_artifact_repository_map)
 
+        reconciled_target_platforms = self._reconcile_target_platforms()
+        reconciled_options = self._reconcile_explainability_options(reconciled_target_platforms)
+        reconciled_options = self._reconcile_relax_version(reconciled_options, reconciled_target_platforms)
+
         return ReconciledParameters(
             conda_dependencies=self._conda_dependencies,
             pip_requirements=self._pip_requirements,
-            target_platforms=self._target_platforms,
+            target_platforms=reconciled_target_platforms,
             artifact_repository_map=reconciled_artifact_repository_map,
-            options=self._options,
+            options=reconciled_options,
             save_location=reconciled_save_location,
         )
 
@@ -82,6 +104,45 @@ class ModelParameterReconciler:
 
         return None
 
+    def _reconcile_target_platforms(self) -> Optional[list[model_types.TargetPlatform]]:
+        """Reconcile target platforms with proper defaulting logic."""
+        # User specified target platforms are defaulted to None and will not show up in the generated manifest.
+        if self._target_platforms:
+            # Convert any string target platforms to TargetPlatform objects
+            return [model_types.TargetPlatform(platform) for platform in self._target_platforms]
+
+        # Default the target platform to warehouse if not specified and any table function exists
+        if self._has_table_function():
+            logger.info(
+                "Logging a partitioned model with a table function without specifying `target_platforms`. "
+                'Default to `target_platforms=["WAREHOUSE"]`.'
+            )
+            return [target_platform.TargetPlatform.WAREHOUSE]
+
+        # Default the target platform to SPCS if not specified when running in ML runtime
+        if 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"]`.'
+            )
+            return [target_platform.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]
+
+        return None
+
+    def _has_table_function(self) -> bool:
+        """Check if any table function exists in options."""
+        if self._options is None:
+            return False
+
+        if self._options.get("function_type") == model_manifest_schema.ModelMethodFunctionTypes.TABLE_FUNCTION.value:
+            return True
+
+        for opt in self._options.get("method_options", {}).values():
+            if opt.get("function_type") == model_manifest_schema.ModelMethodFunctionTypes.TABLE_FUNCTION.value:
+                return True
+
+        return False
+
     def _validate_pip_requirements_warehouse_compatibility(
         self, artifact_repository_map: Optional[dict[str, str]]
     ) -> None:
@@ -103,3 +164,131 @@ class ModelParameterReconciler:
             or model_types.TargetPlatform.WAREHOUSE in target_platforms
             or "WAREHOUSE" in target_platforms
         )
+
+    def _reconcile_explainability_options(
+        self, target_platforms: Optional[list[model_types.TargetPlatform]]
+    ) -> model_types.ModelSaveOption:
+        """Reconcile explainability settings and embed_local_ml_library based on warehouse runnability."""
+        options = self._options.copy() if self._options else model_types.BaseModelSaveOption()
+
+        conda_dep_dict = env_utils.validate_conda_dependency_string_list(self._conda_dependencies or [])
+
+        enable_explainability = options.get("enable_explainability", None)
+
+        # Handle case where user explicitly disabled explainability
+        if enable_explainability is False:
+            return self._handle_embed_local_ml_library(options, target_platforms)
+
+        target_platform_set = set(target_platforms) if target_platforms else set()
+
+        is_warehouse_runnable = self._is_warehouse_runnable(conda_dep_dict)
+        only_spcs = target_platform_set == set(target_platform.SNOWPARK_CONTAINER_SERVICES_ONLY)
+        has_both_platforms = target_platform_set == set(target_platform.BOTH_WAREHOUSE_AND_SNOWPARK_CONTAINER_SERVICES)
+
+        # Handle case where user explicitly requested explainability
+        if enable_explainability:
+            if only_spcs or not is_warehouse_runnable:
+                raise ValueError(
+                    "`enable_explainability` cannot be set to True when the model is not runnable in WH "
+                    "or the target platforms include SPCS."
+                )
+            elif has_both_platforms:
+                warnings.warn(
+                    ("Explain function will only be available for model deployed to warehouse."),
+                    category=UserWarning,
+                    stacklevel=2,
+                )
+
+        # Handle case where explainability is not specified (None) - set default behavior
+        if enable_explainability is None:
+            if only_spcs or not is_warehouse_runnable:
+                options["enable_explainability"] = False
+
+        return self._handle_embed_local_ml_library(options, target_platforms)
+
+    def _handle_embed_local_ml_library(
+        self, options: model_types.ModelSaveOption, target_platforms: Optional[list[model_types.TargetPlatform]]
+    ) -> model_types.ModelSaveOption:
+        """Handle embed_local_ml_library logic."""
+        if not snowpark_utils.is_in_stored_procedure() and target_platforms != [  # type: ignore[no-untyped-call]
+            model_types.TargetPlatform.SNOWPARK_CONTAINER_SERVICES  # no information schema check for SPCS-only models
+        ]:
+            snowml_matched_versions = env_utils.get_matched_package_versions_in_information_schema(
+                self._session,
+                reqs=[requirements.Requirement(f"{env_utils.SNOWPARK_ML_PKG_NAME}=={snowml_version.VERSION}")],
+                python_version=self._python_version or snowml_env.PYTHON_VERSION,
+                statement_params=self._statement_params,
+            ).get(env_utils.SNOWPARK_ML_PKG_NAME, [])
+
+            if len(snowml_matched_versions) < 1 and not options.get("embed_local_ml_library", False):
+                logging.info(
+                    f"Local snowflake-ml-python library has version {snowml_version.VERSION},"
+                    " which is not available in the Snowflake server, embedding local ML library automatically."
+                )
+                options["embed_local_ml_library"] = True
+
+        return options
+
+    def _is_warehouse_runnable(self, conda_dep_dict: dict[str, list[Any]]) -> bool:
+        """Check if model can run in warehouse based on conda channels and pip requirements."""
+        # If pip requirements are present but no artifact repository map, model cannot run in warehouse
+        if self._pip_requirements and not self._artifact_repository_map:
+            return False
+
+        # If no conda dependencies, model can run in warehouse
+        if not conda_dep_dict:
+            return True
+
+        # Check if all conda channels are warehouse-compatible
+        warehouse_compatible_channels = {env_utils.DEFAULT_CHANNEL_NAME, env_utils.SNOWFLAKE_CONDA_CHANNEL_URL}
+        for channel in conda_dep_dict:
+            if channel not in warehouse_compatible_channels:
+                return False
+
+        return True
+
+    def _reconcile_relax_version(
+        self,
+        options: model_types.ModelSaveOption,
+        target_platforms: Optional[list[model_types.TargetPlatform]],
+    ) -> model_types.ModelSaveOption:
+        """Reconcile relax_version setting based on pip requirements and target platforms."""
+        target_platform_set = set(target_platforms) if target_platforms else set()
+        has_pip_requirements = bool(self._pip_requirements)
+        only_spcs = target_platform_set == set(target_platform.SNOWPARK_CONTAINER_SERVICES_ONLY)
+
+        if "relax_version" not in options:
+            if has_pip_requirements or only_spcs:
+                logger.info(
+                    "Setting `relax_version=False` as this model will run in Snowpark Container Services "
+                    "or in Warehouse with a specified artifact_repository_map where exact version "
+                    " specifications will be honored."
+                )
+                relax_version = False
+            else:
+                warnings.warn(
+                    (
+                        "`relax_version` is not set and therefore defaulted to True. Dependency version constraints"
+                        " relaxed from ==x.y.z to >=x.y, <(x+1). To use specific dependency versions for compatibility,"
+                        " reproducibility, etc., set `options={'relax_version': False}` when logging the model."
+                    ),
+                    category=UserWarning,
+                    stacklevel=2,
+                )
+                relax_version = True
+            options["relax_version"] = relax_version
+            return options
+
+        # Handle case where relax_version is already set
+        relax_version = options["relax_version"]
+        if relax_version and (has_pip_requirements or only_spcs):
+            raise exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_ARGUMENT,
+                original_exception=ValueError(
+                    "Setting `relax_version=True` is only allowed for models to be run in Warehouse with "
+                    "Snowflake Conda Channel dependencies. It cannot be used with pip requirements or when "
+                    "targeting only Snowpark Container Services."
+                ),
+            )
+
+        return options

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.10.0"
+VERSION = "1.11.0"

{snowflake_ml_python-1.10.0.dist-info → snowflake_ml_python-1.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.10.0
+Version: 1.11.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: 
@@ -410,12 +410,32 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
-## 1.10.0
+## 1.11.0
 
 ### Bug Fixes
 
+* ML Job: Fix `Error: Unable to retrieve head IP address` if not all instances start within the timeout.
+* ML Job: Fix `TypeError: SnowflakeCursor.execute() got an unexpected keyword argument '_force_qmark_paramstyle'`
+  when running inside Stored Procedures.
+
+### Behavior Changes
+
+### New Features
+
+* `ModelVersion.create_service()`: Made `image_repo` argument optional. By
+  default it will use a default image repo, which is
+  being rolled out in server version 9.22+.
+* Experiment Tracking (PrPr): Automatically log the model, metrics, and parameters while training Keras models with
+  `snowflake.ml.experiment.callback.keras.SnowflakeKerasCallback`.
+
+## 1.10.0
+
 ### Behavior Changes
 
+* Experiment Tracking (PrPr): The import paths for the auto-logging callbacks have changed to
+  `snowflake.ml.experiment.callback.xgboost.SnowflakeXgboostCallback` and
+  `snowflake.ml.experiment.callback.lightgbm.SnowflakeLightgbmCallback`.
+
 ### New Features
 
 * Registry: add progress bars for `ModelVersion.create_service` and `ModelVersion.log_model`.
@@ -436,13 +456,13 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 ```python
 from snowflake.ml.experiment import ExperimentTracking
+from snowflake.ml.experiment.callback import SnowflakeXgboostCallback, SnowflakeLightgbmCallback
 
 exp = ExperimentTracking(session=sp_session, database_name="ML", schema_name="PUBLIC")
 
 exp.set_experiment("MY_EXPERIMENT")
 
 # XGBoost
-from snowflake.ml.experiment.callback.xgboost import SnowflakeXgboostCallback
 callback = SnowflakeXgboostCallback(
   exp, log_model=True, log_metrics=True, log_params=True, model_name="model_name", model_signature=sig
 )
@@ -451,7 +471,6 @@ with exp.start_run():
   model.fit(X, y, eval_set=[(X_test, y_test)])
 
 # LightGBM
-from snowflake.ml.experiment.callback.lightgbm import SnowflakeLightgbmCallback
 callback = SnowflakeLightgbmCallback(
   exp, log_model=True, log_metrics=True, log_params=True, model_name="model_name", model_signature=sig
 )