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

snowflake/ml/model/_packager/model_handlers/sentence_transformers.py

@@ -16,6 +16,7 @@ from snowflake.ml.model._packager.model_meta import (
     model_meta as model_meta_api,
     model_meta_schema,
 )
+from snowflake.ml.model._signatures import utils as model_signature_utils
 from snowflake.snowpark._internal import utils as snowpark_utils
 
 if TYPE_CHECKING:
@@ -23,24 +24,59 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+# Allowlist of supported target methods for SentenceTransformer models.
+# Note: sentence-transformers >= 3.0 uses singular names (encode_query, encode_document)
+# while older versions may use plural names (encode_queries, encode_documents).
+_ALLOWED_TARGET_METHODS = ["encode", "encode_query", "encode_document", "encode_queries", "encode_documents"]
+
+
+def _validate_sentence_transformers_signatures(
+    sigs: dict[str, model_signature.ModelSignature],
+) -> None:
+    """Validate signatures for SentenceTransformer models.
+
+    Args:
+        sigs: Dictionary mapping method names to their signatures.
+
+    Raises:
+        ValueError: If signatures are empty, contain unsupported methods, or violate per-method constraints.
+    """
+    # Check that signatures are non-empty
+    if not sigs:
+        raise ValueError("At least one signature must be provided.")
+
+    # Check that all methods are in the allowlist
+    unsupported_methods = set(sigs.keys()) - set(_ALLOWED_TARGET_METHODS)
+    if unsupported_methods:
+        raise ValueError(
+            f"Unsupported target methods: {sorted(unsupported_methods)}. "
+            f"Supported methods are: {_ALLOWED_TARGET_METHODS}."
+        )
 
-def _validate_sentence_transformers_signatures(sigs: dict[str, model_signature.ModelSignature]) -> None:
-    if list(sigs.keys()) != ["encode"]:
-        raise ValueError("target_methods can only be ['encode']")
-
-    if len(sigs["encode"].inputs) != 1:
-        raise ValueError("SentenceTransformer can only accept 1 input column")
+    # Validate per-method constraints
+    for method_name, sig in sigs.items():
+        if len(sig.inputs) != 1:
+            raise ValueError(f"SentenceTransformer method '{method_name}' must have exactly 1 input column.")
 
-    if len(sigs["encode"].outputs) != 1:
-        raise ValueError("SentenceTransformer can only return 1 output column")
+        if len(sig.outputs) != 1:
+            raise ValueError(f"SentenceTransformer method '{method_name}' must have exactly 1 output column.")
 
-    assert isinstance(sigs["encode"].inputs[0], model_signature.FeatureSpec)
+        # FeatureSpec is expected here; FeatureGroupSpec would indicate a nested/grouped input
+        # which SentenceTransformer does not support.
+        if not isinstance(sig.inputs[0], model_signature.FeatureSpec):
+            raise ValueError(
+                f"SentenceTransformer method '{method_name}' requires a FeatureSpec input, "
+                f"got {type(sig.inputs[0]).__name__}."
+            )
 
-    if sigs["encode"].inputs[0]._shape is not None:
-        raise ValueError("SentenceTransformer does not support input shape")
+        if sig.inputs[0]._shape is not None:
+            raise ValueError(f"SentenceTransformer method '{method_name}' does not support input shape.")
 
-    if sigs["encode"].inputs[0]._dtype != model_signature.DataType.STRING:
-        raise ValueError("SentenceTransformer only accepts string input")
+        if sig.inputs[0]._dtype != model_signature.DataType.STRING:
+            raise ValueError(
+                f"SentenceTransformer method '{method_name}' only accepts STRING input, "
+                f"got {sig.inputs[0]._dtype.name}."
+            )
 
 
 @final
@@ -51,7 +87,9 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
     _HANDLER_MIGRATOR_PLANS: dict[str, type[base_migrator.BaseModelHandlerMigrator]] = {}
 
     MODEL_BLOB_FILE_OR_DIR = "model"
-    DEFAULT_TARGET_METHODS = ["encode"]
+    # Default to singular names which are used in sentence-transformers >= 3.0
+    DEFAULT_TARGET_METHODS = ["encode", "encode_query", "encode_document"]
+    IS_AUTO_SIGNATURE = True
 
     @classmethod
     def can_handle(
@@ -98,11 +136,17 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
                 target_methods=kwargs.pop("target_methods", None),
                 default_target_methods=cls.DEFAULT_TARGET_METHODS,
             )
