triton-model-analyzer 1.49.0__py3-none-any.whl → 1.50.0__py3-none-any.whl

model_analyzer/config/generate/model_profile_spec.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from copy import deepcopy
-from typing import List
+from typing import List, Optional
 
 from model_analyzer.config.input.config_command_profile import ConfigCommandProfile
 from model_analyzer.config.input.objects.config_model_profile_spec import (
@@ -27,15 +27,72 @@ class ModelProfileSpec(ConfigModelProfileSpec):
         client: TritonClient,
         gpus: List[GPUDevice],
     ):
-        super().__init__(spec.model_name())
-        self.__dict__ = deepcopy(spec.__dict__)
+        # Determine cpu_only based on priority (before copying spec's __dict__):
+        # 1) User-specified kind in instance_group (highest)
+        # 2) cpu_only_composing_models config
+        # 3) Inherited from spec (default False)
+        explicit_kind = self._get_explicit_instance_kind(spec)
+        if explicit_kind == "KIND_CPU":
+            cpu_only = True
+        elif explicit_kind == "KIND_GPU":
+            cpu_only = False
+        elif spec.model_name() in config.cpu_only_composing_models:
+            cpu_only = True
+        else:
+            cpu_only = spec.cpu_only()
+
+        super().__init__(spec.model_name(), cpu_only=cpu_only)
+
+        # Copy remaining attributes from spec (excluding _cpu_only which we set above)
+        spec_dict = deepcopy(spec.__dict__)
+        spec_dict.pop("_cpu_only", None)
+        self.__dict__.update(spec_dict)
 
         self._default_model_config = ModelConfig.create_model_config_dict(
             config, client, gpus, config.model_repository, spec.model_name()
         )
 
-        if spec.model_name() in config.cpu_only_composing_models:
-            self._cpu_only = True
+    @staticmethod
+    def _get_explicit_instance_kind(spec: ConfigModelProfileSpec) -> Optional[str]:
+        """
+        Check if the spec has an explicit kind specified in instance_group.
+
+        Returns the kind if explicitly specified, None otherwise.
+        This allows users to specify KIND_CPU or KIND_GPU directly in
+        model_config_parameters.instance_group instead of using the
+        separate cpu_only_composing_models config option.
+
+        The config parser may wrap values in lists for sweep support, so we need
+        to handle structures like:
+        - [[{'count': [1, 2, 4], 'kind': ['KIND_CPU']}]]  (double-wrapped, kind is list)
+        - [{'count': [1, 2, 4], 'kind': 'KIND_CPU'}]      (single-wrapped, kind is string)
+        """
+        model_config_params = spec.model_config_parameters()
+        if model_config_params is None:
+            return None
+
+        instance_group = model_config_params.get("instance_group")
+        if instance_group is None or not isinstance(instance_group, list):
+            return None
+
+        # instance_group structure can be doubly wrapped due to config parsing:
+        # [[ {'kind': ['KIND_GPU'], 'count': [1, 2, 4]} ]]
+        # Unwrap the nested structure if needed
+        if len(instance_group) > 0 and isinstance(instance_group[0], list):
+            instance_group = instance_group[0]
+
+        # instance_group is now a list of dicts, each potentially containing 'kind'
+        for ig in instance_group:
+            if isinstance(ig, dict):
+                kind = ig.get("kind")
+                # Handle case where kind is wrapped in a list by config parser
+                # e.g., ['KIND_CPU'] instead of 'KIND_CPU'
+                if isinstance(kind, list) and len(kind) > 0:
+                    kind = kind[0]
+                if kind in ("KIND_CPU", "KIND_GPU"):
+                    return kind
+
+        return None
 
     def get_default_config(self) -> dict:
         """Returns the default configuration for this model"""

model_analyzer/config/generate/quick_run_config_generator.py

@@ -25,6 +25,7 @@ from model_analyzer.config.input.config_defaults import DEFAULT_BATCH_SIZES
 from model_analyzer.config.run.model_run_config import ModelRunConfig
 from model_analyzer.config.run.run_config import RunConfig
 from model_analyzer.constants import LOGGER_NAME
+from model_analyzer.model_analyzer_exceptions import TritonModelAnalyzerException
 from model_analyzer.perf_analyzer.perf_config import PerfAnalyzerConfig
 from model_analyzer.result.run_config_measurement import RunConfigMeasurement
 from model_analyzer.triton.model.model_config import ModelConfig
@@ -425,33 +426,53 @@ class QuickRunConfigGenerator(ConfigGeneratorInterface):
         )
 
         model_config_params = deepcopy(model.model_config_parameters())
