triton-model-analyzer 1.48.0__py3-none-any.whl

model_analyzer/record/record.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+
+# Copyright 2020-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 importlib
+import os
+from abc import ABCMeta, abstractmethod
+from statistics import mean
+from typing import Dict
+
+from model_analyzer.model_analyzer_exceptions import TritonModelAnalyzerException
+
+
+class RecordType(ABCMeta):
+    """
+    A metaclass that holds the instantiated Record types
+    """
+
+    record_types: Dict[str, "RecordType"] = {}
+
+    def __new__(cls, name, base, namespace):
+        """
+        This function is called upon declaration of any classes of type
+        RecordType
+        """
+
+        record_type = super().__new__(cls, name, base, namespace)
+
+        # If record_type.tag is a string, register it here
+        if isinstance(record_type.tag, str):
+            cls.record_types[record_type.tag] = record_type
+        return record_type
+
+    @classmethod
+    def get(cls, tag):
+        """
+        Parameters
+        ----------
+        tag : str
+            tag that a record type has registered it classname with
+
+        Returns
+        -------
+        The class of type RecordType corresponding to the tag
+        """
+
+        if tag not in cls.record_types:
+            try:
+                importlib.import_module("model_analyzer.record.types.%s" % tag)
+            except ImportError as e:
+                print(e)
+        return cls.record_types[tag]
+
+    @classmethod
+    def get_all_record_types(cls):
+        """
+        Returns
+        -------
+        dict
+            keys are tags and values are
+            all the types that have this as a
+            metaclass
+        """
+
+        type_module_directory = os.path.join(
+            globals()["__spec__"].origin.rsplit("/", 1)[0], "types"
+        )
+        for filename in os.listdir(type_module_directory):
+            if filename != "__init__.py" and filename.endswith(".py"):
+                try:
+                    importlib.import_module(
+                        f"model_analyzer.record.types.{filename[:-3]}"
+                    )
+                except AttributeError:
+                    raise TritonModelAnalyzerException(
+                        "Error retrieving all record types"
+                    )
+        return cls.record_types
+
+
+class Record(metaclass=RecordType):
+    """
+    This class is used for representing
+    records
+    """
+
+    def __init__(self, value, timestamp):
+        """
+        Parameters
+        ----------
+        value : float or int
+            The value of the GPU metrtic
+        timestamp : int
+            The timestamp for the record in nanoseconds
+        """
+
+        assert type(value) is float or type(value) is int
+        assert type(timestamp) is int
+
+        self._value = value
+        self._timestamp = timestamp
+
+    @staticmethod
+    def aggregation_function():
+        """
+        The function that is used to aggregate
+        this type of record
+
+        Returns
+        -------
+        callable()
+            [Records] -> Record
+        """
+
+        return lambda records: max(records, key=lambda r: r.value())
+
+    @staticmethod
+    def value_function():
+        """
+        Returns the average value from a list
+
+        Returns
+        -------
+        Average value of the list
+        """
+        return mean
+
+    @staticmethod
+    @abstractmethod
+    def header(aggregation_tag=False):
+        """
+        Parameters
+        ----------
+        aggregation_tag : boolean
+            An optional tag that may be displayed as part of the header
+            indicating that this record has been aggregated using max, min or
+            average etc.
+
+        Returns
+        -------
+        str
+            The full name of the
+            metric.
+        """
+
+    @property
+    @abstractmethod
+    def tag(self):
+        """
+        Returns
+        -------
+        str
+            the name tag of the record type.
+        """
+
+    def to_dict(self):
+        return (self.tag, self.__dict__)
+
+    @classmethod
+    def from_dict(cls, record_dict):
+        record = cls(0)
+        for key in ["_value", "_timestamp"]:
+            if key in record_dict:
+                setattr(record, key, record_dict[key])
+        return record
+
+    def value(self):
+        """
+        This method returns the value of recorded metric
+
+        Returns
+        -------
+        float
+            value of the metric
+        """
+
+        return self._value
+
+    def timestamp(self):
+        """
+        This method should return the time at which the record was created.
+
+        Returns
+        -------
+        float
+            timestamp passed in during
+            record creation
+        """
+
+        return self._timestamp
+
+    def __mul__(self, other):
+        """
+        Defines left multiplication for records with floats or ints.
+
+        Returns
+        -------
+        Record
+        """
+
+        if isinstance(other, (int, float)):
+            return self.__class__(value=(self.value() * other))
+        else:
+            raise TypeError
+
+    def __rmul__(self, other):
+        """
+        Defines right multiplication
+        """
+
+        return self.__mul__(other)
+
+    def __truediv__(self, other):
+        """
+        Defines left multiplication for records with floats or ints
+
+        Returns
+        -------
+        Record
+        """
+
+        if isinstance(other, (int, float)):
+            return self.__class__(value=(self.value() / other))
+
+        else:
+            raise TypeError
+
+    @abstractmethod
+    def _positive_is_better(self) -> bool:
+        """
+        Returns a bool indicating if a larger positive value is better
+        for a given record type
+        """
+
+    def calculate_percentage_gain(self, other: "Record") -> float:
+        """
+        Calculates percentage gain between records
+        """
+
+        # When increasing values are better gain is based on the original value (other):
+        # example: 200 vs. 100 is (200 - 100) / 100 = 100%
+        # example: 100 vs. 200 is (100 - 200) / 200 = -50%
+        if self._positive_is_better():
+            return ((self.value() - other.value()) / other.value()) * 100
+
+        # When decreasing values are better gain is based on the new value (self):
+        # example: 100 vs. 200 is (200 - 100) / 100 = 100%
+        # example: 200 vs. 100 is (100 - 200) / 200 = -50%
+        else:
+            return ((other.value() - self.value()) / self.value()) * 100
+
+
+class IncreasingRecord(Record):
+    """
+    Record where an increasing positive value is better
+    """
+
+    def _positive_is_better(self) -> bool:
+        return True
+
+
+class DecreasingRecord(Record):
+    """
+    Record where an increasing positive value is worse
+    """
+
+    def _positive_is_better(self) -> bool:
+        return False

