change: improve jumpstart hyperparam validation logic

Author: evakravi

src/sagemaker/environment_variables.py

@@ -44,7 +44,9 @@ def retrieve_default(
         ValueError: If the combination of arguments specified is not supported.
     """
     if not jumpstart_utils.is_jumpstart_model_input(model_id, model_version):
-        raise ValueError("Must specify `model_id` and `model_version` when retrieving script URIs.")
+        raise ValueError(
+            "Must specify `model_id` and `model_version` when retrieving environment variables."
+        )
 
     # mypy type checking require these assertions
     assert model_id is not None

src/sagemaker/hyperparameters.py

@@ -53,7 +53,9 @@ def retrieve_default(
         ValueError: If the combination of arguments specified is not supported.
     """
     if not jumpstart_utils.is_jumpstart_model_input(model_id, model_version):
-        raise ValueError("Must specify `model_id` and `model_version` when retrieving script URIs.")
+        raise ValueError(
+            "Must specify `model_id` and `model_version` when retrieving hyperparameters."
+        )
 
     return artifacts._retrieve_default_hyperparameters(
         model_id, model_version, region, include_container_hyperparameters
@@ -84,11 +86,16 @@ def validate(
           If set to ``VALIDATE_ALL``, all hyperparameters for the model will be validated.
           (Default: None)
 
+    Raises:
+        JumpStartHyperparametersError: If the hyperparameter is not formatted correctly,
+            according to its specs in the model metadata.
 
     """
 
     if not jumpstart_utils.is_jumpstart_model_input(model_id, model_version):
-        raise ValueError("Must specify `model_id` and `model_version` when retrieving script URIs.")
+        raise ValueError(
+            "Must specify `model_id` and `model_version` when validating hyperparameters."
+        )
 
     if hyperparameters is None:
         raise ValueError("Must specify hyperparameters.")

src/sagemaker/jumpstart/enums.py

@@ -1,3 +1,18 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+"""This module stores enums related to SageMaker JumpStart."""
+from __future__ import absolute_import
+
 from enum import Enum
 
 
@@ -42,3 +57,4 @@ class VariableTypes(str, Enum):
     TEXT = "text"
     INT = "int"
     FLOAT = "float"
+    BOOL = "bool"

src/sagemaker/jumpstart/exceptions.py

@@ -11,12 +11,13 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 """This module stores exceptions related to SageMaker JumpStart."""
+from __future__ import absolute_import
 
 from typing import Optional
 
 
 class JumpStartHyperparametersError(Exception):
-    """Exception raised for errors with hyperparameters for JumpStart models."""
+    """Exception raised for bad hyperparameters of a JumpStart model."""
 
     def __init__(
         self,

src/sagemaker/jumpstart/types.py

@@ -181,6 +181,8 @@ class JumpStartHyperparameter(JumpStartDataHolderType):
         "scope",
         "min",
         "max",
+        "exclusive_min",
+        "exclusive_max",
     }
 
     def __init__(self, spec: Dict[str, Any]):
@@ -215,6 +217,14 @@ def from_json(self, json_obj: Dict[str, Any]) -> None:
         if max_val is not None:
             self.max = max_val
 
+        exclusive_min_val = json_obj.get("exclusive_min")
+        if exclusive_min_val is not None:
+            self.exclusive_min = exclusive_min_val
+
+        exclusive_max_val = json_obj.get("exclusive_max")
+        if exclusive_max_val is not None:
+            self.exclusive_max = exclusive_max_val
+
     def to_json(self) -> Dict[str, Any]:
         """Returns json representation of JumpStartHyperparameter object."""
         json_obj = {att: getattr(self, att) for att in self.__slots__ if hasattr(self, att)}

src/sagemaker/jumpstart/validators.py

@@ -12,7 +12,7 @@
 # language governing permissions and limitations under the License.
 """This module contains validators related to SageMaker JumpStart."""
 from __future__ import absolute_import
-from typing import Any, List, Optional
+from typing import Any, Dict, List, Optional
 from sagemaker.jumpstart.constants import JUMPSTART_DEFAULT_REGION_NAME
 
 from sagemaker.jumpstart.enums import HyperparameterValidationMode, VariableScope, VariableTypes
@@ -33,36 +33,88 @@ def _validate_hyperparameter(
       hyperparameter_value (Any): The value of the hyperparemter to validate.
       hyperparameter_specs (List[JumpStartHyperparameter]): List of ``JumpStartHyperparameter`` to
         use when validating the hyperparameter.
+
+    Raises:
+        JumpStartHyperparametersError: If the hyperparameter is not formatted correctly,
+            according to its specs in the model metadata.
     """
     hyperparameter_spec = [
         spec for spec in hyperparameter_specs if spec.name == hyperparameter_name
     ]
     if len(hyperparameter_spec) == 0:
         raise JumpStartHyperparametersError(
-            f"Unable to perform validation -- cannot find hyperparameter '{hyperparameter_name}' in model specs."
+            f"Unable to perform validation -- cannot find hyperparameter '{hyperparameter_name}' "
+            "in model specs."
+        )
+
+    if len(hyperparameter_spec) > 1:
+        raise JumpStartHyperparametersError(
+            f"Unable to perform validation -- found multiple hyperparameter "
+            f"'{hyperparameter_name}' in model specs."
         )
+
     hyperparameter_spec = hyperparameter_spec[0]
 
-    if hyperparameter_spec.type == VariableTypes.TEXT.value:
-        if type(hyperparameter_value) != str:
+    if hyperparameter_spec.type == VariableTypes.BOOL.value:
+        if isinstance(hyperparameter_value, bool):
+            return
+        if not isinstance(hyperparameter_value, str):
+            raise JumpStartHyperparametersError(
+                f"Expecting boolean valued hyperparameter, but got '{str(hyperparameter_value)}'."
+            )
+        if str(hyperparameter_value).lower() not in ["true", "false"]:
             raise JumpStartHyperparametersError(
-                f"Expecting text valued hyperparameter to have string type."
+                f"Expecting boolean valued hyperparameter, but got '{str(hyperparameter_value)}'."
+            )
+    elif hyperparameter_spec.type == VariableTypes.TEXT.value:
+        if not isinstance(hyperparameter_value, str):
+            raise JumpStartHyperparametersError(
+                "Expecting text valued hyperparameter to have string type."
             )
 
-        if getattr(hyperparameter_spec, "options", None):
+        if hasattr(hyperparameter_spec, "options"):
             if hyperparameter_value not in hyperparameter_spec.options:
                 raise JumpStartHyperparametersError(
-                    f"Hyperparameter '{hyperparameter_name}' must have one of the following values: "
-                    ", ".join(hyperparameter_spec.options)
+                    f"Hyperparameter '{hyperparameter_name}' must have one of the following "
+                    f"values: {', '.join(hyperparameter_spec.options)}"
+                )
+
+        if hasattr(hyperparameter_spec, "min"):
+            if len(hyperparameter_value) < hyperparameter_spec.min:
+                raise JumpStartHyperparametersError(
+                    f"Hyperparameter '{hyperparameter_name}' must have length no less than "
+                    f"{hyperparameter_spec.min}"
+                )
+
+        if hasattr(hyperparameter_spec, "exclusive_min"):
+            if len(hyperparameter_value) <= hyperparameter_spec.exclusive_min:
+                raise JumpStartHyperparametersError(
+                    f"Hyperparameter '{hyperparameter_name}' must have length greater than "
+                    f"{hyperparameter_spec.exclusive_min}"
+                )
+
+        if hasattr(hyperparameter_spec, "max"):
+            if len(hyperparameter_value) > hyperparameter_spec.max:
+                raise JumpStartHyperparametersError(
+                    f"Hyperparameter '{hyperparameter_name}' must have length no greater than "
+                    f"{hyperparameter_spec.max}"
+                )
+
+        if hasattr(hyperparameter_spec, "exclusive_max"):
+            if len(hyperparameter_value) >= hyperparameter_spec.exclusive_max:
+                raise JumpStartHyperparametersError(
+                    f"Hyperparameter '{hyperparameter_name}' must have length less than "
+                    f"{hyperparameter_spec.exclusive_max}"
                 )
 
     # validate numeric types
-    if hyperparameter_spec.type in [VariableTypes.INT.value, VariableTypes.FLOAT.value]:
+    elif hyperparameter_spec.type in [VariableTypes.INT.value, VariableTypes.FLOAT.value]:
         try:
             numeric_hyperparam_value = float(hyperparameter_value)
         except ValueError:
             raise JumpStartHyperparametersError(
-                f"Hyperparameter '{hyperparameter_name}' must be numeric type ('{hyperparameter_value}')."
+                f"Hyperparameter '{hyperparameter_name}' must be numeric type "
+                f"('{hyperparameter_value}')."
             )
 
         if hyperparameter_spec.type == VariableTypes.INT.value:
@@ -72,29 +124,46 @@ def _validate_hyperparameter(
                 start_index = 1
             if not hyperparameter_value_str[start_index:].isdigit():
                 raise JumpStartHyperparametersError(
-                    f"Hyperparameter '{hyperparameter_name}' must be integer type ('{hyperparameter_value}')."
+                    f"Hyperparameter '{hyperparameter_name}' must be integer type "
+                    "('{hyperparameter_value}')."
                 )
 
-        if getattr(hyperparameter_spec, "min", None):
+        if hasattr(hyperparameter_spec, "min"):
             if numeric_hyperparam_value < hyperparameter_spec.min:
                 raise JumpStartHyperparametersError(
-                    f"Hyperparameter '{hyperparameter_name}' can be no less than {hyperparameter_spec.min}."
+                    f"Hyperparameter '{hyperparameter_name}' can be no less than "
+                    "{hyperparameter_spec.min}."
                 )
 
-        if getattr(hyperparameter_spec, "max", None):
+        if hasattr(hyperparameter_spec, "max"):
             if numeric_hyperparam_value > hyperparameter_spec.max:
                 raise JumpStartHyperparametersError(
-                    f"Hyperparameter '{hyperparameter_name}' can be no greater than {hyperparameter_spec.max}."
+                    f"Hyperparameter '{hyperparameter_name}' can be no greater than "
+                    "{hyperparameter_spec.max}."
+                )
+
+        if hasattr(hyperparameter_spec, "exclusive_min"):
+            if numeric_hyperparam_value <= hyperparameter_spec.exclusive_min:
+                raise JumpStartHyperparametersError(
+                    f"Hyperparameter '{hyperparameter_name}' must be greater than "
+                    "{hyperparameter_spec.exclusive_min}."
+                )
+
+        if hasattr(hyperparameter_spec, "exclusive_max"):
+            if numeric_hyperparam_value >= hyperparameter_spec.exclusive_max:
+                raise JumpStartHyperparametersError(
+                    f"Hyperparameter '{hyperparameter_name}' must be less than than "
+                    "{hyperparameter_spec.exclusive_max}."
                 )
 
 
 def validate_hyperparameters(
     model_id: str,
     model_version: str,
-    hyperparameters: dict,
+    hyperparameters: Dict[str, Any],
     validation_mode: HyperparameterValidationMode = HyperparameterValidationMode.VALIDATE_PROVIDED,
     region: Optional[str] = JUMPSTART_DEFAULT_REGION_NAME,
-):
+) -> None:
     """Validate hyperparameters for JumpStart models.
 
     Args:
@@ -109,6 +178,10 @@ def validate_hyperparameters(
         region (str): Region for which to validate hyperparameters. (Default: JumpStart
           default region).
 
+    Raises:
+        JumpStartHyperparametersError: If the hyperparameter is not formatted correctly,
+            according to its specs in the model metadata.
+
     """
 
     if validation_mode is None:

src/sagemaker/model_uris.py

@@ -46,7 +46,7 @@ def retrieve(
         ValueError: If the combination of arguments specified is not supported.
     """
     if not jumpstart_utils.is_jumpstart_model_input(model_id, model_version):
-        raise ValueError("Must specify `model_id` and `model_version` when retrieving script URIs.")
+        raise ValueError("Must specify `model_id` and `model_version` when retrieving model URIs.")
 
     # mypy type checking require these assertions
     assert model_id is not None