+
+        # Extract user-specified instance_group kind before removing it
+        instance_kind = self._extract_instance_group_kind(model_config_params)
+        if not instance_kind:
+            # Fallback to cpu_only flag
+            instance_kind = "KIND_CPU" if model.cpu_only() else "KIND_GPU"
+
         if model_config_params:
+            # Remove parameters that are controlled by search dimensions
             model_config_params.pop("max_batch_size", None)
+            model_config_params.pop("instance_group", None)
 
-            # This is guaranteed to only generate one combination (check is in config_command)
+            # Generate combinations from remaining parameters
+            # For composing models, this may include dynamic_batching settings, etc.
             param_combos = GeneratorUtils.generate_combinations(model_config_params)
-            assert len(param_combos) == 1
 
-            param_combo = param_combos[0]
+            # Top-level models must have exactly 1 combination (validated earlier)
+            # Composing models can have 1 combination (non-searchable params are fixed)
+            if len(param_combos) > 1:
+                raise TritonModelAnalyzerException(
+                    f"Model {model.model_name()} has multiple parameter combinations "
+                    f"after removing searchable parameters. This should have been caught "
+                    f"during config validation."
+                )
+
+            param_combo = param_combos[0] if param_combos else {}
         else:
             param_combo = {}
 
-        kind = "KIND_CPU" if model.cpu_only() else "KIND_GPU"
+        # Add instance_group with count from dimension and kind from config
         instance_count = self._calculate_instance_count(dimension_values)
-
         param_combo["instance_group"] = [
             {
                 "count": instance_count,
-                "kind": kind,
+                "kind": instance_kind,
             }
         ]
 
+        # Add max_batch_size from dimension if applicable
         if "max_batch_size" in dimension_values:
             param_combo["max_batch_size"] = self._calculate_model_batch_size(
                 dimension_values
             )
 
