snowflake-ml-python 1.20.0__py3-none-any.whl → 1.22.0__py3-none-any.whl

snowflake/ml/model/models/huggingface_pipeline.py

@@ -1,25 +1,19 @@
 import logging
-import warnings
 from typing import Any, Optional, Union
 
-from packaging import version
-
 from snowflake import snowpark
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.human_readable_id import hrid_generator
 from snowflake.ml._internal.utils import sql_identifier
 from snowflake.ml.model._client.model import inference_engine_utils
 from snowflake.ml.model._client.ops import service_ops
+from snowflake.ml.model.models import huggingface
 from snowflake.snowpark import async_job, session
 
 logger = logging.getLogger(__name__)
 
 
-_TELEMETRY_PROJECT = "MLOps"
-_TELEMETRY_SUBPROJECT = "ModelManagement"
-
-
-class HuggingFacePipelineModel:
+class HuggingFacePipelineModel(huggingface.TransformersPipeline):
     def __init__(
         self,
         task: Optional[str] = None,
@@ -65,208 +59,25 @@ class HuggingFacePipelineModel:
 
         Return:
             A wrapper over transformers [`Pipeline`].
-
-        Raises:
-            RuntimeError: Raised when the input argument cannot determine the pipeline.
-            ValueError: Raised when the pipeline contains remote code but trust_remote_code is not set or False.
-            ValueError: Raised when having conflicting arguments.
         """
-        import transformers
-
-        config = kwargs.get("config", None)
-        tokenizer = kwargs.get("tokenizer", None)
-        framework = kwargs.get("framework", None)
-        feature_extractor = kwargs.get("feature_extractor", None)
-
-        _can_download_snapshot = False
-        if download_snapshot:
-            try:
-                import huggingface_hub as hf_hub
-
-                _can_download_snapshot = True
-            except ImportError:
-                pass
-
-        # ==== Start pipeline logic from transformers ====
-        if model_kwargs is None:
-            model_kwargs = {}
-
-        use_auth_token = model_kwargs.pop("use_auth_token", None)
-        if use_auth_token is not None:
-            warnings.warn(
-                "The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers.",
-                FutureWarning,
-                stacklevel=2,
-            )
-            if token is not None:
-                raise ValueError(
-                    "`token` and `use_auth_token` are both specified. Please set only the argument `token`."
-                )
-            token = use_auth_token
-
-        hub_kwargs = {
-            "revision": revision,
-            "token": token,
-            "trust_remote_code": trust_remote_code,
-            "_commit_hash": None,
-        }
-
-        # Backward compatibility since HF interface change.
-        if version.parse(transformers.__version__) < version.parse("4.32.0"):
-            # Backward compatibility since HF interface change.
-            hub_kwargs["use_auth_token"] = hub_kwargs["token"]
-            del hub_kwargs["token"]
-
-        if task is None and model is None:
-            raise RuntimeError(
-                "Impossible to instantiate a pipeline without either a task or a model being specified. "
-            )
-
-        if model is None and tokenizer is not None:
-            raise RuntimeError(
-                "Impossible to instantiate a pipeline with tokenizer specified but not the model as the provided"
-                " tokenizer may not be compatible with the default model. Please provide an identifier to a pretrained"
-                " model when providing tokenizer."
-            )
-        if model is None and feature_extractor is not None:
-            raise RuntimeError(
-                "Impossible to instantiate a pipeline with feature_extractor specified but not the model as the "
-                "provided feature_extractor may not be compatible with the default model. Please provide an identifier"
-                " to a pretrained model when providing feature_extractor."
-            )
-
-        # ==== End pipeline logic from transformers ====
-
-        # We only support string as model argument.
-
-        if model is not None and not isinstance(model, str):
-            raise RuntimeError(
-                "Impossible to use non-string model as input for HuggingFacePipelineModel. Use transformers.Pipeline"
-                " object if required."
-            )
-
-        # ==== Start pipeline logic (Config) from transformers ====
-
-        # Config is the primordial information item.
-        # Instantiate config if needed
-        config_obj = None
-
-        if not _can_download_snapshot:
-            if isinstance(config, str):
-                config_obj = transformers.AutoConfig.from_pretrained(
-                    config, _from_pipeline=task, **hub_kwargs, **model_kwargs
-                )
-                hub_kwargs["_commit_hash"] = config_obj._commit_hash
-            elif config is None and isinstance(model, str):
-                config_obj = transformers.AutoConfig.from_pretrained(
-                    model, _from_pipeline=task, **hub_kwargs, **model_kwargs
-                )
-                hub_kwargs["_commit_hash"] = config_obj._commit_hash
-            # We only support string as config argument.
-            elif config is not None and not isinstance(config, str):
-                raise RuntimeError(
-                    "Impossible to use non-string config as input for HuggingFacePipelineModel. "
-                    "Use transformers.Pipeline object if required."
-                )
-
-        # ==== Start pipeline logic (Task) from transformers ====
-
-        custom_tasks = {}
-        if config_obj is not None and len(getattr(config_obj, "custom_pipelines", {})) > 0:
-            custom_tasks = config_obj.custom_pipelines
-            if task is None and trust_remote_code is not False:
-                if len(custom_tasks) == 1:
-                    task = list(custom_tasks.keys())[0]
-                else:
-                    raise RuntimeError(
-                        "We can't infer the task automatically for this model as there are multiple tasks available. "
-                        f"Pick one in {', '.join(custom_tasks.keys())}"
-                    )
-
-        if task is None and model is not None:
-            task = transformers.pipelines.get_task(model, token)
-
-        # Retrieve the task
-        if task in custom_tasks:
-            normalized_task = task
-            targeted_task, task_options = transformers.pipelines.clean_custom_task(custom_tasks[task])
-            if not trust_remote_code:
-                raise ValueError(
-                    "Loading this pipeline requires you to execute the code in the pipeline file in that"
-                    " repo on your local machine. Make sure you have read the code there to avoid malicious use, then"
-                    " set the option `trust_remote_code=True` to remove this error."
-                )
-        else:
-            (
-                normalized_task,
-                targeted_task,
-                task_options,
-            ) = transformers.pipelines.check_task(task)
-
-        # ==== Start pipeline logic (Model) from transformers ====
-
-        # Use default model/config/tokenizer for the task if no model is provided
-        if model is None:
-            # At that point framework might still be undetermined
-            (
-                model,
-                default_revision,
-            ) = transformers.pipelines.get_default_model_and_revision(targeted_task, framework, task_options)
-            revision = revision if revision is not None else default_revision
-            warnings.warn(
-                f"No model was supplied, defaulted to {model} and revision"
-                f" {revision} ({transformers.pipelines.HUGGINGFACE_CO_RESOLVE_ENDPOINT}/{model}).\n"
-                "Using a pipeline without specifying a model name and revision in production is not recommended.",
-                stacklevel=2,
-            )
-            if not _can_download_snapshot and config is None and isinstance(model, str):
-                config_obj = transformers.AutoConfig.from_pretrained(
-                    model, _from_pipeline=task, **hub_kwargs, **model_kwargs
-                )
-                hub_kwargs["_commit_hash"] = config_obj._commit_hash
-
-        if kwargs.get("device_map", None) is not None:
-            if "device_map" in model_kwargs:
-                raise ValueError(
-                    'You cannot use both `pipeline(... device_map=..., model_kwargs={"device_map":...})` as those'
-                    " arguments might conflict, use only one.)"
-                )
-            if kwargs.get("device", None) is not None:
-                warnings.warn(
-                    "Both `device` and `device_map` are specified. `device` will override `device_map`. You"
-                    " will most likely encounter unexpected behavior. Please remove `device` and keep `device_map`.",
-                    stacklevel=2,
-                )
-
-        repo_snapshot_dir: Optional[str] = None
-        if _can_download_snapshot:
-            try:
-
-                repo_snapshot_dir = hf_hub.snapshot_download(
-                    repo_id=model,
-                    revision=revision,
-                    token=token,
-                    allow_patterns=allow_patterns,
-                    ignore_patterns=ignore_patterns,
-                )
-            except ImportError:
-                logger.info("huggingface_hub package is not installed, skipping snapshot download")
-
-        # ==== End pipeline logic from transformers ====
-
-        self.task = normalized_task
-        self.model = model
-        self.revision = revision
+        logger.warning("HuggingFacePipelineModel is deprecated. Please use TransformersPipeline instead.")
+        super().__init__(
+            task=task,
+            model=model,
+            revision=revision,
+            token_or_secret=token,
+            trust_remote_code=trust_remote_code,
+            model_kwargs=model_kwargs,
+            compute_pool_for_log=None,
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+            **kwargs,
+        )
         self.token = token
-        self.trust_remote_code = trust_remote_code
-        self.model_kwargs = model_kwargs
-        self.tokenizer = tokenizer
-        self.repo_snapshot_dir = repo_snapshot_dir
-        self.__dict__.update(kwargs)
 
     @telemetry.send_api_usage_telemetry(
-        project=_TELEMETRY_PROJECT,
-        subproject=_TELEMETRY_SUBPROJECT,
+        project=huggingface._TELEMETRY_PROJECT,
+        subproject=huggingface._TELEMETRY_SUBPROJECT,
         func_params_to_log=[
             "service_name",
             "image_build_compute_pool",
@@ -345,8 +156,8 @@ class HuggingFacePipelineModel:
         .. # noqa: DAR003
         """
         statement_params = telemetry.get_statement_params(
-            project=_TELEMETRY_PROJECT,
-            subproject=_TELEMETRY_SUBPROJECT,
+            project=huggingface._TELEMETRY_PROJECT,
+            subproject=huggingface._TELEMETRY_SUBPROJECT,
         )
 
         database_name_id, schema_name_id, model_name_id = sql_identifier.parse_fully_qualified_name(model_name)

snowflake/ml/model/type_hints.py

@@ -13,6 +13,11 @@ from typing import (
 import numpy.typing as npt
 from typing_extensions import NotRequired
 
+from snowflake.ml.model.code_path import CodePath
+from snowflake.ml.model.compute_pool import (
+    DEFAULT_CPU_COMPUTE_POOL,
+    DEFAULT_GPU_COMPUTE_POOL,
+)
 from snowflake.ml.model.target_platform import TargetPlatform
 from snowflake.ml.model.task import Task
 from snowflake.ml.model.volatility import Volatility
@@ -362,6 +367,7 @@ ModelLoadOption = Union[
 
 
 SupportedTargetPlatformType = Union[TargetPlatform, str]
+CodePathLike = Union[str, CodePath]
 
 
 class ProgressStatus(Protocol):
@@ -380,4 +386,4 @@ class ProgressStatus(Protocol):
         ...
 
 
-__all__ = ["TargetPlatform", "Task"]
+__all__ = ["TargetPlatform", "Task", "DEFAULT_CPU_COMPUTE_POOL", "DEFAULT_GPU_COMPUTE_POOL"]

snowflake/ml/modeling/_internal/snowpark_implementations/distributed_hpo_trainer.py

@@ -365,8 +365,8 @@ class DistributedHPOTrainer(SnowparkModelTrainer):
 
         required_deps = dependencies + [
             "snowflake-snowpark-python<2",
-            "fastparquet<2023.11",
-            "pyarrow<14",
+            "fastparquet<2024.3",
+            "pyarrow<18",
             "cachetools<6",
         ]
 

snowflake/ml/monitoring/_client/model_monitor_sql_client.py

@@ -92,6 +92,9 @@ class ModelMonitorSQLClient:
         baseline: Optional[sql_identifier.SqlIdentifier] = None,
         segment_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
         custom_metric_columns: Optional[list[sql_identifier.SqlIdentifier]] = None,
+        timestamp_custom_metric_database: Optional[sql_identifier.SqlIdentifier] = None,
+        timestamp_custom_metric_schema: Optional[sql_identifier.SqlIdentifier] = None,
+        timestamp_custom_metric_table: Optional[sql_identifier.SqlIdentifier] = None,
         statement_params: Optional[dict[str, Any]] = None,
     ) -> None:
         baseline_sql = ""
@@ -106,6 +109,14 @@ class ModelMonitorSQLClient:
         if custom_metric_columns:
             custom_metric_columns_sql = f"CUSTOM_METRIC_COLUMNS={_build_sql_list_from_columns(custom_metric_columns)}"
 
+        timestamp_custom_metric_table_sql = ""
+        if timestamp_custom_metric_table:
+            timestamp_custom_metric_table_sql = (
+                f"TIMESTAMP_CUSTOM_METRIC_TABLE="
+                f"{self._infer_qualified_schema(timestamp_custom_metric_database, timestamp_custom_metric_schema)}."
+                f"{timestamp_custom_metric_table}"
+            )
+
         query_result_checker.SqlResultValidator(
             self._sql_client._session,
             f"""
@@ -126,6 +137,7 @@ class ModelMonitorSQLClient:
                     AGGREGATION_WINDOW='{aggregation_window}'
                     {segment_columns_sql}
                     {custom_metric_columns_sql}
+                    {timestamp_custom_metric_table_sql}
                     {baseline_sql}""",
             statement_params=statement_params,
         ).has_column("status").has_dimensions(1, 1).validate()

snowflake/ml/monitoring/_manager/model_monitor_manager.py

@@ -100,6 +100,15 @@ class ModelMonitorManager:
             if source_config.baseline
             else (None, None, None)
         )
+        (
+            timestamp_custom_metric_database_name_id,
+            timestamp_custom_metric_schema_name_id,
+            timestamp_custom_metric_table_name_id,
+        ) = (
+            sql_identifier.parse_fully_qualified_name(source_config.timestamp_custom_metric_table)
+            if source_config.timestamp_custom_metric_table
+            else (None, None, None)
+        )
         model_database_name_id, model_schema_name_id, model_name_id = sql_identifier.parse_fully_qualified_name(
             model_monitor_config.model_version.fully_qualified_model_name
         )
@@ -155,6 +164,9 @@ class ModelMonitorManager:
             baseline_database=baseline_database_name_id,
             baseline_schema=baseline_schema_name_id,
             baseline=baseline_name_id,
+            timestamp_custom_metric_database=timestamp_custom_metric_database_name_id,
+            timestamp_custom_metric_schema=timestamp_custom_metric_schema_name_id,
+            timestamp_custom_metric_table=timestamp_custom_metric_table_name_id,
             statement_params=self.statement_params,
         )
         return model_monitor.ModelMonitor._ref(

snowflake/ml/monitoring/entities/model_monitor_config.py

@@ -39,6 +39,11 @@ class ModelMonitorSourceConfig:
     custom_metric_columns: Optional[list[str]] = None
     """List of columns in the source containing custom metrics."""
 
+    timestamp_custom_metric_table: Optional[str] = None
+    """Optional name of a table containing timestamp-based custom metrics.
+    Can be specified unqualified or fully qualified as database.schema.table.
+    """
+
 
 @dataclass
 class ModelMonitorConfig:

snowflake/ml/registry/_manager/model_manager.py

@@ -1,8 +1,10 @@
+import json
 import logging
 from types import ModuleType
 from typing import TYPE_CHECKING, Any, Optional, Union
 
 import pandas as pd
+import yaml
 
 from snowflake.ml._internal import platform_capabilities, telemetry
 from snowflake.ml._internal.exceptions import error_codes, exceptions
@@ -11,8 +13,13 @@ from snowflake.ml._internal.utils import sql_identifier
 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._client.service import (
+    import_model_spec_schema,
+    model_deployment_spec_schema,
+)
 from snowflake.ml.model._model_composer import model_composer
 from snowflake.ml.model._packager.model_meta import model_meta
+from snowflake.ml.model.models import huggingface
 from snowflake.ml.registry._manager import model_parameter_reconciler
 from snowflake.snowpark import exceptions as snowpark_exceptions, session
 from snowflake.snowpark._internal import utils as snowpark_utils
@@ -59,7 +66,7 @@ class ModelManager:
         signatures: Optional[dict[str, model_signature.ModelSignature]] = None,
         sample_input_data: Optional[type_hints.SupportedDataType] = None,
         user_files: Optional[dict[str, list[str]]] = None,
-        code_paths: Optional[list[str]] = None,
+        code_paths: Optional[list[type_hints.CodePathLike]] = None,
         ext_modules: Optional[list[ModuleType]] = None,
         task: type_hints.Task = task.Task.UNKNOWN,
         experiment_info: Optional["ExperimentInfo"] = None,
@@ -170,7 +177,7 @@ class ModelManager:
         signatures: Optional[dict[str, model_signature.ModelSignature]] = None,
         sample_input_data: Optional[type_hints.SupportedDataType] = None,
         user_files: Optional[dict[str, list[str]]] = None,
-        code_paths: Optional[list[str]] = None,
+        code_paths: Optional[list[type_hints.CodePathLike]] = None,
         ext_modules: Optional[list[ModuleType]] = None,
         task: type_hints.Task = task.Task.UNKNOWN,
         experiment_info: Optional["ExperimentInfo"] = None,
@@ -180,6 +187,31 @@ class ModelManager:
         database_name_id, schema_name_id, model_name_id = sql_identifier.parse_fully_qualified_name(model_name)
         version_name_id = sql_identifier.SqlIdentifier(version_name)
 
+        # Check if model is HuggingFace TransformersPipeline with no repo_snapshot_dir
+        # If so, use remote logging via SYSTEM$IMPORT_MODEL
+        if (
+            isinstance(model, huggingface.TransformersPipeline)
+            and model.compute_pool_for_log is not None
+            and (not hasattr(model, "repo_snapshot_dir") or model.repo_snapshot_dir is None)
+        ):
+            logger.info("HuggingFace model has compute_pool_for_log, using remote logging")
+            return self._remote_log_huggingface_model(
+                model=model,
+                model_name=model_name,
+                version_name=version_name,
+                database_name_id=database_name_id,
+                schema_name_id=schema_name_id,
+                model_name_id=model_name_id,
+                version_name_id=version_name_id,
+                comment=comment,
+                conda_dependencies=conda_dependencies,
+                pip_requirements=pip_requirements,
+                target_platforms=target_platforms,
+                options=options,
+                statement_params=statement_params,
+                progress_status=progress_status,
+            )
+
         # TODO(SNOW-2091317): Remove this when the snowpark enables file PUT operation for snowurls
         use_live_commit = (
             not snowpark_utils.is_in_stored_procedure()  # type: ignore[no-untyped-call]
@@ -298,19 +330,11 @@ class ModelManager:
             use_live_commit=use_live_commit,
         )
 
-        mv = model_version_impl.ModelVersion._ref(
-            model_ops=model_ops.ModelOperator(
-                self._model_ops._session,
-                database_name=database_name_id or self._database_name,
-                schema_name=schema_name_id or self._schema_name,
-            ),
-            service_ops=service_ops.ServiceOperator(
-                self._service_ops._session,
-                database_name=database_name_id or self._database_name,
-                schema_name=schema_name_id or self._schema_name,
-            ),
-            model_name=model_name_id,
-            version_name=version_name_id,
+        mv = self._create_model_version_ref(
+            database_name_id=database_name_id,
+            schema_name_id=schema_name_id,
+            model_name_id=model_name_id,
+            version_name_id=version_name_id,
         )
 
         progress_status.update("setting model metadata...")
@@ -333,6 +357,73 @@ class ModelManager:
 
         return mv
 
+    def _remote_log_huggingface_model(
+        self,
+        model: huggingface.TransformersPipeline,
+        model_name: str,
+        version_name: str,
+        database_name_id: Optional[sql_identifier.SqlIdentifier],
+        schema_name_id: Optional[sql_identifier.SqlIdentifier],
+        model_name_id: sql_identifier.SqlIdentifier,
+        version_name_id: sql_identifier.SqlIdentifier,
+        comment: Optional[str],
+        conda_dependencies: Optional[list[str]],
+        pip_requirements: Optional[list[str]],
+        target_platforms: Optional[list[type_hints.SupportedTargetPlatformType]],
+        options: Optional[type_hints.ModelSaveOption],
+        statement_params: Optional[dict[str, Any]],
+        progress_status: type_hints.ProgressStatus,
+    ) -> model_version_impl.ModelVersion:
+        """Log HuggingFace model remotely using SYSTEM$IMPORT_MODEL."""
+        if not isinstance(model, huggingface.TransformersPipeline):
+            raise ValueError(
+                f"Model must be a TransformersPipeline object. The provided model is a {type(model)} object"
+            )
+        progress_status.update("preparing remote model logging...")
+        progress_status.increment()
+
+        # Get compute pool from options or use default
+        compute_pool = model.compute_pool_for_log
+        if compute_pool is None:
+            raise ValueError("compute_pool_for_log is required for remote logging")
+
+        # Construct fully qualified model name
+        db_name = database_name_id.identifier() if database_name_id else self._database_name.identifier()
+        schema_name = schema_name_id.identifier() if schema_name_id else self._schema_name.identifier()
+        fq_model_name = f"{db_name}.{schema_name}.{model_name_id.identifier()}"
+
+        # Build YAML spec for import model
+        yaml_content = self._build_import_model_yaml_spec(
+            model=model,
+            fq_model_name=fq_model_name,
+            version_name=version_name,
+            compute_pool=compute_pool,
+            comment=comment,
+            conda_dependencies=conda_dependencies,
+            pip_requirements=pip_requirements,
+            target_platforms=target_platforms,
+        )
+
+        progress_status.update("Remotely logging the model...")
+        progress_status.increment()
+
+        self._model_ops.run_import_model_query(
+            database_name=db_name,
+            schema_name=schema_name,
+            yaml_content=yaml_content,
+            statement_params=statement_params,
+        )
+        progress_status.update("Remotely logged the model")
+        progress_status.increment()
+
+        # Return ModelVersion object
+        return self._create_model_version_ref(
+            database_name_id=database_name_id,
+            schema_name_id=schema_name_id,
+            model_name_id=model_name_id,
+            version_name_id=version_name_id,
+        )
+
     def get_model(
         self,
         model_name: str,
@@ -408,6 +499,130 @@ class ModelManager:
             statement_params=statement_params,
         )
 
+    def _create_model_version_ref(
+        self,
+        database_name_id: Optional[sql_identifier.SqlIdentifier],
+        schema_name_id: Optional[sql_identifier.SqlIdentifier],
+        model_name_id: sql_identifier.SqlIdentifier,
+        version_name_id: sql_identifier.SqlIdentifier,
+    ) -> model_version_impl.ModelVersion:
+        """Create a ModelVersion reference object.
+
+        Args:
+            database_name_id: Database name identifier, falls back to instance database if None.
+            schema_name_id: Schema name identifier, falls back to instance schema if None.
+            model_name_id: Model name identifier.
+            version_name_id: Version name identifier.
+
+        Returns:
+            ModelVersion reference object.
+        """
+        return model_version_impl.ModelVersion._ref(
+            model_ops=model_ops.ModelOperator(
+                self._model_ops._session,
+                database_name=database_name_id or self._database_name,
+                schema_name=schema_name_id or self._schema_name,
+            ),
+            service_ops=service_ops.ServiceOperator(
+                self._service_ops._session,
+                database_name=database_name_id or self._database_name,
+                schema_name=schema_name_id or self._schema_name,
+            ),
+            model_name=model_name_id,
+            version_name=version_name_id,
+        )
+
+    def _build_import_model_yaml_spec(
+        self,
+        model: huggingface.TransformersPipeline,
+        fq_model_name: str,
+        version_name: str,
+        compute_pool: str,
+        comment: Optional[str],
+        conda_dependencies: Optional[list[str]],
+        pip_requirements: Optional[list[str]],
+        target_platforms: Optional[list[type_hints.SupportedTargetPlatformType]],
+    ) -> str:
+        """Build YAML spec for SYSTEM$IMPORT_MODEL.
+
+        Args:
+            model: HuggingFace TransformersPipeline model.
+            fq_model_name: Fully qualified model name.
+            version_name: Model version name.
+            compute_pool: Compute pool name.
+            comment: Optional comment for the model.
+            conda_dependencies: Optional conda dependencies.
+            pip_requirements: Optional pip requirements.
+            target_platforms: Optional target platforms.
+
+        Returns:
+            YAML string representing the import model spec.
+        """
+        # Convert target_platforms to list of strings
+        target_platforms_list = self._convert_target_platforms_to_list(target_platforms)
+
+        # Build HuggingFaceModel spec
+        hf_model = model_deployment_spec_schema.HuggingFaceModel(
+            hf_model_name=model.model,
+            task=model.task,
+            tokenizer=getattr(model, "tokenizer", None),
+            token_secret_object=model.secret_identifier,
+            trust_remote_code=model.trust_remote_code if model.trust_remote_code is not None else False,
+            revision=model.revision,
+            hf_model_kwargs=json.dumps(model.model_kwargs) if model.model_kwargs else "{}",
+        )
+
+        # Build LogModelArgs
+        log_model_args = model_deployment_spec_schema.LogModelArgs(
+            pip_requirements=pip_requirements,
+            conda_dependencies=conda_dependencies,
+            target_platforms=target_platforms_list,
+            comment=comment,
+        )
+
+        # Build ModelSpec
+        model_spec = import_model_spec_schema.ModelSpec(
+            name=import_model_spec_schema.ModelName(
+                model_name=fq_model_name,
+                version_name=version_name,
+            ),
+            hf_model=hf_model,
+            log_model_args=log_model_args,
+        )
+
+        # Build ImportModelSpec
+        import_spec = import_model_spec_schema.ImportModelSpec(
+            compute_pool=compute_pool,
+            models=[model_spec],
+        )
+
+        # Convert to YAML
+        return yaml.safe_dump(import_spec.model_dump(exclude_none=True))
+
+    def _convert_target_platforms_to_list(
+        self, target_platforms: Optional[list[type_hints.SupportedTargetPlatformType]]
+    ) -> Optional[list[str]]:
+        """Convert target_platforms to list of strings.
+
+        Args:
+            target_platforms: List of target platforms (enums or strings).
+
+        Returns:
+            List of platform strings, or None if input is None.
+        """
+        if not target_platforms:
+            return None
+
+        target_platforms_list = []
+        for tp in target_platforms:
+            if hasattr(tp, "value"):
+                # It's an enum, get the value
+                target_platforms_list.append(tp.value)
+            else:
+                # It's already a string
+                target_platforms_list.append(str(tp))
+        return target_platforms_list
+
     def _parse_fully_qualified_name(
         self, model_name: str
     ) -> tuple[