{"id":13478354,"url":"https://github.com/vra/flopth","last_synced_at":"2025-07-22T23:34:28.908Z","repository":{"id":57431442,"uuid":"171872392","full_name":"vra/flopth","owner":"vra","description":"A simple program to calculate and visualize the FLOPs and Parameters of Pytorch models, with handy CLI and easy-to-use Python API.","archived":false,"fork":false,"pushed_at":"2024-11-23T15:25:11.000Z","size":141,"stargazers_count":129,"open_issues_count":2,"forks_count":9,"subscribers_count":2,"default_branch":"master","last_synced_at":"2025-06-24T14:11:36.774Z","etag":null,"topics":["cnn","deep-learning","deeplearning","flop","flops","pip","pypi","python","python3","pytorch","visualization"],"latest_commit_sha":null,"homepage":"https://vra.github.io/flopth","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/vra.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2019-02-21T13:00:08.000Z","updated_at":"2025-05-22T20:26:25.000Z","dependencies_parsed_at":"2024-01-13T19:20:55.297Z","dependency_job_id":"113a631b-ad02-4c48-bc82-f4cf9ace25fb","html_url":"https://github.com/vra/flopth","commit_stats":{"total_commits":76,"total_committers":4,"mean_commits":19.0,"dds":0.4078947368421053,"last_synced_commit":"d5f77e68bf52dfb8214bcf3257787cb17664e1dc"},"previous_names":[],"tags_count":2,"template":false,"template_full_name":null,"purl":"pkg:github/vra/flopth","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vra%2Fflopth","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vra%2Fflopth/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vra%2Fflopth/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vra%2Fflopth/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/vra","download_url":"https://codeload.github.com/vra/flopth/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vra%2Fflopth/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":266590682,"owners_count":23952982,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-07-22T02:00:09.085Z","response_time":66,"last_error":null,"robots_txt_status":null,"robots_txt_updated_at":null,"robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["cnn","deep-learning","deeplearning","flop","flops","pip","pypi","python","python3","pytorch","visualization"],"created_at":"2024-07-31T16:01:55.901Z","updated_at":"2025-07-22T23:34:28.878Z","avatar_url":"https://github.com/vra.png","language":"Python","funding_links":[],"categories":["Python"],"sub_categories":[],"readme":"\u003cpre align=center style='color:green'\u003e\n\n    ______            __  __  \n   / __/ /___  ____  / /_/ /_ \n  / /_/ / __ \\/ __ \\/ __/ __ \\\n / __/ / /_/ / /_/ / /_/ / / /\n/_/ /_/\\____/ .___/\\__/_/ /_/ \n           /_/                \n\n\u003c/pre\u003e\n\n# flopth\n\nA simple program to calculate and visualize the FLOPs and Parameters of Pytorch models, with cli tool and Python API.\n\n# Features\n - Handy cli command to show flops and params quickly\n - Visualization percent of flops and params in each layer\n - Support multiple inputs in model's `forward` function\n - Support Both CPU and GPU mode\n - Support Torchscript Model (Only Parameters are shown)\n - Support Python3.5 and above\n\n# Installation\nInstall stable version of flopth via pypi:\n```bash\npip install flopth \n```\n\nor install latest version via github:\n```bash\npip install -U git+https://github.com/vra/flopth.git\n```\n\n# Usage examples\n## cli command\nflopth provide cli command `flopth` after installation. You can use it to get information of pytorch models quickly\n### Running on models in torchvision.models\nwith `flopth -m \u003cmodel_name\u003e`, flopth gives you all information about the `\u003cmodel_name\u003e`, input shape, output shape, parameter and flops of each layer, and total flops and params.\n\nHere is an example running on alexnet (default input size in (3, 224, 224)):\n```plain\n$ flopth -m alexnet \n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| module_name   | module_type       | in_shape    | out_shape   | params   | params_percent   | params_percent_vis             | flops    | flops_percent   | flops_percent_vis   |\n+===============+===================+=============+=============+==========+==================+================================+==========+=================+=====================+\n| features.0    | Conv2d            | (3,224,224) | (64,55,55)  | 23.296K  | 0.0381271%       |                                | 70.4704M | 9.84839%        | ####                |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.1    | ReLU              | (64,55,55)  | (64,55,55)  | 0.0      | 0.0%             |                                | 193.6K   | 0.027056%       |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.2    | MaxPool2d         | (64,55,55)  | (64,27,27)  | 0.0      | 0.0%             |                                | 193.6K   | 0.027056%       |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.3    | Conv2d            | (64,27,27)  | (192,27,27) | 307.392K | 0.50309%         |                                | 224.089M | 31.3169%        | ###############     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.4    | ReLU              | (192,27,27) | (192,27,27) | 0.0      | 0.0%             |                                | 139.968K | 0.0195608%      |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.5    | MaxPool2d         | (192,27,27) | (192,13,13) | 0.0      | 0.0%             |                                | 139.968K | 0.0195608%      |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.6    | Conv2d            | (192,13,13) | (384,13,13) | 663.936K | 1.08662%         |                                | 112.205M | 15.6809%        | #######             |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.7    | ReLU              | (384,13,13) | (384,13,13) | 0.0      | 0.0%             |                                | 64.896K  | 0.00906935%     |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.8    | Conv2d            | (384,13,13) | (256,13,13) | 884.992K | 1.44841%         |                                | 149.564M | 20.9018%        | ##########          |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.9    | ReLU              | (256,13,13) | (256,13,13) | 0.0      | 0.0%             |                                | 43.264K  | 0.00604624%     |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.10   | Conv2d            | (256,13,13) | (256,13,13) | 590.08K  | 0.965748%        |                                | 99.7235M | 13.9366%        | ######              |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.11   | ReLU              | (256,13,13) | (256,13,13) | 0.0      | 0.0%             |                                | 43.264K  | 0.00604624%     |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| features.12   | MaxPool2d         | (256,13,13) | (256,6,6)   | 0.0      | 0.0%             |                                | 43.264K  | 0.00604624%     |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| avgpool       | AdaptiveAvgPool2d | (256,6,6)   | (256,6,6)   | 0.0      | 0.0%             |                                | 9.216K   | 0.00128796%     |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| classifier.0  | Dropout           | (9216)      | (9216)      | 0.0      | 0.0%             |                                | 0.0      | 0.0%            |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| classifier.1  | Linear            | (9216)      | (4096)      | 37.7528M | 61.7877%         | ############################## | 37.7487M | 5.27547%        | ##                  |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| classifier.2  | ReLU              | (4096)      | (4096)      | 0.0      | 0.0%             |                                | 4.096K   | 0.000572425%    |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| classifier.3  | Dropout           | (4096)      | (4096)      | 0.0      | 0.0%             |                                | 0.0      | 0.0%            |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| classifier.4  | Linear            | (4096)      | (4096)      | 16.7813M | 27.4649%         | #############                  | 16.7772M | 2.34465%        | #                   |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| classifier.5  | ReLU              | (4096)      | (4096)      | 0.0      | 0.0%             |                                | 4.096K   | 0.000572425%    |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n| classifier.6  | Linear            | (4096)      | (1000)      | 4.097M   | 6.70531%         | ###                            | 4.096M   | 0.572425%       |                     |\n+---------------+-------------------+-------------+-------------+----------+------------------+--------------------------------+----------+-----------------+---------------------+\n\n\nFLOPs: 715.553M\nParams: 61.1008M\n```\n\n### Running on custom models\nAlso, given model name and the file path where the model defined, flopth will output model information:\n\nFor the dummpy network `MyModel` defined in `/tmp/my_model.py`,\n```python\n# file path: /tmp/my_model.py\n# model name:  MyModel\nimport torch.nn as nn\n\n\nclass MyModel(nn.Module):\n    def __init__(self):\n        super(MyModel, self).__init__()\n        self.conv1 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv2 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv3 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv4 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n\n    def forward(self, x1):\n        x1 = self.conv1(x1)\n        x1 = self.conv2(x1)\n        x1 = self.conv3(x1)\n        x1 = self.conv4(x1)\n        return x1\n```\nYou can use `flopth -m MyModel -p /tmp/my_model -i 3 224 224` to print model information:\n\n```plain\n$ flopth -m MyModel -p /tmp/my_model.py -i 3 224 224\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| module_name   | module_type   | in_shape    | out_shape   |   params | params_percent   | params_percent_vis   | flops    | flops_percent   | flops_percent_vis   |\n+===============+===============+=============+=============+==========+==================+======================+==========+=================+=====================+\n| conv1         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 25.0%           | ############        |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv2         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 25.0%           | ############        |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv3         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 25.0%           | ############        |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv4         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 25.0%           | ############        |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n\nFLOPs: 16.8591M\nParams: 336.0\n```\n\n#### Multiple inputs\nIf your model has more than one input in `forward`, you can add multiple `-i` parameters to flopth:\n\n```python\n# file path: /tmp/my_model.py\n# model name:  MyModel\nimport torch.nn as nn\n\n\nclass MyModel(nn.Module):\n    def __init__(self):\n        super(MyModel, self).__init__()\n        self.conv1 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv2 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv3 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv4 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n\n    def forward(self, x1, x2):\n        x1 = self.conv1(x1)\n        x1 = self.conv2(x1)\n        x2 = self.conv3(x2)\n        x2 = self.conv4(x2)\n        return (x1, x2)\n```\nYou can use `flopth -m MyModel -p /tmp/my_model -i 3 224 224 -i 3 128 128` to print model information:\n\n```plain\n flopth -m MyModel -p /tmp/my_model.py  -i 3 224 224 -i 3 128 128\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| module_name   | module_type   | in_shape    | out_shape   |   params | params_percent   | params_percent_vis   | flops    | flops_percent   | flops_percent_vis   |\n+===============+===============+=============+=============+==========+==================+======================+==========+=================+=====================+\n| conv1         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 37.6923%        | ##################  |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv2         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 37.6923%        | ##################  |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv3         | Conv2d        | (3,128,128) | (3,128,128) |       84 | 25.0%            | ############         | 1.37626M | 12.3077%        | ######              |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv4         | Conv2d        | (3,128,128) | (3,128,128) |       84 | 25.0%            | ############         | 1.37626M | 12.3077%        | ######              |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n\n\nFLOPs: 11.1821M\nParams: 336.0\n```\n\n#### Extra arguments in model's initialization\nflopth with options like `-x param1=int:3 param2=float:5.2` to process the extra parameters in model's initialization:\n```python\n# file path: /tmp/my_model.py\n# model name:  MyModel\nimport torch.nn as nn\n\n\nclass MyModel(nn.Module):\n    # Please Notice the parameters ks1 and ks2 here!\n    def __init__(self, ks1, ks2):\n        super(MyModel, self).__init__()\n        self.conv1 = nn.Conv2d(3, 3, kernel_size=ks1, padding=1)\n        self.conv2 = nn.Conv2d(3, 3, kernel_size=ks1, padding=1)\n        self.conv3 = nn.Conv2d(3, 3, kernel_size=ks2, padding=1)\n        self.conv4 = nn.Conv2d(3, 3, kernel_size=ks2, padding=1)\n\n    def forward(self, x1, x2):\n        x1 = self.conv1(x1)\n        x1 = self.conv2(x1)\n        x2 = self.conv3(x2)\n        x2 = self.conv4(x2)\n        return (x1, x2)\n```\nIn order to pass value to the arguments of `ks1` and `ks2`, we can run flopth like this:\n```plain\n$ flopth -m MyModel -p /tmp/my_model.py -i 3 224 224 -i 3 128 128 -x ks1=int:3 ks2=int:1\n+---------------+---------------+-------------+-------------+----------+------------------+-----------------------+----------+-----------------+-------------------------+\n| module_name   | module_type   | in_shape    | out_shape   |   params | params_percent   | params_percent_vis    | flops    | flops_percent   | flops_percent_vis       |\n+===============+===============+=============+=============+==========+==================+=======================+==========+=================+=========================+\n| conv1         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 43.75%           | ##################### | 4.21478M | 47.6707%        | ####################### |\n+---------------+---------------+-------------+-------------+----------+------------------+-----------------------+----------+-----------------+-------------------------+\n| conv2         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 43.75%           | ##################### | 4.21478M | 47.6707%        | ####################### |\n+---------------+---------------+-------------+-------------+----------+------------------+-----------------------+----------+-----------------+-------------------------+\n| conv3         | Conv2d        | (3,128,128) | (3,130,130) |       12 | 6.25%            | ###                   | 202.8K   | 2.29374%        | #                       |\n+---------------+---------------+-------------+-------------+----------+------------------+-----------------------+----------+-----------------+-------------------------+\n| conv4         | Conv2d        | (3,130,130) | (3,132,132) |       12 | 6.25%            | ###                   | 209.088K | 2.36486%        | #                       |\n+---------------+---------------+-------------+-------------+----------+------------------+-----------------------+----------+-----------------+-------------------------+\n\n\nFLOPs: 8.84146M\nParams: 192.0\n```\n\n### Line number mode\nOne of the fancy features of flopth is that given the line number where the model **object** is definited, flopth can print model information:\n```python\n# file path: /tmp/my_model.py\n# model name:  MyModel\nimport torch.nn as nn\n\n\nclass MyModel(nn.Module):\n    def __init__(self):\n        super(MyModel, self).__init__()\n        self.conv1 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv2 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv3 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv4 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n\n    def forward(self, x1, x2):\n        x1 = self.conv1(x1)\n        x1 = self.conv2(x1)\n        x2 = self.conv3(x2)\n        x2 = self.conv4(x2)\n        return (x1, x2)\n\n\nif __name__ == '__main__':\n    my_model = MyModel()\n```\n\nSince the model object `my_model` in defined in line 23, we can run flopth like this:\n```plain\n$ flopth -n 23 -p /tmp/my_model.py -i 3 224 224 -i 3 128 128\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| module_name   | module_type   | in_shape    | out_shape   |   params | params_percent   | params_percent_vis   | flops    | flops_percent   | flops_percent_vis   |\n+===============+===============+=============+=============+==========+==================+======================+==========+=================+=====================+\n| conv1         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 37.6923%        | ##################  |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv2         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 37.6923%        | ##################  |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv3         | Conv2d        | (3,128,128) | (3,128,128) |       84 | 25.0%            | ############         | 1.37626M | 12.3077%        | ######              |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv4         | Conv2d        | (3,128,128) | (3,128,128) |       84 | 25.0%            | ############         | 1.37626M | 12.3077%        | ######              |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n\n\nFLOPs: 11.1821M\nParams: 336.0\n```\n\n**Notice: Although line number mode of flopth is quite handy, it may fail when the model definition is too complex, e.g., using outer config file to initialize a model. In this case, I recommend you to use flopth's Python API detailed below.**\n\n## Python API\nThe Python API of flopth is quite simple:\n```python\nimport torch\nimport torch.nn as nn\n\n# import flopth\nfrom flopth import flopth\n\n# define Model\nclass MyModel(nn.Module):\n    def __init__(self):\n        super(MyModel, self).__init__()\n        self.conv1 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv2 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv3 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n        self.conv4 = nn.Conv2d(3, 3, kernel_size=3, padding=1)\n\n    def forward(self, x1):\n        x1 = self.conv1(x1)\n        x1 = self.conv2(x1)\n        x1 = self.conv3(x1)\n        x1 = self.conv4(x1)\n        return x1\n\n\n# declare Model object\nmy_model = MyModel()\n\n# Use input size\nflops, params = flopth(my_model, in_size=((3, 224, 224),))\nprint(flops, params)\n\n# Or use input tensors\ndummy_inputs = torch.rand(1, 3, 224, 224)\nflops, params = flopth(my_model, inputs=(dummy_inputs,))\nprint(flops, params)\n```\n\nThe output is like this:\n```plain\n16.8591M 336.0\n```\n\nTo show detail information of each layer, add `show_detail=True` in flopth function call:\n```python\nflops, params = flopth(my_model, in_size=((3, 224, 224),), show_detail=True)\n```\n\nThe outputs:\n```plain\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| module_name   | module_type   | in_shape    | out_shape   |   params | params_percent   | params_percent_vis   | flops    | flops_percent   | flops_percent_vis   |\n+===============+===============+=============+=============+==========+==================+======================+==========+=================+=====================+\n| conv1         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 25.0%           | ############        |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv2         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 25.0%           | ############        |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv3         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 25.0%           | ############        |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n| conv4         | Conv2d        | (3,224,224) | (3,224,224) |       84 | 25.0%            | ############         | 4.21478M | 25.0%           | ############        |\n+---------------+---------------+-------------+-------------+----------+------------------+----------------------+----------+-----------------+---------------------+\n\n\n16.8591M 336.0\n```\n\nTo show only the value of flops and params (no unit conversion), add `bare_number=True` to flopth function call:\n```python\nflops, params = flopth(my_model, in_size=((3, 224, 224),), bare_number=True)\n```\n\nThe outputs:\n```plain\n16859136 336\n```\n\n# Known issues\n 1. When use a module more than one time during `forward`, the FLOPs calculation is not correct, For example:\n ```python\nimport torch.nn as nn\n\nclass Net(nn.Module):\n    def __init__(self):\n        super(Net, self).__init__()\n\n        self.l1 = nn.Linear(10, 10)\n\n    def forward(self, x, y):\n        x = self.l1(x)\n        x = self.l1(x)\n        x = self.l1(x)\n\n        return x\n ```\n Will give wrong FLOPs value, because we use [register_buffer ](https://pytorch.org/docs/stable/_modules/torch/nn/modules/module.html#Module.register_buffer), which is bind to a `nn.Module` (in this example, `l1`). \n\n# TODOs\n - [x] Support multiple inputs\n - [x] Add parameter size\n - [x] Add file line mode\n - [x] Add line number mode \n - [ ] Support more modules \n\n# Contribution and issue\nAny discussion and contribution are very welcomed. Please open an issue to reach me. \n\n# Acknowledge\nThis program is mostly inspired by [torchstat](https://github.com/Swall0w/torchstat), great thanks to the creators of it.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvra%2Fflopth","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fvra%2Fflopth","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvra%2Fflopth/lists"}