snowflake-ml-python 2.2.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

snowflake/ml/experiment/experiment_tracking.py

@@ -1,9 +1,9 @@
 import contextlib
 import functools
 import json
+import logging
 import sys
 import traceback
-import warnings
 from collections.abc import Callable
 from types import TracebackType
 from typing import Any
@@ -32,6 +32,8 @@ from snowflake.snowpark import functions
 
 DEFAULT_EXPERIMENT_NAME = sql_identifier.SqlIdentifier("DEFAULT")
 
+logger = logging.getLogger(__name__)
+
 
 class ExperimentTracking:
     """
@@ -52,6 +54,8 @@ class ExperimentTracking:
         database_name: str | None = None,
         schema_name: str | None = None,
         capture_source_info: bool = True,
+        model_registry: registry.Registry | None = None,
+        warnings_as_errors: bool = False,
     ) -> None:
         """
         Initializes experiment tracking within a pre-created schema.
@@ -68,20 +72,27 @@ class ExperimentTracking:
                 of the enclosing ML job when running inside one. Set to False to skip collection
                 entirely. Collection is always non-fatal and never blocks run creation. Defaults to
                 True.
+            model_registry: An optional Registry instance to use for ``log_model``. When provided,
+                models are logged to the database and schema owned by this registry instead of the
+                experiment's database and schema. This is useful when the experiment lives in one
+                schema (e.g. ``analytics.experiments``) but models should be stored in another
+                (e.g. ``ml.models``). If None, models are logged to the same location as the
+                experiment. Defaults to None.
+            warnings_as_errors: If True, conditions that are normally reported as warnings are raised
+                instead.
 
         Raises:
             ValueError: If no database is provided and no active database exists in the session.
         """
         # Applied on every construction (even when reusing the singleton)
         self._capture_source_info = capture_source_info
+        self._warnings_as_errors = warnings_as_errors
 
         if hasattr(self, "_initialized"):
-            warnings.warn(
+            logger.info(
                 "ExperimentTracking is a singleton class. Reusing the existing instance, which has the setting:\n"
                 f"    Database: {self._database_name}, Schema: {self._schema_name}\n"
-                "To change the database or schema, use the database_name and schema_name arguments to set_experiment.",
-                UserWarning,
-                stacklevel=2,
+                "To change the database or schema, use the database_name and schema_name arguments to set_experiment."
             )
             return
 
@@ -109,11 +120,7 @@ class ExperimentTracking:
             database_name=self._database_name,
             schema_name=self._schema_name,
         )
-        self._registry = registry.Registry(
-            session=session,
-            database_name=self._database_name,
-            schema_name=self._schema_name,
-        )
+        self._registry = model_registry
         self._session = session
 
         # The experiment in context
@@ -139,7 +146,10 @@ class ExperimentTracking:
         else:
             state = dict(self.__dict__)
 
-        # Remove unpicklable attributes
+        # Remove unpicklable attributes; save registry coordinates for reconstruction.
+        if self._registry is not None:
+            state["_registry_database_name"] = self._registry._database_name
+            state["_registry_schema_name"] = self._registry._schema_name
         state["_session"] = None
         state["_sql_client"] = None
         state["_registry"] = None
@@ -168,11 +178,14 @@ class ExperimentTracking:
             database_name=self._database_name,
             schema_name=self._schema_name,
         )
-        self._registry = registry.Registry(
-            session=self._session,
-            database_name=self._database_name,
-            schema_name=self._schema_name,
-        )
+        registry_db = state.pop("_registry_database_name", None)
+        registry_schema = state.pop("_registry_schema_name", None)
+        if registry_db is not None:
+            self._registry = registry.Registry(
+                session=self._session,
+                database_name=registry_db,
+                schema_name=registry_schema,
+            )
         if self._run:
             self._patch_stdout_and_stderr()
             # _patch_stdout_and_stderr sets _logging_context if live logging is enabled
@@ -277,8 +290,17 @@ class ExperimentTracking:
         **kwargs: Any,
     ) -> ml_model.ModelVersion:
         run = self._get_or_start_run()
+        target_registry = (
+            self._registry
+            if self._registry is not None
+            else registry.Registry(
+                session=self._session,
+                database_name=self._database_name,
+                schema_name=self._schema_name,
+            )
+        )
         with experiment_info.ExperimentInfoPatcher(experiment_info=run._get_experiment_info()):
-            return self._registry.log_model(model, model_name=model_name, **kwargs)
+            return target_registry.log_model(model, model_name=model_name, **kwargs)
 
     def list_model_versions(self, run_name: str | None = None) -> list[ml_model.ModelVersion]:
         """
