update logging for finetuning operations

Author: VipulMascarenhas

ads/aqua/common/utils.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/
 """AQUA utils and constants."""
 
@@ -12,11 +12,12 @@
 import re
 import shlex
 import subprocess
+from dataclasses import fields
 from datetime import datetime, timedelta
 from functools import wraps
 from pathlib import Path
 from string import Template
-from typing import List, Union
+from typing import Any, List, Optional, Type, TypeVar, Union
 
 import fsspec
 import oci
@@ -74,6 +75,7 @@
 from ads.model import DataScienceModel, ModelVersionSet
 
 logger = logging.getLogger("ads.aqua")
+T = TypeVar("T")
 
 
 class LifecycleStatus(str, metaclass=ExtendedEnumMeta):
@@ -788,7 +790,9 @@ def get_ocid_substring(ocid: str, key_len: int) -> str:
     return ocid[-key_len:] if ocid and len(ocid) > key_len else ""
 
 
-def upload_folder(os_path: str, local_dir: str, model_name: str, exclude_pattern: str = None) -> str:
+def upload_folder(
+    os_path: str, local_dir: str, model_name: str, exclude_pattern: str = None
+) -> str:
     """Upload the local folder to the object storage
 
     Args:
@@ -1159,3 +1163,44 @@ def validate_cmd_var(cmd_var: List[str], overrides: List[str]) -> List[str]:
 
     combined_cmd_var = cmd_var + overrides
     return combined_cmd_var
+
+
+def validate_dataclass_params(dataclass_type: Type[T], **kwargs: Any) -> Optional[T]:
+    """This method tries to initialize a dataclass with the provided keyword arguments. It handles
+    errors related to missing, unexpected or invalid arguments.
+
+    Parameters
+    ----------
+    dataclass_type (Type[T]):
+        the dataclass type to instantiate.
+    kwargs (Any):
+        the keyword arguments to initialize the dataclass
+    Returns
+    -------
+    Optional[T]
+        instance of dataclass if successfully initialized
+    """
+
+    try:
+        return dataclass_type(**kwargs)
+    except TypeError as ex:
+        error_message = str(ex)
+        allowed_params = ", ".join(
+            field.name for field in fields(dataclass_type)
+        ).rstrip()
+        if "__init__() missing" in error_message:
+            missing_params = error_message.split("missing ")[1]
+            raise AquaValueError(
+                "Error: Missing required parameters: "
+                f"{missing_params}. Allowable parameters are: {allowed_params}."
+            ) from ex
+        elif "__init__() got an unexpected keyword argument" in error_message:
+            unexpected_param = error_message.split("argument '")[1].rstrip("'")
+            raise AquaValueError(
+                "Error: Unexpected parameter: "
+                f"{unexpected_param}. Allowable parameters are: {allowed_params}."
+            ) from ex
+        else:
+            raise AquaValueError(
+                "Invalid parameters. Allowable parameters are: " f"{allowed_params}."
+            ) from ex

ads/aqua/extension/finetune_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/
 
 
@@ -33,7 +33,7 @@ def get(self, id=""):
             raise HTTPError(400, f"The request {self.request.path} is invalid.")
 
     @handle_exceptions
-    def post(self, *args, **kwargs):
+    def post(self, *args, **kwargs):  # noqa: ARG002
         """Handles post request for the fine-tuning API
 
         Raises
@@ -43,8 +43,8 @@ def post(self, *args, **kwargs):
         """
         try:
             input_data = self.get_json_body()
-        except Exception:
-            raise HTTPError(400, Errors.INVALID_INPUT_DATA_FORMAT)
+        except Exception as ex:
+            raise HTTPError(400, Errors.INVALID_INPUT_DATA_FORMAT) from ex
 
         if not input_data:
             raise HTTPError(400, Errors.NO_INPUT_DATA)
@@ -71,7 +71,7 @@ def get(self, model_id):
         )
 
     @handle_exceptions
-    def post(self, *args, **kwargs):
+    def post(self, *args, **kwargs):  # noqa: ARG002
         """Handles post request for the finetuning param handler API.
 
         Raises
@@ -81,15 +81,15 @@ def post(self, *args, **kwargs):
         """
         try:
             input_data = self.get_json_body()
-        except Exception:
-            raise HTTPError(400, Errors.INVALID_INPUT_DATA_FORMAT)
+        except Exception as ex:
+            raise HTTPError(400, Errors.INVALID_INPUT_DATA_FORMAT) from ex
 
         if not input_data:
             raise HTTPError(400, Errors.NO_INPUT_DATA)
 
         params = input_data.get("params", None)
         return self.finish(
-            AquaFineTuningApp().validate_finetuning_params(
+            AquaFineTuningApp.validate_finetuning_params(
                 params=params,
             )
         )

ads/aqua/finetuning/finetuning.py

@@ -1,10 +1,10 @@
 #!/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
+from dataclasses import asdict, fields
 from typing import Dict
 
 from oci.data_science.models import (
@@ -20,6 +20,7 @@
 from ads.aqua.common.utils import (
     get_container_image,
     upload_local_to_os,
+    validate_dataclass_params,
 )
 from ads.aqua.constants import (
     DEFAULT_FT_BATCH_SIZE,
@@ -102,26 +103,10 @@ def create(
             The instance of AquaFineTuningSummary.
         """
         if not create_fine_tuning_details:
-            try:
-                create_fine_tuning_details = CreateFineTuningDetails(**kwargs)
-            except Exception as ex:
-                allowed_create_fine_tuning_details = ", ".join(
-                    field.name for field in fields(CreateFineTuningDetails)
-                ).rstrip()
-                raise AquaValueError(
-                    "Invalid create fine tuning parameters. Allowable parameters are: "
-                    f"{allowed_create_fine_tuning_details}."
-                ) from ex
+            validate_dataclass_params(CreateFineTuningDetails, **kwargs)
 
         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."
-        #     )
-
         target_compartment = (
             create_fine_tuning_details.compartment_id or COMPARTMENT_OCID
         )
@@ -401,13 +386,19 @@ def create(
                 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,
             update_model_provenance_details=UpdateModelProvenanceDetails(
                 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 = (
@@ -587,7 +578,7 @@ def get_finetuning_config(self, model_id: str) -> Dict:
         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
 
@@ -622,7 +613,8 @@ def get_finetuning_default_params(self, model_id: str) -> Dict:
 
         return default_params
 
-    def validate_finetuning_params(self, params: Dict = None) -> Dict:
+    @staticmethod
+    def validate_finetuning_params(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.
 
@@ -633,21 +625,7 @@ def validate_finetuning_params(self, params: Dict = None) -> Dict:
 
         Returns
         -------
-            Return a list of restricted params.
+            Return a dict with value true if valid, else raises AquaValueError.
         """
-        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}."
-            ) from e
-
+        validate_dataclass_params(AquaFineTuningParams, **(params or {}))
         return {"valid": True}