Merge branch 'main' into ODSC-77200-auto-select-latest-conda-2

Author: ahosler

ads/aqua/cli.py

@@ -111,5 +111,5 @@ def install():
         wheel_file_path = os.environ.get(
             "AQUA_EXTENSTION_PATH", "/ads/extension/adsjupyterlab_aqua_extension*.whl"
         )
-        status = subprocess.run(f"pip install {wheel_file_path}", shell=True, check=False)
+        status = subprocess.run(f"pip install {wheel_file_path} --no-deps", shell=True, check=False)
         return status.check_returncode

ads/aqua/modeldeployment/deployment.py

@@ -34,6 +34,7 @@
     get_params_list,
     get_resource_name,
     get_restricted_params_by_container,
+    is_valid_ocid,
     load_gpu_shapes_index,
     validate_cmd_var,
 )
@@ -125,6 +126,9 @@ class AquaDeploymentApp(AquaApp):
         the GPU allocations for all compatible shapes.
     list_shapes(self, **kwargs) -> List[Dict]:
         Lists the valid model deployment shapes.
+    recommend_shape(self, **kwargs) -> ShapeRecommendationReport:
+        Generates a recommendation report or table of valid GPU deployment shapes
+        for the provided model and configuration.
 
     Note:
         Use `ads aqua deployment <method_name> --help` to get more details on the parameters available.
@@ -1283,56 +1287,97 @@ def validate_deployment_params(
             )
         return {"valid": True}
 
+    @cached(cache=TTLCache(maxsize=1, ttl=timedelta(minutes=1), timer=datetime.now))
     def recommend_shape(self, **kwargs) -> Union[Table, ShapeRecommendationReport]:
         """
-        For the CLI (set by default, generate_table = True), generates the table (in rich diff) with valid
-        GPU deployment shapes for the provided model and configuration.
+        Generates a recommendation report or table of valid GPU deployment shapes
+        for the provided model and configuration.
 
-        For the API (set generate_table = False), generates the JSON with valid
-        GPU deployment shapes for the provided model and configuration.
+        For CLI (default `generate_table=True`): generates a rich table.
+        For API (`generate_table=False`): returns a structured JSON report.
+        Example: ads aqua deployment recommend_shape --model-id meta-llama/Llama-3.3-70B-Instruct --generate_table false
 
-        Validates the input and determines whether recommendations are available.
-
-        Parameters
-        ----------
-        **kwargs
-            model_ocid : str
-                (Required) The OCID of the model to recommend feasible compute shapes for.
+        Args:
+            model_id : str
+                (Required) The OCID or Hugging Face model ID to recommend compute shapes for.
             generate_table : bool, optional
-                If True, generate and return a rich-diff table; if False, return a JSON response (default is False).
-            compartment_id : str, optional
-                The OCID of the user's compartment to use for the recommendation.
+                If True, generates and returns a table (default: False).
 
         Returns
         -------
-        Table (generate_table = True)
-            If `generate_table` is True, a table displaying the recommendation report with compatible deployment shapes,
-            or troubleshooting info if no shape is suitable.
+        Table
+            If `generate_table=True`, returns a table of shape recommendations.
 
-        ShapeRecommendationReport (generate_table = False)
-            If `generate_table` is False, a structured recommendation report with compatible deployment shapes,
-            or troubleshooting info and citing the largest shapes if no shape is suitable.
+        ShapeRecommendationReport
+            If `generate_table=False`, returns a structured recommendation report.
 
         Raises
         ------
         AquaValueError
-            If the model type is unsupported and no recommendation report can be generated.
+            If required parameters are missing or invalid.
         """
-        deployment_config = self.get_deployment_config(model_id=kwargs.get("model_id"))
-        kwargs["deployment_config"] = deployment_config
+        model_id = kwargs.pop("model_id", None)
+        if not model_id:
+            raise AquaValueError(
+                "The 'model_id' parameter is required to generate shape recommendations. "
+                "Please provide a valid OCID or Hugging Face model identifier."
+            )
+
+        logger.info(f"Starting shape recommendation for model_id: {model_id}")
+
+        self.telemetry.record_event_async(
+            category="aqua/deployment",
+            action="recommend_shape",
+            detail=get_ocid_substring(model_id, key_len=8)
+            if is_valid_ocid(ocid=model_id)
+            else model_id,
+            **kwargs,
+        )
+
+        if is_valid_ocid(ocid=model_id):
+            logger.debug(
+                f"Attempting to retrieve deployment configuration for model_id={model_id}"
+            )
+            try:
+                deployment_config = self.get_deployment_config(model_id=model_id)
+                kwargs["deployment_config"] = deployment_config
+                logger.debug(
+                    f"Retrieved deployment configuration for model: {model_id}"
+                )
+            except Exception as e:
+                logger.warning(
+                    f"Failed to retrieve deployment configuration for model_id={model_id}: {e}"
+                )
 
         try:
-            request = RequestRecommend(**kwargs)
+            request = RequestRecommend(model_id=model_id, **kwargs)
         except ValidationError as e:
             custom_error = build_pydantic_error_message(e)
-            raise AquaValueError(  # noqa: B904
-                f"Failed to request shape recommendation due to invalid input parameters: {custom_error}"
+            logger.error(
+                f"Validation failed for shape recommendation request: {custom_error}"
             )
+            raise AquaValueError(
+                f"Invalid input parameters for shape recommendation: {custom_error}"
+            ) from e
 
-        shape_recommend = AquaShapeRecommend()
-        shape_recommend_report = shape_recommend.which_shapes(request)
-
-        return shape_recommend_report
+        try:
+            shape_recommend = AquaShapeRecommend()
+            logger.info(
+                f"Running shape recommendation for model '{model_id}' "
+                f"with generate_table={getattr(request, 'generate_table', False)}"
+            )
+            shape_recommend_report = shape_recommend.which_shapes(request)
+            logger.info(f"Shape recommendation completed successfully for {model_id}")
+            return shape_recommend_report
+        except AquaValueError:
+            raise
+        except Exception as e:
+            logger.exception(
+                f"Unexpected error while generating shape recommendations: {e}"
+            )
+            raise AquaValueError(
+                f"An unexpected error occurred during shape recommendation: {e}"
+            ) from e
 
     @telemetry(entry_point="plugin=deployment&action=list_shapes", name="aqua")
     @cached(cache=TTLCache(maxsize=1, ttl=timedelta(minutes=5), timer=datetime.now))

ads/aqua/shaperecommend/recommend.py

@@ -2,9 +2,13 @@
 # Copyright (c) 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 re
 import shutil
-from typing import List, Union
+from typing import Dict, List, Optional, Tuple, Union
 
+from huggingface_hub import hf_hub_download
+from huggingface_hub.utils import HfHubHTTPError
 from pydantic import ValidationError
 from rich.table import Table
 
@@ -17,7 +21,9 @@
 )
 from ads.aqua.common.utils import (
     build_pydantic_error_message,
+    format_hf_custom_error_message,
     get_resource_type,
+    is_valid_ocid,
     load_config,
     load_gpu_shapes_index,
 )
@@ -37,6 +43,7 @@
     ShapeRecommendationReport,
     ShapeReport,
 )