model_analyzer/record/record_aggregator.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+
+# Copyright 2020-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 itertools
+from collections import defaultdict
+
+from model_analyzer.model_analyzer_exceptions import TritonModelAnalyzerException
+from model_analyzer.record.record import Record
+
+
+class RecordAggregator:
+    """
+    Stores a collection of Record objects.
+    """
+
+    def __init__(self):
+        self._records = defaultdict(list)
+
+    def insert(self, record):
+        """
+        Insert a record into the RecordAggregator
+
+        Parameters
+        ----------
+        record : Record
+            A record to be inserted
+        """
+
+        if isinstance(record, Record):
+            record_type = type(record)
+            self._records[record_type].append(record)
+        else:
+            raise TritonModelAnalyzerException(
+                "Can only add objects of type 'Record' to RecordAggregator"
+            )
+
+    def insert_all(self, record_list):
+        """
+        Insert records from a list of records
+        into the RecordAggregator
+
+        Parameters
+        ----------
+        record_list : List of Records
+            The records to insert
+        """
+
+        for record in record_list:
+            self.insert(record)
+
+    def add_key(self, record_type, records):
+        """
+        Adds or replaces all the records of a given record_type with the new
+        records
+
+        Parameters
+        ----------
+        record_type : Record
+            record_type to add to the records.
+        records : list
+            List of new records to be added.
+        """
+
+        self._records[record_type] = records
+
+    def filter_records(self, record_types=None, filters=None):
+        """
+        Get records that satisfy the given list of criteria.
+
+        Parameters
+        ----------
+
+        record_types : list of types of Records
+            the types of the records we are
+            imposing the filter criteria on.
+
+        filters : list of callables
+            conditions that determine whether
+            a given record should be returned.
+            If no filters specified, all records
+            of types specified by record_types will be
+            returned.
+            Note : This must be of the same length
+                   as the list of record_types, or omitted.
+
+        Returns
+        -------
+        RecordAggregator
+            Returns a new RecordAggregator containing the filtered
+            records
+        """
+
+        filtered_records = RecordAggregator()
+        if not record_types and not filters:
+            for record_type, records in self._records.items():
+                filtered_records.add_key(record_type, records)
+            return filtered_records
+
+        if record_types and not filters:
+            try:
+                for record_type in record_types:
+                    filtered_records.add_key(record_type, self._records[record_type])
+                return filtered_records
+            except KeyError as k:
+                raise TritonModelAnalyzerException(
+                    f"Record type '{k.header()}' not found in this RecordAggregator"
+                )
+        if filters and not record_types:
+            raise TritonModelAnalyzerException(
+                "Must specify the record types corresponding to each filter criterion."
+            )
+        if len(record_types) != len(filters):
+            raise TritonModelAnalyzerException(
+                "Must specify the same number of record types as filter criteria."
+            )
+
+        # Remove records that do not satisfy criteria
+        for h, f in zip(record_types, filters):
+            for record in self._records[h]:
+                if f(record):
+                    filtered_records.insert(record)
+
+        return filtered_records
+
+    def groupby(self, record_types, groupby_criterion):
+        """
+        Group all the records of a certain type together if they have the
+        same value for a given groupbby criteria.
+
+        Parameters
+        ----------
+        record_types : list
+            A list of record type
+        groupby_criterion : callable
+            This callable will receive a single record as the argument and
+            must return the value that will be used for groupby
+
+        Returns
+        -------
+        dict
+            A dictionary of dictionaries where the first level keys are the
+            record type and the second level keys are unique values returned
+            by groupby_criteria and the values are the aggregated records.
+        """
+
+        field_values = {
+            record_type: set(
+                [groupby_criterion(record) for record in self._records[record_type]]
+            )
+            for record_type in record_types
+        }
+        groupby_result = defaultdict(list)
+        for record_type in record_types:
+            groupby_result[record_type] = defaultdict(list)
+            for field_value in field_values[record_type]:
+                aggregated_result = self.filter_records(
+                    record_types=[record_type],
+                    filters=[lambda r: groupby_criterion(r) == field_value],
+                ).aggregate(record_types=[record_type])
+                groupby_result[record_type][field_value] = aggregated_result[
+                    record_type
+                ]
+        return groupby_result
+
+    def record_types(self):
+        """
+        Returns
+        -------
+        list of str
+            a list of the types of records in this
+            RecordAgrregator
+        """
+
+        return list(self._records)
+
+    def total(self, record_type=None):
+        """
+        Get the total number of records in
+        the RecordAggregator
+
+        Parameters
+        ----------
+        record_type : a class name of type Record
+            The type of records to count,
+            if None, count all types
+
+        Returns
+        -------
+        int
+            number of records in
+            the RecordAggregator
+        """
+
+        if record_type:
+            if record_type not in self._records:
+                raise TritonModelAnalyzerException(
+                    f"Record type '{record_type.header()}' not found in this RecordAggregator"
+                )
+            return len(self._records[record_type])
+        return sum(len(self._records[k]) for k in self._records)
+
+    def aggregate(self, record_types=None):
+        """
+        Parameters
+        ----------
+        record_types : List of Record types
+            The type of records to aggregate.
+            If None, aggregates all records
+
+        Returns
+        -------
+        dict
+            keys are requested record types
+            and values are the aggregated values
+        """
+
+        if not record_types:
+            record_types = self.record_types()
+        aggregated_records = {
+            record_type: record_type.aggregation_function()(self._records[record_type])
+            for record_type in record_types
+        }
+        return aggregated_records
+
+    def get_records(self):
+        """
+        Get all the records.
+
+        Returns
+        -------
+        dict
+            A dictionary where the keys are record types and the values are
+            an array of records with the specified type
+        """
+
+        return self._records
+
+    def _flatten_records(self, records):
+        """
+        Flatten the records array by joining all the arrays together.
+        """
+
+        return list(itertools.chain.from_iterable(records))