-            if target_methods != ["encode"]:
-                raise ValueError("target_methods can only be ['encode']")
+
+            # Validate target_methods
+            if not target_methods:
+                raise ValueError("At least one target method must be specified.")
+
+            if not set(target_methods).issubset(_ALLOWED_TARGET_METHODS):
+                raise ValueError(f"target_methods {target_methods} must be a subset of {_ALLOWED_TARGET_METHODS}.")
 
             def get_prediction(
-                target_method_name: str, sample_input_data: model_types.SupportedLocalDataType
+                target_method_name: str,
+                sample_input_data: model_types.SupportedLocalDataType,
             ) -> model_types.SupportedLocalDataType:
                 if not isinstance(sample_input_data, pd.DataFrame):
                     sample_input_data = model_signature._convert_local_data_to_df(data=sample_input_data)
@@ -113,8 +157,13 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
                     )
                 X_list = sample_input_data.iloc[:, 0].tolist()
 
-                assert callable(getattr(model, "encode", None))
-                return pd.DataFrame({0: model.encode(X_list, batch_size=batch_size).tolist()})
+                # Call the appropriate method based on target_method_name
+                method_to_call = getattr(model, target_method_name, None)
+                if not callable(method_to_call):
+                    raise ValueError(
+                        f"SentenceTransformer model does not have a callable method '{target_method_name}'."
+                    )
+                return pd.DataFrame({0: method_to_call(X_list, batch_size=batch_size).tolist()})
 
             if model_meta.signatures:
                 handlers_utils.validate_target_methods(model, list(model_meta.signatures.keys()))
@@ -135,6 +184,36 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
                         sample_input_data=sample_input_data,
                         get_prediction_fn=get_prediction,
                     )
+                else:
+                    # Auto-infer signature from model when no sample_input_data is provided
+                    # Get the embedding dimension from the model
+                    embedding_dim = model.get_sentence_embedding_dimension()
+                    if embedding_dim is None:
+                        raise ValueError(
+                            "Unable to auto-infer signature: model.get_sentence_embedding_dimension() returned None. "
+                            "Please provide sample_input_data or signatures explicitly."
+                        )
+
+                    for target_method in target_methods:
+                        # target_methods are already validated as callable by get_target_methods()
+                        inferred_sig = model_signature_utils.sentence_transformers_signature_auto_infer(
+                            target_method=target_method,
+                            embedding_dim=embedding_dim,
+                        )
+                        if inferred_sig is None:
+                            raise ValueError(
+                                f"Unable to auto-infer signature for method '{target_method}'. "
+                                "Please provide sample_input_data or signatures explicitly."
+                            )
+                        model_meta.signatures[target_method] = inferred_sig
+
+                    # Ensure at least one method was successfully inferred
+                    if not model_meta.signatures:
+                        raise ValueError(
+                            "No valid target methods found on the model. "
+                            "Please provide sample_input_data or signatures explicitly, "
+                            "or specify target_methods that exist on your model."
+                        )
 
             _validate_sentence_transformers_signatures(model_meta.signatures)
 
@@ -160,7 +239,10 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
 
         model_meta.env.include_if_absent(
             [
-                model_env.ModelDependency(requirement="sentence-transformers", pip_name="sentence-transformers"),
+                model_env.ModelDependency(
+                    requirement="sentence-transformers",
+                    pip_name="sentence-transformers",
+                ),
                 model_env.ModelDependency(requirement="transformers", pip_name="transformers"),
                 model_env.ModelDependency(requirement="pytorch", pip_name="torch"),
             ],
@@ -169,7 +251,9 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
         model_meta.env.cuda_version = kwargs.get("cuda_version", handlers_utils.get_default_cuda_version())
 
     @staticmethod
-    def _get_device_config(**kwargs: Unpack[model_types.SentenceTransformersLoadOptions]) -> Optional[str]:
+    def _get_device_config(
+        **kwargs: Unpack[model_types.SentenceTransformersLoadOptions],
+    ) -> Optional[str]:
         if kwargs.get("device", None) is not None:
             return kwargs["device"]
         elif kwargs.get("use_gpu", False):
@@ -226,7 +310,8 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
             model_meta: model_meta_api.ModelMetadata,
         ) -> type[custom_model.CustomModel]:
             batch_size = cast(
-                model_meta_schema.SentenceTransformersModelBlobOptions, model_meta.models[model_meta.name].options
+                model_meta_schema.SentenceTransformersModelBlobOptions,
+                model_meta.models[model_meta.name].options,
             ).get("batch_size", None)
 
             def get_prediction(
@@ -234,22 +319,30 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
                 signature: model_signature.ModelSignature,
                 target_method: str,
             ) -> Callable[[custom_model.CustomModel, pd.DataFrame], pd.DataFrame]:
+                # Capture target_method in closure to call the correct model method
+                method_to_call = getattr(raw_model, target_method, None)
+                if not callable(method_to_call):
+                    raise ValueError(
+                        f"SentenceTransformer model does not have a callable method '{target_method}'. "
+                        f"This method may not be available in your version of sentence-transformers."
+                    )
+
                 @custom_model.inference_api
                 def fn(self: custom_model.CustomModel, X: pd.DataFrame) -> pd.DataFrame:
                     X_list = X.iloc[:, 0].tolist()
 
                     return pd.DataFrame(
-                        {signature.outputs[0].name: raw_model.encode(X_list, batch_size=batch_size).tolist()}
+                        {signature.outputs[0].name: method_to_call(X_list, batch_size=batch_size).tolist()}
                     )
 
                 return fn
 
             type_method_dict = {}
             for target_method_name, sig in model_meta.signatures.items():
-                if target_method_name == "encode":
+                if target_method_name in _ALLOWED_TARGET_METHODS:
                     type_method_dict[target_method_name] = get_prediction(raw_model, sig, target_method_name)
                 else:
-                    ValueError(f"{target_method_name} is currently not supported.")
+                    raise ValueError(f"{target_method_name} is currently not supported.")
 
             _SentenceTransformer = type(
                 "_SentenceTransformer",
@@ -262,7 +355,6 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
         model = raw_model
 
         _SentenceTransformer = _create_custom_model(model, model_meta)
-        sentence_transformers_SentenceTransformer_model = _SentenceTransformer(custom_model.ModelContext())
-        predict_method = getattr(sentence_transformers_SentenceTransformer_model, "encode", None)
-        assert callable(predict_method)
-        return sentence_transformers_SentenceTransformer_model
+        sentence_transformers_model = _SentenceTransformer(custom_model.ModelContext())
+
+        return sentence_transformers_model

snowflake/ml/model/_signatures/utils.py

@@ -9,6 +9,7 @@ from snowflake.ml._internal.exceptions import (
     error_codes,
     exceptions as snowml_exceptions,
 )
+from snowflake.ml.model import openai_signatures
 from snowflake.ml.model._signatures import core
 
 
@@ -259,6 +260,66 @@ def huggingface_pipeline_signature_auto_infer(
             ],
         )
 
+    # https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.ImageClassificationPipeline
+    if task == "image-classification":
+        return core.ModelSignature(
+            inputs=[
+                core.FeatureSpec(name="images", dtype=core.DataType.BYTES),
+            ],
+            outputs=[
+                core.FeatureGroupSpec(
+                    name="labels",
+                    specs=[
+                        core.FeatureSpec(name="label", dtype=core.DataType.STRING),
+                        core.FeatureSpec(name="score", dtype=core.DataType.DOUBLE),
+                    ],
+                    shape=(-1,),
+                ),
+            ],
+        )
+
+    # https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline
+    if task == "automatic-speech-recognition":
+        return core.ModelSignature(
+            inputs=[
+                core.FeatureSpec(name="audio", dtype=core.DataType.BYTES),
+            ],
+            outputs=[
+                core.FeatureGroupSpec(
+                    name="outputs",
+                    specs=[
+                        core.FeatureSpec(name="text", dtype=core.DataType.STRING),
+                        core.FeatureGroupSpec(
+                            name="chunks",
+                            specs=[
+                                core.FeatureSpec(name="timestamp", dtype=core.DataType.DOUBLE, shape=(2,)),
+                                core.FeatureSpec(name="text", dtype=core.DataType.STRING),
+                            ],
+                            shape=(-1,),  # Variable length list of chunks
+                        ),
+                    ],
+                )
+            ],
+        )
+
+    # https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.VideoClassificationPipeline
+    if task == "video-classification":
+        return core.ModelSignature(
+            inputs=[
+                core.FeatureSpec(name="video", dtype=core.DataType.BYTES),
+            ],
+            outputs=[
+                core.FeatureGroupSpec(
+                    name="labels",
+                    specs=[
+                        core.FeatureSpec(name="label", dtype=core.DataType.STRING),
+                        core.FeatureSpec(name="score", dtype=core.DataType.DOUBLE),
+                    ],
+                    shape=(-1,),
+                ),
+            ],
+        )
+
     # https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.TextGenerationPipeline
     if task == "text-generation":
         if params.get("return_tensors", False):
@@ -288,6 +349,22 @@ def huggingface_pipeline_signature_auto_infer(
                 )
             ],
         )