+from ads.config import COMPARTMENT_OCID
 from ads.model.datascience_model import DataScienceModel
 from ads.model.service.oci_datascience_model_deployment import (
     OCIDataScienceModelDeployment,
@@ -91,20 +98,23 @@ def which_shapes(
         try:
             shapes = self.valid_compute_shapes(compartment_id=request.compartment_id)
 
-            ds_model = self._get_data_science_model(request.model_id)
-
-            model_name = ds_model.display_name if ds_model.display_name else ""
-
             if request.deployment_config:
+                if is_valid_ocid(request.model_id):
+                    ds_model = self._get_data_science_model(request.model_id)
+                    model_name = ds_model.display_name
+                else:
+                    model_name = request.model_id
+
                 shape_recommendation_report = (
                     ShapeRecommendationReport.from_deployment_config(
                         request.deployment_config, model_name, shapes
                     )
                 )
 
             else:
-                data = self._get_model_config(ds_model)
-
+                data, model_name = self._get_model_config_and_name(
+                    model_id=request.model_id,
+                )
                 llm_config = LLMConfig.from_raw_config(data)
 
                 shape_recommendation_report = self._summarize_shapes_for_seq_lens(
@@ -135,7 +145,57 @@ def which_shapes(
 
         return shape_recommendation_report
 
-    def valid_compute_shapes(self, compartment_id: str) -> List["ComputeShapeSummary"]:
+    def _get_model_config_and_name(
+        self,
+        model_id: str,
+    ) -> Tuple[Dict, str]:
+        """
+        Loads model configuration by trying OCID logic first, then falling back
+        to treating the model_id as a Hugging Face Hub ID.
+
+        Parameters
+        ----------
+        model_id : str
+            The model OCID or Hugging Face model ID.
+        # compartment_id : Optional[str]
+        #     The compartment OCID, used for searching the model catalog.
+
+        Returns
+        -------
+        Tuple[Dict, str]
+            A tuple containing:
+            - The model configuration dictionary.
+            - The display name for the model.
+        """
+        if is_valid_ocid(model_id):
+            logger.info(f"Detected OCID: Fetching OCI model config for '{model_id}'.")
+            ds_model = self._get_data_science_model(model_id)
+            config = self._get_model_config(ds_model)
+            model_name = ds_model.display_name
+        else:
+            logger.info(
+                f"Assuming Hugging Face model ID: Fetching config for '{model_id}'."
+            )
+            config = self._fetch_hf_config(model_id)
+            model_name = model_id
+
+        return config, model_name
+
+    def _fetch_hf_config(self, model_id: str) -> Dict:
+        """
+        Downloads a model's config.json from Hugging Face Hub using the
+        huggingface_hub library.
+        """
+        try:
+            config_path = hf_hub_download(repo_id=model_id, filename="config.json")
+            with open(config_path, encoding="utf-8") as f:
+                return json.load(f)
+        except HfHubHTTPError as e:
+            format_hf_custom_error_message(e)
+
+    def valid_compute_shapes(
+        self, compartment_id: Optional[str] = None
+    ) -> List["ComputeShapeSummary"]:
         """
         Returns a filtered list of GPU-only ComputeShapeSummary objects by reading and parsing a JSON file.
 
@@ -151,9 +211,23 @@ def valid_compute_shapes(self, compartment_id: str) -> List["ComputeShapeSummary
 
         Raises
         ------
-        ValueError
-            If the file cannot be opened, parsed, or the 'shapes' key is missing.
+        AquaValueError
+            If a compartment_id is not provided and cannot be found in the
+            environment variables.
         """
+        if not compartment_id:
+            compartment_id = COMPARTMENT_OCID
+            if compartment_id:
+                logger.info(f"Using compartment_id from environment: {compartment_id}")
+
+        if not compartment_id:
+            raise AquaValueError(
+                "A compartment OCID is required to list available shapes. "
+                "Please specify it using the --compartment_id parameter.\n\n"
+                "Example:\n"
+                'ads aqua deployment recommend_shape --model_id "<YOUR_MODEL_OCID>" --compartment_id "<YOUR_COMPARTMENT_OCID>"'
+            )
+
         oci_shapes = OCIDataScienceModelDeployment.shapes(compartment_id=compartment_id)
         set_user_shapes = {shape.name: shape for shape in oci_shapes}
 
@@ -206,6 +280,13 @@ def _rich_diff_table(shape_report: ShapeRecommendationReport) -> Table:
             if name
             else "Model Deployment Recommendations"
         )
+
+        header = (
+            f"{header}\n"
+            "Currently, only the VLLM container is supported. "
+            "All shape and parameter recommendations will be generated for the VLLM container."
+        )
+
         logger.debug(f"Table header set to: {header!r}")
 
         if shape_report.troubleshoot:
@@ -324,6 +405,7 @@ def _get_model_config(model: DataScienceModel):
         """
 
         model_task = model.freeform_tags.get("task", "").lower()
+        model_task = re.sub(r"-", "_", model_task)
         model_format = model.freeform_tags.get("model_format", "").lower()
 
         logger.info(f"Current model task type: {model_task}")

ads/aqua/shaperecommend/shape_report.py

@@ -29,21 +29,30 @@ class RequestRecommend(BaseModel):
     """
 
     model_id: str = Field(
-        ..., description="The OCID of the model to recommend feasible compute shapes."
+        ...,
+        description=(
+            "The OCID or Hugging Face ID of the model for which to recommend feasible compute shapes."
+        ),
     )
-    generate_table: Optional[bool] = (
-        Field(
-            True,
-            description="True - to generate the rich diff Table, False - generate the JSON response",
+
+    generate_table: Optional[bool] = Field(
+        True,
+        description=(
+            "If True, generate a rich formatted table as the response. "
+            "If False, return the recommendation as a JSON structure."
         ),
     )
+
     compartment_id: Optional[str] = Field(
-        COMPARTMENT_OCID, description="The OCID of user's compartment"
+        COMPARTMENT_OCID,
+        description="The OCID of the user's compartment.",
     )
 
-    deployment_config: Optional[AquaDeploymentConfig] = Field(
+    deployment_config: Optional["AquaDeploymentConfig"] = Field(
         None,
-        description="The deployment configuration for model (only available for service models).",
+        description=(
+            "The deployment configuration for the model (only available for service models)."
+        ),
     )
 
     class Config: