afe.apis.model
==============

.. py:module:: afe.apis.model


Classes
-------

.. autoapisummary::

   afe.apis.model.Model


Module Contents
---------------

.. py:class:: Model(net: afe.ir.net.AwesomeNet, fp32_net: Optional[afe.ir.net.AwesomeNet] = None)

   .. py:method:: execute(inputs: afe.apis.defines.InputValues, *, fast_mode: bool = False, use_jax: bool = False, log_level: int | None = logging.NOTSET, keep_layer_outputs: list[afe.ir.defines.NodeName] | str | None = None, output_file_path: str | None = None) -> List[numpy.ndarray]

      Run input data through the quantized model.

      :param inputs: Dictionary of placeholder node names (str) to the input data.
      :param fast_mode: If True, use a fast implementation of operators.  If False, use an implementation that exactly
                        matches execution on the MLA.  Has no effect when use_jax argument is True.
      :param use_jax: If True, use JAX implementation of operators.
      :param log_level: Logging level.
      :param keep_layer_outputs: List of quantized model layer output names that should be saved.  Each element of a
                                 list must have a valid name, according to the model layer outputs.  Iff 'all', all intermediate results
                                 are saved.
      :param output_file_path: Location where the layer outputs should be saved.  If defined, keep_layer_outputs
                               argument must also be provided by the user.

      Returns: Outputs of quantized model.
              Also, saves the requested intermediate results inside output_file_path location.



   .. py:method:: save(model_name: str, output_directory: str = '', *, log_level: Optional[int] = logging.NOTSET, include_unquantized_net: bool = True) -> None


   .. py:method:: load(model_name: str, network_directory: str = '', *, log_level: Optional[int] = logging.NOTSET, include_unquantized_net: bool = True) -> Model
      :staticmethod:



   .. py:method:: compile(output_path: str, batch_size: int = 1, compress: bool = True, log_level: Optional[int] = logging.NOTSET, tessellate_parameters: Optional[afe.backends.mpk.interface.TessellateParameters] = None, l2_caching_mode: afe.backends.mpk.interface.L2CachingMode = L2CachingMode.NONE, preserve: bool = True, **kwargs) -> None

      Compile the model and generate MPK JSON file.

      :param output_path: Lm file directory path.
      :param batch_size: The batch size of the input to the model.
      :param compress: If True mlc file is compressed before generating .lm file.
      :param log_level: Logging message level.
      :param tessellate_parameters: Dictionary defining the tessellation parameters
                                    for inputs and outputs of the MLA segments.
      :param l2_caching_mode: Specifies mode of L2 caching in n2a compiler.
      :param preserve: If True, leave the model graph unchanged;
                       compilation will use a temporary copy of the model graph.
                       If False, the model graph will be modified during compilation and will not be usable afterward.



   .. py:method:: create_auxiliary_network(transforms: List[afe.apis.transform.Transform], input_types: Dict[afe.ir.defines.InputName, afe.ir.tensor_type.TensorType], *, target: sima_utils.common.Platform = gen1_target, log_level: Optional[int] = logging.NOTSET) -> Model
      :staticmethod:



   .. py:method:: compose(nets: List[Model], combined_model_name: str = 'main', log_level: Optional[int] = logging.NOTSET) -> Model
      :staticmethod:



   .. py:method:: evaluate(evaluation_data: Iterable[Tuple[afe.apis.defines.InputValues, afe.apis.compilation_job_base.GroundTruth]], criterion: afe.apis.statistic.Statistic[Tuple[List[numpy.ndarray], afe.apis.compilation_job_base.GroundTruth], str], *, fast_mode: bool = False, log_level: Optional[int] = logging.NOTSET) -> str


   .. py:method:: analyze_quantization_error(evaluation_data: Iterable[afe.apis.defines.InputValues], error_metric: afe.core.graph_analyzer.utils.Metric, *, local_feed: bool, log_level: Optional[int] = logging.NOTSET)


   .. py:method:: get_performance_metrics(output_kpi_path: str, *, log_level: Optional[int] = logging.NOTSET)


   .. py:method:: generate_elf_and_reference_files(input_data: Iterable[afe.apis.defines.InputValues], output_dir: str, *, batch_size: int = 1, compress: bool = True, tessellate_parameters: Optional[afe.backends.mpk.interface.TessellateParameters] = None, log_level: Optional[int] = logging.NOTSET, l2_caching_mode: afe.backends.mpk.interface.L2CachingMode = L2CachingMode.NONE) -> None


   .. py:method:: execute_in_accelerator_mode(input_data: Iterable[afe.apis.defines.InputValues], devkit: str, *, username: str = cp.DEFAULT_USERNAME, password: str = '', batch_size: int = 1, compress: bool = True, tessellate_parameters: Optional[afe.backends.mpk.interface.TessellateParameters] = None, log_level: Optional[int] = logging.NOTSET, l2_caching_mode: afe.backends.mpk.interface.L2CachingMode = L2CachingMode.NONE) -> List[numpy.ndarray]