o
    ϯi                     @   s   U d dl mZ d dlmZmZmZmZmZmZm	Z	 d dl
mZ d dlmZ ddlmZ ddlmZmZ ede e e e e d	Zeeef ed
< G dd deZ	ddejdeedf deeeef  deeeef ee f fddZdS )    )defaultdict)AnyCounterDefaultDictDictOptionalTupleUnionN)Tensor   )JitModelAnalysis)generic_activation_jitHandleconv)zaten::_convolutionzaten::addmmz	aten::bmmzaten::einsumzaten::matmulzaten::linear_DEFAULT_SUPPORTED_OPSc                       sJ   e Zd ZdZdejdeeeedf f ddf fddZ	e
j	je	_  ZS )	ActivationCountAnalysisaK  
    Provides access to per-submodule model activation count obtained by
    tracing a model with pytorch's jit tracing functionality. By default,
    comes with standard activation counters for convolutional and dot-product
    operators.

    Handles for additional operators may be added, or the default ones
    overwritten, using the ``.set_op_handle(name, func)`` method.
    See the method documentation for details.

    Activation counts can be obtained as:

    * ``.total(module_name="")``: total activation count for a module
    * ``.by_operator(module_name="")``: activation counts for the module, as a
      Counter over different operator types
    * ``.by_module()``: Counter of activation counts for all submodules
    * ``.by_module_and_operator()``: dictionary indexed by descendant of Counters
      over different operator types

    An operator is treated as within a module if it is executed inside the
    module's ``__call__`` method. Note that this does not include calls to
    other methods of the module or explicit calls to ``module.forward(...)``.

    Example usage:

    >>> import torch.nn as nn
    >>> import torch
    >>> class TestModel(nn.Module):
    ...     def __init__(self):
    ...        super().__init__()
    ...        self.fc = nn.Linear(in_features=1000, out_features=10)
    ...        self.conv = nn.Conv2d(
    ...            in_channels=3, out_channels=10, kernel_size=1
    ...        )
    ...        self.act = nn.ReLU()
    ...    def forward(self, x):
    ...        return self.fc(self.act(self.conv(x)).flatten(1))

    >>> model = TestModel()
    >>> inputs = (torch.randn((1,3,10,10)),)
    >>> acts = ActivationCountAnalysis(model, inputs)
    >>> acts.total()
    1010
    >>> acts.total("fc")
    10
    >>> acts.by_operator()
    Counter({"conv" : 1000, "addmm" : 10})
    >>> acts.by_module()
    Counter({"" : 1010, "fc" : 10, "conv" : 1000, "act" : 0})
    >>> acts.by_module_and_operator()
    {"" : Counter({"conv" : 1000, "addmm" : 10}),
     "fc" : Counter({"addmm" : 10}),
     "conv" : Counter({"conv" : 1000}),
     "act" : Counter()
    }
    modelinputs.returnNc                    s$   t  j||d | jdi t d S )N)r   r    )super__init__set_op_handler   )selfr   r   	__class__r   N/home/ubuntu/.local/lib/python3.10/site-packages/fvcore/nn/activation_count.pyr   S   s   z ActivationCountAnalysis.__init__)__name__
__module____qualname____doc__nnModuler	   r
   r   r   r   __classcell__r   r   r   r   r      s    9r   r   r   .supported_opsr   c                 C   sX   |du ri }t | |jdi |}tt}|  D ]
\}}|d ||< q|| fS )a-  
    Given a model and an input to the model, compute the total number of
    activations of the model.

    Args:
        model (nn.Module): The model to compute activation counts.
        inputs (tuple): Inputs that are passed to `model` to count activations.
            Inputs need to be in a tuple.
        supported_ops (dict(str,Callable) or None) : provide additional
            handlers for extra ops, or overwrite the existing handlers for
            convolution and matmul. The key is operator name and the value
            is a function that takes (inputs, outputs) of the op.

    Returns:
        tuple[defaultdict, Counter]: A dictionary that records the number of
            activation (mega) for each operation and a Counter that records the
            number of unsupported operations.
    Ng    .Ar   )r   r   r   floatby_operatoritemsunsupported_ops)r   r   r$   act_counter	mega_actsopactr   r   r   activation_count^   s   r-   )N)collectionsr   typingr   r   r   r   r   r   r	   torch.nnr!   torchr
   jit_analysisr   jit_handlesr   r   r   str__annotations__r   r"   r%   r-   r   r   r   r   <module>   s0   $
H
