oracle-ads 2.12.8__py3-none-any.whl → 2.12.10__py3-none-any.whl

ads/aqua/extension/model_handler.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# Copyright (c) 2024 Oracle and/or its affiliates.
+# Copyright (c) 2024, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 from typing import Optional
@@ -8,6 +8,9 @@ from urllib.parse import urlparse
 from tornado.web import HTTPError
 
 from ads.aqua.common.decorator import handle_exceptions
+from ads.aqua.common.enums import (
+    CustomInferenceContainerTypeFamily,
+)
 from ads.aqua.common.errors import AquaRuntimeError, AquaValueError
 from ads.aqua.common.utils import (
     get_hf_model_info,
@@ -96,7 +99,7 @@ class AquaModelHandler(AquaAPIhandler):
         )
 
     @handle_exceptions
-    def post(self, *args, **kwargs):
+    def post(self, *args, **kwargs):  # noqa: ARG002
         """
         Handles post request for the registering any Aqua model.
         Raises
@@ -128,15 +131,27 @@ class AquaModelHandler(AquaAPIhandler):
         download_from_hf = (
             str(input_data.get("download_from_hf", "false")).lower() == "true"
         )
+        local_dir = input_data.get("local_dir")
+        cleanup_model_cache = (
+            str(input_data.get("cleanup_model_cache", "false")).lower() == "true"
+        )
         inference_container_uri = input_data.get("inference_container_uri")
         allow_patterns = input_data.get("allow_patterns")
         ignore_patterns = input_data.get("ignore_patterns")
+        freeform_tags = input_data.get("freeform_tags")
+        defined_tags = input_data.get("defined_tags")
+        ignore_model_artifact_check = (
+            str(input_data.get("ignore_model_artifact_check", "false")).lower()
+            == "true"
+        )
 
         return self.finish(
             AquaModelApp().register(
                 model=model,
                 os_path=os_path,
                 download_from_hf=download_from_hf,
+                local_dir=local_dir,
+                cleanup_model_cache=cleanup_model_cache,
                 inference_container=inference_container,
                 finetuning_container=finetuning_container,
                 compartment_id=compartment_id,
@@ -145,6 +160,9 @@ class AquaModelHandler(AquaAPIhandler):
                 inference_container_uri=inference_container_uri,
                 allow_patterns=allow_patterns,
                 ignore_patterns=ignore_patterns,
+                freeform_tags=freeform_tags,
+                defined_tags=defined_tags,
+                ignore_model_artifact_check=ignore_model_artifact_check,
             )
         )
 
@@ -159,7 +177,9 @@ class AquaModelHandler(AquaAPIhandler):
             raise HTTPError(400, Errors.NO_INPUT_DATA)
 
         inference_container = input_data.get("inference_container")
+        inference_container_uri = input_data.get("inference_container_uri")
         inference_containers = AquaModelApp.list_valid_inference_containers()
+        inference_containers.extend(CustomInferenceContainerTypeFamily.values())
         if (
             inference_container is not None
             and inference_container not in inference_containers
@@ -170,10 +190,14 @@ class AquaModelHandler(AquaAPIhandler):
 
         enable_finetuning = input_data.get("enable_finetuning")
         task = input_data.get("task")
-        app=AquaModelApp()
+        app = AquaModelApp()
         self.finish(
             app.edit_registered_model(
-                id, inference_container, enable_finetuning, task
+                id,
+                inference_container,
+                inference_container_uri,
+                enable_finetuning,
+                task,
             )
         )
         app.clear_model_details_cache(model_id=id)
@@ -218,7 +242,7 @@ class AquaHuggingFaceHandler(AquaAPIhandler):
         return None
 
     @handle_exceptions
-    def get(self, *args, **kwargs):
+    def get(self, *args, **kwargs):  # noqa: ARG002
         """
         Finds a list of matching models from hugging face based on query string provided from users.
 
@@ -239,7 +263,7 @@ class AquaHuggingFaceHandler(AquaAPIhandler):
         return self.finish({"models": models})
 
     @handle_exceptions