+
+    # https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.ImageTextToTextPipeline
+    if task in [
+        "image-text-to-text",
+        "video-text-to-text",
+        "audio-text-to-text",
+    ]:
+        if params.get("return_tensors", False):
+            raise NotImplementedError(
+                f"Auto deployment for HuggingFace pipeline {task} "
+                "when `return_tensors` set to `True` has not been supported yet."
+            )
+        # Always generate a dict per input
+        # defaulting to OPENAI_CHAT_SIGNATURE_SPEC for image-text-to-text pipeline
+        return openai_signatures._OPENAI_CHAT_SIGNATURE_SPEC
+
     # https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.Text2TextGenerationPipeline
     if task == "text2text-generation":
         if params.get("return_tensors", False):
@@ -406,3 +483,56 @@ def infer_dict(name: str, data: dict[str, Any]) -> core.FeatureGroupSpec:
 
 def check_if_series_is_empty(series: Optional[pd.Series]) -> bool:
     return series is None or series.empty
+
+
+def sentence_transformers_signature_auto_infer(
+    target_method: str,
+    embedding_dim: int,
+) -> Optional[core.ModelSignature]:
+    """Auto-infer signature for SentenceTransformer models.
+
+    SentenceTransformer models have a simple signature: they take a string input
+    and return an embedding vector (array of floats).
+
+    Args:
+        target_method: The target method name. Supported methods:
+            - "encode": General encoding method
+            - "encode_query" / "encode_queries": Query encoding for asymmetric search
+            - "encode_document" / "encode_documents": Document encoding for asymmetric search
+        embedding_dim: The dimension of the embedding vector output by the model.
+
+    Returns:
+        A ModelSignature for the target method, or None if the method is not supported.
+
+    Note:
+        sentence-transformers >= 3.0 uses singular names (encode_query, encode_document)
+        while older versions may use plural names (encode_queries, encode_documents).
+        Both naming conventions are supported for backward compatibility.
+    """
+    # Support both singular (new) and plural (old) naming conventions
+    supported_methods = [
+        "encode",
+        "encode_query",
+        "encode_document",
+        "encode_queries",
+        "encode_documents",
+    ]
+
+    if target_method not in supported_methods:
+        return None
+
+    # All SentenceTransformer encode methods have the same signature pattern:
+    # - Input: a single string column
+    # - Output: a single column containing embedding vectors (array of floats)
+    return core.ModelSignature(
+        inputs=[
+            core.FeatureSpec(name="text", dtype=core.DataType.STRING),
+        ],
+        outputs=[
+            core.FeatureSpec(
+                name="output",
+                dtype=core.DataType.DOUBLE,
+                shape=(embedding_dim,),
+            ),
+        ],
+    )

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/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/version.py

@@ -1,2 +1,2 @@
 # This is parsed by regex in conda recipe meta file. Make sure not to break it.
-VERSION = "1.22.0"
+VERSION = "1.24.0"

{snowflake_ml_python-1.22.0.dist-info → snowflake_ml_python-1.24.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-ml-python
-Version: 1.22.0
+Version: 1.24.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,60 @@ NOTE: Version 1.7.0 is used as example here. Please choose the the latest versio
 
 # Release History
 
+## 1.24.0
+
+### New Features
+
+* Feature Store: Added tile-based aggregation support with a new `Feature` API for efficient and
+  point-in-time correct time-series feature computation using pre-computed tiles stored in Dynamic Tables.
+
+* Registry: Added auto-signature inference for SentenceTransformer models. When logging a SentenceTransformer
+  model, `sample_input_data` is now optional. If not provided, the signature is automatically inferred from
+  the model's embedding dimension. Supported methods: `encode`, `encode_query`, `encode_document`,
+  `encode_queries`, `encode_documents`.
+
+```python
+import sentence_transformers
+from snowflake.ml.registry import Registry
+
+# Create model
+model = sentence_transformers.SentenceTransformer("all-MiniLM-L6-v2")
+
+# Log model without sample_input_data - signature is auto-inferred
+registry = Registry(session)
+mv = registry.log_model(
+    model=model,
+    model_name="my_sentence_transformer",
+    version_name="v1",
+)
+
+# Run inference with auto-inferred signature (input: "text", output: "output")
+import pandas as pd
+result = mv.run(pd.DataFrame({"text": ["Hello world"]}))
+```
+
+### Bug Fixes
+
+### Behavior Changes
+
+### Deprecations
+
+## 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
@@ -439,10 +493,60 @@ mv = registry.log_model(
 )
 ```
 
+* 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