model_analyzer/record/types/__init__.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+
+# Copyright 2020-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.

model_analyzer/record/types/cpu_available_ram.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+
+# Copyright 2020-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.
+
+from functools import total_ordering
+
+from model_analyzer.record.record import IncreasingRecord
+
+
+@total_ordering
+class CPUAvailableRAM(IncreasingRecord):
+    """
+    The Available CPU memory
+    """
+
+    tag = "cpu_available_ram"
+
+    def __init__(self, value, timestamp=0):
+        """
+        Parameters
+        ----------
+        value : float
+            CPU free memory
+        timestamp : int
+            The timestamp for the record in nanoseconds
+        """
+
+        super().__init__(value, timestamp)
+
+    @staticmethod
+    def header(aggregation_tag=False):
+        """
+        Parameters
+        ----------
+        aggregation_tag: bool
+            An optional tag that may be displayed
+            as part of the header indicating that
+            this record has been aggregated using
+            max, min or average etc.
+
+        Returns
+        -------
+        str
+            The full name of the
+            metric.
+        """
+
+        return ("Max " if aggregation_tag else "") + "RAM Available (MB)"
+
+    def __eq__(self, other):
+        """
+        Allows checking for
+        equality between two records
+        """
+
+        return self.value() == other.value()
+
+    def __lt__(self, other):
+        """
+        Allows checking if
+        this record is less than
+        the other
+        """
+
+        return self.value() < other.value()
+
+    def __add__(self, other):
+        """
+        Allows adding two records together
+        to produce a brand new record.
+        """
+
+        return CPUAvailableRAM(value=(self.value() + other.value()))
+
+    def __sub__(self, other):
+        """
+        Allows subtracting two records together
+        to produce a brand new record.
+        """
+
+        return CPUAvailableRAM(value=(self.value() - other.value()))