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

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

@@ -1,3 +1,4 @@
+import json
 import os
 import pathlib
 import tempfile
@@ -6,6 +7,7 @@ from typing import Any, Dict, List, Literal, Optional, Union, cast, overload
 
 import yaml
 
+from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml._internal.utils import formatting, identifier, sql_identifier
 from snowflake.ml.model import model_signature, type_hints
 from snowflake.ml.model._client.ops import metadata_ops
@@ -512,6 +514,71 @@ class ModelOperator:
             statement_params=statement_params,
         )
 
+    def list_inference_services(
+        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[str]:
+        res = self._model_client.show_versions(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+            statement_params=statement_params,
+        )
+        col_name = self._model_client.MODEL_VERSION_INFERENCE_SERVICES_COL_NAME
+        if col_name not in res[0]:
+            # User need to opt into BCR 2024_08
+            raise exceptions.SnowflakeMLException(
+                error_code=error_codes.OPT_IN_REQUIRED,
+                original_exception=RuntimeError(
+                    "Please opt in to BCR Bundle 2024_08 ("
+                    "https://docs.snowflake.com/en/release-notes/bcr-bundles/2024_08_bundle)."
+                ),
+            )
+        json_array = json.loads(res[0][col_name])
+        # TODO(sdas): Figure out a better way to filter out MODEL_BUILD_ services server side.
+        return [str(service) for service in json_array if "MODEL_BUILD_" not in service]
+
+    def delete_service(
+        self,
+        *,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        model_name: sql_identifier.SqlIdentifier,
+        version_name: sql_identifier.SqlIdentifier,
+        service_name: str,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        services = self.list_inference_services(
+            database_name=database_name,
+            schema_name=schema_name,
+            model_name=model_name,
+            version_name=version_name,
+            statement_params=statement_params,
+        )
+        db, schema, service_name = sql_identifier.parse_fully_qualified_name(service_name)
+        fully_qualified_service_name = sql_identifier.get_fully_qualified_name(
+            db, schema, service_name, self._session.get_current_database(), self._session.get_current_schema()
+        )
+
+        for service in services:
+            if service == fully_qualified_service_name:
+                self._service_client.drop_service(
+                    database_name=db,
+                    schema_name=schema,
+                    service_name=service_name,
+                    statement_params=statement_params,
+                )
+                return
+        raise ValueError(
+            f"Service '{service_name}' does not exist or unauthorized or not associated with this model version."
+        )
+
     def get_model_version_manifest(
         self,
         *,
@@ -538,7 +605,8 @@ class ModelOperator:
     def _match_model_spec_with_sql_functions(
         sql_functions_names: List[sql_identifier.SqlIdentifier], target_methods: List[str]
     ) -> Dict[sql_identifier.SqlIdentifier, str]:
-        res = {}
+        res: Dict[sql_identifier.SqlIdentifier, str] = {}
+
         for target_method in target_methods:
             # Here we need to find the SQL function corresponding to the Python function.
             # If the python function name is `abc`, then SQL function name can be `ABC` or `"abc"`.
@@ -554,15 +622,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 +640,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_task(
+        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.Task:
+        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,
+        )
+        task_val = model_spec.get("task", type_hints.Task.UNKNOWN.value)
+        return type_hints.Task(task_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,
@@ -597,6 +701,20 @@ class ModelOperator:
 
             function_names_and_types.append((function_name, function_type))
 
+        if not function_names_and_types:
+            # If function_names_and_types is not populated, there are currently
+            # no warehouse functions for the model version. In order to do inference
+            # we must populate the functions so the mapping can be constructed.
+            model_manifest = self.get_model_version_manifest(
+                database_name=database_name,
+                schema_name=schema_name,
+                model_name=model_name,
+                version_name=version_name,
+                statement_params=statement_params,
+            )
+            for method in model_manifest["methods"]:
+                function_names_and_types.append((sql_identifier.SqlIdentifier(method["name"]), method["type"]))
+
         signatures = model_spec["signatures"]
         function_names = [name for name, _ in function_names_and_types]
         function_name_mapping = ModelOperator._match_model_spec_with_sql_functions(
@@ -763,7 +881,7 @@ class ModelOperator:
 
         if keep_order:
             # if it's a partitioned table function, _ID will be null and we won't be able to sort.
-            if df_res.select("_ID").limit(1).collect()[0][0] is None:
+            if df_res.select(snowpark_handler._KEEP_ORDER_COL_NAME).limit(1).collect()[0][0] is None:
                 warnings.warn(
                     formatting.unwrap(
                         """
@@ -776,7 +894,7 @@ class ModelOperator:
                 )
             else:
                 df_res = df_res.sort(
-                    "_ID",
+                    snowpark_handler._KEEP_ORDER_COL_NAME,
                     ascending=True,
                 )
 

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

@@ -1,14 +1,50 @@
+import dataclasses
+import hashlib
+import logging
 import pathlib
+import re
 import tempfile
-from typing import Any, Dict, Optional
+import threading
+import time
+from typing import Any, Dict, List, Optional, Tuple, cast
 
+from packaging import version
+
+from snowflake import snowpark
 from snowflake.ml._internal import file_utils
-from snowflake.ml._internal.utils import sql_identifier
+from snowflake.ml._internal.utils import service_logger, snowflake_env, 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
 
+module_logger = service_logger.get_logger(__name__, service_logger.LogColor.GREY)
+module_logger.propagate = False
+
+
+@dataclasses.dataclass
+class ServiceLogInfo:
+    database_name: Optional[sql_identifier.SqlIdentifier]
+    schema_name: Optional[sql_identifier.SqlIdentifier]
+    service_name: sql_identifier.SqlIdentifier
+    container_name: str
+    instance_id: str = "0"
+
+    def __post_init__(self) -> None:
+        # service name used in logs for display
+        self.display_service_name = sql_identifier.get_fully_qualified_name(
+            self.database_name, self.schema_name, self.service_name
+        )
+
+
+@dataclasses.dataclass
+class ServiceLogMetadata:
+    service_logger: logging.Logger
+    service: ServiceLogInfo
+    service_status: Optional[service_sql.ServiceStatus]
+    is_model_build_service_done: bool
+    log_offset: int
+
 
 class ServiceOperator:
     """Service operator for container services logic."""
@@ -62,11 +98,11 @@ 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],
+        max_batch_rows: Optional[int],
         force_rebuild: bool,
         build_external_access_integration: sql_identifier.SqlIdentifier,
         statement_params: Optional[Dict[str, Any]] = None,
@@ -96,11 +132,11 @@ 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,
+            max_batch_rows=max_batch_rows,
             force_rebuild=force_rebuild,
             external_access_integration=build_external_access_integration,
         )
@@ -111,11 +147,275 @@ class ServiceOperator:
             statement_params=statement_params,
         )
 
+        # check if the inference service is already running
+        model_inference_service_exists = self._check_if_service_exists(
+            database_name=service_database_name,
+            schema_name=service_schema_name,
+            service_name=service_name,
+            service_status_list_if_exists=[service_sql.ServiceStatus.READY],
+            statement_params=statement_params,
+        )
+
         # 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,
         )
 
-        return service_name
+        # TODO(hayu): Remove the version check after Snowflake 8.37.0 release
+        if snowflake_env.get_current_snowflake_version(
+            self._session, statement_params=statement_params
+        ) >= version.parse("8.37.0"):
+            # stream service logs in a thread
+            model_build_service_name = sql_identifier.SqlIdentifier(self._get_model_build_service_name(query_id))
+            model_build_service = ServiceLogInfo(
+                database_name=service_database_name,
+                schema_name=service_schema_name,
+                service_name=model_build_service_name,
+                container_name="model-build",
+            )
+            model_inference_service = ServiceLogInfo(
+                database_name=service_database_name,
+                schema_name=service_schema_name,
+                service_name=service_name,
+                container_name="model-inference",
+            )
+            services = [model_build_service, model_inference_service]
+            log_thread = self._start_service_log_streaming(
+                async_job, services, model_inference_service_exists, force_rebuild, statement_params
+            )
+            log_thread.join()
+        else:
+            while not async_job.is_done():
+                time.sleep(5)
+
+        res = cast(str, cast(List[row.Row], async_job.result())[0][0])
+        module_logger.info(f"Inference service {service_name} deployment complete: {res}")
+        return res
+
+    def _start_service_log_streaming(
+        self,
+        async_job: snowpark.AsyncJob,
+        services: List[ServiceLogInfo],
+        model_inference_service_exists: bool,
+        force_rebuild: bool,
+        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,
+                force_rebuild,
+                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,
+        force_rebuild: bool,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Stream service logs while the async job is running."""
+
+        def fetch_logs(service: ServiceLogInfo, offset: int) -> Tuple[str, int]:
+            service_logs = self._service_client.get_service_logs(
+                database_name=service.database_name,
+                schema_name=service.schema_name,
+                service_name=service.service_name,
+                container_name=service.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
+
+        def set_service_log_metadata_to_model_inference(
+            meta: ServiceLogMetadata, inference_service: ServiceLogInfo, msg: str
+        ) -> None:
+            model_inference_service_logger = service_logger.get_logger(  # InferenceServiceName-InstanceId
+                f"{inference_service.display_service_name}-{inference_service.instance_id}",
+                service_logger.LogColor.BLUE,
+            )
+            model_inference_service_logger.propagate = False
+            meta.service_logger = model_inference_service_logger
+            meta.service = inference_service
+            meta.service_status = None
+            meta.is_model_build_service_done = True
+            meta.log_offset = 0
+            block_size = 180
+            module_logger.info(msg)
+            module_logger.info("-" * block_size)
+
+        model_build_service, model_inference_service = services[0], services[1]
+        model_build_service_logger = service_logger.get_logger(  # BuildJobName
+            model_build_service.display_service_name, service_logger.LogColor.GREEN
+        )
+        model_build_service_logger.propagate = False
+        service_log_meta = ServiceLogMetadata(
+            service_logger=model_build_service_logger,
+            service=model_build_service,
+            service_status=None,
+            is_model_build_service_done=False,
+            log_offset=0,
+        )
+        while not async_job.is_done():
+            if model_inference_service_exists:
+                time.sleep(5)
+                continue
+
+            try:
+                # check if using an existing model build image
+                if not force_rebuild and not service_log_meta.is_model_build_service_done:
+                    model_build_service_exists = self._check_if_service_exists(
+                        database_name=model_build_service.database_name,
+                        schema_name=model_build_service.schema_name,
+                        service_name=model_build_service.service_name,
+                        statement_params=statement_params,
+                    )
+                    new_model_inference_service_exists = self._check_if_service_exists(
+                        database_name=model_inference_service.database_name,
+                        schema_name=model_inference_service.schema_name,
+                        service_name=model_inference_service.service_name,
+                        statement_params=statement_params,
+                    )
+                    if not model_build_service_exists and new_model_inference_service_exists:
+                        set_service_log_metadata_to_model_inference(
+                            service_log_meta,
+                            model_inference_service,
+                            "Model Inference image build is not rebuilding the image and using previously built image.",
+                        )
+                        continue
+
+                service_status, message = self._service_client.get_service_status(
+                    database_name=service_log_meta.service.database_name,
+                    schema_name=service_log_meta.service.schema_name,
+                    service_name=service_log_meta.service.service_name,
+                    include_message=True,
+                    statement_params=statement_params,
+                )
+                if (service_status != service_sql.ServiceStatus.READY) or (
+                    service_status != service_log_meta.service_status
+                ):
+                    service_log_meta.service_status = service_status
+                    module_logger.info(
+                        f"{'Inference' if service_log_meta.is_model_build_service_done else 'Image build'} service "
+                        f"{service_log_meta.service.display_service_name} is "
+                        f"{service_log_meta.service_status.value}."
+                    )
+                    module_logger.info(f"Service message: {message}")
+
+                new_logs, new_offset = fetch_logs(
+                    service_log_meta.service,
+                    service_log_meta.log_offset,
+                )
+                if new_logs:
+                    service_log_meta.service_logger.info(new_logs)
+                    service_log_meta.log_offset = new_offset
+
+                # check if model build service is done
+                if not service_log_meta.is_model_build_service_done:
+                    service_status, _ = self._service_client.get_service_status(
+                        database_name=model_build_service.database_name,
+                        schema_name=model_build_service.schema_name,
+                        service_name=model_build_service.service_name,
+                        include_message=False,
+                        statement_params=statement_params,
+                    )
+
+                    if service_status == service_sql.ServiceStatus.DONE:
+                        set_service_log_metadata_to_model_inference(
+                            service_log_meta,
+                            model_inference_service,
+                            f"Image build service {model_build_service.display_service_name} complete.",
+                        )
+            except Exception as ex:
+                pattern = r"002003 \(02000\)"  # error code: service does not exist
+                is_snowpark_sql_exception = isinstance(ex, exceptions.SnowparkSQLException)
+                contains_msg = any(msg in str(ex) for msg in ["Pending scheduling", "Waiting to start"])
+                matches_pattern = service_log_meta.service_status is None and re.search(pattern, str(ex)) is not None
+                if not (is_snowpark_sql_exception and (contains_msg or matches_pattern)):
+                    module_logger.warning(f"Caught an exception when logging: {repr(ex)}")
+
+            time.sleep(5)
+
+        if model_inference_service_exists:
+            module_logger.info(f"Inference service {model_inference_service.display_service_name} is already RUNNING.")
+        else:
+            self._finalize_logs(
+                service_log_meta.service_logger, service_log_meta.service, service_log_meta.log_offset, statement_params
+            )
+
+    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:
+            time.sleep(5)  # wait for complete service logs
+            service_logs = self._service_client.get_service_logs(
+                database_name=service.database_name,
+                schema_name=service.schema_name,
+                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:
+            module_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."""
+        uuid = query_id.replace("-", "")
+        big_int = int(uuid, 16)
+        md5_hash = hashlib.md5(str(big_int).encode()).hexdigest()
+        identifier = md5_hash[:8]
+        return ("model_build_" + identifier).upper()
+
+    def _check_if_service_exists(
+        self,
+        database_name: Optional[sql_identifier.SqlIdentifier],
+        schema_name: Optional[sql_identifier.SqlIdentifier],
+        service_name: sql_identifier.SqlIdentifier,
+        service_status_list_if_exists: Optional[List[service_sql.ServiceStatus]] = None,
+        statement_params: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        if service_status_list_if_exists is None:
+            service_status_list_if_exists = [
+                service_sql.ServiceStatus.PENDING,
+                service_sql.ServiceStatus.READY,
+                service_sql.ServiceStatus.DONE,
+                service_sql.ServiceStatus.FAILED,
+            ]
+        try:
+            service_status, _ = self._service_client.get_service_status(
+                database_name=database_name,
+                schema_name=schema_name,
+                service_name=service_name,
+                include_message=False,
+                statement_params=statement_params,
+            )
+            return any(service_status == status for status in service_status_list_if_exists)
+        except exceptions.SnowparkSQLException:
+            return False

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

@@ -34,11 +34,11 @@ 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],
+        max_batch_rows: Optional[int],
         force_rebuild: bool,
         external_access_integration: sql_identifier.SqlIdentifier,
     ) -> None:
@@ -61,8 +61,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 +72,17 @@ 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
+
+        if max_batch_rows:
+            service_dict["max_batch_rows"] = max_batch_rows
+
         # 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,10 @@ 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]
+    max_batch_rows: NotRequired[int]
 
 
 class ModelDeploymentSpecDict(TypedDict):

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

@@ -2,6 +2,7 @@ from typing import Optional
 
 from snowflake.ml._internal.utils import identifier, sql_identifier
 from snowflake.snowpark import session
+from snowflake.snowpark._internal import utils as snowpark_utils
 
 
 class _BaseSQLClient:
@@ -32,3 +33,7 @@ class _BaseSQLClient:
         return identifier.get_schema_level_object_identifier(
             actual_database_name.identifier(), actual_schema_name.identifier(), object_name.identifier()
         )
+
+    @staticmethod
+    def get_tmp_name_with_prefix(prefix: str) -> str:
+        return f"{prefix}_{snowpark_utils.generate_random_alphanumeric().upper()}"

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

@@ -15,6 +15,7 @@ class ModelSQLClient(_base._BaseSQLClient):
     MODEL_VERSION_METADATA_COL_NAME = "metadata"
     MODEL_VERSION_MODEL_SPEC_COL_NAME = "model_spec"
     MODEL_VERSION_ALIASES_COL_NAME = "aliases"
+    MODEL_VERSION_INFERENCE_SERVICES_COL_NAME = "inference_services"
 
     def show_models(
         self,

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

@@ -298,7 +298,9 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
     ) -> dataframe.DataFrame:
         with_statements = []
         if len(input_df.queries["queries"]) == 1 and len(input_df.queries["post_actions"]) == 0:
-            INTERMEDIATE_TABLE_NAME = "SNOWPARK_ML_MODEL_INFERENCE_INPUT"
+            INTERMEDIATE_TABLE_NAME = ModelVersionSQLClient.get_tmp_name_with_prefix(
+                "SNOWPARK_ML_MODEL_INFERENCE_INPUT"
+            )
             with_statements.append(f"{INTERMEDIATE_TABLE_NAME} AS ({input_df.queries['queries'][0]})")
         else:
             actual_database_name = database_name or self._database_name
@@ -316,9 +318,9 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
                 statement_params=statement_params,
             )
 
-        INTERMEDIATE_OBJ_NAME = "TMP_RESULT"
+        INTERMEDIATE_OBJ_NAME = ModelVersionSQLClient.get_tmp_name_with_prefix("TMP_RESULT")
 
-        module_version_alias = "MODEL_VERSION_ALIAS"
+        module_version_alias = ModelVersionSQLClient.get_tmp_name_with_prefix("MODEL_VERSION_ALIAS")
         with_statements.append(
             f"{module_version_alias} AS "
             f"MODEL {self.fully_qualified_object_name(database_name, schema_name, model_name)}"
@@ -375,7 +377,9 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
     ) -> dataframe.DataFrame:
         with_statements = []
         if len(input_df.queries["queries"]) == 1 and len(input_df.queries["post_actions"]) == 0:
-            INTERMEDIATE_TABLE_NAME = "SNOWPARK_ML_MODEL_INFERENCE_INPUT"
+            INTERMEDIATE_TABLE_NAME = (
+                f"SNOWPARK_ML_MODEL_INFERENCE_INPUT_{snowpark_utils.generate_random_alphanumeric().upper()}"
+            )
             with_statements.append(f"{INTERMEDIATE_TABLE_NAME} AS ({input_df.queries['queries'][0]})")
         else:
             actual_database_name = database_name or self._database_name
@@ -393,7 +397,7 @@ class ModelVersionSQLClient(_base._BaseSQLClient):
                 statement_params=statement_params,
             )
 
-        module_version_alias = "MODEL_VERSION_ALIAS"
+        module_version_alias = f"MODEL_VERSION_ALIAS_{snowpark_utils.generate_random_alphanumeric().upper()}"
         with_statements.append(
             f"{module_version_alias} AS "
             f"MODEL {self.fully_qualified_object_name(database_name, schema_name, model_name)}"