-    def post(self, *args, **kwargs):
+    def post(self, *args, **kwargs):  # noqa: ARG002
         """Handles post request for the HF Models APIs
 
         Raises

ads/aqua/extension/ui_handler.py

@@ -68,6 +68,8 @@ class AquaUIHandler(AquaAPIhandler):
             return self.list_buckets()
         elif paths.startswith("aqua/job/shapes"):
             return self.list_job_shapes()
+        elif paths.startswith("aqua/modeldeployment/shapes"):
+            return self.list_model_deployment_shapes()
         elif paths.startswith("aqua/vcn"):
             return self.list_vcn()
         elif paths.startswith("aqua/subnets"):
@@ -160,6 +162,15 @@ class AquaUIHandler(AquaAPIhandler):
             AquaUIApp().list_job_shapes(compartment_id=compartment_id, **kwargs)
         )
 
+    def list_model_deployment_shapes(self, **kwargs):
+        """Lists model deployment shapes available in the specified compartment."""
+        compartment_id = self.get_argument("compartment_id", default=COMPARTMENT_OCID)
+        return self.finish(
+            AquaUIApp().list_model_deployment_shapes(
+                compartment_id=compartment_id, **kwargs
+            )
+        )
+
     def list_vcn(self, **kwargs):
         """Lists the virtual cloud networks (VCNs) in the specified compartment."""
         compartment_id = self.get_argument("compartment_id", default=COMPARTMENT_OCID)
@@ -255,8 +266,9 @@ class AquaCLIHandler(AquaAPIhandler):
 __handlers__ = [
     ("logging/?([^/]*)", AquaUIHandler),
     ("compartments/?([^/]*)", AquaUIHandler),
-    # TODO: change url to evaluation/experiements/?([^/]*)
+    # TODO: change url to evaluation/experiments/?([^/]*)
     ("experiment/?([^/]*)", AquaUIHandler),
+    ("modeldeployment/?([^/]*)", AquaUIHandler),
     ("versionsets/?([^/]*)", AquaUIHandler),
     ("buckets/?([^/]*)", AquaUIHandler),
     ("job/shapes/?([^/]*)", AquaUIHandler),

ads/aqua/finetuning/constants.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright (c) 2024 Oracle and/or its affiliates.
+# Copyright (c) 2024, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 from ads.common.extended_enum import ExtendedEnumMeta
@@ -17,4 +16,8 @@ class FineTuneCustomMetadata(str, metaclass=ExtendedEnumMeta):
     SERVICE_MODEL_FINE_TUNE_CONTAINER = "finetune-container"
 
 
+class FineTuningRestrictedParams(str, metaclass=ExtendedEnumMeta):
+    OPTIMIZER = "optimizer"
+
+
 ENV_AQUA_FINE_TUNING_CONTAINER = "AQUA_FINE_TUNING_CONTAINER"

ads/aqua/finetuning/entities.py

@@ -1,18 +1,24 @@
 #!/usr/bin/env python
-# Copyright (c) 2024 Oracle and/or its affiliates.
+# Copyright (c) 2024, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
-from dataclasses import dataclass, field
-from typing import List, Optional
 
-from ads.aqua.data import AquaJobSummary
-from ads.common.serializer import DataClassSerializable
+import json
+from typing import List, Literal, Optional, Union
 
+from pydantic import Field, model_validator
 
-@dataclass(repr=False)
-class AquaFineTuningParams(DataClassSerializable):
-    epochs: int
+from ads.aqua.common.errors import AquaValueError
+from ads.aqua.config.utils.serializer import Serializable
+from ads.aqua.data import AquaResourceIdentifier
+from ads.aqua.finetuning.constants import FineTuningRestrictedParams
+
+
+class AquaFineTuningParams(Serializable):
+    """Class for maintaining aqua fine-tuning model parameters"""
+
+    epochs: Optional[int] = None
     learning_rate: Optional[float] = None
-    sample_packing: Optional[bool] = "auto"
+    sample_packing: Union[bool, None, Literal["auto"]] = "auto"
     batch_size: Optional[int] = (
         None  # make it batch_size for user, but internally this is micro_batch_size
     )
@@ -22,21 +28,59 @@ class AquaFineTuningParams(DataClassSerializable):
     lora_alpha: Optional[int] = None
     lora_dropout: Optional[float] = None
     lora_target_linear: Optional[bool] = None
-    lora_target_modules: Optional[List] = None
+    lora_target_modules: Optional[List[str]] = None
     early_stopping_patience: Optional[int] = None
     early_stopping_threshold: Optional[float] = None
 
+    class Config:
+        extra = "allow"
+
+    def to_dict(self) -> dict:
+        return json.loads(super().to_json(exclude_none=True))
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_restricted_fields(cls, data: dict):
+        # we may want to skip validation if loading data from config files instead of user entered parameters
+        validate = data.pop("_validate", True)
+        if not (validate and isinstance(data, dict)):
+            return data
+        restricted_params = [
+            param for param in data if param in FineTuningRestrictedParams.values()
+        ]
+        if restricted_params:
+            raise AquaValueError(
+                f"Found restricted parameter name: {restricted_params}"
+            )
+        return data
 
-@dataclass(repr=False)
-class AquaFineTuningSummary(AquaJobSummary, DataClassSerializable):
-    parameters: AquaFineTuningParams = field(default_factory=AquaFineTuningParams)
 
+class AquaFineTuningSummary(Serializable):
+    """Represents a summary of Aqua Finetuning job."""
 
-@dataclass(repr=False)
-class CreateFineTuningDetails(DataClassSerializable):
-    """Dataclass to create aqua model fine tuning.
+    id: str
+    name: str
+    console_url: str
+    lifecycle_state: str
+    lifecycle_details: str
+    time_created: str
+    tags: dict
+    experiment: AquaResourceIdentifier = Field(default_factory=AquaResourceIdentifier)
+    source: AquaResourceIdentifier = Field(default_factory=AquaResourceIdentifier)
+    job: AquaResourceIdentifier = Field(default_factory=AquaResourceIdentifier)
+    parameters: AquaFineTuningParams = Field(default_factory=AquaFineTuningParams)
 