-        if model.supports_dynamic_batching():
+        # Add default dynamic_batching if model supports it and not already specified
+        # Preserves user-specified dynamic_batching settings (single combinations only)
+        if model.supports_dynamic_batching() and "dynamic_batching" not in param_combo:
             param_combo["dynamic_batching"] = {}
 
         model_config_variant = BaseModelConfigGenerator.make_model_config_variant(
@@ -463,6 +484,48 @@ class QuickRunConfigGenerator(ConfigGeneratorInterface):
 
         return model_config_variant
 
+    def _extract_instance_group_kind(self, model_config_params: dict) -> str:
+        """
+        Extract the 'kind' field from instance_group in model_config_parameters.
+
+        The config parser may wrap values in lists for sweep support, so we need
+        to handle structures like:
+        - [[{'count': [1, 2, 4], 'kind': ['KIND_CPU']}]]  (double-wrapped, kind is list)
+        - [{'count': [1, 2, 4], 'kind': 'KIND_CPU'}]      (single-wrapped, kind is string)
+
+        Returns empty string if not found or if instance_group is not specified.
+        """
+        if not model_config_params or "instance_group" not in model_config_params:
+            return ""
+
+        instance_group = model_config_params["instance_group"]
+
+        # Handle various nested list structures from config parsing
+        if isinstance(instance_group, list) and len(instance_group) > 0:
+            # Handle nested structure: [[ {...} ]]
+            while (
+                isinstance(instance_group, list)
+                and len(instance_group) > 0
+                and isinstance(instance_group[0], list)
+            ):
+                instance_group = instance_group[0]
+
+            # Now should have [{...}] structure
+            if (
+                isinstance(instance_group, list)
+                and len(instance_group) > 0
+                and isinstance(instance_group[0], dict)
+            ):
+                kind = instance_group[0].get("kind", "")
+                # Handle case where kind is wrapped in a list by config parser
+                # e.g., ['KIND_CPU'] instead of 'KIND_CPU'
+                if isinstance(kind, list) and len(kind) > 0:
+                    kind = kind[0]
+                if isinstance(kind, str) and kind in ("KIND_CPU", "KIND_GPU"):
+                    return kind
+
+        return ""
+
     def _create_next_model_run_config(
         self,
         model: ModelProfileSpec,

model_analyzer/config/generate/run_config_generator_factory.py

@@ -1,19 +1,9 @@
 #!/usr/bin/env python3
+# SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
-# Copyright 2022-2023, NVIDIA CORPORATION & 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.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License 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.
-
+import logging
+import math
 from typing import Dict, List
 
 from model_analyzer.config.generate.model_profile_spec import ModelProfileSpec
@@ -25,7 +15,7 @@ from model_analyzer.config.input.config_command_profile import ConfigCommandProf
 from model_analyzer.config.input.objects.config_model_profile_spec import (
     ConfigModelProfileSpec,
 )
-from model_analyzer.constants import MIN_INITIALIZED, RADIUS
+from model_analyzer.constants import LOGGER_NAME, MIN_INITIALIZED, RADIUS
 from model_analyzer.device.gpu_device import GPUDevice
 from model_analyzer.model_analyzer_exceptions import TritonModelAnalyzerException
 from model_analyzer.result.result_manager import ResultManager
@@ -47,6 +37,8 @@ from .search_config import SearchConfig
 from .search_dimension import SearchDimension
 from .search_dimensions import SearchDimensions
 
+logger = logging.getLogger(LOGGER_NAME)
+
 
 class RunConfigGeneratorFactory:
     """
@@ -221,9 +213,7 @@ class RunConfigGeneratorFactory:
             if model.is_ensemble():
                 continue
 
-            dims = RunConfigGeneratorFactory._get_dimensions_for_model(
-                model.supports_batching()
-            )
+            dims = RunConfigGeneratorFactory._get_dimensions_for_model(model)
             dimensions.add_dimensions(index, dims)
             index += 1
 
@@ -234,14 +224,161 @@ class RunConfigGeneratorFactory:
         return search_config
 
     @staticmethod
-    def _get_dimensions_for_model(is_batching_supported: bool) -> List[SearchDimension]:
-        if is_batching_supported:
-            return RunConfigGeneratorFactory._get_batching_supported_dimensions()
+    def _get_dimensions_for_model(model: ModelProfileSpec) -> List[SearchDimension]:
+        """
+        Create search dimensions for a model, respecting user-specified
+        instance_group count lists if provided.
+        """
+        dims = []
+
+        # Check if user specified instance_group with a count list
+        instance_count_list = RunConfigGeneratorFactory._get_instance_count_list(model)
+
+        if instance_count_list:
+            # User specified a list - create constrained dimension
+            dim = RunConfigGeneratorFactory._create_instance_dimension_from_list(
+                instance_count_list
+            )
+            dims.append(dim)
+        else:
+            # Use default unbounded dimension
+            dims.append(
+                SearchDimension("instance_count", SearchDimension.DIMENSION_TYPE_LINEAR)
+            )
+
+        # Add max_batch_size dimension if model supports batching
+        if model.supports_batching():
+            # For now, max_batch_size always uses default exponential dimension
+            # Could be extended to support user-specified lists in the future
+            dims.insert(
+                0,
+                SearchDimension(
+                    "max_batch_size", SearchDimension.DIMENSION_TYPE_EXPONENTIAL
+                ),
+            )
+
+        return dims
+
+    @staticmethod
+    def _get_instance_count_list(model: ModelProfileSpec) -> List[int]:
+        """
+        Extract instance_group count list from model config parameters if specified.
+
+        Returns empty list if not specified or not a list.
+        """
+        model_config_params = model.model_config_parameters()
+        if not model_config_params:
+            return []
+
+        if "instance_group" not in model_config_params:
+            return []
+
+        # instance_group structure: [[ {'kind': 'KIND_GPU', 'count': [1, 2, 4]} ]]
+        # The outer lists are from config parsing wrapping
+        instance_group = model_config_params["instance_group"]
+
+        if not instance_group or not isinstance(instance_group, list):
+            return []
+
+        # Unwrap the nested structure
+        if len(instance_group) > 0 and isinstance(instance_group[0], list):
+            instance_group = instance_group[0]
+
+        if len(instance_group) == 0 or not isinstance(instance_group[0], dict):
+            return []
+
+        count = instance_group[0].get("count")
+        if isinstance(count, list) and len(count) > 0:
+            return count
+
+        return []
+
+    @staticmethod
+    def _create_instance_dimension_from_list(
+        count_list: List[int],
+    ) -> SearchDimension:
+        """
+        Create a SearchDimension for instance_count from a user-specified list.
+
+        For lists that are powers of 2 (e.g., [1, 2, 4, 8, 16, 32]),
+        uses EXPONENTIAL dimension type with appropriate min/max indexes.
+
+        For other lists, uses LINEAR dimension type with appropriate min/max.
+
+        Raises TritonModelAnalyzerException if the list is not compatible with
+        either LINEAR or EXPONENTIAL growth patterns.
+        """
+        if not count_list or len(count_list) == 0:
+            raise TritonModelAnalyzerException("Instance count list cannot be empty")
+
+        # Sort the list to check for patterns
+        sorted_counts = sorted(count_list)
+
+        # Check if it's powers of 2
+        if RunConfigGeneratorFactory._is_powers_of_two(sorted_counts):
+            # Use EXPONENTIAL: 2^idx gives the value
+            # For [1, 2, 4, 8, 16, 32]: min_idx=0 (2^0=1), max_idx=5 (2^5=32)
+            min_idx = int(math.log2(sorted_counts[0]))
+            max_idx = int(math.log2(sorted_counts[-1]))
+
+            return SearchDimension(
+                "instance_count",
+                SearchDimension.DIMENSION_TYPE_EXPONENTIAL,
+                min=min_idx,
+                max=max_idx,
+            )
+
+        # Check if it's a contiguous linear sequence
+        elif RunConfigGeneratorFactory._is_linear_sequence(sorted_counts):
+            # Use LINEAR: idx+1 gives the value (LINEAR starts at 1, not 0)
+            # For [1, 2, 3, 4]: min_idx=0 (0+1=1), max_idx=3 (3+1=4)
+            min_idx = sorted_counts[0] - 1
+            max_idx = sorted_counts[-1] - 1
+
+            return SearchDimension(
+                "instance_count",
+                SearchDimension.DIMENSION_TYPE_LINEAR,
+                min=min_idx,
+                max=max_idx,
+            )
+
         else:
-            return RunConfigGeneratorFactory._get_batching_not_supported_dimensions()
+            # List is not compatible with LINEAR or EXPONENTIAL
+            raise TritonModelAnalyzerException(
+                f"Instance count list {count_list} is not compatible with Quick search mode. "
+                f"Lists must be either powers of 2 (e.g., [1, 2, 4, 8, 16, 32]) "
+                f"or a contiguous sequence (e.g., [1, 2, 3, 4, 5])."
+            )
+
+    @staticmethod
+    def _is_powers_of_two(sorted_list: List[int]) -> bool:
+        """Check if all values in the list are powers of 2 and form a valid sequence."""
+        for val in sorted_list:
+            if val <= 0:
+                return False
+            # Check if val is a power of 2: log2(val) should be an integer
+            log_val = math.log2(val)
+            if not log_val.is_integer():
+                return False
+
+        return True
+
+    @staticmethod
+    def _is_linear_sequence(sorted_list: List[int]) -> bool:
+        """Check if the list is a contiguous linear sequence."""
+        if len(sorted_list) < 2:
+            return True
+
+        # Check if values are consecutive: diff should always be 1
+        for i in range(1, len(sorted_list)):
+            if sorted_list[i] - sorted_list[i - 1] != 1:
+                return False
+
+        return True
 
     @staticmethod
     def _get_batching_supported_dimensions() -> List[SearchDimension]:
+        """Legacy method - kept for backward compatibility."""
         return [
             SearchDimension(
                 f"max_batch_size", SearchDimension.DIMENSION_TYPE_EXPONENTIAL
@@ -251,6 +388,7 @@ class RunConfigGeneratorFactory:
 
     @staticmethod
     def _get_batching_not_supported_dimensions() -> List[SearchDimension]:
+        """Legacy method - kept for backward compatibility."""
         return [
             SearchDimension(f"instance_count", SearchDimension.DIMENSION_TYPE_LINEAR)
         ]
@@ -306,24 +444,50 @@ class RunConfigGeneratorFactory:
         gpus: List[GPUDevice],
     ) -> List[ModelProfileSpec]:
         """
-        Creates a list of Ensemble composing model configs based on the model
+        Creates a list of Ensemble composing model configs based on the model.
+
+        If user specified ensemble_composing_models configs, use those for matching models.
+        Otherwise, use auto-discovered configs from ensemble_scheduling.
         """
         model_config = ModelConfig.create_from_profile_spec(model, config, client, gpus)
 
         if not model_config.is_ensemble():
             return []
 
+        # Auto-discover composing model names from ensemble_scheduling
         ensemble_composing_model_names = model_config.get_ensemble_composing_models()
+        if ensemble_composing_model_names is None:
+            return []
 
-        ensemble_composing_model_specs = (
-            ConfigModelProfileSpec.model_list_to_config_model_profile_spec(
+        # Check if user provided configs for any of these models
+        user_provided_configs = {}
+        if config.ensemble_composing_models is not None:
+            for user_spec in config.ensemble_composing_models:
+                user_provided_configs[user_spec.model_name()] = user_spec
+
+        # Create ModelProfileSpecs, using user configs when available
+        ensemble_composing_model_configs = []
+        for model_name in ensemble_composing_model_names:
+            if model_name in user_provided_configs:
+                # Use user-provided config with model_config_parameters
+                model_spec = user_provided_configs[model_name]
+            else:
+                # Use auto-discovered config (just model name, no parameters)
+                model_spec = ConfigModelProfileSpec(model_name)
+
+            mps = ModelProfileSpec(model_spec, config, client, gpus)
+            ensemble_composing_model_configs.append(mps)
+
+        # Warn if user specified models that aren't in the ensemble
+        if user_provided_configs:
+            unused_models = set(user_provided_configs.keys()) - set(
                 ensemble_composing_model_names
             )
-        )
-
-        ensemble_composing_model_configs = [
-            ModelProfileSpec(ensemble_composing_model_spec, config, client, gpus)
-            for ensemble_composing_model_spec in ensemble_composing_model_specs
-        ]
+            if unused_models:
+                logger.warning(
+                    f"The following models in ensemble_composing_models were not found "
+                    f"in the ensemble '{model.model_name()}' and will be ignored: "
+                    f"{', '.join(sorted(unused_models))}"
+                )
 
         return ensemble_composing_model_configs

model_analyzer/config/input/config_command.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2021-2023, NVIDIA CORPORATION & 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.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License 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.
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 from argparse import Namespace
 from copy import deepcopy
@@ -251,8 +239,18 @@ class ConfigCommand:
         ):
             return
 
+        # Get composing model names for validation
+        bls_composing = (
+            self._get_config_value("bls_composing_models", args, yaml_config) or []
+        )
+        cpu_only_composing = (
+            self._get_config_value("cpu_only_composing_models", args, yaml_config) or []
+        )
+
         self._check_per_model_parameters(profile_models)
-        self._check_per_model_model_config_parameters(profile_models)
+        self._check_per_model_model_config_parameters(
+            profile_models, bls_composing, cpu_only_composing
+        )
 
     def _check_per_model_parameters(self, profile_models: Dict) -> None:
         for model in profile_models.values():
@@ -268,23 +266,81 @@ class ConfigCommand:
                     "\nPlease use brute search mode or remove concurrency/batch sizes list."
                 )
 
-    def _check_per_model_model_config_parameters(self, profile_models: Dict) -> None:
-        for model in profile_models.values():
+    def _check_per_model_model_config_parameters(
+        self, profile_models: Dict, bls_composing: List, cpu_only_composing: List
+    ) -> None:
+        for model_name, model in profile_models.items():
             if not "model_config_parameters" in model:
                 continue
 
+            # Check if this is a composing model
+            is_composing = False
+            if bls_composing:
+                # bls_composing might be a list of dicts or list of strings
+                if isinstance(bls_composing, list):
+                    is_composing = any(
+                        (isinstance(m, dict) and m.get("model_name") == model_name)
+                        or (isinstance(m, str) and m == model_name)
+                        for m in bls_composing
+                    )
+            if (
+                not is_composing
+                and cpu_only_composing
+                and model_name in cpu_only_composing
+            ):
+                is_composing = True
+
+            # Composing models are allowed to have these parameters with ranges
+            if is_composing:
+                continue
+
             if "max_batch_size" in model["model_config_parameters"]:
                 raise TritonModelAnalyzerException(
-                    f"\nProfiling of models in quick search mode is not supported with lists of max batch sizes."
+                    f"\nProfiling of top-level models in quick search mode is not supported with lists of max batch sizes."
                     "\nPlease use brute search mode or remove max batch size list."
+                    "\nNote: Composing models in ensembles/BLS can have max_batch_size ranges in Quick mode."
                 )
 
             if "instance_group" in model["model_config_parameters"]:
                 raise TritonModelAnalyzerException(
-                    f"\nProfiling of models in quick search mode is not supported with instance group as a model config parameter"
+                    f"\nProfiling of top-level models in quick search mode is not supported with instance group as a model config parameter."
                     "\nPlease use brute search mode or remove instance_group from 'model_config_parameters'."
+                    "\nNote: Composing models in ensembles/BLS can have instance_group with count ranges in Quick mode."
                 )
 
+    def _is_composing_model(self, model_name: str, config: Dict) -> bool:
+        """
+        Determine if a model is a composing model by checking:
+        1. If it's in bls_composing_models list
+        2. If it's in ensemble_composing_models list
+        3. If it's in cpu_only_composing_models list
+
+        Note: We cannot check ensemble_scheduling at this stage because
+        we haven't loaded the model configs from the repository yet.
+        Users must explicitly list ensemble composing models in ensemble_composing_models
+        to enable parameter ranges for them.
+        """
+        if "bls_composing_models" in config:
+            bls_composing = config["bls_composing_models"].value()
+            if bls_composing and any(
+                m.model_name() == model_name for m in bls_composing
+            ):
+                return True
+
+        if "ensemble_composing_models" in config:
+            ensemble_composing = config["ensemble_composing_models"].value()
+            if ensemble_composing and any(
+                m.model_name() == model_name for m in ensemble_composing
+            ):
+                return True
+
+        if "cpu_only_composing_models" in config:
+            cpu_only_composing = config["cpu_only_composing_models"].value()
+            if cpu_only_composing and model_name in cpu_only_composing:
+                return True
+
+        return False
+
     def _check_quick_search_model_config_parameters_combinations(self) -> None:
         config = self.get_config()
         if not "profile_models" in config:
@@ -295,13 +351,18 @@ class ConfigCommand:
 
         profile_models = config["profile_models"].value()
         for model in profile_models:
+            # Composing models are allowed to have parameter ranges in Quick mode
+            if self._is_composing_model(model.model_name(), config):
+                continue
+
             model_config_params = deepcopy(model.model_config_parameters())
             if model_config_params:
                 if len(GeneratorUtils.generate_combinations(model_config_params)) > 1:
                     raise TritonModelAnalyzerException(
-                        f"\nProfiling of models in quick search mode is not supported for the specified model config parameters, "
+                        f"\nProfiling of top-level models in quick search mode is not supported for the specified model config parameters, "
                         f"as more than one combination of parameters can be generated."
                         f"\nPlease use brute search mode to profile or remove the model config parameters specified."
+                        f"\nNote: Composing models in ensembles/BLS can have parameter ranges in Quick mode."
                     )
 
     def _check_bls_no_brute_search(

model_analyzer/config/input/config_command_profile.py

@@ -1,18 +1,6 @@
 #!/usr/bin/env python3
-
-# Copyright 2021-2023, NVIDIA CORPORATION & 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.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License 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.
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
 
 import argparse
 import logging
@@ -803,6 +791,39 @@ class ConfigCommandProfile(ConfigCommand):
                 description="List of the models to be profiled",
             )
         )
+        self._add_config(
+            ConfigField(
+                "ensemble_composing_models",
+                flags=["--ensemble-composing-models"],
+                field_type=ConfigUnion(
+                    [
+                        profile_model_scheme,
+                        ConfigListGeneric(
+                            ConfigUnion(
+                                [
+                                    profile_model_scheme,
+                                    ConfigPrimitive(
+                                        str,
+                                        output_mapper=ConfigModelProfileSpec.model_str_to_config_model_profile_spec,
+                                    ),
+                                ]
+                            ),
+                            required=True,
+                            output_mapper=ConfigModelProfileSpec.model_mixed_to_config_model_profile_spec,
+                        ),
+                        ConfigListString(
+                            output_mapper=ConfigModelProfileSpec.model_list_to_config_model_profile_spec
+                        ),
+                    ],
+                    required=True,
+                ),
+                default_value=[],
+                description="List of ensemble composing models with optional model config parameters. "
+                "Composing models are auto-discovered from ensemble_scheduling. Use this option to specify "
+                "configurations (e.g., instance_group count ranges) for any auto-discovered models. "
+                "Only models found in ensemble_scheduling will be profiled; others will be ignored with a warning.",
+            )
+        )
         self._add_config(
             ConfigField(
                 "cpu_only_composing_models",
@@ -1701,9 +1722,15 @@ class ConfigCommandProfile(ConfigCommand):
             new_profile_models[model.model_name()] = new_model
 
         # deepcopy is necessary, else it gets overwritten when updating profile_models
+        # Both bls_composing_models and ensemble_composing_models share the same
+        # profile_model_scheme ConfigObject, so updating profile_models would
+        # overwrite their values.
         self._fields["bls_composing_models"] = deepcopy(
             self._fields["bls_composing_models"]
         )
+        self._fields["ensemble_composing_models"] = deepcopy(
+            self._fields["ensemble_composing_models"]
+        )
         self._fields["profile_models"].set_value(new_profile_models)
 
     def _using_request_rate(self) -> bool:

model_analyzer/config/input/config_defaults.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
 import os
@@ -52,7 +52,7 @@ DEFAULT_REQUEST_RATE_SEARCH_ENABLE = False
 DEFAULT_CONCURRENCY_SWEEP_DISABLE = False
 DEFAULT_DCGM_DISABLE = False
 DEFAULT_TRITON_LAUNCH_MODE = "local"
-DEFAULT_TRITON_DOCKER_IMAGE = "nvcr.io/nvidia/tritonserver:25.12-py3"
+DEFAULT_TRITON_DOCKER_IMAGE = "nvcr.io/nvidia/tritonserver:26.01-py3"
 DEFAULT_TRITON_HTTP_ENDPOINT = "localhost:8000"
 DEFAULT_TRITON_GRPC_ENDPOINT = "localhost:8001"
 DEFAULT_TRITON_METRICS_URL = "http://localhost:8002/metrics"

{triton_model_analyzer-1.49.0.dist-info → triton_model_analyzer-1.50.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: triton-model-analyzer
-Version: 1.49.0
+Version: 1.50.0
 Summary: Triton Model Analyzer is a tool to profile and analyze the runtime performance of one or more models on the Triton Inference Server
 Author-email: "NVIDIA Inc." <sw-dl-triton@nvidia.com>
 License-Expression: Apache-2.0

{triton_model_analyzer-1.49.0.dist-info → triton_model_analyzer-1.50.0.dist-info}/RECORD

@@ -20,7 +20,7 @@ model_analyzer/config/generate/coordinate_data.py,sha256=deqoRIvO0aN5D5sNDZcjmT0
 model_analyzer/config/generate/generator_utils.py,sha256=5hj7qGzVs-oHk6UK_ggBzKJiTDVdX6MSLrXyEfU-kFE,4157
 model_analyzer/config/generate/manual_model_config_generator.py,sha256=_Y78ORijg5E6c2a2zESwJzK55S8fbhoy2rqFTQq-seA,7088
 model_analyzer/config/generate/model_config_generator_factory.py,sha256=5BjSJxRmrEVy3LyjIPnMT-QCz8GABa62oY1VvJfmhbE,3334
-model_analyzer/config/generate/model_profile_spec.py,sha256=fOCTNSK_GOOQ1FaRuCo_rDeVEf8H_67hUVERFlRndtM,2739
+model_analyzer/config/generate/model_profile_spec.py,sha256=WSznjBRO16vwet4f3XhrjmHx3tgAQU9ZJDh8CYI4E3c,5321
 model_analyzer/config/generate/model_run_config_generator.py,sha256=Ip1djtZ3wlwG_Zs3YivIlJxmwS1TsNa_7aMCU9bCQP0,5484
 model_analyzer/config/generate/model_variant_name_manager.py,sha256=qPAcvDQhkbArkW-A1A1mdRyqALUgfLlyV3dhNV6jKgs,5362
 model_analyzer/config/generate/neighborhood.py,sha256=s9g9igetHvF6Xm9FhuzjbhPBVWO65SngABrX3RGOUBQ,19481
@@ -28,18 +28,18 @@ model_analyzer/config/generate/optuna_plus_concurrency_sweep_run_config_generato
 model_analyzer/config/generate/optuna_run_config_generator.py,sha256=Z09p5tZP8wl0hp9NpHXpGovv1dZZkZzH11FnuXe8HhU,33099
 model_analyzer/config/generate/perf_analyzer_config_generator.py,sha256=cCLQTV5V65QelGFMP3B4JaYvejNZj4tHJUQSZ3nTZSY,11112
 model_analyzer/config/generate/quick_plus_concurrency_sweep_run_config_generator.py,sha256=hAL6YD6hqLDL7ttOgJuDIUvEe6BpHNlYv82cQdHUo5o,4516
-model_analyzer/config/generate/quick_run_config_generator.py,sha256=ccs8W7Bh20pmxel5iQF92pF7pirpaBQeveQNhUwWPq0,27719
-model_analyzer/config/generate/run_config_generator_factory.py,sha256=KPjZGz0R-upqf7pwrtWrVRroNC-aDPeGZd63XR92zDU,13008
+model_analyzer/config/generate/quick_run_config_generator.py,sha256=1JQo3gaZeC2eUNrtuMeyQzuILZX3lBlNX-UhNaXMvBY,30880
+model_analyzer/config/generate/run_config_generator_factory.py,sha256=DDAsqWQoKhBA2XFb68igVX7cO1WY5xt15_hkBxX6_Cg,19453
 model_analyzer/config/generate/search_config.py,sha256=mvQaoQ9wIeNEHWJtIwXh0JujPQZqXLLXmWpI7uBHDGA,3655
 model_analyzer/config/generate/search_dimension.py,sha256=iUoh4IhhMy9zhMhaY-q9DoBEku4--4o4j8RYQfXUVVk,2375
 model_analyzer/config/generate/search_dimensions.py,sha256=_hbpnb3gUYuCVh_LLP4FMjB1sV-IKrvekpEhi2lTCIs,2618
 model_analyzer/config/generate/search_parameter.py,sha256=E-mM5bWKdPUXjT8DCmVLWuJWTs-jBC8U8ZBDmx8GGMs,1392
 model_analyzer/config/generate/search_parameters.py,sha256=knTE9Vw7lS37SuGi1hZpVb01DFLubJpzAPJSbTHlQDA,14876
 model_analyzer/config/input/__init__.py,sha256=1vqDBvdG5Wrb-tDrHGyS9LC_cQst-QqLt5wOa3TD9rI,647
-model_analyzer/config/input/config_command.py,sha256=63Y6aJrGBA-tR5eljlZSNwgFbHc4hZYd8mEOpmdrJxc,18776
-model_analyzer/config/input/config_command_profile.py,sha256=P5V0y_J3p6BCDCu_QBsl5AXaz_Y73y7CpiessWbuCy4,70509
+model_analyzer/config/input/config_command.py,sha256=kS02U8c5AO2XNsxM8VFOMYhFaN5r8-aPm5tjFrCiyxA,21495
+model_analyzer/config/input/config_command_profile.py,sha256=Rbx5x_jj0SC7r1SXEVPLkT8CXu_KX0iLzVySdOyQJ2c,72018
 model_analyzer/config/input/config_command_report.py,sha256=Igiid6XK5OB23jvXZKPI4Pg5ZsSDkXgHU-QAGOo6_-E,9535
-model_analyzer/config/input/config_defaults.py,sha256=DYmjHUPQxqhlhRmE2VtzLBHhdwhk-zXkMrlTJuYQGTg,6202
+model_analyzer/config/input/config_defaults.py,sha256=t1hkTDqc82tNtyfr39NDEb_n2a4qtnf0GrR69BtzpAU,6202
 model_analyzer/config/input/config_enum.py,sha256=lu9cUz_MY52EcLEXxcLYWqB5If6FhsM1K8w1srzhDt4,2386
 model_analyzer/config/input/config_field.py,sha256=XlqlouNuPENEYCBLYtHxsfMACrFlcYZGkbh6yE1psNo,5156
 model_analyzer/config/input/config_list_generic.py,sha256=-4vhDxIEMPOwYcUIkMIFzxJ61mOmX6GEgGCpTfbCFsc,3355
@@ -196,9 +196,9 @@ model_analyzer/triton/server/server_config.py,sha256=3pNQAnUmSXVAO7pKLNWak7AFGm1
 model_analyzer/triton/server/server_docker.py,sha256=38e_tMniv2PBiEIh2KMxgqsMZlttL0yCrpD0lKd0r5g,8248
 model_analyzer/triton/server/server_factory.py,sha256=WMZfXFQfO9aeFxCWewQhRk9ygMcne0ershGZ75XQ5IE,11152
 model_analyzer/triton/server/server_local.py,sha256=i5t5MaDwfvWqBA3zG15GPkGiUm6I4Bb4i0d-wBP0WNs,5406
-triton_model_analyzer-1.49.0.dist-info/licenses/LICENSE,sha256=vs3gOjyLmy49WMe2XKf_2eGOmBYjlsw3QFKYPB-qpHw,9144
-triton_model_analyzer-1.49.0.dist-info/METADATA,sha256=ebuhiEKjcPklcz1N1BXDHRZRM2B_a1OyAHCGBeirh_I,2512
-triton_model_analyzer-1.49.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-triton_model_analyzer-1.49.0.dist-info/entry_points.txt,sha256=k6Q0D76sL3qUNxe80hUThftycJAT7Sj5dBk8IjHXJoI,66
-triton_model_analyzer-1.49.0.dist-info/top_level.txt,sha256=mTebknhUDSE7cCVyUtpzNVQ-tEUi8zZKFvp15xpIP2c,15
-triton_model_analyzer-1.49.0.dist-info/RECORD,,
+triton_model_analyzer-1.50.0.dist-info/licenses/LICENSE,sha256=vs3gOjyLmy49WMe2XKf_2eGOmBYjlsw3QFKYPB-qpHw,9144
+triton_model_analyzer-1.50.0.dist-info/METADATA,sha256=uDYfY5KZsLOHaugxXsqh2mCc6ByjTQvg2TT_j1IStBA,2512
+triton_model_analyzer-1.50.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+triton_model_analyzer-1.50.0.dist-info/entry_points.txt,sha256=k6Q0D76sL3qUNxe80hUThftycJAT7Sj5dBk8IjHXJoI,66
+triton_model_analyzer-1.50.0.dist-info/top_level.txt,sha256=mTebknhUDSE7cCVyUtpzNVQ-tEUi8zZKFvp15xpIP2c,15
+triton_model_analyzer-1.50.0.dist-info/RECORD,,

{triton_model_analyzer-1.49.0.dist-info → triton_model_analyzer-1.50.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any