o ϯiC@s:UddlmZddlmZmZmZmZmZmZm Z ddl m Z ddl m Z ddlmZddlmZmZmZmZmZmZmZmZmZmZeeeeeeeeededededdedd eddedd d Zeeefed <Gd d d eZ dde jdeedfdeeeefdeeee feeffddZ!dS)) defaultdict)AnyCounter DefaultDictDictOptionalTupleUnionN)Tensor)JitModelAnalysis) addmm_flop_jitbatchnorm_flop_jit bmm_flop_jit conv_flop_jiteinsum_flop_jitelementwise_flop_counterHandlelinear_flop_jitmatmul_flop_jitnorm_flop_counter)z aten::addmmz aten::bmmzaten::_convolutionz aten::einsumz aten::matmulzaten::mmz aten::linearzaten::batch_normzaten::group_normzaten::layer_normzaten::instance_normzaten::upsample_nearest2dzaten::upsample_bilinear2dzaten::adaptive_avg_pool2dzaten::grid_sampler_DEFAULT_SUPPORTED_OPScsJeZdZdZdejdeeeedffddffdd Z e j je _Z S) FlopCountAnalysisa Provides access to per-submodule model flop count obtained by tracing a model with pytorch's jit tracing functionality. By default, comes with standard flop counters for a few common operators. Note that: 1. Flop is not a well-defined concept. We just produce our best estimate. 2. We count one fused multiply-add as one flop. 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. Flop counts can be obtained as: * ``.total(module_name="")``: total flop count for the module * ``.by_operator(module_name="")``: flop counts for the module, as a Counter over different operator types * ``.by_module()``: Counter of flop 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)),) >>> flops = FlopCountAnalysis(model, inputs) >>> flops.total() 13000 >>> flops.total("fc") 10000 >>> flops.by_operator() Counter({"addmm" : 10000, "conv" : 3000}) >>> flops.by_module() Counter({"" : 13000, "fc" : 10000, "conv" : 3000, "act" : 0}) >>> flops.by_module_and_operator() {"" : Counter({"addmm" : 10000, "conv" : 3000}), "fc" : Counter({"addmm" : 10000}), "conv" : Counter({"conv" : 3000}), "act" : Counter() } modelinputs.returnNcs$tj||d|jditdS)N)rr)super__init__ set_op_handler)selfrr __class__rH/home/ubuntu/.local/lib/python3.10/site-packages/fvcore/nn/flop_count.pyr lszFlopCountAnalysis.__init__) __name__ __module__ __qualname____doc__nnModuler r rr r __classcell__rrr#r%r/s<rrr. supported_opsrcCsX|duri}t||jdi|}tt}|D] \}}|d||<q||fS)aR Given a model and an input to the model, compute the per-operator Gflops of the given model. Args: model (nn.Module): The model to compute flop counts. inputs (tuple): Inputs that are passed to `model` to count flops. 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 and einsum. The key is operator name and the value is a function that takes (inputs, outputs) of the op. We count one Multiply-Add as one FLOP. Returns: tuple[defaultdict, Counter]: A dictionary that records the number of gflops for each operation and a Counter that records the number of unsupported operations. NgeAr)rr!rfloat by_operatoritemsunsupported_ops)rrr- flop_counter giga_flopsopfloprrr% flop_countws r6)N)" collectionsrtypingrrrrrrr torch.nnr*torchr jit_analysisr jit_handlesr rrrrrrrrrrstr__annotations__rr+r.r6rrrr%sB$   0K