-    Fields
+    class Config:
+        extra = "ignore"
+
+    def to_dict(self) -> dict:
+        return json.loads(super().to_json(exclude_none=True))
+
+
+class CreateFineTuningDetails(Serializable):
+    """Class to create aqua model fine-tuning instance.
+
+    Properties
     ------
     ft_source_id: str
         The fine tuning source id. Must be model ocid.
@@ -78,8 +122,14 @@ class CreateFineTuningDetails(DataClassSerializable):
         The log group id for fine tuning job infrastructure.
     log_id: (str, optional). Defaults to `None`.
         The log id for fine tuning job infrastructure.
+    watch_logs: (bool, optional). Defaults to `False`.
+        The flag to watch the job run logs when a fine-tuning job is created.
     force_overwrite: (bool, optional). Defaults to `False`.
         Whether to force overwrite the existing file in object storage.
+    freeform_tags: (dict, optional)
+        Freeform tags for the fine-tuning model
+    defined_tags: (dict, optional)
+        Defined tags for the fine-tuning model
     """
 
     ft_source_id: str
@@ -100,4 +150,10 @@ class CreateFineTuningDetails(DataClassSerializable):
     subnet_id: Optional[str] = None
     log_id: Optional[str] = None
     log_group_id: Optional[str] = None
+    watch_logs: Optional[bool] = False
     force_overwrite: Optional[bool] = False
+    freeform_tags: Optional[dict] = None
+    defined_tags: Optional[dict] = None
+
+    class Config:
+        extra = "ignore"

ads/aqua/finetuning/finetuning.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python
-# Copyright (c) 2024 Oracle and/or its affiliates.
+# Copyright (c) 2024, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 import json
 import os
-from dataclasses import MISSING, asdict, fields
+import time
+import traceback
 from typing import Dict
 
 from oci.data_science.models import (
@@ -12,12 +13,14 @@ from oci.data_science.models import (
     UpdateModelDetails,
     UpdateModelProvenanceDetails,
 )
+from pydantic import ValidationError
 
 from ads.aqua import logger
 from ads.aqua.app import AquaApp
 from ads.aqua.common.enums import Resource, Tags
 from ads.aqua.common.errors import AquaFileExistsError, AquaValueError
 from ads.aqua.common.utils import (
+    build_pydantic_error_message,
     get_container_image,
     upload_local_to_os,
 )
@@ -35,7 +38,11 @@ from ads.aqua.finetuning.constants import (
     ENV_AQUA_FINE_TUNING_CONTAINER,
     FineTuneCustomMetadata,
 )
-from ads.aqua.finetuning.entities import *
+from ads.aqua.finetuning.entities import (
+    AquaFineTuningParams,
+    AquaFineTuningSummary,
+    CreateFineTuningDetails,
+)
 from ads.common.auth import default_signer
 from ads.common.object_storage_details import ObjectStorageDetails
 from ads.common.utils import get_console_link
@@ -100,23 +107,11 @@ class AquaFineTuningApp(AquaApp):
         if not create_fine_tuning_details:
             try:
                 create_fine_tuning_details = CreateFineTuningDetails(**kwargs)
-            except:
-                allowed_create_fine_tuning_details = ", ".join(
-                    field.name for field in fields(CreateFineTuningDetails)
-                ).rstrip()
+            except ValidationError as ex:
+                custom_errors = build_pydantic_error_message(ex)
                 raise AquaValueError(
-                    "Invalid create fine tuning parameters. Allowable parameters are: "
-                    f"{allowed_create_fine_tuning_details}."
-                )
-
-        source = self.get_source(create_fine_tuning_details.ft_source_id)
-
-        # todo: revisit validation for fine tuned models
-        # if source.compartment_id != ODSC_MODEL_COMPARTMENT_OCID:
-        #     raise AquaValueError(
-        #         f"Fine tuning is only supported for Aqua service models in {ODSC_MODEL_COMPARTMENT_OCID}. "
-        #         "Use a valid Aqua service model id instead."
-        #     )
+                    f"Invalid parameters for creating a fine-tuned model. Error details: {custom_errors}."
+                ) from ex
 
         target_compartment = (
             create_fine_tuning_details.compartment_id or COMPARTMENT_OCID
@@ -148,29 +143,27 @@ class AquaFineTuningApp(AquaApp):
                 "Specify the subnet id via API or environment variable AQUA_JOB_SUBNET_ID."
             )
 