@@ -475,7 +497,7 @@ class ExperimentTracking:
             )
         except snowpark.exceptions.SnowparkSQLException as e:
             if e.sql_error_code == 400003:  # EXPERIMENT_RUN_PROPERTY_SIZE_LIMIT_EXCEEDED
-                run._warn_about_run_metadata_size(e.message)
+                run._handle_run_metadata_size_limit(e.message)
             else:
                 raise
 
@@ -520,7 +542,7 @@ class ExperimentTracking:
             )
         except snowpark.exceptions.SnowparkSQLException as e:
             if e.sql_error_code == 400003:  # EXPERIMENT_RUN_PROPERTY_SIZE_LIMIT_EXCEEDED
-                run._warn_about_run_metadata_size(e.message)
+                run._handle_run_metadata_size_limit(e.message)
             else:
                 raise
 
@@ -784,11 +806,6 @@ class ExperimentTracking:
             database_name=database_name,
             schema_name=schema_name,
         )
-        self._registry = registry.Registry(
-            session=self._session,
-            database_name=database_name,
-            schema_name=schema_name,
-        )
 
     def _print_urls(
         self,

snowflake/ml/feature_store/feature_store.py

@@ -1770,6 +1770,8 @@ class FeatureStore:
                     error_code=error_codes.INVALID_ARGUMENT, original_exception=e
                 ) from e
 
