snowflake-ml-python 1.21.0__py3-none-any.whl → 1.23.0__py3-none-any.whl

snowflake/ml/model/model_signature.py

@@ -34,6 +34,9 @@ DataType = core.DataType
 BaseFeatureSpec = core.BaseFeatureSpec
 FeatureSpec = core.FeatureSpec
 FeatureGroupSpec = core.FeatureGroupSpec
+BaseParamSpec = core.BaseParamSpec
+ParamSpec = core.ParamSpec
+ParamGroupSpec = core.ParamGroupSpec
 ModelSignature = core.ModelSignature
 
 
@@ -711,6 +714,7 @@ def infer_signature(
     output_feature_names: Optional[list[str]] = None,
     input_data_limit: Optional[int] = 100,
     output_data_limit: Optional[int] = 100,
+    params: Optional[Sequence[core.BaseParamSpec]] = None,
 ) -> core.ModelSignature:
     """
     Infer model signature from given input and output sample data.
@@ -740,12 +744,20 @@ def infer_signature(
         output_data_limit: Limit the number of rows to be used in signature inference in the output data. Defaults to
             100. If None, all rows are used. If the number of rows in the output data is less than the limit, all rows
             are used.
+        params: Optional sequence of parameter specifications to include in the signature. Parameters define
+            optional configuration values that can be passed to model inference. Defaults to None.
+
+    Raises:
+        SnowflakeMLException: ValueError: Raised when input data contains columns matching parameter names.
 
     Returns:
         A model signature inferred from the given input and output sample data.
+
+    # noqa: DAR402
     """
     inputs = _infer_signature(_truncate_data(input_data, input_data_limit), role="input")
     inputs = utils.rename_features(inputs, input_feature_names)
+
     outputs = _infer_signature(_truncate_data(output_data, output_data_limit), role="output")
     outputs = utils.rename_features(outputs, output_feature_names)
-    return core.ModelSignature(inputs, outputs)
+    return core.ModelSignature(inputs, outputs, params=params)

snowflake/ml/model/openai_signatures.py

