update messaging

Author: gwang111

src/sagemaker/serve/validations/optimization.py

@@ -41,18 +41,6 @@ class _OptimizationCombination(BaseModel):
 
     def validate_against(self, optimization_combination, rule_set: _OptimizationContainer):
         """Validator for optimization containers"""
-        print(optimization_combination)
-        print(rule_set)
-        print(optimization_combination.speculative_decoding.issubset(self.speculative_decoding))
-
-        # check the case where no optimization combination is provided
-        if (
-            optimization_combination.compilation == {None}
-            and optimization_combination.quantization_technique == {None}
-            and optimization_combination.speculative_decoding == {None}
-            and optimization_combination.sharding == {None}
-        ):
-            raise ValueError("no optimization configurations")
 
         # check the validity of each individual field
         if not optimization_combination.compilation.issubset(self.compilation):
@@ -68,17 +56,22 @@ def validate_against(self, optimization_combination, rule_set: _OptimizationCont
             raise ValueError("Sharding")
 
         # optimization technique combinations that need to be validated
+        if optimization_combination.compilation and optimization_combination.speculative_decoding:
+            copy_compilation = optimization_combination.compilation.copy()
+            copy_speculative_decoding = optimization_combination.speculative_decoding.copy()
+            if (
+                copy_compilation.pop() and copy_speculative_decoding.pop()
+            ):  # Check that the 2 techniques are not None
+                raise ValueError("Compilation and Speculative Decoding together")
+
         if rule_set == _OptimizationContainer.TRT:
             if (
                 optimization_combination.compilation
-                and optimization_combination.speculative_decoding
+                and not optimization_combination.quantization_technique
+                or not optimization_combination.compilation
+                and optimization_combination.quantization_technique
             ):
-                copy_compilation = optimization_combination.compilation.copy()
-                copy_speculative_decoding = optimization_combination.speculative_decoding.copy()
-                if (
-                    copy_compilation.pop() and copy_speculative_decoding.pop()
-                ):  # Check that the 2 techniques are not None
-                    raise ValueError("Compilation and Speculative Decoding")
+                raise ValueError("Compilation must be provided with Quantization")
         else:
             copy_compilation = optimization_combination.compilation.copy()
             copy_quantization_technique = optimization_combination.quantization_technique.copy()
@@ -106,7 +99,7 @@ def validate_against(self, optimization_combination, rule_set: _OptimizationCont
     "supported_instance_families": {"p4d", "p4de", "p5", "g5", "g6"},
     "optimization_combination": _OptimizationCombination(
         optimization_container=_OptimizationContainer.VLLM,
-        compilation=FALSY_SET,
+        compilation=TRUTHY_SET,
         quantization_technique={None, "awq", "fp8"},
         speculative_decoding=TRUTHY_SET,
         sharding=TRUTHY_SET,
@@ -123,11 +116,6 @@ def validate_against(self, optimization_combination, rule_set: _OptimizationCont
     ),
 }
 
-VALIDATION_ERROR_MSG = (
-    "Optimizations for {optimization_container} that use {optimization_technique} "
-    "are not currently supported on {instance_type} instances"
-)
-
 
 def _validate_optimization_configuration(
     instance_type: str,
@@ -150,7 +138,8 @@ def _validate_optimization_configuration(
         and instance_family not in NEURON_CONFIGURATION["supported_instance_families"]
     ):
         invalid_instance_type_msg = (
-            f"Optimizations that uses {instance_type} instance type are not currently supported"
+            f"Optimizations that uses {instance_type} instance type are "
+            "not currently supported both on GPU and Neuron instances"
         )
         raise ValueError(invalid_instance_type_msg)
 
@@ -166,13 +155,26 @@ def _validate_optimization_configuration(
 
     optimization_combination = _OptimizationCombination(
         compilation={None if compilation_config is None else True},
-        speculative_decoding={
-            None if speculative_decoding_config is None else True
-        },
+        speculative_decoding={None if speculative_decoding_config is None else True},
         sharding={None if sharding_config is None else True},
         quantization_technique={quantization_technique},
     )
 
+    # Check the case where no optimization combination is provided
+    if (
+        optimization_combination.compilation == {None}
+        and optimization_combination.quantization_technique == {None}
+        and optimization_combination.speculative_decoding == {None}
+        and optimization_combination.sharding == {None}
+    ):
+        raise ValueError(
+            (
+                "Optimizations that provide no optimization configs "
+                "are currently not support on both GPU and Neuron instances."
+            )
+        )
+
+    # Validate based off of instance type
     if instance_family in NEURON_CONFIGURATION["supported_instance_families"]:
         try:
             (
@@ -182,11 +184,7 @@ def _validate_optimization_configuration(
             )
         except ValueError as neuron_compare_error:
             raise ValueError(
-                VALIDATION_ERROR_MSG.format(
-                    optimization_container=_OptimizationContainer.NEURON.value,
-                    optimization_technique=str(neuron_compare_error),
-                    instance_type="Neuron",
-                )
+                f"Optimizations that use {neuron_compare_error} are not supported on Neuron instances."
             )
     else:
         try:
@@ -203,19 +201,16 @@ def _validate_optimization_configuration(
                     )
                 )
             except ValueError as vllm_compare_error:
-                trt_error_msg = VALIDATION_ERROR_MSG.format(
-                    optimization_container=_OptimizationContainer.TRT.value,
-                    optimization_technique=str(trt_compare_error),
-                    instance_type="GPU",
-                )
-                vllm_error_msg = VALIDATION_ERROR_MSG.format(
-                    optimization_container=_OptimizationContainer.VLLM.value,
-                    optimization_technique=str(vllm_compare_error),
-                    instance_type="GPU",
-                )
-                joint_error_msg = f"""
-                Optimization cannot be performed for the following reasons:
-                - {trt_error_msg}
-                - {vllm_error_msg}
-                """
+                if trt_compare_error == "Compilation must be provided with Quantization":
+                    joint_error_msg = f"""
+                    Optimization cannot be performed for the following reasons:
+                    - Optimizations that use {trt_compare_error} and vice-versa for GPU instances.
+                    - Optimizations that use {vllm_compare_error} are not supported for GPU instances.
+                    """
+                else:
+                    joint_error_msg = f"""
+                    Optimization cannot be performed for the following reasons:
+                    - Optimizations that use {trt_compare_error} are not supported for GPU instances.
+                    - Optimizations that use {vllm_compare_error} are not supported for GPU instances.
+                    """
                 raise ValueError(textwrap.dedent(joint_error_msg))

tests/unit/sagemaker/serve/builder/test_model_builder.py

@@ -2682,8 +2682,8 @@ def test_optimize_exclusive_sharding(self, mock_get_serve_setting):
 
         expected_error_message = """
         Optimization cannot be performed for the following reasons:
-        - Optimizations for TRT that use Sharding are not currently supported on GPU instances
-        - Optimizations for vLLM that use Compilation are not currently supported on GPU instances
+        - Optimizations that use Sharding are not supported for GPU instances.
+        - Optimizations that use Compilation and Quantization:awq are not supported for GPU instances.
         """
 
         self.assertRaisesRegex(
@@ -2850,14 +2850,12 @@ def test_corner_cases_throw_errors(self):
             ),
         )
 
-        expected_missing_optimization_configs_error_message = """
-        Optimization cannot be performed for the following reasons:
-        - Optimizations for TRT that use no optimization configurations are not currently supported on GPU instances
-        - Optimizations for vLLM that use no optimization configurations are not currently supported on GPU instances
-        """
         self.assertRaisesRegex(
             ValueError,
-            textwrap.dedent(expected_missing_optimization_configs_error_message),
+            (
+                "Optimizations that provide no optimization configs "
+                "are currently not support on both GPU and Neuron instances."
+            ),
             lambda: _validate_optimization_configuration(
                 instance_type="ml.g5.24xlarge",
                 quantization_config=None,
@@ -2870,8 +2868,8 @@ def test_corner_cases_throw_errors(self):
     def test_trt_and_vllm_configurations_throw_errors_for_rule_set(self):
         expected_quantization_error_message = """
         Optimization cannot be performed for the following reasons:
-        - Optimizations for TRT that use Quantization:test are not currently supported on GPU instances
-        - Optimizations for vLLM that use Quantization:test are not currently supported on GPU instances
+        - Optimizations that use Quantization:test are not supported for GPU instances.
+        - Optimizations that use Quantization:test are not supported for GPU instances.
         """
         self.assertRaisesRegex(
             ValueError,
@@ -2890,10 +2888,7 @@ def test_trt_and_vllm_configurations_throw_errors_for_rule_set(self):
     def test_neuron_configurations_throw_errors_for_rule_set(self):
         self.assertRaisesRegex(
             ValueError,
-            (
-                "Optimizations for Neuron that use Speculative Decoding "
-                "are not currently supported on Neuron instances"
-            ),
+            "Optimizations that use Speculative Decoding are not supported on Neuron instances.",
             lambda: _validate_optimization_configuration(
                 instance_type="ml.inf2.xlarge",
                 quantization_config=None,
@@ -2905,10 +2900,7 @@ def test_neuron_configurations_throw_errors_for_rule_set(self):
 
         self.assertRaisesRegex(
             ValueError,
-            (
-                "Optimizations for Neuron that use Sharding "
-                "are not currently supported on Neuron instances"
-            ),
+            "Optimizations that use Sharding are not supported on Neuron instances.",
             lambda: _validate_optimization_configuration(
                 instance_type="ml.inf2.xlarge",
                 quantization_config=None,