-        if create_fine_tuning_details.replica > DEFAULT_FT_REPLICA:
-            if not (
-                create_fine_tuning_details.log_id
-                and create_fine_tuning_details.log_group_id
-            ):
-                raise AquaValueError(
-                    f"Logging is required for fine tuning if replica is larger than {DEFAULT_FT_REPLICA}."
-                )
-
-        ft_parameters = None
-        try:
-            ft_parameters = AquaFineTuningParams(
-                **create_fine_tuning_details.ft_parameters,
+        if create_fine_tuning_details.replica > DEFAULT_FT_REPLICA and not (
+            create_fine_tuning_details.log_id
+            and create_fine_tuning_details.log_group_id
+        ):
+            raise AquaValueError(
+                f"Logging is required for fine tuning if replica is larger than {DEFAULT_FT_REPLICA}."
             )
-        except:
-            allowed_fine_tuning_parameters = ", ".join(
-                field.name for field in fields(AquaFineTuningParams)
-            ).rstrip()
+
+        if create_fine_tuning_details.watch_logs and not (
+            create_fine_tuning_details.log_id
+            and create_fine_tuning_details.log_group_id
+        ):
             raise AquaValueError(
-                "Invalid fine tuning parameters. Fine tuning parameters should "
-                f"be a dictionary with keys: {allowed_fine_tuning_parameters}."
+                "Logging is required for fine tuning if watch_logs is set to True. "
+                "Please provide log_id and log_group_id with the request parameters."
             )
 
+        ft_parameters = self._get_finetuning_params(
+            create_fine_tuning_details.ft_parameters
+        )
+
         experiment_model_version_set_id = create_fine_tuning_details.experiment_id
         experiment_model_version_set_name = create_fine_tuning_details.experiment_name
 
@@ -197,11 +190,11 @@ class AquaFineTuningApp(AquaApp):
                     auth=default_signer(),
                     force_overwrite=create_fine_tuning_details.force_overwrite,
                 )
-            except FileExistsError:
+            except FileExistsError as fe:
                 raise AquaFileExistsError(
                     f"Dataset {dataset_file} already exists in {create_fine_tuning_details.report_path}. "
                     "Please use a new dataset file name, report path or set `force_overwrite` as True."
-                )
+                ) from fe
             logger.debug(
                 f"Uploaded local file {ft_dataset_path} to object storage {dst_uri}."
             )
@@ -222,8 +215,12 @@ class AquaFineTuningApp(AquaApp):
             description=create_fine_tuning_details.experiment_description,
             compartment_id=target_compartment,
             project_id=target_project,
+            freeform_tags=create_fine_tuning_details.freeform_tags,
+            defined_tags=create_fine_tuning_details.defined_tags,
         )
 
+        source = self.get_source(create_fine_tuning_details.ft_source_id)
+
         ft_model_custom_metadata = ModelCustomMetadata()
         ft_model_custom_metadata.add(
             key=FineTuneCustomMetadata.FINE_TUNE_SOURCE,
@@ -272,6 +269,7 @@ class AquaFineTuningApp(AquaApp):
         ft_job_freeform_tags = {
             Tags.AQUA_TAG: UNKNOWN,
             Tags.AQUA_FINE_TUNED_MODEL_TAG: f"{source.id}#{source.display_name}",
+            **(create_fine_tuning_details.freeform_tags or {}),
         }
 
         ft_job = Job(name=ft_model.display_name).with_infrastructure(
@@ -286,6 +284,7 @@ class AquaFineTuningApp(AquaApp):
                 or DEFAULT_FT_BLOCK_STORAGE_SIZE
             )
             .with_freeform_tag(**ft_job_freeform_tags)
+            .with_defined_tag(**(create_fine_tuning_details.defined_tags or {}))
         )
 
         if not subnet_id:
@@ -353,6 +352,7 @@ class AquaFineTuningApp(AquaApp):
         ft_job_run = ft_job.run(
             name=ft_model.display_name,
             freeform_tags=ft_job_freeform_tags,
+            defined_tags=create_fine_tuning_details.defined_tags or {},
             wait=False,
         )
         logger.debug(
@@ -372,24 +372,30 @@ class AquaFineTuningApp(AquaApp):
             for metadata in ft_model_custom_metadata.to_dict()["data"]
         ]
 
-        source_freeform_tags = source.freeform_tags or {}
-        source_freeform_tags.pop(Tags.LICENSE, None)
-        source_freeform_tags.update({Tags.READY_TO_FINE_TUNE: "false"})
-        source_freeform_tags.update({Tags.AQUA_TAG: UNKNOWN})
-        source_freeform_tags.pop(Tags.BASE_MODEL_CUSTOM, None)
+        model_freeform_tags = source.freeform_tags or {}
+        model_freeform_tags.pop(Tags.LICENSE, None)
+        model_freeform_tags.pop(Tags.BASE_MODEL_CUSTOM, None)
+
+        model_freeform_tags = {
+            **model_freeform_tags,
+            Tags.READY_TO_FINE_TUNE: "false",
+            Tags.AQUA_TAG: UNKNOWN,
+            Tags.AQUA_FINE_TUNED_MODEL_TAG: f"{source.id}#{source.display_name}",
+            **(create_fine_tuning_details.freeform_tags or {}),
+        }
+        model_defined_tags = create_fine_tuning_details.defined_tags or {}
 
         self.update_model(
             model_id=ft_model.id,
             update_model_details=UpdateModelDetails(
                 custom_metadata_list=updated_custom_metadata_list,
-                freeform_tags={
-                    Tags.AQUA_FINE_TUNED_MODEL_TAG: (
-                        f"{source.id}#{source.display_name}"
-                    ),
-                    **source_freeform_tags,
-                },
+                freeform_tags=model_freeform_tags,
+                defined_tags=model_defined_tags,
             ),
         )
+        logger.debug(
+            f"Successfully updated model custom metadata list and freeform tags for the model {ft_model.id}."
+        )
 
         self.update_model_provenance(
             model_id=ft_model.id,
@@ -397,6 +403,9 @@ class AquaFineTuningApp(AquaApp):
                 training_id=ft_job_run.id
             ),
         )
+        logger.debug(
+            f"Successfully updated model provenance for the model {ft_model.id}."
+        )
 
         # tracks the shape and replica used for fine-tuning the service models
         telemetry_kwargs = (
@@ -424,6 +433,20 @@ class AquaFineTuningApp(AquaApp):
             value=source.display_name,
         )
 
+        if create_fine_tuning_details.watch_logs:
+            logger.info(
+                f"Watching fine-tuning job run logs for {ft_job_run.id}. Press Ctrl+C to stop watching logs.\n"
+            )
+            try:
+                ft_job_run.watch()
+            except KeyboardInterrupt:
+                logger.info(f"\nStopped watching logs for {ft_job_run.id}.\n")
+                time.sleep(1)
+            except Exception:
+                logger.debug(
+                    f"Something unexpected occurred while watching logs.\n{traceback.format_exc()}"
+                )
+
         return AquaFineTuningSummary(
             id=ft_model.id,
             name=ft_model.display_name,
@@ -462,17 +485,15 @@ class AquaFineTuningApp(AquaApp):
                     region=self.region,
                 ),
             ),
-            tags=dict(
-                aqua_finetuning=Tags.AQUA_FINE_TUNING,
-                finetuning_job_id=ft_job.id,
-                finetuning_source=source.id,
-                finetuning_experiment_id=experiment_model_version_set_id,
-            ),
-            parameters={
-                key: value
-                for key, value in asdict(ft_parameters).items()
-                if value is not None
+            tags={
+                "aqua_finetuning": Tags.AQUA_FINE_TUNING,
+                "finetuning_job_id": ft_job.id,
+                "finetuning_source": source.id,
+                "finetuning_experiment_id": experiment_model_version_set_id,
+                **model_freeform_tags,
+                **model_defined_tags,
             },
+            parameters=ft_parameters,
         )
 
     def _build_fine_tuning_runtime(
@@ -535,7 +556,7 @@ class AquaFineTuningApp(AquaApp):
     ) -> str:
         """Builds the oci launch cmd for fine tuning container runtime."""
         oci_launch_cmd = f"--training_data {dataset_path} --output_dir {report_path} --val_set_size {val_set_size} "
-        for key, value in asdict(parameters).items():
+        for key, value in parameters.to_dict().items():
             if value is not None:
                 if key == "batch_size":
                     oci_launch_cmd += f"--micro_{key} {value} "
@@ -574,7 +595,7 @@ class AquaFineTuningApp(AquaApp):
         config = self.get_config(model_id, AQUA_MODEL_FINETUNING_CONFIG)
         if not config:
             logger.debug(
-                f"Fine-tuning config for custom model: {model_id} is not available."
+                f"Fine-tuning config for custom model: {model_id} is not available. Use defaults."
             )
         return config
 
@@ -600,15 +621,36 @@ class AquaFineTuningApp(AquaApp):
         default_params = {"params": {}}
         finetuning_config = self.get_finetuning_config(model_id)
         config_parameters = finetuning_config.get("configuration", UNKNOWN_DICT)
-        dataclass_fields = {field.name for field in fields(AquaFineTuningParams)}
+        dataclass_fields = self._get_finetuning_params(
+            config_parameters, validate=False
+        ).to_dict()
         for name, value in config_parameters.items():
-            if name == "micro_batch_size":
-                name = "batch_size"
             if name in dataclass_fields:
+                if name == "micro_batch_size":
+                    name = "batch_size"
                 default_params["params"][name] = value
 
         return default_params
 
+    @staticmethod
+    def _get_finetuning_params(
+        params: Dict = None, validate: bool = True
+    ) -> AquaFineTuningParams:
+        """
+        Get and validate the fine-tuning params, and return an error message if validation fails. In order to skip
+        @model_validator decorator's validation, pass validate=False.
+        """
+        try:
+            finetuning_params = AquaFineTuningParams(
+                **{**params, **{"_validate": validate}}
+            )
+        except ValidationError as ex:
+            custom_errors = build_pydantic_error_message(ex)
+            raise AquaValueError(
+                f"Invalid finetuning parameters. Error details: {custom_errors}."
+            ) from ex
+        return finetuning_params
+
     def validate_finetuning_params(self, params: Dict = None) -> Dict:
         """Validate if the fine-tuning parameters passed by the user can be overridden. Parameter values are not
         validated, only param keys are validated.
@@ -622,19 +664,5 @@ class AquaFineTuningApp(AquaApp):
         -------
             Return a list of restricted params.
         """
-        try:
-            AquaFineTuningParams(
-                **params,
-            )
-        except Exception as e:
-            logger.debug(str(e))
-            allowed_fine_tuning_parameters = ", ".join(
-                f"{field.name} (required)" if field.default is MISSING else field.name
-                for field in fields(AquaFineTuningParams)
-            ).rstrip()
-            raise AquaValueError(
-                f"Invalid fine tuning parameters. Allowable parameters are: "
-                f"{allowed_fine_tuning_parameters}."
-            )
-
-        return dict(valid=True)
+        self._get_finetuning_params(params or {})
+        return {"valid": True}

ads/aqua/model/entities.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# Copyright (c) 2024 Oracle and/or its affiliates.
+# Copyright (c) 2024, 2025 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 """
@@ -283,6 +283,7 @@ class ImportModelDetails(CLIBuilderMixin):
     os_path: str
     download_from_hf: Optional[bool] = True
     local_dir: Optional[str] = None
+    cleanup_model_cache: Optional[bool] = False
     inference_container: Optional[str] = None
     finetuning_container: Optional[str] = None
     compartment_id: Optional[str] = None
@@ -291,6 +292,9 @@ class ImportModelDetails(CLIBuilderMixin):
     inference_container_uri: Optional[str] = None
     allow_patterns: Optional[List[str]] = None
     ignore_patterns: Optional[List[str]] = None
+    freeform_tags: Optional[dict] = None
+    defined_tags: Optional[dict] = None
+    ignore_model_artifact_check: Optional[bool] = None
 
     def __post_init__(self):
         self._command = "model register"