@@ -1,6 +1,94 @@
 from snowflake.ml.model._signatures import core
 
 _OPENAI_CHAT_SIGNATURE_SPEC = core.ModelSignature(
+    inputs=[
+        core.FeatureGroupSpec(
+            name="messages",
+            specs=[
+                core.FeatureGroupSpec(
+                    name="content",
+                    specs=[
+                        core.FeatureSpec(name="type", dtype=core.DataType.STRING),
+                        # Text prompts
+                        core.FeatureSpec(name="text", dtype=core.DataType.STRING),
+                        # Image URL prompts
+                        core.FeatureGroupSpec(
+                            name="image_url",
+                            specs=[
+                                # Base64 encoded image URL or image URL
+                                core.FeatureSpec(name="url", dtype=core.DataType.STRING),
+                                # Image detail level (e.g., "low", "high", "auto")
+                                core.FeatureSpec(name="detail", dtype=core.DataType.STRING),
+                            ],
+                        ),
+                        # Video URL prompts
+                        core.FeatureGroupSpec(
+                            name="video_url",
+                            specs=[
+                                # Base64 encoded video URL
+                                core.FeatureSpec(name="url", dtype=core.DataType.STRING),
+                            ],
+                        ),
+                        # Audio prompts
+                        core.FeatureGroupSpec(
+                            name="input_audio",
+                            specs=[
+                                core.FeatureSpec(name="data", dtype=core.DataType.STRING),
+                                core.FeatureSpec(name="format", dtype=core.DataType.STRING),
+                            ],
+                        ),
+                    ],
+                    shape=(-1,),
+                ),
+                core.FeatureSpec(name="name", dtype=core.DataType.STRING),
+                core.FeatureSpec(name="role", dtype=core.DataType.STRING),
+                core.FeatureSpec(name="title", dtype=core.DataType.STRING),
+            ],
+            shape=(-1,),
+        ),
+        core.FeatureSpec(name="temperature", dtype=core.DataType.DOUBLE),
+        core.FeatureSpec(name="max_completion_tokens", dtype=core.DataType.INT64),
+        core.FeatureSpec(name="stop", dtype=core.DataType.STRING, shape=(-1,)),
+        core.FeatureSpec(name="n", dtype=core.DataType.INT32),
+        core.FeatureSpec(name="stream", dtype=core.DataType.BOOL),
+        core.FeatureSpec(name="top_p", dtype=core.DataType.DOUBLE),
+        core.FeatureSpec(name="frequency_penalty", dtype=core.DataType.DOUBLE),
+        core.FeatureSpec(name="presence_penalty", dtype=core.DataType.DOUBLE),
+    ],
+    outputs=[
+        core.FeatureSpec(name="id", dtype=core.DataType.STRING),
+        core.FeatureSpec(name="object", dtype=core.DataType.STRING),
+        core.FeatureSpec(name="created", dtype=core.DataType.FLOAT),
+        core.FeatureSpec(name="model", dtype=core.DataType.STRING),
+        core.FeatureGroupSpec(
+            name="choices",
+            specs=[
+                core.FeatureSpec(name="index", dtype=core.DataType.INT32),
+                core.FeatureGroupSpec(
+                    name="message",
+                    specs=[
+                        core.FeatureSpec(name="content", dtype=core.DataType.STRING),
+                        core.FeatureSpec(name="name", dtype=core.DataType.STRING),
+                        core.FeatureSpec(name="role", dtype=core.DataType.STRING),
+                    ],
+                ),
+                core.FeatureSpec(name="logprobs", dtype=core.DataType.STRING),
+                core.FeatureSpec(name="finish_reason", dtype=core.DataType.STRING),
+            ],
+            shape=(-1,),
+        ),
+        core.FeatureGroupSpec(
+            name="usage",
+            specs=[
+                core.FeatureSpec(name="completion_tokens", dtype=core.DataType.INT32),
+                core.FeatureSpec(name="prompt_tokens", dtype=core.DataType.INT32),
+                core.FeatureSpec(name="total_tokens", dtype=core.DataType.INT32),
+            ],
+        ),
+    ],
+)
+
+_OPENAI_CHAT_SIGNATURE_SPEC_WITH_CONTENT_FORMAT_STRING = core.ModelSignature(
     inputs=[
         core.FeatureGroupSpec(
             name="messages",
@@ -54,4 +142,13 @@ _OPENAI_CHAT_SIGNATURE_SPEC = core.ModelSignature(
     ],
 )
 
+
+# Refer vLLM documentation: https://docs.vllm.ai/en/stable/serving/openai_compatible_server/#chat-template
+
+# Use this if you prefer to use the content format string instead of the default ChatML template.
+# Most models support this.
+OPENAI_CHAT_SIGNATURE_WITH_CONTENT_FORMAT_STRING = {"__call__": _OPENAI_CHAT_SIGNATURE_SPEC_WITH_CONTENT_FORMAT_STRING}
+
+# This is the default signature.
+# The content format allows vLLM to handler content parts like text, image, video, audio, file, etc.
 OPENAI_CHAT_SIGNATURE = {"__call__": _OPENAI_CHAT_SIGNATURE_SPEC}

snowflake/ml/model/type_hints.py

@@ -13,6 +13,7 @@ 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,
@@ -366,6 +367,7 @@ ModelLoadOption = Union[
 
 
 SupportedTargetPlatformType = Union[TargetPlatform, str]
+CodePathLike = Union[str, CodePath]
 
 
 class ProgressStatus(Protocol):

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[

snowflake/ml/registry/_manager/model_parameter_reconciler.py

@@ -126,7 +126,7 @@ class ModelParameterReconciler:
         # 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`. "
+                "Logging the model on Container Runtime without specifying `target_platforms`. "
                 'Default to `target_platforms=["SNOWPARK_CONTAINER_SERVICES"]`.'
             )
             return [target_platform.TargetPlatform.SNOWPARK_CONTAINER_SERVICES]

snowflake/ml/registry/registry.py

@@ -146,7 +146,7 @@ class Registry:
         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: task.Task = task.Task.UNKNOWN,
         options: Optional[type_hints.ModelSaveOption] = None,
@@ -200,7 +200,7 @@ class Registry:
                 It would also be used as background data in explanation and to capture data lineage. Defaults to None.
             user_files: Dictionary where the keys are subdirectories, and values are lists of local file name
                 strings. The local file name strings can include wildcards (? or *) for matching multiple files.
-            code_paths: List of directories containing code to import. Defaults to None.
+            code_paths: List of directories or CodePath objects containing code to import. Defaults to None.
             ext_modules: List of external modules to pickle with the model object.
                 Only supported when logging the following types of model:
                 Scikit-learn, Snowpark ML, PyTorch, TorchScript and Custom Model. Defaults to None.
@@ -298,7 +298,7 @@ class Registry:
         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: task.Task = task.Task.UNKNOWN,
         options: Optional[type_hints.ModelSaveOption] = None,
@@ -352,7 +352,7 @@ class Registry:
                 It would also be used as background data in explanation and to capture data lineage. Defaults to None.
             user_files: Dictionary where the keys are subdirectories, and values are lists of local file name
                 strings. The local file name strings can include wildcards (? or *) for matching multiple files.
-            code_paths: List of directories containing code to import. Defaults to None.
+            code_paths: List of directories or CodePath objects containing code to import. Defaults to None.
             ext_modules: List of external modules to pickle with the model object.
                 Only supported when logging the following types of model:
                 Scikit-learn, Snowpark ML, PyTorch, TorchScript and Custom Model. Defaults to None.

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.21.0"
+VERSION = "1.23.0"

{snowflake_ml_python-1.21.0.dist-info → snowflake_ml_python-1.23.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.21.0
+Version: 1.23.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: 
@@ -417,6 +417,100 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
+## 1.23.0
+
+### New Features
+
+* ML Jobs: Enabled support for Python 3.11 and Python 3.12 by default. Jobs will automatically select a
+  runtime environment matching the client Python version.
+
+### Bug Fixes
+
+* Registry: Fix failures on empty output in HuggingFace's Token Classification (aka Named Entity Recognition) models.
+* Model serving: don't parse instance or container statuses to fix bug with missing container status.
+
+### Behavior Changes
+
+### Deprecations
+
+## 1.22.0
+
+### New Features
+
+* Registry: Introducing remotely logging a transformer pipeline model using SPCS job.
+
+```python
+# create reference of the model
+model = huggingface.TransformersPipeline(
+    model="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+    task="text-generation",
+)
+
+# Remotely log the model, a SPCS job will run async and log the model
+mv = registry.log_model(
+    model=model,
+    model_name="tinyllama_remote_log",
+    target_platforms=["SNOWPARK_CONTAINER_SERVICES"],
+    signatures=openai_signatures.OPENAI_CHAT_SIGNATURE,
+)
+```
+
+* Registry: Added support for `image-text-to-text` task type in `huggingface.TransformersPipeline`.
+  Note: Requires vLLM inference engine while creating the service.
+
+### Bug Fixes
+
+### Behavior Changes
+
+* Registry: The `openai_signatures.OPENAI_CHAT_SIGNATURE` signature now handles content parts and
+  requires input data to be passed in list of dictionary. To use string content (previous behavior),
+  use `openai_signatures.OPENAI_CHAT_SIGNATURE_WITH_CONTENT_FORMAT_STRING`.
+
+```python
+from snowflake.ml.model import openai_signatures
+import pandas as pd
+
+mv = snowflake_registry.log_model(
+    model=generator,
+    model_name=...,
+    ...,
+    signatures=openai_signatures.OPENAI_CHAT_SIGNATURE,
+)
+
+# create a pd.DataFrame with openai.client.chat.completions arguments like below:
+x_df = pd.DataFrame.from_records(
+    [
+        {
+            "messages": [
+                {"role": "system", "content": "Complete the sentence."},
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "A descendant of the Lost City of Atlantis, who swam to Earth while saying, ",
+                        }
+                    ],
+                },
+            ],
+            "max_completion_tokens": 250,
+            "temperature": 0.9,
+            "stop": None,
+            "n": 3,
+            "stream": False,
+            "top_p": 1.0,
+            "frequency_penalty": 0.1,
+            "presence_penalty": 0.2,
+        }
+    ],
+)
+
+# OpenAI Chat Completion compatible output
+output_df = mv.run(X=x_df)
+```
+
+### Deprecations
+
 ## 1.21.0
 
 ### New Features