+            self._validate_online_target_lag_change(feature_view, online_config)
+
         if updated_feature_df is not None:
             if not feature_view.append_only:
                 raise snowml_exceptions.SnowflakeMLException(
@@ -4543,6 +4545,59 @@ class FeatureStore:
         rollback_operations: list[tuple[str, str | FeatureView]]
         final_config: fv_mod.OnlineConfig | None
 
+    @staticmethod
+    def _validate_online_target_lag_change(feature_view: FeatureView, online_config: fv_mod.OnlineConfig) -> None:
+        """Reject a target_lag change on an online feature table backed by Postgres.
+
+        Postgres-backed online feature tables accept the target lag they are created with but
+        not a later change to it: the ALTER is acknowledged without being applied. Rejecting the
+        change here keeps the call from reporting a success that did not happen.
+
+        Only a change that would otherwise be attempted is rejected. Enabling online storage
+        creates the table with the requested lag, disabling it ignores the lag, and a lag equal
+        to the current one is already a no-op.
+
+        Args:
+            feature_view: The registered feature view being updated.
+            online_config: The caller-supplied target online configuration.
+
+        Raises:
+            SnowflakeMLException: [ValueError] The feature view's online store is Postgres and
+                the requested target_lag differs from the current one.
+        """
+        existing_config = feature_view.online_config
+        if online_config.target_lag is None or online_config.enable is False:
+            return
+        if not feature_view.online or existing_config is None:
+            return
+        if existing_config.store_type != OnlineStoreType.POSTGRES:
+            return
+        deployed_lag = existing_config.target_lag
+        if deployed_lag is None:
+            return
+
+        # Neither lag is canonical: the table may report "300 SECONDS" where the caller asked
+        # for "5 minutes", so an unchanged lag is only recognizable on seconds. An unreadable
+        # lag lets the call through, because OnlineConfig accepts any non-empty string and
+        # reporting malformed intervals is not this check's job.
+        try:
+            if interval_utils.interval_to_seconds(online_config.target_lag) == interval_utils.interval_to_seconds(
+                deployed_lag
+            ):
+                return
+        except ValueError:
+            return
+
+        raise snowml_exceptions.SnowflakeMLException(
+            error_code=error_codes.INVALID_ARGUMENT,
+            original_exception=ValueError(
+                f"target_lag cannot be changed for a feature view whose online store is "
+                f"{OnlineStoreType.POSTGRES.name}; it is fixed at "
+                f"'{existing_config.target_lag}'. Delete and re-register the feature view with "
+                f"the desired target_lag."
+            ),
+        )
+
     def _plan_online_update(
         self, feature_view: FeatureView, online_config: fv_mod.OnlineConfig | None
     ) -> _OnlineUpdateStrategy:

snowflake/ml/feature_store/tile_sql_generator.py

@@ -1143,6 +1143,34 @@ class MergingSqlGenerator:
 
         return cte_name, cte_body.strip()
 
+    def _left_join_subqueries_on_bounds(self, subqueries: list[tuple[str, list[str]]]) -> str:
+        """LEFT JOIN each per-subquery result onto the unique (entity, boundary) rows.
+
+        Driving from UNIQUE_BOUNDS rather than from the first subquery keeps row
+        presence independent of any single window or feature: each subquery applies
+        its own row-level filter, so one with no qualifying tiles must contribute
+        NULLs for its own columns instead of dropping the entity from the CTE and
+        taking every other subquery's results with it.
+
+        Args:
+            subqueries: One (subquery_sql, output_columns) pair per window group or
+                feature. Each subquery must be grouped by the join keys plus
+                TILE_BOUNDARY so the joins stay one-to-one.
+
+        Returns:
+            SQL string selecting the join keys plus every subquery's output columns.
+        """
+        group_by_cols = list(self._join_keys) + [_TILE_BOUNDARY_COL]
+        projected = [f"UB.{col}" for col in group_by_cols]
+        for index, (_, output_cols) in enumerate(subqueries):
+            projected.extend(f"sq{index}.{col}" for col in output_cols)
+
+        result = f"SELECT {', '.join(projected)}\n    FROM UNIQUE_BOUNDS_FV{self._fv_index} UB"
+        for index, (query, _) in enumerate(subqueries):
+            join_cond = " AND ".join(f"UB.{col} = sq{index}.{col}" for col in group_by_cols)
+            result += f"\n    LEFT JOIN {query} sq{index}\n    ON {join_cond}"
+        return result
+
     def _generate_secondary_key_merged_cte(self) -> tuple[str, str]:
         """Generate the CTE for secondary-key aggregations.
 
@@ -1315,22 +1343,13 @@ class MergingSqlGenerator:
         if len(subqueries) == 1:
             cte_body = subqueries[0][2].strip()
         else:
-            # Multiple (sk, window) groups — LEFT JOIN on (entity_keys, boundary).
-            _, _, first_query = subqueries[0]
-            projected: list[str] = [f"sq0.{col}" for col in group_by_cols]
-            projected.append(f"sq0.{subqueries[0][0]}")
-            for col in subqueries[0][1]:
-                projected.append(f"sq0.{col}")
-            for i, (keys_col, value_cols, _) in enumerate(subqueries[1:], 1):
-                projected.append(f"sq{i}.{keys_col}")
-                for col in value_cols:
-                    projected.append(f"sq{i}.{col}")
-
-            result = f"SELECT {', '.join(projected)}\n    FROM {first_query} sq0"
-            for i, (_, _, query) in enumerate(subqueries[1:], 1):
-                join_cond = " AND ".join(f"sq0.{col} = sq{i}.{col}" for col in group_by_cols)
-                result += f"\n    LEFT JOIN {query} sq{i}\n    ON {join_cond}"
-            cte_body = result
+            # Multiple (sk, window) groups: a group whose window covers no tiles
+            # emits no row, so the chain is driven from the unique (entity,
+            # boundary) rows to keep each group's arrays independent. Missing
+            # groups surface as [] via the combined CTE's COALESCE.
+            cte_body = self._left_join_subqueries_on_bounds(
+                [(query, [keys_col, *value_cols]) for keys_col, value_cols, query in subqueries]
+            )
 
         return cte_name, cte_body.strip()
 
@@ -1574,21 +1593,11 @@ class MergingSqlGenerator:
         if len(feature_subqueries) == 1:
             return feature_subqueries[0][1]
 
-        # Multiple list features: join them together
-        first_name, first_query = feature_subqueries[0]
-        result = "SELECT sq0.*, "
-        for i, (name, _) in enumerate(feature_subqueries[1:], 1):
-            result += f"sq{i}.{name}"
-            if i < len(feature_subqueries) - 1:
-                result += ", "
-
-        result += f"\n    FROM {first_query} sq0"
-
-        for i, (_name, query) in enumerate(feature_subqueries[1:], 1):
-            join_cond = " AND ".join(f"sq0.{col} = sq{i}.{col}" for col in group_by_cols)
-            result += f"\n    LEFT JOIN {query} sq{i}\n    ON {join_cond}"
-
-        return result
+        # Multiple list features: a feature with no non-NULL values in the window
+        # emits no row, so the chain is driven from the unique (entity, boundary)
+        # rows to keep each feature's array independent of the others. A missing
+        # feature stays NULL, which is this path's "no data" encoding.
+        return self._left_join_subqueries_on_bounds([(query, [name]) for name, query in feature_subqueries])
 
     def _generate_combined_cte(self) -> tuple[str, str]:
         """Generate the final CTE that combines and expands results.

snowflake/ml/jobs/job.py

@@ -362,13 +362,29 @@ class MLJob(Generic[T], SerializableSessionMixin):
         """
         if self._result is None:
             self.wait(timeout)
+            # Retrying would push the call past the caller's timeout, so only retry when unbounded.
+            remaining = _INSTANCE_RECORD_TIMEOUT_SECONDS if timeout < 0 else 0
             try:
-                self._result = interop_utils.load(
-                    self._result_path, session=self._session, path_transform=self._transform_path
-                )
+                while True:
+                    try:
+                        self._result = interop_utils.load(
+                            self._result_path, session=self._session, path_transform=self._transform_path
+                        )
+                        break
+                    except (OSError, json.JSONDecodeError) as error:
+                        if remaining <= 0:
+                            raise
+                        logger.warning(
+                            "job result retrieval: result is not yet readable: %s; retrying in %d second(s)",
+                            error,
+                            _INSTANCE_RECORD_POLL_INTERVAL_SECONDS,
+                        )
+                        time.sleep(_INSTANCE_RECORD_POLL_INTERVAL_SECONDS)
+                        remaining -= _INSTANCE_RECORD_POLL_INTERVAL_SECONDS
             except Exception as e:
                 raise RuntimeError(f"Failed to retrieve result for job, error: {e!r}") from e
 
+        assert self._result is not None
         return cast(T, self._result.get_value())
 
     @telemetry.send_api_usage_telemetry(project=_PROJECT, func_params_to_log=["timeout"])

snowflake/ml/model/_client/model/batch_inference_job_specs.py

@@ -132,6 +132,20 @@ class EngineOptions(BaseModel):
         return engine.name if engine is not None else None
 
 
+class AdapterSpec(BaseModel):
+    """Serialized adapter identity nested under ``inference.adapters``.
+
+    ``alias`` is optional. Dict keys from the Python API set it; list items and
+    adapter-as-target omit it so the server can default to ``{name}/VERSIONS/{version}``.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+    version: str
+    alias: str | None = None
+
+
 class InferenceSpec(BaseModel):
     """Inference block of the batch inference job specification.
 
@@ -141,13 +155,79 @@ class InferenceSpec(BaseModel):
         max_batch_rows (Optional[int]): Maximum number of rows to process in a single batch.
             Auto determined if None. Larger values may improve throughput.
         engine_options (Optional[EngineOptions]): Options for a custom inference engine.
+        adapters (Optional[dict[str, ModelVersion] | list[ModelVersion]]): Adapter versions for
+            this job. A dict maps job alias (``input.params.model``) to adapter versions; keys
+            become ``alias`` on each emitted list item. A nonempty list and adapter-as-target omit
+            ``alias``. Empty ``{}`` / ``[]`` are treated as unset so the YAML key is omitted.
+            ``run_batch`` serializes these to name/version identities before writing the job spec.
     """
 
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
 
     num_workers: int | None = None
     max_batch_rows: int | None = None
     engine_options: EngineOptions | None = None
+    adapters: dict[str, Any] | list[Any] | None = None
+
+    @field_validator("adapters", mode="before")
+    @classmethod
+    def _empty_adapters_to_none(cls, value: Any) -> Any:
+        if value == [] or value == {}:
+            return None
+        return value
+
+    @field_serializer("adapters")
+    def _serialize_adapters(self, value: Any) -> list[dict[str, Any]] | None:
+        if not value:
+            return None
+        if not isinstance(value, list) or not all(isinstance(item, AdapterSpec) for item in value):
+            raise ValueError(
+                "batch inference: adapter versions cannot be written into the job spec until they are "
+                "resolved to name and version."
+            )
+        return [item.model_dump(mode="json", exclude_none=True) for item in value]
+
+
+def split_inference_adapters(
+    inference_spec: InferenceSpec | None,
+) -> tuple[InferenceSpec | None, dict[str, Any] | list[Any] | None]:
+    """Peel ``adapters`` off ``inference_spec`` without mutating the caller object.
+
+    Args:
+        inference_spec: Existing inference block, or None.
+
+    Returns:
+        The spec with ``adapters`` cleared (or None if that leaves an empty spec), and the
+        peeled adapters value (or None when unset).
+    """
+    if inference_spec is None or inference_spec.adapters is None:
+        return inference_spec, None
+    raw = inference_spec.adapters
+    stripped = inference_spec.model_copy(update={"adapters": None})
+    if not stripped.model_dump(exclude_none=True):
+        return None, raw
+    return stripped, raw
+
+
+def inference_spec_with_adapters(
+    inference_spec: InferenceSpec | None,
+    adapters: dict[str, Any] | list[Any] | None,
+) -> InferenceSpec | None:
+    """Return ``inference_spec`` with ``adapters`` set when nonempty.
+
+    Args:
+        inference_spec: Existing inference block, or None.
+        adapters: Adapter versions or serialized identities. Empty or None leaves
+            ``inference_spec`` unchanged.
+
+    Returns:
+        The original spec when ``adapters`` is empty, otherwise a spec that includes them.
+    """
+    if not adapters:
+        return inference_spec
+    if inference_spec is None:
+        return InferenceSpec(adapters=adapters)
+    return inference_spec.model_copy(update={"adapters": adapters})
 
 
 class ImageBuildSpec(BaseModel):

snowflake/ml/model/_client/model/batch_inference_task.py

@@ -79,7 +79,13 @@ class BatchInferenceTask(DAGTask):
                 one of ``query`` or ``input_stage_location``.
             input_spec: Optional input block.
             resources_spec: Optional resources block.
-            inference_spec: Optional inference block.
+            inference_spec: Optional inference block. Optional ``adapters`` is a mapping from
+                job alias (``input.params.model``) to adapter ``ModelVersion``s, or a list of
+                adapter versions. Dict keys become ``alias`` on each emitted list item. A
+                nonempty list and adapter-as-target omit ``alias``. Omit, ``None``, ``{}``, or
+                ``[]`` attaches none. Constructing the task on an adapter version is equivalent
+                to running the lineage pin with a one-item list, and defaults job-level
+                ``params.model`` to the defaulted alias when unset.
             image_build_spec: Optional image build block.
             function_name: Model function name. Resolved against the model's function list
                 when omitted.
@@ -125,24 +131,36 @@ class BatchInferenceTask(DAGTask):
         if (self._query is None) == (self._input_stage_location is None):
             raise ValueError("Exactly one of query or input_stage_location must be provided.")
 
-        target_function_info = self._model_version._validate_batch_inference_request(
+        inference_spec, raw_adapters = batch_inference_job_specs.split_inference_adapters(self._inference_spec)
+        deploy_target, adapters_map, input_spec = self._model_version._prepare_lora_batch(
+            adapters=raw_adapters,
             input_spec=self._input_spec,
+            input_spec_cls=batch_inference_job_specs.InputSpec,
+        )
+
+        target_function_info = deploy_target._validate_batch_inference_request(
+            input_spec=input_spec,
             resources_spec=self._resources_spec,
             function_name=self._function_name,
         )
 
+        inference_spec = batch_inference_job_specs.inference_spec_with_adapters(
+            inference_spec,
+            deploy_target._serialize_batch_adapters(adapters_map) if adapters_map else None,
+        )
+
         return service_ops.build_batch_inference_task_definition(
             session=self._model_version._service_ops._session,
-            model_fqn=self._model_version.fully_qualified_model_name,
-            version_name=self._model_version.version_name,
+            model_fqn=deploy_target.fully_qualified_model_name,
+            version_name=deploy_target.version_name,
             compute_pool=self._compute_pool,
             function_name=target_function_info["target_method"],
             query=self._query,
             input_stage_location=self._input_stage_location,
-            input_spec=self._input_spec,
+            input_spec=input_spec,
             output_spec=self._output_spec,
             resources_spec=self._resources_spec,
-            inference_spec=self._inference_spec,
+            inference_spec=inference_spec,
             image_build_spec=self._image_build_spec,
             replicas=self._replicas,
         )

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

@@ -688,7 +688,14 @@ class ModelVersion(lineage_node.LineageNode):
                 ``<stage_location>/<job_name>/``.
             input_spec: Input block.
             resources_spec: Resources block.
-            inference_spec: Inference block.
+            inference_spec: Inference block. Optional ``adapters`` is a mapping from job alias
+                (``input.params.model``) to adapter ``ModelVersion``s, or a list of adapter
+                versions. Dict keys become ``alias`` on each emitted list item. A nonempty list
+                and adapter-as-target omit ``alias`` (the server defaults each to
+                ``<FQN>/VERSIONS/<version>``). Omit, ``None``, ``{}``, or ``[]`` attaches none.
+                Calling ``run_batch`` on an adapter version is equivalent to running the lineage
+                pin with a one-item list, and defaults job-level ``params.model`` to that
+                defaulted alias when unset.
             image_build_spec: Image build block.
             function_name: Model function name. Resolved against the model's
                 function list when omitted.
@@ -763,6 +770,29 @@ class ModelVersion(lineage_node.LineageNode):
         if (X is None) == (input_stage_location is None):
             raise ValueError("Exactly one of X or input_stage_location must be provided.")
 
+        inference_spec, raw_adapters = batch_inference_job_specs.split_inference_adapters(inference_spec)
+        deploy_target, adapters_map, input_spec = self._prepare_lora_batch(
+            adapters=raw_adapters,
+            input_spec=input_spec,
+            input_spec_cls=batch_inference_job_specs.InputSpec,
+        )
+        if deploy_target is not self:
+            forwarded = [mv for _, mv in adapters_map] if adapters_map else None
+            return deploy_target.run_batch(
+                X,
+                input_stage_location=input_stage_location,
+                compute_pool=compute_pool,
+                output_spec=output_spec,
+                input_spec=input_spec,
+                resources_spec=resources_spec,
+                inference_spec=batch_inference_job_specs.inference_spec_with_adapters(inference_spec, forwarded),
+                image_build_spec=image_build_spec,
+                function_name=function_name,
+                job_name=job_name,
+                replicas=replicas,
+                async_=async_,
+            )
+
         target_function_info = self._validate_batch_inference_request(
             input_spec=input_spec,
             resources_spec=resources_spec,
@@ -770,6 +800,11 @@ class ModelVersion(lineage_node.LineageNode):
             statement_params=statement_params,
         )
 
+        inference_spec = batch_inference_job_specs.inference_spec_with_adapters(
+            inference_spec,
+            self._serialize_batch_adapters(adapters_map) if adapters_map else None,
+        )
+
         return self._service_ops.execute_inference_job_service(
             X=X,
             input_stage_location=input_stage_location,
@@ -1238,11 +1273,13 @@ class ModelVersion(lineage_node.LineageNode):
         return caps(features={}).is_lora_adapters_enabled()
 
     @staticmethod
-    def _require_lora_adapters_enabled() -> None:
+    def _require_lora_adapters_enabled(
+        *,
+        unavailable_what: str = "Creating a service with adapters",
+    ) -> None:
         if not ModelVersion._lora_adapters_enabled():
             ModelVersion._adapter_invalid_argument(
-                "Creating a service with adapters is unavailable because ENABLE_LORA_ADAPTERS is not enabled "
-                "for this account."
+                f"{unavailable_what} is unavailable because ENABLE_LORA_ADAPTERS is not enabled " "for this account."
             )
 
     def _is_peft_adapter_version(self) -> bool:
@@ -1263,7 +1300,7 @@ class ModelVersion(lineage_node.LineageNode):
 
     def _normalize_adapters(
         self,
-        adapters: dict[str, "ModelVersion"] | list["ModelVersion"] | None,
+        adapters: dict[str, Any] | list[Any] | None,
     ) -> list[tuple[str | None, "ModelVersion"]] | None:
         if adapters is None:
             return None
@@ -1300,6 +1337,61 @@ class ModelVersion(lineage_node.LineageNode):
             for alias, adapter_mv in adapters
         ]
 
+    @staticmethod
+    def _serialize_batch_adapters(
+        adapters: list[tuple[str | None, "ModelVersion"]],
+    ) -> list[batch_inference_job_specs.AdapterSpec]:
+        return [
+            batch_inference_job_specs.AdapterSpec(
+                name=adapter_mv.fully_qualified_model_name,
+                version=adapter_mv.version_name,
+                alias=alias,
+            )
+            for alias, adapter_mv in adapters
+        ]
+
+    @staticmethod
+    def _default_adapter_alias(mv: "ModelVersion") -> str:
+        return f"{mv.fully_qualified_model_name}/VERSIONS/{mv.version_name}"
+
+    @staticmethod
+    def _with_default_batch_params_model(
+        input_spec: Any | None,
+        *,
+        alias: str,
+        spec_cls: Any,
+    ) -> Any:
+        if input_spec is not None and input_spec.params and input_spec.params.get("model") is not None:
+            return input_spec
+        params = dict(input_spec.params) if input_spec and input_spec.params else {}
+        params["model"] = alias
+        if input_spec is None:
+            return spec_cls(params=params)
+        return input_spec.model_copy(update={"params": params})
+
+    def _prepare_lora_batch(
+        self,
+        *,
+        adapters: dict[str, Any] | list[Any] | None,
+        input_spec: Any | None,
+        input_spec_cls: Any,
+    ) -> tuple["ModelVersion", list[tuple[str | None, "ModelVersion"]] | None, Any]:
+        adapters_items = self._normalize_adapters(adapters)
+        if adapters_items:
+            self._require_lora_adapters_enabled(unavailable_what="Running a batch job with adapters")
+        if self._is_peft_adapter_version():
+            self._require_lora_adapters_enabled(unavailable_what="Running a batch job on a LoRA adapter")
+            if adapters_items:
+                self._adapter_invalid_argument(
+                    "batch inference: an adapter version does not accept adapters on the inference spec. "
+                    "The adapter is attached under its default FQN/VERSIONS alias."
+                )
+            pin = self._resolve_adapter_pin()
+            alias = self._default_adapter_alias(self)
+            input_spec = self._with_default_batch_params_model(input_spec, alias=alias, spec_cls=input_spec_cls)
+            return (pin, [(None, self)], input_spec)
+        return (self, adapters_items, input_spec)
+
     @overload
     def create_service(
         self,