snowflake-ml-python 1.6.1__py3-none-any.whl → 1.6.2__py3-none-any.whl

snowflake/ml/feature_store/feature_store.py

@@ -604,7 +604,7 @@ class FeatureStore:
         logger.info(f"Registered FeatureView {feature_view.name}/{version} successfully.")
         return self.get_feature_view(feature_view.name, str(version))
 
-    @dispatch_decorator()
+    @overload
     def update_feature_view(
         self,
         name: str,
@@ -613,13 +613,37 @@ class FeatureStore:
         refresh_freq: Optional[str] = None,
         warehouse: Optional[str] = None,
         desc: Optional[str] = None,
+    ) -> FeatureView:
+        ...
+
+    @overload
+    def update_feature_view(
+        self,
+        name: FeatureView,
+        version: Optional[str] = None,
+        *,
+        refresh_freq: Optional[str] = None,
+        warehouse: Optional[str] = None,
+        desc: Optional[str] = None,
+    ) -> FeatureView:
+        ...
+
+    @dispatch_decorator()  # type: ignore[misc]
+    def update_feature_view(
+        self,
+        name: Union[FeatureView, str],
+        version: Optional[str] = None,
+        *,
+        refresh_freq: Optional[str] = None,
+        warehouse: Optional[str] = None,
+        desc: Optional[str] = None,
     ) -> FeatureView:
         """Update a registered feature view.
             Check feature_view.py for which fields are allowed to be updated after registration.
 
         Args:
-            name: name of the FeatureView to be updated.
-            version: version of the FeatureView to be updated.
+            name: FeatureView object or name to suspend.
+            version: Optional version of feature view. Must set when argument feature_view is a str.
             refresh_freq: updated refresh frequency.
             warehouse: updated warehouse.
             desc: description of feature view.
@@ -661,7 +685,7 @@ class FeatureStore:
             SnowflakeMLException: [RuntimeError] If FeatureView is not managed and refresh_freq is defined.
             SnowflakeMLException: [RuntimeError] Failed to update feature view.
         """
-        feature_view = self.get_feature_view(name=name, version=version)
+        feature_view = self._validate_feature_view_name_and_version_input(name, version)
         new_desc = desc if desc is not None else feature_view.desc
 
         if feature_view.status == FeatureViewStatus.STATIC:
@@ -696,7 +720,7 @@ class FeatureStore:
                     f"Update feature view {feature_view.name}/{feature_view.version} failed: {e}"
                 ),
             ) from e
-        return self.get_feature_view(name=name, version=version)
+        return self.get_feature_view(name=feature_view.name, version=str(feature_view.version))
 
     @overload
     def read_feature_view(self, feature_view: str, version: str) -> DataFrame:
@@ -2121,7 +2145,7 @@ class FeatureStore:
         if "." not in name:
             return f"{self._config.full_schema_path}.{name}"
 
-        db_name, schema_name, object_name, _ = identifier.parse_schema_level_object_identifier(name)
+        db_name, schema_name, object_name = identifier.parse_schema_level_object_identifier(name)
         return "{}.{}.{}".format(
             db_name or self._config.database,
             schema_name or self._config.schema,
@@ -2186,11 +2210,7 @@ class FeatureStore:
         if len(fv_maps.keys()) == 0:
             return self._session.create_dataframe([], schema=_LIST_FEATURE_VIEW_SCHEMA)
 
-        filters = (
-            [lambda d: d["entityName"].startswith(feature_view_name.resolved())]  # type: ignore[union-attr]
-            if feature_view_name
-            else None
-        )
+        filters = [lambda d: d["entityName"].startswith(feature_view_name.resolved())] if feature_view_name else None
         res = self._lookup_tagged_objects(self._get_entity_name(entity_name), filters)
 
         output_values: List[List[Any]] = []
@@ -2281,16 +2301,20 @@ class FeatureStore:
                 timestamp_col=timestamp_col,
                 desc=desc,
                 version=version,
-                status=FeatureViewStatus(row["scheduling_state"])
-                if len(row["scheduling_state"]) > 0
-                else FeatureViewStatus.MASKED,
+                status=(
+                    FeatureViewStatus(row["scheduling_state"])
+                    if len(row["scheduling_state"]) > 0
+                    else FeatureViewStatus.MASKED
+                ),
                 feature_descs=self._fetch_column_descs("DYNAMIC TABLE", fv_name),
                 refresh_freq=row["target_lag"],
                 database=self._config.database.identifier(),
                 schema=self._config.schema.identifier(),
-                warehouse=SqlIdentifier(row["warehouse"], case_sensitive=True).identifier()
-                if len(row["warehouse"]) > 0
-                else None,
+                warehouse=(
+                    SqlIdentifier(row["warehouse"], case_sensitive=True).identifier()
+                    if len(row["warehouse"]) > 0
+                    else None
+                ),
                 refresh_mode=row["refresh_mode"],
                 refresh_mode_reason=row["refresh_mode_reason"],
                 owner=row["owner"],

snowflake/ml/feature_store/feature_view.py

@@ -706,7 +706,7 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
             >>> ).attach_feature_desc({"AGE": "my age", "TITLE": '"my title"'})
             >>> fv = fs.register_feature_view(draft_fv, '1.0')
             <BLANKLINE>
-            fv.to_df().show()
+            >>> fv.to_df().show()
             ----------------------------------------------------------------...
             |"NAME"  |"ENTITIES"                |"TIMESTAMP_COL"  |"DESC"  |
             ----------------------------------------------------------------...
@@ -801,7 +801,7 @@ Got {len(self._feature_df.queries['queries'])}: {self._feature_df.queries['queri
 
     @staticmethod
     def _load_from_lineage_node(session: Session, name: str, version: str) -> FeatureView:
-        db_name, feature_store_name, feature_view_name, _ = identifier.parse_schema_level_object_identifier(name)
+        db_name, feature_store_name, feature_view_name = identifier.parse_schema_level_object_identifier(name)
 
         session_warehouse = session.get_current_warehouse()
 

snowflake/ml/fileset/embedded_stage_fs.py

@@ -35,7 +35,7 @@ class SFEmbeddedStageFileSystem(stage_fs.SFStageFileSystem):
         **kwargs: Any,
     ) -> None:
 
-        (db, schema, object_name, _) = identifier.parse_schema_level_object_identifier(name)
+        (db, schema, object_name) = identifier.parse_schema_level_object_identifier(name)
         self._name = name  # TODO: Require or resolve FQN
         self._domain = domain
 

snowflake/ml/fileset/fileset.py

@@ -538,7 +538,7 @@ def _validate_target_stage_loc(snowpark_session: snowpark.Session, target_stage_
             original_exception=fileset_errors.FileSetLocationError('FileSet location should start with "@".'),
         )
     try:
-        db, schema, stage, _ = identifier.parse_schema_level_object_identifier(target_stage_loc[1:])
+        db, schema, stage, _ = identifier.parse_snowflake_stage_path(target_stage_loc[1:])
         if db is None or schema is None:
             raise ValueError("The stage path should be in the form '@<database>.<schema>.<stage>/*'")
         df_stages = snowpark_session.sql(f"Show stages like '{stage}' in SCHEMA {db}.{schema}")

snowflake/ml/fileset/sfcfs.py

@@ -15,6 +15,7 @@ from snowflake.ml._internal.exceptions import (
 from snowflake.ml._internal.utils import identifier
 from snowflake.ml.fileset import stage_fs
 from snowflake.ml.utils import connection_params
+from snowflake.snowpark import context, exceptions as snowpark_exceptions
 
 PROTOCOL_NAME = "sfc"
 
@@ -84,7 +85,7 @@ class SFFileSystem(fsspec.AbstractFileSystem):
         """
         if kwargs.get(_RECREATE_FROM_SERIALIZED):
             try:
-                snowpark_session = self._create_default_session()
+                snowpark_session = self._get_default_session()
             except Exception as e:
                 raise snowml_exceptions.SnowflakeMLException(
                     error_code=error_codes.SNOWML_DESERIALIZATION_FAILED,
@@ -103,7 +104,7 @@ class SFFileSystem(fsspec.AbstractFileSystem):
 
         super().__init__(**kwargs)
 
-    def _create_default_session(self) -> snowpark.Session:
+    def _get_default_session(self) -> snowpark.Session:
         """Create a Snowpark Session from default login options.
 
         Returns:
@@ -114,6 +115,11 @@ class SFFileSystem(fsspec.AbstractFileSystem):
             ValueError: Snowflake Connection could not be created.
 
         """
+        try:
+            return context.get_active_session()
+        except snowpark_exceptions.SnowparkSessionException:
+            pass
+
         try:
             snowflake_config = connection_params.SnowflakeLoginOptions()
         except Exception as e:
@@ -328,7 +334,7 @@ class SFFileSystem(fsspec.AbstractFileSystem):
                 ),
             )
         try:
-            res = identifier.parse_schema_level_object_identifier(path[1:])
+            res = identifier.parse_snowflake_stage_path(path[1:])
             if res[1] is None or res[0] is None or (res[3] and not res[3].startswith("/")):
                 raise ValueError("Invalid path. Missing database or schema identifier.")
             logging.debug(f"Parsed path: {res}")

snowflake/ml/model/_client/model/model_version_impl.py

@@ -306,6 +306,23 @@ class ModelVersion(lineage_node.LineageNode):
             statement_params=statement_params,
         )
 
+    @telemetry.send_api_usage_telemetry(
+        project=_TELEMETRY_PROJECT,
+        subproject=_TELEMETRY_SUBPROJECT,
+    )
+    def get_model_objective(self) -> model_types.ModelObjective:
+        statement_params = telemetry.get_statement_params(
+            project=_TELEMETRY_PROJECT,
+            subproject=_TELEMETRY_SUBPROJECT,
+        )
+        return self._model_ops.get_model_objective(
+            database_name=None,
+            schema_name=None,
+            model_name=self._model_name,
+            version_name=self._version_name,
+            statement_params=statement_params,
+        )
+
     @telemetry.send_api_usage_telemetry(
         project=_TELEMETRY_PROJECT,
         subproject=_TELEMETRY_SUBPROJECT,
@@ -606,8 +623,8 @@ class ModelVersion(lineage_node.LineageNode):
             "image_repo_database",
             "image_repo_schema",
             "image_repo",
-            "image_name",
             "gpu_requests",
+            "num_workers",
         ],
     )
     def create_service(
@@ -617,11 +634,10 @@ class ModelVersion(lineage_node.LineageNode):
         image_build_compute_pool: Optional[str] = None,
         service_compute_pool: str,
         image_repo: str,
-        image_name: Optional[str] = None,
         ingress_enabled: bool = False,
-        min_instances: int = 1,
         max_instances: int = 1,
         gpu_requests: Optional[str] = None,
+        num_workers: Optional[int] = None,
         force_rebuild: bool = False,
         build_external_access_integration: str,
     ) -> str:
@@ -635,12 +651,12 @@ class ModelVersion(lineage_node.LineageNode):
             service_compute_pool: The name of the compute pool used to run the inference service.
             image_repo: The name of the image repository, can be fully qualified. If not fully qualified, the database
                 or schema of the model will be used.
-            image_name: The name of the model inference image. Use a generated name if None.
             ingress_enabled: Whether to enable ingress.
-            min_instances: The minimum number of inference service instances to run.
             max_instances: The maximum number of inference service instances to run.
             gpu_requests: The gpu limit for GPU based inference. Can be integer, fractional or string values. Use CPU
                 if None.
+            num_workers: The number of workers (replicas of models) to run the inference service.
+                Auto determined if None.
             force_rebuild: Whether to force a model inference image rebuild.
             build_external_access_integration: The external access integration for image build.
 
@@ -670,11 +686,10 @@ class ModelVersion(lineage_node.LineageNode):
             image_repo_database_name=image_repo_db_id,
             image_repo_schema_name=image_repo_schema_id,
             image_repo_name=image_repo_id,
-            image_name=sql_identifier.SqlIdentifier(image_name) if image_name else None,
             ingress_enabled=ingress_enabled,
-            min_instances=min_instances,
             max_instances=max_instances,
             gpu_requests=gpu_requests,
+            num_workers=num_workers,
             force_rebuild=force_rebuild,
             build_external_access_integration=sql_identifier.SqlIdentifier(build_external_access_integration),
             statement_params=statement_params,

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

@@ -554,15 +554,14 @@ class ModelOperator:
             res[function_name] = target_method
         return res
 
-    def get_functions(
+    def _fetch_model_spec(
         self,
-        *,
         database_name: Optional[sql_identifier.SqlIdentifier],
         schema_name: Optional[sql_identifier.SqlIdentifier],
         model_name: sql_identifier.SqlIdentifier,
         version_name: sql_identifier.SqlIdentifier,
         statement_params: Optional[Dict[str, Any]] = None,
-    ) -> List[model_manifest_schema.ModelFunctionInfo]:
+    ) -> model_meta_schema.ModelMetadataDict:
         raw_model_spec_res = self._model_client.show_versions(
             database_name=database_name,
             schema_name=schema_name,
@@ -573,6 +572,43 @@ class ModelOperator:
         )[0][self._model_client.MODEL_VERSION_MODEL_SPEC_COL_NAME]
         model_spec_dict = yaml.safe_load(raw_model_spec_res)
         model_spec = model_meta.ModelMetadata._validate_model_metadata(model_spec_dict)
+        return model_spec
+
+    def get_model_objective(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> type_hints.ModelObjective:
+        model_spec = self._fetch_model_spec(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+            statement_params=statement_params,
+        )
+        model_objective_val = model_spec.get("model_objective", type_hints.ModelObjective.UNKNOWN.value)
+        return type_hints.ModelObjective(model_objective_val)
+
+    def get_functions(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> List[model_manifest_schema.ModelFunctionInfo]:
+        model_spec = self._fetch_model_spec(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+            statement_params=statement_params,
+        )
         show_functions_res = self._model_version_client.show_functions(
             database_name=database_name,
             schema_name=schema_name,

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

@@ -1,15 +1,45 @@
+import dataclasses
+import hashlib
+import logging
 import pathlib
+import queue
+import sys
 import tempfile
-from typing import Any, Dict, Optional
+import threading
+import time
+import uuid
+from typing import Any, Dict, List, Optional, Tuple, cast
 
+from snowflake import snowpark
 from snowflake.ml._internal import file_utils
 from snowflake.ml._internal.utils import 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
-from snowflake.snowpark import session
+from snowflake.snowpark import exceptions, row, session
 from snowflake.snowpark._internal import utils as snowpark_utils
 
 
+def get_logger(logger_name: str) -> logging.Logger:
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(logging.INFO)
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(logging.INFO)
+    handler.setFormatter(logging.Formatter("%(name)s [%(asctime)s] [%(levelname)s] %(message)s"))
+    logger.addHandler(handler)
+    return logger
+
+
+logger = get_logger(__name__)
+logger.propagate = False
+
+
+@dataclasses.dataclass
+class ServiceLogInfo:
+    service_name: str
+    container_name: str
+    instance_id: str = "0"
+
+
 class ServiceOperator:
     """Service operator for container services logic."""
 
@@ -62,11 +92,10 @@ class ServiceOperator:
         image_repo_database_name: Optional[sql_identifier.SqlIdentifier],
         image_repo_schema_name: Optional[sql_identifier.SqlIdentifier],
         image_repo_name: sql_identifier.SqlIdentifier,
-        image_name: Optional[sql_identifier.SqlIdentifier],
         ingress_enabled: bool,
-        min_instances: int,
         max_instances: int,
         gpu_requests: Optional[str],
+        num_workers: Optional[int],
         force_rebuild: bool,
         build_external_access_integration: sql_identifier.SqlIdentifier,
         statement_params: Optional[Dict[str, Any]] = None,
@@ -96,11 +125,10 @@ class ServiceOperator:
             image_repo_database_name=image_repo_database_name,
             image_repo_schema_name=image_repo_schema_name,
             image_repo_name=image_repo_name,
-            image_name=image_name,
             ingress_enabled=ingress_enabled,
-            min_instances=min_instances,
             max_instances=max_instances,
             gpu=gpu_requests,
+            num_workers=num_workers,
             force_rebuild=force_rebuild,
             external_access_integration=build_external_access_integration,
         )
@@ -111,11 +139,174 @@ class ServiceOperator:
             statement_params=statement_params,
         )
 
+        # check if the inference service is already running
+        try:
+            model_inference_service_status, _ = self._service_client.get_service_status(
+                service_name=service_name,
+                include_message=False,
+                statement_params=statement_params,
+            )
+            model_inference_service_exists = model_inference_service_status == service_sql.ServiceStatus.READY
+        except exceptions.SnowparkSQLException:
+            model_inference_service_exists = False
+
         # deploy the model service
-        self._service_client.deploy_model(
+        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,
             statement_params=statement_params,
         )
 
+        # stream service logs in a thread
+        services = [
+            ServiceLogInfo(service_name=self._get_model_build_service_name(query_id), container_name="model-build"),
+            ServiceLogInfo(service_name=service_name, container_name="model-inference"),
+        ]
+        exception_queue: queue.Queue = queue.Queue()  # type: ignore[type-arg]
+        log_thread = self._start_service_log_streaming(
+            async_job, services, model_inference_service_exists, exception_queue, statement_params
+        )
+        log_thread.join()
+
+        try:
+            # non-blocking check for an exception
+            exception = exception_queue.get(block=False)
+            if exception:
+                raise exception
+        except queue.Empty:
+            pass
+
         return service_name
+
+    def _start_service_log_streaming(
+        self,
+        async_job: snowpark.AsyncJob,
+        services: List[ServiceLogInfo],
+        model_inference_service_exists: bool,
+        exception_queue: queue.Queue,  # type: ignore[type-arg]
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> threading.Thread:
+        """Start the service log streaming in a separate thread."""
+        log_thread = threading.Thread(
+            target=self._stream_service_logs,
+            args=(async_job, services, model_inference_service_exists, exception_queue, statement_params),
+        )
+        log_thread.start()
+        return log_thread
+
+    def _stream_service_logs(
+        self,
+        async_job: snowpark.AsyncJob,
+        services: List[ServiceLogInfo],
+        model_inference_service_exists: bool,
+        exception_queue: queue.Queue,  # type: ignore[type-arg]
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Stream service logs while the async job is running."""
+
+        def fetch_logs(service_name: str, container_name: str, offset: int) -> Tuple[str, int]:
+            service_logs = self._service_client.get_service_logs(
+                service_name=service_name,
+                container_name=container_name,
+                statement_params=statement_params,
+            )
+
+            # return only new logs starting after the offset
+            if len(service_logs) > offset:
+                new_logs = service_logs[offset:]
+                new_offset = len(service_logs)
+            else:
+                new_logs = ""
+                new_offset = offset
+
+            return new_logs, new_offset
+
+        is_model_build_service_done = False
+        log_offset = 0
+        model_build_service, model_inference_service = services[0], services[1]
+        service_name, container_name = model_build_service.service_name, model_build_service.container_name
+        # BuildJobName
+        service_logger = get_logger(service_name)
+        service_logger.propagate = False
+        while not async_job.is_done():
+            if model_inference_service_exists:
+                time.sleep(5)
+                continue
+
+            try:
+                block_size = 180
+                service_status, message = self._service_client.get_service_status(
+                    service_name=service_name, include_message=True, statement_params=statement_params
+                )
+                logger.info(f"Inference service {service_name} is {service_status.value}.")
+
+                new_logs, new_offset = fetch_logs(service_name, container_name, log_offset)
+                if new_logs:
+                    service_logger.info(new_logs)
+                    log_offset = new_offset
+
+                # check if model build service is done
+                if not is_model_build_service_done:
+                    service_status, _ = self._service_client.get_service_status(
+                        service_name=model_build_service.service_name,
+                        include_message=False,
+                        statement_params=statement_params,
+                    )
+
+                    if service_status == service_sql.ServiceStatus.DONE:
+                        is_model_build_service_done = True
+                        log_offset = 0
+                        service_name = model_inference_service.service_name
+                        container_name = model_inference_service.container_name
+                        # InferenceServiceName-InstanceId
+                        service_logger = get_logger(f"{service_name}-{model_inference_service.instance_id}")
+                        service_logger.propagate = False
+                        logger.info(f"Model build service {model_build_service.service_name} complete.")
+                        logger.info("-" * block_size)
+            except ValueError:
+                logger.warning(f"Unknown service status: {service_status.value}")
+            except Exception as ex:
+                logger.warning(f"Caught an exception when logging: {repr(ex)}")
+
+            time.sleep(5)
+
+        if model_inference_service_exists:
+            logger.info(f"Inference service {model_inference_service.service_name} is already RUNNING.")
+        else:
+            self._finalize_logs(service_logger, services[-1], log_offset, statement_params)
+
+        # catch exceptions from the deploy model execution
+        try:
+            res = cast(List[row.Row], async_job.result())
+            logger.info(f"Model deployment for inference service {model_inference_service.service_name} complete.")
+            logger.info(res[0][0])
+        except Exception as ex:
+            exception_queue.put(ex)
+
+    def _finalize_logs(
+        self,
+        service_logger: logging.Logger,
+        service: ServiceLogInfo,
+        offset: int,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Fetch service logs after the async job is done to ensure no logs are missed."""
+        try:
+            service_logs = self._service_client.get_service_logs(
+                service_name=service.service_name,
+                container_name=service.container_name,
+                statement_params=statement_params,
+            )
+
+            if len(service_logs) > offset:
+                service_logger.info(service_logs[offset:])
+        except Exception as ex:
+            logger.warning(f"Caught an exception when logging: {repr(ex)}")
+
+    @staticmethod
+    def _get_model_build_service_name(query_id: str) -> str:
+        """Get the model build service name through the server-side logic."""
+        most_significant_bits = uuid.UUID(query_id).int >> 64
+        md5_hash = hashlib.md5(str(most_significant_bits).encode()).hexdigest()
+        identifier = md5_hash[:6]
+        return ("model_build_" + identifier).upper()

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

@@ -34,11 +34,10 @@ class ModelDeploymentSpec:
         image_repo_database_name: Optional[sql_identifier.SqlIdentifier],
         image_repo_schema_name: Optional[sql_identifier.SqlIdentifier],
         image_repo_name: sql_identifier.SqlIdentifier,
-        image_name: Optional[sql_identifier.SqlIdentifier],
         ingress_enabled: bool,
-        min_instances: int,
         max_instances: int,
         gpu: Optional[str],
+        num_workers: Optional[int],
         force_rebuild: bool,
         external_access_integration: sql_identifier.SqlIdentifier,
     ) -> None:
@@ -61,8 +60,6 @@ class ModelDeploymentSpec:
             force_rebuild=force_rebuild,
             external_access_integrations=[external_access_integration.identifier()],
         )
-        if image_name:
-            image_build_dict["image_name"] = image_name.identifier()
 
         # service spec
         saved_service_database = service_database_name or database_name
@@ -74,12 +71,14 @@ class ModelDeploymentSpec:
             name=fq_service_name,
             compute_pool=service_compute_pool_name.identifier(),
             ingress_enabled=ingress_enabled,
-            min_instances=min_instances,
             max_instances=max_instances,
         )
         if gpu:
             service_dict["gpu"] = gpu
 
+        if num_workers:
+            service_dict["num_workers"] = num_workers
+
         # model deployment spec
         model_deployment_spec_dict = model_deployment_spec_schema.ModelDeploymentSpecDict(
             models=[model_dict],

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

@@ -11,7 +11,6 @@ class ModelDict(TypedDict):
 class ImageBuildDict(TypedDict):
     compute_pool: Required[str]
     image_repo: Required[str]
-    image_name: NotRequired[str]
     force_rebuild: Required[bool]
     external_access_integrations: Required[List[str]]
 
@@ -20,9 +19,9 @@ class ServiceDict(TypedDict):
     name: Required[str]
     compute_pool: Required[str]
     ingress_enabled: Required[bool]
-    min_instances: Required[int]
     max_instances: Required[int]
     gpu: NotRequired[str]
+    num_workers: NotRequired[int]
 
 
 class ModelDeploymentSpecDict(TypedDict):